MCP Memory Service
Summary: A persistent, self-hosted memory backend that lets AI agents store, search, organize, and maintain knowledge across sessions and agents.
Store memories with tags, types, agent attribution, conversation IDs, and optional restoration of deleted content.
Store full conversation sessions as single memory units for better session-level recall.
Search semantically, exactly, hybrid, or ranked, with filters for tags, time ranges, entities, agents, quality, superseded memories, and optional LLM summaries.
Browse and list memories with pagination and filters by tag, type, agent, or staleness.
Update memories in place (tags, type, metadata) or create versioned replacements.
Delete memories safely by hash, tags, or date ranges with dry-run previews; also clean up duplicates.
Ingest documents (PDF, TXT, MD, JSON) from files or directories with chunking.
Harvest session transcripts to extract decisions, bugs, conventions, learnings, and context, optionally LLM-validated.
Consolidate memories via scheduled or manual runs (clustering, compression, association discovery, controlled forgetting) and merge multiple memories into one.
Manage quality: rate memories, analyze quality distribution, run maintenance, and rebuild entity extraction.
Explore a knowledge graph: find connected memories, shortest paths, subgraphs, inferred relationships, suggestions, entity profiles, and common-cause explanations.
Handle conflicts and beliefs: list unresolved contradictions, resolve them by choosing a winner, review quarantined memories, and unquarantine valid ones.
Track mistakes with add/search/update/delete for error-replay patterns.
Build agent bootstrap profiles and record end-of-session learnings for ephemeral agents.
Explore entity-based knowledge maps and drill into entity details with ranked chunks and related entities.
Monitor health, stats, and caches, and get client integration guides.
Mentioned as a potential cloud storage option where users should ensure sync is complete before accessing from another device.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@MCP Memory Service search for my notes about authentication setup"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
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
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/docsKnowledge graph — agents share causal chains, not just facts
X-Agent-IDheader — auto-tag memories by agent identity for scoped retrievalconversation_id— bypass deduplication for incremental conversation storageSSE 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.jsonWindows:
%APPDATA%\Claude\claude_desktop_config.jsonLinux:
~/.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 serverRestart Claude Code. Memory tools will appear automatically.
MCP_ALLOW_ANONYMOUS_ACCESS=true memory server --http
# REST API running at http://localhost:8000Store 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 --httpThe 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.pyRestart 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.pyChoose 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, orallfor cross-store search).📝 Optional search summaries — Request
summarize=truefor query-aware summaries with validated source references. RequiresMCP_SEARCH_SUMMARIZE_ENABLED=trueand 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_harvesttool 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_profileassembles behavioral context for a new agent within a token budget, with optional task-aware retrieval. RequiresMCP_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 serverThese 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.0exposes 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
Setup Guide – Decision tree and step-by-step paths
Agent Integration Guides – LangGraph, CrewAI, AutoGen, HTTP generic
Remote MCP Setup – claude.ai and ChatGPT via HTTPS + OAuth
Configuration Guide – Backend options and customization
Architecture Overview – How it works under the hood
Knowledge Graph Dashboard – Interactive graph visualization
Benchmarks – LongMemEval, DevBench, LoCoMo, xerj agent-memory, with run commands
Migration Guide – Upgrading between major versions
Troubleshooting – Common issues and solutions
Wiki – Long-form guides and API reference
Full documentation index – Everything else
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 suiteSupporting 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 toolscommit_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_guideCRead-only
Get integration guide for a specific client type.
Inputs: client_type.
get_quarantined_memoriesARead-only
List memories that have been quarantined due to contradicting active beliefs. Use to review flagged memories.
Inputs: limit.
memory_cleanupCDestructive
Find and remove duplicate entries
Inputs: no named parameters.
memory_conflictsARead-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_deleteADestructive
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_detailARead-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_exploreARead-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_healthCRead-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_listARead-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_qualityADestructive
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_resolveCDestructive
Resolve a memory conflict by choosing a winner
Inputs: loser_hash (required), winner_hash (required).
memory_searchARead-only
Search memories with flexible modes and filters. Primary tool for finding stored information.
USE THIS WHEN:
User asks "what do you remember about X", "recall", "find memories"
Looking for past decisions, preferences, context from previous sessions
Need semantic, exact, or time-based search
User references "last time we discussed", "you should know"
HASH LOOKUP:
Provide content_hash instead of query to retrieve one memory by its exact identifier
Hash misses return no results; they do not fall back to semantic search
query and content_hash are mutually exclusive; store scoping applies to both
Only store, entity, limit, max_response_chars, and include_beliefs may accompany content_hash
MODES:
semantic (default): Finds conceptually similar content even if exact words differ
exact: Finds memories containing the exact query string
hybrid: Combines semantic similarity with quality scoring
TIME FILTERS (can combine with other filters):
time_expr: Natural language like "yesterday", "last week", "2 days ago", "last month"
after/before: Explicit ISO dates (YYYY-MM-DD)
QUALITY BOOST (for semantic/hybrid modes):
0.0 = pure semantic ranking (default)
0.3 = 30% quality weight, 70% semantic (recommended for important lookups)
1.0 = pure quality ranking
TAG FILTER:
Filter results to only memories with specific tags
Useful for categorical searches ("find all 'reference' memories about databases")
DEBUG:
include_debug=true adds timing, embedding info, filter details
SUMMARIZATION (opt-in):
summarize=true returns a query-aware LLM summary with validated source hashes
Requires a query and the existing HARVEST_LLM_PROVIDERS/GROQ_API_KEY configuration
Bounds model input at whole-memory boundaries; original memories remain stored
Returns raw results with a warning if summarization or source validation fails
Examples: {"query": "python async patterns"} {"content_hash": "aa6caea3d060e736c8b412e6b34a1354148ec04527a4bf547cfd4185140573d0"} {"query": "API endpoint", "mode": "exact"} {"time_expr": "last week", "limit": 20} {"query": "database config", "time_expr": "yesterday"} {"query": "architecture decisions", "tags": ["important"], "quality_boost": 0.3} {"after": "2024-01-01", "before": "2024-06-30", "limit": 50} {"query": "error handling", "include_debug": true} {"query": "replication consistency issue", "summarize": true}
Inputs: mode, tags, after, as_of, +18 more.
memory_statsARead-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_updateADestructive
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_deleteADestructive
Delete a mistake note by content hash. Only deletes memories with memory_type='mistake'.
Inputs: content_hash (required).
mistake_note_searchARead-only
Search mistake notes by semantic similarity. Use before starting a task to check for known pitfalls and past errors.
Inputs: query (required), limit.
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
Scored across 28 tools
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.
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.
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.
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
Related MCP Connectors
Private persistent memory for Claude, ChatGPT & Gemini via MCP - semantic search, zero-code setup.
Persistent memory for AI agents across Claude, ChatGPT and any MCP client.
Persistent memory for Claude Code and Cursor. Stop re-explaining your project every session.
Your own memory inside ChatGPT and Claude, with the source of every note.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceProvides 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.1MIT
- FlicenseAqualityDmaintenanceSupercharges 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-
- AlicenseNot gradedqualityDmaintenanceProvides 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.4MIT
- AlicenseNot gradedqualityFmaintenanceProvides Claude with long-term memory by indexing conversation history, enabling semantic search, decision tracking, and cross-project search.18 npm29MIT