{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github-thedotmack--claude-mem","slug":"thedotmack--claude-mem","name":"claude-mem","type":"skill","url":"https://claude-mem.ai","page_url":"https://unfragile.ai/thedotmack--claude-mem","categories":["app-builders"],"tags":["ai","ai-agents","ai-memory","anthropic","artificial-intelligence","chromadb","claude","claude-agent-sdk","claude-agents","claude-code","claude-code-plugin","claude-skills","embeddings","long-term-memory","mem0","memory-engine","openmemory","rag","sqlite","supermemory"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github-thedotmack--claude-mem__cap_0","uri":"capability://automation.workflow.lifecycle.hook.based.session.observation.capture","name":"lifecycle-hook-based session observation capture","description":"Captures tool usage observations at five discrete lifecycle points (SessionStart, UserPromptSubmit, PostToolUse, Summary, SessionEnd) via CLAUDE.md plugin hooks registered with Claude Code. Each hook fires at specific moments in the agent's execution flow, collecting raw tool invocations, outputs, and user interactions without requiring manual instrumentation. The system queues observations asynchronously and routes them to a worker service for processing.","intents":["I want Claude Code to automatically record what it does without me having to manually log anything","I need to capture tool usage at specific moments in the agent's workflow to build a complete session history","I want to intercept tool outputs before they're processed to extract meaningful context"],"best_for":["Claude Code users building long-running coding agents","teams needing persistent memory across multiple Claude Code sessions","developers who want zero-instrumentation memory capture"],"limitations":["Hook system is Claude Code-specific; cannot be used with other IDEs without custom integration","PostToolUse hook fires after tool execution completes, so real-time tool monitoring is not possible","Hook registration requires CLAUDE.md configuration; no dynamic hook injection at runtime"],"requires":["Claude Code IDE with plugin support","CLAUDE.md manifest in project root","Worker service running on port 37777"],"input_types":["tool invocation metadata","tool output text","user prompt text","session context"],"output_types":["structured observation objects","queued task entries in worker service"],"categories":["automation-workflow","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-thedotmack--claude-mem__cap_1","uri":"capability://data.processing.analysis.asynchronous.observation.compression.with.multi.provider.ai","name":"asynchronous observation compression with multi-provider ai","description":"Extracts and compresses raw tool observations into structured, semantically meaningful summaries using Claude 3.5 Sonnet, Haiku, or other models via Claude Agent SDK, Gemini, or OpenRouter. The system implements agent selection with fallback logic—if the primary provider fails, it automatically retries with a secondary provider. Compression happens asynchronously in a worker service queue, preventing blocking of the IDE during AI processing.","intents":["I want raw tool outputs automatically summarized into concise, searchable observations","I need fallback AI providers in case my primary API is rate-limited or down","I want compression to happen in the background without slowing down my coding session"],"best_for":["teams using multiple AI providers (Claude, Gemini, OpenRouter) for cost optimization","developers needing reliable observation processing with automatic failover","users with bandwidth constraints who want async processing"],"limitations":["Compression quality depends on the selected model; Haiku produces less detailed summaries than Sonnet","Asynchronous processing means observations are not immediately available for search after tool execution","Multi-provider fallback adds complexity; requires API keys for multiple services"],"requires":["API key for Claude (Anthropic), Gemini (Google), or OpenRouter","Claude Agent SDK installed","Worker service with HTTP access to AI provider endpoints"],"input_types":["raw tool output text","tool invocation metadata","session context"],"output_types":["compressed observation objects","structured summary text","metadata tags"],"categories":["data-processing-analysis","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-thedotmack--claude-mem__cap_10","uri":"capability://automation.workflow.configuration.priority.system.with.environment.variables.and.config.files","name":"configuration priority system with environment variables and config files","description":"Implements a hierarchical configuration system where settings are resolved in priority order: environment variables (highest), .claude-mem/config.json, .claude-mem/.env, and hardcoded defaults (lowest). This allows users to configure the system via environment variables (for CI/CD), config files (for projects), or defaults (for simplicity). The system supports configuration for AI providers, database paths, privacy controls, and token budgets. Configuration is validated on startup and errors are reported clearly.","intents":["I want to configure claude-mem differently for different projects","I need to set API keys via environment variables for CI/CD","I want sensible defaults but the ability to override them"],"best_for":["teams with multiple projects having different memory configurations","CI/CD pipelines that need to configure claude-mem programmatically","developers who want project-specific settings without global changes"],"limitations":["Configuration priority system adds complexity; users must understand the resolution order","No GUI for configuration; users must edit JSON or environment variables","Configuration validation is basic; invalid settings may not be caught until runtime","No hot-reload; configuration changes require IDE restart"],"requires":[".claude-mem/config.json or environment variables","Valid JSON syntax for config files","API keys for configured AI providers"],"input_types":["environment variables","config.json file",".env file"],"output_types":["resolved configuration object","validation errors"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-thedotmack--claude-mem__cap_11","uri":"capability://tool.use.integration.web.viewer.ui.with.real.time.updates.via.server.sent.events","name":"web viewer ui with real-time updates via server-sent events","description":"Provides a web-based UI (accessible via localhost) for viewing observations, searching memory, and managing settings. The UI uses Server-Sent Events (SSE) for real-time updates, allowing the browser to receive notifications when new observations are captured or processed. The UI includes a settings modal for configuring privacy controls, AI providers, and token budgets. Component architecture separates concerns (search, timeline, settings) into reusable React components.","intents":["I want to visually browse my observation history","I need to search and filter observations without using the CLI","I want to see real-time updates as Claude Code captures new observations"],"best_for":["developers who prefer GUI over CLI","teams needing visibility into what claude-mem is doing","users wanting to audit or review observations before they're used"],"limitations":["Web UI requires a browser; not available in headless environments","SSE updates are one-way (server to client); UI cannot directly trigger observation processing","Real-time updates depend on SSE connection stability; network interruptions cause update loss","UI is read-mostly; editing observations requires API calls"],"requires":["Web browser (Chrome, Firefox, Safari, Edge)","Worker service running with HTTP API","SSE support in the browser"],"input_types":["HTTP requests from browser","SSE stream from worker service"],"output_types":["HTML/CSS/JavaScript UI","JSON API responses","real-time SSE updates"],"categories":["tool-use-integration","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-thedotmack--claude-mem__cap_12","uri":"capability://data.processing.analysis.ragtime.batch.processor.for.bulk.observation.compression","name":"ragtime batch processor for bulk observation compression","description":"Implements a batch processing system (Ragtime) that compresses multiple observations in parallel, optimizing for throughput over latency. The batch processor groups observations by session, submits them to the AI API in batches, and persists results to SQLite/ChromaDB. This is useful for backfilling observations from previous sessions or processing high-volume observation streams. Batch processing is configurable (batch size, parallelism) and can be triggered manually or scheduled.","intents":["I want to compress months of old observations that were captured before claude-mem was installed","I need to process a high volume of observations efficiently without overwhelming the AI API","I want to backfill memory from existing logs or transcripts"],"best_for":["teams migrating to claude-mem from other memory systems","users with large backlogs of unprocessed observations","projects with high-volume observation streams"],"limitations":["Batch processing is asynchronous; results are not immediately available","Batch size and parallelism must be tuned for the AI API's rate limits","No built-in deduplication; duplicate observations may be processed multiple times","Batch processing can be resource-intensive; may slow down the IDE if run on the same machine"],"requires":["Ragtime batch processor implementation","Unprocessed observations in SQLite","AI API with sufficient rate limits for batch processing"],"input_types":["unprocessed observations","batch configuration (size, parallelism)","session grouping criteria"],"output_types":["compressed observations","batch processing logs","persisted results in SQLite/ChromaDB"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-thedotmack--claude-mem__cap_2","uri":"capability://memory.knowledge.dual.storage.persistence.with.sqlite.and.chromadb.vector.embeddings","name":"dual-storage persistence with sqlite and chromadb vector embeddings","description":"Persists compressed observations in two complementary stores: SQLite (~/.claude-mem/claude-mem.db) for structured relational data with schema migrations, and ChromaDB (~/.claude-mem/vector-db) for semantic vector embeddings. The system maintains schema consistency through migrations, syncs embeddings via ChromaSync operations, and enables both SQL queries (for exact matches, filtering) and vector similarity search (for semantic retrieval). Data flows from observation compression → SQLite insert → ChromaDB embedding sync.","intents":["I want observations persisted locally so they survive IDE restarts","I need to search observations both by exact criteria (file name, timestamp) and by semantic meaning","I want to avoid cloud storage for privacy while maintaining queryable memory"],"best_for":["developers prioritizing local-first, privacy-preserving memory","teams needing both structured and semantic search across observations","users with large session histories requiring efficient indexing"],"limitations":["Dual storage adds complexity; ChromaSync operations can lag behind SQLite writes by seconds to minutes","SQLite is single-writer, so concurrent observation writes from multiple IDE instances can cause lock contention","ChromaDB vector embeddings are generated locally or via API, adding latency (~100-500ms per observation)","No built-in replication; data loss if ~/.claude-mem directory is deleted"],"requires":["SQLite 3.x (bundled with most systems)","ChromaDB Python package or HTTP server","~500MB disk space for typical 6-month session history","Write permissions to ~/.claude-mem directory"],"input_types":["compressed observation objects","metadata (timestamp, file path, tool name)"],"output_types":["SQLite rows (observations, sessions, metadata)","ChromaDB vector embeddings","query results (structured or semantic)"],"categories":["memory-knowledge","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-thedotmack--claude-mem__cap_3","uri":"capability://search.retrieval.3.layer.search.strategy.with.progressive.disclosure","name":"3-layer search strategy with progressive disclosure","description":"Implements a three-layer search workflow that progressively discloses context to optimize token usage: Layer 1 (fast metadata filtering) uses SQLite queries to narrow candidates by timestamp, file path, or tags; Layer 2 (semantic search) queries ChromaDB for vector similarity to the user's query; Layer 3 (context assembly) constructs the final MEMORY.md with ranked results. The system uses progressive disclosure—it starts with minimal context and expands only if the agent requests more, reducing token overhead for simple queries.","intents":["I want fast, relevant context injected into Claude Code without overwhelming it with irrelevant observations","I need to search across months of sessions but only retrieve the most relevant snippets","I want to minimize token usage by only including context that's actually needed"],"best_for":["developers with large session histories (100+ sessions) needing efficient retrieval","teams optimizing for token cost and latency","users working on multiple projects simultaneously who need project-specific context"],"limitations":["Progressive disclosure requires multiple round-trips; initial context may be insufficient, requiring follow-up queries","Layer 1 filtering depends on accurate tagging; poorly tagged observations may be missed","Vector similarity search (Layer 2) is only as good as the embedding model; semantic mismatches can occur","MEMORY.md assembly adds ~50-200ms latency per search"],"requires":["SQLite database with indexed observation tables","ChromaDB with pre-computed embeddings","Timeline service for temporal filtering","Context builder pipeline for MEMORY.md generation"],"input_types":["user query text","optional filters (file path, timestamp range, tags)","session context"],"output_types":["MEMORY.md formatted context","ranked observation list","metadata about search results"],"categories":["search-retrieval","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-thedotmack--claude-mem__cap_4","uri":"capability://memory.knowledge.memory.md.context.injection.into.claude.code.prompts","name":"memory.md context injection into claude code prompts","description":"Generates a structured MEMORY.md file containing compressed observations, ranked by relevance, and injects it into Claude Code's context at session start via the SessionStart hook. The MEMORY.md format includes observation summaries, metadata (timestamps, file paths, tool names), and optional tags. The system uses a Context Builder Pipeline to assemble MEMORY.md from search results, ensuring consistent formatting and token budgeting.","intents":["I want Claude Code to automatically know about my previous work without me pasting context","I need a human-readable record of what Claude did in previous sessions","I want to control how much context is injected to avoid overwhelming the model"],"best_for":["Claude Code users building multi-session projects","teams needing audit trails of agent work","developers who want to review what Claude did before the current session"],"limitations":["MEMORY.md is injected at session start only; it's not updated during the session as new observations are captured","Token budget for MEMORY.md is fixed; if observations exceed the budget, lower-ranked items are truncated","MEMORY.md is plain text; Claude must parse it to extract structured data","No versioning of MEMORY.md; if context is stale, the user must manually refresh"],"requires":["SessionStart hook firing successfully","Search results from 3-layer search strategy","Context Builder Pipeline configured","Token budget parameter set (default ~2000 tokens)"],"input_types":["ranked observation list from search","session metadata","token budget"],"output_types":["MEMORY.md file (markdown format)","injected context in Claude Code prompt"],"categories":["memory-knowledge","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-thedotmack--claude-mem__cap_5","uri":"capability://automation.workflow.worker.service.http.api.with.session.queue.management","name":"worker service http api with session queue management","description":"A central Express-based HTTP API server (port 37777) managed by Bun that handles asynchronous observation processing, session management, and queue orchestration. The worker service exposes endpoints for session creation, observation submission, search queries, and context generation. It implements a queue architecture where observations are enqueued, processed by AI agents, and persisted to SQLite/ChromaDB. The service manages process supervision, crash recovery, and lifecycle state transitions.","intents":["I want a reliable background service that processes observations without blocking the IDE","I need to decouple observation capture from AI processing so they can happen at different rates","I want to monitor and debug what the memory system is doing via HTTP endpoints"],"best_for":["developers comfortable running a local HTTP service","teams needing visibility into observation processing via API","users with high-volume observation streams requiring queue management"],"limitations":["Worker service is a separate process; if it crashes, observations are queued but not processed until restart","Port 37777 must be available; conflicts with other services will prevent startup","No built-in authentication; assumes localhost-only access","Queue is in-memory; observations are lost if the service crashes before they're persisted"],"requires":["Bun runtime (v1.0+)","Node.js 18+ (for compatibility)","Port 37777 available","Express.js framework"],"input_types":["HTTP POST requests with observation JSON","HTTP GET requests for search/context","session metadata"],"output_types":["HTTP JSON responses","queued task entries","processed observations in SQLite/ChromaDB"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-thedotmack--claude-mem__cap_6","uri":"capability://tool.use.integration.mcp.server.integration.with.tool.registry","name":"mcp server integration with tool registry","description":"Exposes claude-mem functionality as Model Context Protocol (MCP) tools that can be called by Claude Desktop or other MCP-compatible clients. The system registers tools for session search, context generation, and observation retrieval via an MCP server. Tools use a schema-based function registry that maps tool names to handler functions, enabling Claude to call memory operations directly without IDE integration. The MCP server runs alongside the worker service and communicates via stdio or HTTP.","intents":["I want to use claude-mem memory in Claude Desktop, not just Claude Code","I need Claude to be able to search and retrieve observations programmatically","I want to integrate claude-mem with other MCP-compatible tools and agents"],"best_for":["Claude Desktop users who want persistent memory across conversations","developers building multi-tool MCP agents","teams using OpenClaw Gateway or other MCP orchestration platforms"],"limitations":["MCP tool calls are synchronous; long-running searches may timeout","Tool schema must be pre-defined; dynamic tool registration is not supported","MCP server requires separate configuration in Claude Desktop or MCP client","No built-in rate limiting; high-frequency tool calls can overwhelm the worker service"],"requires":["Claude Desktop or MCP-compatible client","MCP server running (stdio or HTTP transport)","Tool schema definitions in JSON","Worker service with HTTP API"],"input_types":["MCP tool call requests (JSON)","search queries","session IDs"],"output_types":["MCP tool responses (JSON)","observation data","context strings"],"categories":["tool-use-integration","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-thedotmack--claude-mem__cap_7","uri":"capability://memory.knowledge.session.id.duality.with.timeline.based.filtering","name":"session id duality with timeline-based filtering","description":"Manages two types of session identifiers: IDE session IDs (ephemeral, tied to IDE instance lifetime) and logical session IDs (persistent, tied to project or time period). The Timeline Service uses temporal metadata (start time, end time, duration) to enable filtering observations by time ranges, enabling queries like 'show me work from last Tuesday' or 'observations from the past 3 hours'. Session duality allows observations from multiple IDE sessions to be grouped into a single logical session for context assembly.","intents":["I want to search observations across multiple IDE sessions that worked on the same project","I need to group observations by time period, not just by IDE session","I want to see a timeline of my work across days or weeks"],"best_for":["developers with long-running projects spanning multiple IDE sessions","teams needing temporal context (e.g., 'what did I work on yesterday?')","users wanting to review work history by date range"],"limitations":["Session ID duality adds complexity; mapping between IDE and logical sessions requires careful state management","Timeline filtering depends on accurate timestamps; clock skew can cause observations to be misaligned","Grouping observations into logical sessions requires heuristics (e.g., gap detection); heuristics can fail for non-standard workflows","No built-in session merging; users must manually define logical session boundaries"],"requires":["Accurate system timestamps on the machine running Claude Code","Timeline Service implementation","Session metadata stored in SQLite (start_time, end_time, logical_session_id)"],"input_types":["IDE session ID","timestamp","logical session ID (optional)"],"output_types":["session metadata","observations filtered by time range","timeline visualization data"],"categories":["memory-knowledge","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-thedotmack--claude-mem__cap_8","uri":"capability://automation.workflow.crash.recovery.and.resilience.with.process.supervision","name":"crash recovery and resilience with process supervision","description":"Implements process supervision and crash recovery mechanisms to ensure observations are not lost if the worker service or IDE plugin crashes. The system uses a combination of in-memory queues with periodic SQLite checkpoints, process supervision (Bun manages worker service restarts), and graceful shutdown handlers. If a crash occurs, the system recovers by replaying queued observations from SQLite on restart. Lifecycle hooks are re-registered on IDE restart, ensuring no observations are missed.","intents":["I want observations to survive IDE or worker service crashes","I need the memory system to automatically recover without manual intervention","I want to avoid losing work context due to unexpected failures"],"best_for":["developers with unstable IDE environments or frequent crashes","teams needing high reliability for long-running sessions","users who can't afford to lose observation history"],"limitations":["Crash recovery adds latency on startup (replaying queued observations)","In-memory queue is lost if the process is killed with SIGKILL; only graceful shutdown is recoverable","SQLite checkpoints are periodic; observations captured immediately before a crash may be lost","Process supervision is Bun-specific; other runtimes require different supervision mechanisms"],"requires":["Bun runtime with process supervision enabled","SQLite database with write-ahead logging (WAL) enabled","Graceful shutdown handlers in worker service","Lifecycle hook re-registration on IDE restart"],"input_types":["queued observations","crash signals (SIGTERM, SIGINT)"],"output_types":["recovered observations","restart logs","process state"],"categories":["automation-workflow","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-thedotmack--claude-mem__cap_9","uri":"capability://safety.moderation.privacy.preserving.local.first.architecture.with.optional.cloud.sync","name":"privacy-preserving local-first architecture with optional cloud sync","description":"Stores all observations locally in ~/.claude-mem (SQLite + ChromaDB) by default, ensuring no data leaves the user's machine without explicit consent. The system provides optional cloud sync via OpenClaw Gateway or other integrations, but this is disabled by default. Users can configure privacy controls (e.g., exclude certain file paths, redact sensitive data) via configuration files. The architecture is designed for air-gapped environments where cloud connectivity is not available or desired.","intents":["I want my coding observations to stay on my machine and never touch the cloud","I need to exclude sensitive files (credentials, private keys) from memory","I want to comply with data residency requirements (e.g., GDPR, HIPAA)"],"best_for":["developers working on sensitive projects (security, healthcare, finance)","teams with strict data residency requirements","users in air-gapped or offline environments","organizations that distrust cloud providers"],"limitations":["Local-only storage means no cross-device sync; observations are not available on other machines","No cloud backup; data loss if ~/.claude-mem directory is deleted","Privacy controls require manual configuration; default settings may not be sufficient for all use cases","Optional cloud sync adds complexity; users must understand when data leaves their machine"],"requires":["Local disk space (~500MB for typical history)","Write permissions to ~/.claude-mem","No requirement for internet connectivity (unless cloud sync is enabled)"],"input_types":["privacy configuration (file path exclusions, redaction rules)","observation data"],"output_types":["locally persisted observations","privacy audit logs"],"categories":["safety-moderation","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":40,"verified":false,"data_access_risk":"high","permissions":["Claude Code IDE with plugin support","CLAUDE.md manifest in project root","Worker service running on port 37777","API key for Claude (Anthropic), Gemini (Google), or OpenRouter","Claude Agent SDK installed","Worker service with HTTP access to AI provider endpoints",".claude-mem/config.json or environment variables","Valid JSON syntax for config files","API keys for configured AI providers","Web browser (Chrome, Firefox, Safari, Edge)"],"failure_modes":["Hook system is Claude Code-specific; cannot be used with other IDEs without custom integration","PostToolUse hook fires after tool execution completes, so real-time tool monitoring is not possible","Hook registration requires CLAUDE.md configuration; no dynamic hook injection at runtime","Compression quality depends on the selected model; Haiku produces less detailed summaries than Sonnet","Asynchronous processing means observations are not immediately available for search after tool execution","Multi-provider fallback adds complexity; requires API keys for multiple services","Configuration priority system adds complexity; users must understand the resolution order","No GUI for configuration; users must edit JSON or environment variables","Configuration validation is basic; invalid settings may not be caught until runtime","No hot-reload; configuration changes require IDE restart","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.44793274518628057,"quality":0.5,"ecosystem":0.6000000000000001,"match_graph":0.25,"freshness":0.75,"weights":{"adoption":0.15,"quality":0.25,"ecosystem":0.1,"match_graph":0.45,"freshness":0.05}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-05-24T12:16:22.064Z","last_scraped_at":"2026-05-03T13:57:06.483Z","last_commit":"2026-05-02T23:09:33Z"},"community":{"stars":71309,"forks":6119,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=thedotmack--claude-mem","compare_url":"https://unfragile.ai/compare?artifact=thedotmack--claude-mem"}},"signature":"e0+IuLE1HyeRuYLekgNIvedNAg51ycjeZB4dMqaHwsjWQ6LP9ri9UfGijPEf0DmaBIVKcltTzCVcacuIf/WqAg==","signedAt":"2026-06-21T00:44:06.056Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/thedotmack--claude-mem","artifact":"https://unfragile.ai/thedotmack--claude-mem","verify":"https://unfragile.ai/api/v1/verify?slug=thedotmack--claude-mem","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}