Skip to main content
Glama

mcp-memory-service

Persistent Shared Memory for AI Agent Pipelines

Open-source memory backend for AI agents — REST API, MCP, OAuth, CLI, dashboard. One self-hosted service, every transport. Agents store decisions, share causal knowledge graphs, and retrieve context in 5ms — without cloud lock-in or API costs.

Works with LangGraph · CrewAI · AutoGen · any HTTP client · Claude Desktop · OpenCode


Website License: Apache 2.0 PyPI version Python PyPI Downloads Docker Pulls CI GitHub stars Contributors Remote MCP OAuth 2.0 Ask DeepWiki Glama score

Getting started: English · Deutsch · Español · 日本語 · 简体中文 · 繁體中文 · Français · Português (Brasil) · 한국어



Related MCP server: Neuro MCP V2

Why Agents Need This

Your AI assistant forgets everything when you start a new chat. You spend 10 minutes re-explaining your architecture. Again. MCP Memory Service captures project context, architecture decisions, and code patterns automatically — new sessions start with everything already known.

Without mcp-memory-service

With mcp-memory-service

Each agent run starts from zero

Agents retrieve prior decisions in 5ms

Memory is local to one graph/run

Memory is shared across all agents and runs

You manage Redis + Pinecone + glue code

One self-hosted service, zero cloud cost

No causal relationships between facts

Knowledge graph with typed edges (causes, fixes, contradicts)

Context window limits create amnesia

Autonomous consolidation compresses old memories

Key capabilities for agent pipelines:

  • Framework-agnostic REST API — no MCP client library needed; the live endpoint list is at /api/docs

  • Knowledge graph — agents share causal chains, not just facts

  • X-Agent-ID header — auto-tag memories by agent identity for scoped retrieval

  • conversation_id — bypass deduplication for incremental conversation storage

  • SSE events — real-time notifications when any agent stores or deletes a memory

  • Embeddings run locally via ONNX — memory never leaves your infrastructure


🚀 Get Started in 60 Seconds

Not sure which setup fits? The Setup Guide walks you to the right path in under a minute.

1. Install:

pip install "mcp-memory-service[sqlite]"

The [sqlite] extra brings the local ONNX embedding model. Without it, semantic search falls back to hash embeddings.

Install the memory command into its own environment:

uv tool install "mcp-memory-service[sqlite]"

Or skip the install and let your client start the server through uvx:

{
  "mcpServers": {
    "memory": {
      "command": "uvx",
      "args": ["--from", "mcp-memory-service[sqlite]", "memory", "server"]
    }
  }
}

2. Configure your AI client:

Add to your config file:

  • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

  • Windows: %APPDATA%\Claude\claude_desktop_config.json

  • Linux: ~/.config/Claude/claude_desktop_config.json

{
  "mcpServers": {
    "memory": {
      "command": "memory",
      "args": ["server"]
    }
  }
}

Restart Claude Desktop. Your AI now remembers everything across sessions.

claude mcp add memory -- memory server

Restart Claude Code. Memory tools will appear automatically.

MCP_ALLOW_ANONYMOUS_ACCESS=true memory server --http
# REST API running at http://localhost:8000

Store a memory with POST /api/memories, search with POST /api/search, retrieve by tag with POST /api/search/by-tag. Send X-Agent-ID: <id> on a store request and the server tags the memory agent:<id>, which a tag search then scopes retrieval by.

Worked examples per framework, the tag conventions and the async patterns: docs/agents/

MCP_ALLOW_ANONYMOUS_ACCESS=true memory server --http

The plugin ships as repository files for the local plugin directory, so clone the repository once even if you installed from PyPI. Install steps, the /memory slash command and the endpoint override: opencode/README.md

Start the Memory Service HTTP API, then install the hooks from this repository:

python3 codex/install_hooks.py

Restart Codex and review the hooks with /hooks. They retrieve project context, capture new learnings, and checkpoint outcomes before compaction and at session end. See Codex hook setup for prerequisites, authentication, and project-local installation.

Remote MCP puts persistent memory in the browser on any device, no desktop app required: OAuth 2.0 over HTTPS, self-hosted or cloud-hosted. Both claude.ai and ChatGPT (Developer Mode) connect to the same endpoint.

Cloudflare Tunnel quick start, Let's Encrypt, nginx, Caddy and Docker production setups: Remote MCP Setup · 5-minute tutorial

git clone https://github.com/doobidoo/mcp-memory-service.git
cd mcp-memory-service
python scripts/installation/install.py

Choose from SQLite (local, fast, single-user), Cloudflare (cloud, multi-device sync), Hybrid (5ms local reads with background cloud sync — recommended for production) or Milvus (dedicated vector DB: Lite file, self-hosted, or Zilliz Cloud). For self-hosted team setups, the Hybrid backend can sync to another HTTP MCP Memory Service instead of Cloudflare using MCP_HYBRID_SECONDARY_BACKEND=http.

For long-lived services, prefer Docker Milvus or Zilliz Cloud over Milvus Lite — why.


⚡ Works With Your Favorite AI Tools

  • Agent frameworks (REST): LangGraph · CrewAI · AutoGen · OpenClaw/Nanobot · any HTTP client

  • CLI and terminal (MCP): Claude Code · Gemini CLI · OpenCode · Codex CLI · Goose · Aider · Amp

  • Desktop and IDE (MCP): Claude Desktop · VS Code · Cursor · Windsurf · Raycast · JetBrains · Zed

  • Chat (MCP): ChatGPT (Developer Mode) · claude.ai (Remote MCP over HTTPS)

Full list, plus clients without OAuth such as Home Assistant: docs/integrations.md


✨ Features

Store and retrieve context

  • 🧠 Persistent memory — Keep decisions, notes, and project context across sessions and agents.

  • 🔍 Semantic and keyword search — Combine vector search with BM25; use mode="ranked" to weigh recency, access frequency, and quality. An optional fallback cascade tries exact and tag matching when semantic results are sparse.

  • 🏷️ Scoped retrieval — Filter by tags with AND/OR matching, natural-language time ranges, and store partitions (default, docs, or all for cross-store search).

  • 📝 Optional search summaries — Request summarize=true for query-aware summaries with validated source references. Requires MCP_SEARCH_SUMMARIZE_ENABLED=true and a configured LLM provider; unavailable summaries fall back to raw results. Search API and examples

  • 📄 Document ingestion — Import PDF, text, and Markdown with chunking for retrieval. Additional formats such as DOCX and PPTX require optional parsing tools. Document ingestion guide

Capture and maintain knowledge

  • ⚡ Automatic session capture — Configurable Claude Code hooks retrieve context and save session learnings; the local memory_harvest tool extracts decisions, bugs, conventions, and lessons from transcripts. Hooks setup · Harvest configuration

  • 💡 Autonomous consolidation — Schedule clustering, compression, association discovery, and controlled forgetting. Insight cards surface patterns, trends, and knowledge gaps. Consolidation guide

  • 💭 Beliefs and contradiction handling — Derive confidence-scored beliefs from observations. Heuristic contradiction detection can mark older memories as superseded, hiding them from default retrieval while retaining them for explicit lookup.

  • 🤖 Agent bootstrap profiles — memory_bootstrap_profile assembles behavioral context for a new agent within a token budget, with optional task-aware retrieval. Requires MCP_BOOTSTRAP_ENABLED=true; profiles are not isolated by project.

  • 🧬 Knowledge graph and entities — Explore typed causal relationships in the interactive graph. 🔗 Entity extraction links @mentions, #tags, URLs, and file paths to a queryable entity graph. Knowledge graph guide

  • 🏠 Quality scoring — Use your own OpenAI-compatible endpoint, including Ollama, LiteLLM, or vLLM. Configuration guide

Run locally and share across devices

  • 🔒 Local-first storage — Local ONNX embeddings and SQLite storage keep core memory operations on your infrastructure. Optional LLM features use the providers you configure.

  • ☁️ Cloud or self-hosted sync — Use Cloudflare or another MCP Memory Service instance as a Hybrid secondary. Separately enabled delta-sync exchanges changes between hosts; it is off by default. Self-hosted sync guide

  • 📦 Import, export, and migration — Move memories through JSON import/export, including conversion of mem0 exports. Import/export tools · mem0 migration guide

  • 💾 Database backups — Configure scheduled backups or trigger one manually through the HTTP API. Inspect backup status and available snapshots through the backup endpoints in the live API reference at /api/docs.

  • 📊 Web dashboard — Search, browse, visualize, and manage memories at http://localhost:8000.

The dashboard has eight tabs — Dashboard, Search, Browse, Documents, Manage, Analytics, Quality, API Docs. Two-minute walkthrough on YouTube · Web Dashboard Guide

How it compares to Mem0, Zep and the MCP-native alternatives, benchmark results, and deployments people run in production: mcpmemory.services


🛠️ Configuration Highlights

memory launch                  # Start HTTP server in background (127.0.0.1:8000)
memory launch --port 8192      # Custom port
memory info                    # Status and health
memory logs --lines 50         # Recent logs
memory stop                    # Stop server

These commands are optimized for fast startup and avoid loading heavy ML dependencies unless needed.

⚠️ Security note: the server binds to 127.0.0.1 (localhost only) by default. --host 0.0.0.0 / MCP_HTTP_HOST=0.0.0.0 exposes the API to your network — do that only in trusted environments with authentication and firewall rules, or behind TLS termination or a VPN overlay.

Backends, embedding models, quality scoring and every environment variable: Configuration Guide


📚 Documentation

Also listed on Glama and Spark.


📦 Releases

Every release, with upgrade notes: CHANGELOG.md · GitHub Releases · archived history


🤝 Contributing

We welcome contributions! See CONTRIBUTING.md for guidelines and SECURITY.md for reporting a vulnerability.

Releases, good first issues and new Discussions are announced on our Discord server, which is also the place for informal chat. Claiming an issue, decisions and reviews stay on GitHub.

Who authors this project, who holds copyright, and what every change passes before it reaches main: AUTHORSHIP.md.

Quick Development Setup:

git clone https://github.com/doobidoo/mcp-memory-service.git
cd mcp-memory-service
pip install -e .  # Editable install
pytest tests/      # Run test suite

Supporting the Project

MCP Memory Service is maintained by one person. If it saves you or your company time, you can support its development via Ko-fi, Buy Me a Coffee or PayPal: SPONSORS.md.

Available Tools

28 tools
commit_session_legacyA

Record end-of-session learnings from an ephemeral agent. Stores decisions, errors, corrections as structured observations.

Inputs: outcome (required), agent_id (required), session_id (required), task_summary (required), +4 more.

get_bootstrap_profileA

Generate a behavioral bootstrap profile for an ephemeral agent. Requires write scope because it resets session counters when a fresh start is due. For a read-only profile, read memory://agent/{agent_id}/bootstrap instead.

Inputs: agent_ids (required), max_tokens, project_id, task_summary, +1 more.

get_onboarding_guideC
Read-only

Get integration guide for a specific client type.

Inputs: client_type.

get_quarantined_memoriesA
Read-only

List memories that have been quarantined due to contradicting active beliefs. Use to review flagged memories.

Inputs: limit.

memory_cleanupC
Destructive

Find and remove duplicate entries

Inputs: no named parameters.

memory_conflictsA
Read-only

List unresolved memory conflicts (contradictory memories detected by similarity analysis)

Inputs: no named parameters.

memory_consolidateB

Memory consolidation management - run, monitor, and control memory optimization.

USE THIS WHEN:

  • User asks about memory optimization, cleanup, or consolidation

  • Need to check consolidation system health

  • Want to manually trigger or schedule consolidation

  • Need to pause/resume consolidation jobs

ACTIONS:

  • run: Execute consolidation for a time horizon (requires time_horizon) Performs dream-inspired memory consolidation: • Exponential decay scoring • Creative association discovery • Semantic clustering and compression • Controlled forgetting with archival

  • status: Get consolidation system health and statistics

  • recommend: Get optimization recommendations for a time horizon (requires time_horizon) Analyzes memory state and suggests whether consolidation is needed

  • scheduler: View all scheduled consolidation jobs Shows next run times and execution statistics

  • pause: Pause consolidation (all or specific horizon) Temporarily stops automatic consolidation jobs

  • resume: Resume paused consolidation Re-enables previously paused consolidation jobs

  • merge: Combine multiple existing memories into one consolidated entry (requires content_hashes and merged_content) Verifies all source memories exist, stores the merged content, deletes originals

TIME HORIZONS:

  • daily: Consolidate last 24 hours

  • weekly: Consolidate last 7 days

  • monthly: Consolidate last 30 days

  • quarterly: Consolidate last 90 days

  • yearly: Consolidate last 365 days

Examples: {"action": "status"} {"action": "run", "time_horizon": "weekly"} {"action": "run", "time_horizon": "daily", "immediate": true} {"action": "recommend", "time_horizon": "monthly"} {"action": "scheduler"} {"action": "pause"} {"action": "pause", "time_horizon": "daily"} {"action": "resume", "time_horizon": "weekly"} {"action": "merge", "content_hashes": ["hash1", "hash2"], "merged_content": "Consolidated text"} {"action": "merge", "content_hashes": ["hash1", "hash2"], "merged_content": "text", "tags": ["important"], "memory_type": "note"}

Inputs: action (required), tags, immediate, memory_type, +3 more.

memory_deleteA
Destructive

Delete memories with flexible filtering. Combine filters for precise targeting.

USE THIS WHEN:

  • User says "delete", "remove", "forget" specific memories

  • Need to clean up by tag, time range, or specific hash

  • Bulk deletion with safety preview (dry_run=true)

FILTER COMBINATIONS (AND logic when multiple specified):

  • content_hash only: Delete single memory by hash

  • tags only: Delete memories with matching tags

  • before/after: Delete memories in time range

  • tags + time: Delete tagged memories within time range

SAFETY FEATURES:

  • dry_run=true: Preview what will be deleted without deleting

  • Returns deleted_hashes for audit trail

  • No filters = error (prevents accidental mass deletion)

Examples: {"content_hash": "abc123def456"} {"tags": ["temporary", "draft"], "tag_match": "any"} {"tags": ["archived", "old"], "tag_match": "all"} {"before": "2024-01-01"} {"after": "2024-06-01", "before": "2024-12-31"} {"tags": ["cleanup"], "before": "2024-01-01", "dry_run": true}

Inputs: tags, after, store, before, +3 more.

memory_detailA
Read-only

Get the full ranked detail for a single entity.

USE THIS WHEN:

  • User drills into one entity from a knowledge map ("tell me more about X")

  • Need the full ranked list of chunks for an entity plus its related entities

Returns:

  • entity_id, name

  • chunks: ranked memory chunks (relevance now; composite_score + score_components once #55 lands)

  • related_entities: neighbouring entities (gated by include_related / max_hops)

Read-only.

Examples: {"entity_id": "authentication-design"} {"entity_id": "python", "limit": 20, "include_related": false} {"entity_id": "database", "max_hops": 2}

Inputs: entity_id (required), limit, store, scoring, +2 more.

memory_distillC

Extract insights from existing memories via LLM rewriter (batch mode).

Inputs: dry_run, batch_size, memory_types.

memory_exploreA
Read-only

Explore a knowledge map of entities, with query-scoped chunks per entity (LLM-free).

REQUIRES A POPULATED ENTITY GRAPH — returns {"entities": [], "count": 0} otherwise, for every query. Check with memory_graph {"action": "list_entities"}; populate with memory_quality {"action": "maintain", "dry_run": false} (dry_run defaults to true and stores nothing). Unavailable on the Cloudflare backend. Guide: docs/guides/token-efficient-retrieval.md

USE THIS WHEN:

  • User wants a high-level overview ("what do I know about X", "map out", "explore")

  • Need entities + their relationships rather than raw memory chunks

  • Building a knowledge graph view or entity dashboard

Returns a list of entities. Per entity:

  • entity_id: canonical slug (NFKD-normalized, hash fallback for non-Latin scripts)

  • name, entity_type

  • summary: extractive (LLM-free) summary from top chunks

  • relation_count: number of graph relationships

  • top_chunks: most relevant memory chunks for the entity

Read-only. Composes with store for multi-store scoping.

Examples: {"query": "authentication design"} {"query": "python", "max_entities": 5, "chunks_per_entity": 2} {"query": "database", "tags": ["reference"], "min_score": 0.3}

Inputs: query (required), tags, store, scoring, +3 more.

memory_graphA

Memory association graph operations - explore connections between memories.

ACTIONS:

  • connected: Find memories connected via associations (BFS traversal)

  • path: Find shortest path between two memories

  • subgraph: Get graph structure around a memory for visualization

  • extract_entities: Manually extract and store entities for a memory (write). Params: hash (string)

  • infer: Find transitive relationships (A→B→C implies A→C). Params: rel_type (string), max_hops (int, default 2)

  • suggest: Suggest potential relationships for a memory based on shared neighbors. Params: hash (string)

  • abduct: Find plausible common-cause explanations for a memory's relationships. Params: hash (string)

  • list_entities: List known entities. Params: limit (int, default 50)

  • entity_profile: Show memories linked to one entity. Params: entity_name (string)

Examples: {"action": "connected", "hash": "abc123", "max_hops": 2} {"action": "path", "hash1": "abc123", "hash2": "def456", "max_depth": 5} {"action": "subgraph", "hash": "abc123", "radius": 2} {"action": "infer", "rel_type": "causes", "max_hops": 2} {"action": "suggest", "hash": "abc123"}

Inputs: action (required), hash, as_of, hash1, +7 more.

memory_harvestA

Extract learnings from Claude Code session transcripts.

USE THIS WHEN:

  • End of session — auto-capture decisions, bugs, conventions, learnings

  • User asks to "harvest" or "extract learnings" from sessions

  • Building knowledge base from past sessions

MODES:

  • dry_run=true (DEFAULT): Preview candidates without storing

  • dry_run=false: Store candidates as tagged memories

MEMORY TYPES EXTRACTED:

  • decision: Architectural choices, tool selections

  • bug: Issues encountered and root causes

  • convention: Patterns/rules established

  • learning: Insights, mistakes learned from

  • context: Session state for continuity

LLM CLASSIFICATION (Phase 2):

  • use_llm=true: Validate candidates with Groq LLM (higher precision, ~$0.001/candidate)

  • Filters conversation fragments, deduplicates, refines content

  • Requires GROQ_API_KEY environment variable

Examples: {"sessions": 1, "dry_run": true} {"sessions": 3, "types": ["decision", "bug"]} {"session_ids": ["abc123"], "dry_run": false} {"min_confidence": 0.7, "sessions": 1} {"sessions": 1, "use_llm": true, "dry_run": true}

Inputs: types, dry_run, use_llm, agent_id, +6 more.

memory_healthC
Read-only

Check database health and get statistics

Inputs: no named parameters.

memory_ingestA

Ingest documents or directories into memory database.

USE THIS WHEN:

  • User wants to import a document (PDF, TXT, MD, JSON)

  • Need to batch import a directory of documents

  • Building knowledge base from existing files

SUPPORTED FORMATS:

  • PDF files (.pdf)

  • Text files (.txt, .md, .markdown, .rst)

  • JSON files (.json)

MODE:

  • file: Ingest single document (requires file_path)

  • directory: Batch ingest all documents in directory (requires directory_path)

CHUNKING:

  • Documents are split into chunks for better retrieval

  • chunk_size: Target characters per chunk (default: 1000)

  • chunk_overlap: Overlap between chunks (default: 200)

Examples: {"file_path": "/path/to/document.pdf"} {"file_path": "/path/to/notes.md", "tags": ["documentation"]} {"directory_path": "/path/to/docs", "recursive": true} {"directory_path": "/path/to/project", "file_extensions": ["md", "txt"], "tags": ["project-docs"]}

Inputs: tags, store, file_path, max_files, +6 more.

memory_listA
Read-only

List and browse memories with pagination and optional filters.

USE THIS WHEN:

  • User wants to browse all memories ("show me my memories", "list everything")

  • Need to paginate through large result sets

  • Filter by tag OR memory type for categorical browsing

  • User asks "what do I have stored", "browse my memories"

Unlike memory_search (semantic search), this does categorical listing/filtering.

PAGINATION:

  • page: 1-based page number (default: 1)

  • page_size: Results per page (default: 20, max: 100)

FILTERS (combine with AND logic):

  • tags: Filter to memories with matching tags

  • tag_match: "any" (OR, default) or "all" (AND) — controls how multiple tags are matched

  • memory_type: Filter by type (note, reference, decision, etc.)

  • stale_days: Filter to memories not accessed in the last N days

Examples: {} // List first 20 memories {"page": 2, "page_size": 50} {"tags": ["python", "reference"]} {"tags": ["python", "reference"], "tag_match": "all"} {"memory_type": "decision", "page_size": 10} {"tags": ["important"], "memory_type": "note"} {"stale_days": 30} // Memories not accessed in 30 days {"stale_days": 7, "tags": ["archived"]} // Stale archived memories

Inputs: page, tags, store, agent_id, +4 more.

memory_qualityA
Destructive

Memory quality management - rate, inspect, and analyze.

ACTIONS:

  • rate: Manually rate a memory's quality (thumbs up/down)

  • get: Get quality metrics for a specific memory

  • analyze: Analyze quality distribution across all memories

  • maintain: Run maintenance cycle (cleanup + conflicts + stale + quality)

  • maintain_status: Get stats from last maintenance run

  • rebuild_entities: Rebuild has_entity and shares_entity for ALL live memories using current extraction settings. Preview by default (dry_run=true); back up first and pause other writers before dry_run=false. Requires a graph backend.

Examples: {"action": "rate", "content_hash": "abc123", "rating": 1, "feedback": "Very useful"} {"action": "get", "content_hash": "abc123"} {"action": "analyze"} {"action": "analyze", "min_quality": 0.5, "max_quality": 1.0} {"action": "maintain"} {"action": "maintain", "dry_run": false} {"action": "maintain_status"} {"action": "rebuild_entities"} {"action": "rebuild_entities", "dry_run": false}

Inputs: action (required), rating, dry_run, feedback, +3 more.

memory_resolveC
Destructive

Resolve a memory conflict by choosing a winner

Inputs: loser_hash (required), winner_hash (required).

memory_statsA
Read-only

Get MCP server global cache statistics for performance monitoring.

                Returns detailed metrics about storage and memory service caching,
                including hit rates, initialization times, and cache sizes.

                This tool is useful for:
                - Monitoring cache effectiveness
                - Debugging performance issues
                - Verifying cache persistence across MCP tool calls

                Returns cache statistics including total calls, hit rate percentage,
                storage/service cache metrics, performance metrics, and backend info.

Inputs: no named parameters.

memory_storeA

Store new information with optional tags.

                Accepts two tag formats in metadata:
                - Array: ["tag1", "tag2"]
                - String: "tag1,tag2"

                Use `conversation_id` to bypass semantic deduplication when saving
                incremental memories from the same conversation.

               Examples:
                # Using array format:
                {
                    "content": "Memory content",
                    "metadata": {
                        "tags": ["important", "reference"],
                        "type": "note"
                    }
                }

                # Using string format(preferred):
                {
                    "content": "Memory content",
                    "metadata": {
                        "tags": "important,reference",
                        "type": "note"
                    }
                }

                # Using conversation_id to save incremental notes:
                {
                    "content": "User prefers dark mode",
                    "conversation_id": "conv_abc123",
                    "metadata": {
                        "tags": "preference,ui"
                    }
                }

Inputs: content (required), store, agent_id, metadata, +2 more.

memory_store_sessionA

Store a full conversation session as a single memory unit.

Use this instead of memory_store when you want to preserve the full context of a multi-turn conversation. All turns are stored together, making session-level retrieval more reliable than storing individual turns separately.

Example: { "turns": [ {"role": "user", "content": "How do I configure Redis?"}, {"role": "assistant", "content": "Set REDIS_URL in your .env file..."} ], "session_id": "optional-stable-id", "tags": "redis,configuration" }

Inputs: turns (required), tags, store, agent_id, +2 more.

memory_updateA
Destructive

Update memory metadata without recreating the entire memory entry.

                This provides efficient metadata updates while preserving the original
                memory content, embeddings, and optionally timestamps.
                
                Examples:
                # Add tags to a memory
                {
                    "content_hash": "abc123...",
                    "updates": {
                        "tags": ["important", "reference", "new-tag"]
                    }
                }
                
                # Update memory type and custom metadata
                {
                    "content_hash": "abc123...",
                    "updates": {
                        "memory_type": "reminder",
                        "metadata": {
                            "priority": "high",
                            "due_date": "2024-01-15"
                        }
                    }
                }
                
                # Update custom fields directly
                {
                    "content_hash": "abc123...",
                    "updates": {
                        "priority": "urgent",
                        "status": "active"
                    }
                }

                # Create a new version with updated content (sqlite_vec and milvus)
                {
                    "content_hash": "abc123...",
                    "updates": {
                        "content": "Corrected memory content",
                        "reason": "Fix outdated command"
                    },
                    "versioned": true
                }

Inputs: updates (required), content_hash (required), versioned, preserve_timestamps.

mistake_note_addA

Record a mistake pattern for error replay. Tracks what went wrong and the correct action. Auto-increments failure_count for repeated patterns.

Inputs: error_pattern (required), correct_action (required), incorrect_action (required), context_signature (required).

mistake_note_deleteA
Destructive

Delete a mistake note by content hash. Only deletes memories with memory_type='mistake'.

Inputs: content_hash (required).

mistake_note_updateA

Update fields of an existing mistake note. Can update failure_count, error_pattern, context_signature, incorrect_action, or correct_action. Content changes create a new hash (delete + re-store).

Inputs: content_hash (required), error_pattern, failure_count, correct_action, +2 more.

unquarantine_memoryA

Release a memory from quarantine. Use when a quarantined memory is valid (e.g., the contradicted belief was wrong).

Inputs: content_hash (required).

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    B3.4/5.0

    Scored across 28 tools

    Disambiguation3/5

    Core memory CRUD and search are distinguishable, but several families overlap: store/extract variants (memory_store, memory_store_session, memory_ingest, memory_harvest, commit_session_legacy, memory_distill) and retrieval variants (memory_search, memory_list, memory_explore, memory_detail, memory_graph) require careful description reading. Multi-action tools such as memory_quality, memory_consolidate, and memory_graph bundle unrelated operations, raising misselection risk.

    Naming Consistency4/5

    Almost all names use snake_case with readable domain prefixes (memory_*, mistake_note_*), giving a mostly predictable pattern. Minor inconsistency comes from bare get_* tools (get_quarantined_memories, get_bootstrap_profile, get_onboarding_guide) and commit_session_legacy mixed into the memory_* action pattern.

    Tool Count2/5

    28 tools is heavy for a memory service and exceeds the typical well-scoped 3-15 range. Several tools are multi-action containers that add capability but also cognitive load, making the surface feel overgrown rather than tightly scoped.

    Completeness5/5

    The surface covers the full memory lifecycle: store, retrieve, list, update, delete, cleanup, consolidation, import, session capture, quality, graph exploration, conflicts, quarantine, and mistake notes. Retrieval by hash is available through memory_search, and no major CRUD or lifecycle gaps are apparent.

    Maintenance

    ActivityActive
    ResponsivenessUsually handled

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      Provides Claude AI with persistent, searchable memory management across sessions using SQL database, semantic analysis with multi-provider LLM support (Anthropic/Ollama), vector search via ChromaDB, and graph-based knowledge relationships through Neo4j integration.
      1
      MIT
    • F
      license
      A
      quality
      D
      maintenance
      Supercharges Claude Desktop with persistent semantic memory, sandboxed file I/O, live web search, and local emotional intelligence using a local ChromaDB and Hugging Face model.
      6
      -
    • A
      license
      Not graded
      quality
      D
      maintenance
      Provides persistent, searchable memory for Claude Code using local SQLite, semantic embeddings, and full-text search, enabling Claude to recall and retrieve context across sessions and projects without external services.
      4
      MIT
    • A
      license
      Not graded
      quality
      F
      maintenance
      Provides Claude with long-term memory by indexing conversation history, enabling semantic search, decision tracking, and cross-project search.
      18 npm
      29
      MIT