MCP Memory Service
Servicio de memoria MCP
Un servidor MCP que proporciona memoria semántica y capacidades de almacenamiento persistente para Claude Desktop mediante ChromaDB y transformadores de oraciones. Este servicio permite el almacenamiento en memoria a largo plazo con funciones de búsqueda semántica, lo que lo hace ideal para mantener el contexto entre conversaciones e instancias.
Ayuda
¡Hable con el repositorio con TalkToGitHub !
Related MCP server: Neuro MCP V2
Características
Búsqueda semántica mediante transformadores de oraciones
Recuerdo basado en el tiempo del lenguaje natural (por ejemplo, "la semana pasada", "ayer por la mañana")
Sistema de recuperación de memoria basado en etiquetas
Almacenamiento persistente mediante ChromaDB
Copias de seguridad automáticas de bases de datos
Herramientas de optimización de memoria
Recuperación de coincidencias exactas
Modo de depuración para análisis de similitud
Monitoreo del estado de la base de datos
Detección y limpieza de duplicados
Modelo de incrustación personalizable
Compatibilidad entre plataformas (Apple Silicon, Intel, Windows, Linux)
Optimizaciones basadas en hardware para diferentes entornos
Respaldos elegantes para recursos de hardware limitados
Instalación
Inicio rápido (recomendado)
El script de instalación mejorado detecta automáticamente su sistema e instala las dependencias adecuadas:
# Clone the repository
git clone https://github.com/doobidoo/mcp-memory-service.git
cd mcp-memory-service
# Create and activate a virtual environment
python -m venv venv
source venv/bin/activate # On Windows: venv\Scripts\activate
# Run the installation script
python install.pyEl script install.py hará lo siguiente:
Detecte la arquitectura de su sistema y los aceleradores de hardware disponibles
Instale las dependencias adecuadas para su plataforma
Configure los ajustes óptimos para su entorno
Verificar la instalación y proporcionar diagnósticos si es necesario
Instalación de Docker
Puede ejecutar el servicio de memoria usando Docker:
# Using Docker Compose (recommended)
docker-compose up
# Using Docker directly
docker build -t mcp-memory-service .
docker run -p 8000:8000 -v /path/to/data:/app/chroma_db -v /path/to/backups:/app/backups mcp-memory-serviceProporcionamos múltiples configuraciones de Docker Compose para diferentes escenarios:
docker-compose.yml- Configuración estándar mediante pip installdocker-compose.uv.yml: configuración alternativa mediante el administrador de paquetes UVdocker-compose.pythonpath.yml: configuración con ajustes PYTHONPATH explícitos
Para utilizar una configuración alternativa:
docker-compose -f docker-compose.uv.yml upInstalación de Windows (caso especial)
Los usuarios de Windows podrían experimentar problemas de instalación de PyTorch debido a la disponibilidad de ruedas específicas de cada plataforma. Utilice nuestro script de instalación específico para Windows:
# After activating your virtual environment
python scripts/install_windows.pyEste script maneja:
Detección de la disponibilidad y versión de CUDA
Instalar la versión adecuada de PyTorch desde la URL de índice correcta
Instalar otras dependencias sin entrar en conflicto con PyTorch
Verificando la instalación
Instalación mediante herrería
Para instalar el Servicio de memoria para Claude Desktop automáticamente a través de Smithery :
npx -y @smithery/cli install @doobidoo/mcp-memory-service --client claudeGuía de instalación detallada
Para obtener instrucciones completas de instalación y solución de problemas, consulte la Guía de instalación .
Configuración de Claude MCP
Configuración estándar
Agregue lo siguiente a su archivo claude_desktop_config.json :
{
"memory": {
"command": "uv",
"args": [
"--directory",
"your_mcp_memory_service_directory", // e.g., "C:\\REPOSITORIES\\mcp-memory-service"
"run",
"memory"
],
"env": {
"MCP_MEMORY_CHROMA_PATH": "your_chroma_db_path", // e.g., "C:\\Users\\John.Doe\\AppData\\Local\\mcp-memory\\chroma_db"
"MCP_MEMORY_BACKUPS_PATH": "your_backups_path" // e.g., "C:\\Users\\John.Doe\\AppData\\Local\\mcp-memory\\backups"
}
}
}Configuración específica de Windows (recomendada)
Para los usuarios de Windows, recomendamos utilizar el script contenedor para garantizar que PyTorch esté instalado correctamente:
{
"memory": {
"command": "python",
"args": [
"C:\\path\\to\\mcp-memory-service\\memory_wrapper.py"
],
"env": {
"MCP_MEMORY_CHROMA_PATH": "C:\\Users\\YourUsername\\AppData\\Local\\mcp-memory\\chroma_db",
"MCP_MEMORY_BACKUPS_PATH": "C:\\Users\\YourUsername\\AppData\\Local\\mcp-memory\\backups"
}
}
}El script contenedor hará lo siguiente:
Compruebe si PyTorch está instalado y configurado correctamente
Instale PyTorch con la URL de índice correcta si es necesario
Ejecute el servidor de memoria con la configuración adecuada
Guía de uso
Para obtener instrucciones detalladas sobre cómo interactuar con el servicio de memoria en Claude Desktop:
Guía de invocación : aprenda las palabras clave y frases específicas que activan las operaciones de memoria en Claude
Guía de instalación : instrucciones de configuración detalladas
El servicio de memoria se invoca mediante comandos de lenguaje natural en tus conversaciones con Claude. Por ejemplo:
Para guardar: "Por favor, recuerde que la fecha límite de mi proyecto es el 15 de mayo".
Para recuperar: "¿Recuerdas lo que te dije sobre la fecha límite de mi proyecto?"
Para borrar: "Por favor olvida lo que te dije sobre mi dirección".
Consulte la Guía de invocación para obtener una lista completa de comandos y ejemplos de uso detallados.
Operaciones de memoria
El servicio de memoria proporciona las siguientes operaciones a través del servidor MCP:
Operaciones de memoria central
store_memory- Almacena nueva información con etiquetas opcionalesretrieve_memory- Realizar una búsqueda semántica de recuerdos relevantesrecall_memory- Recupera recuerdos usando expresiones de tiempo en lenguaje naturalsearch_by_tag- Encuentra recuerdos usando etiquetas específicasexact_match_retrieve- Encuentra recuerdos con coincidencia exacta de contenidodebug_retrieve- Recupera memorias con puntuaciones de similitud
Gestión de bases de datos
create_backup- Crear copia de seguridad de la base de datosget_stats- Obtener estadísticas de memoriaoptimize_db- Optimizar el rendimiento de la base de datoscheck_database_health- Obtener métricas de salud de la base de datoscheck_embedding_model- Verificar el estado del modelo
Gestión de la memoria
delete_memory- Eliminar memoria específica por hashdelete_by_tag- Elimina todos los recuerdos con una etiqueta específicacleanup_duplicates- Eliminar entradas duplicadas
Opciones de configuración
Configurar a través de variables de entorno:
CHROMA_DB_PATH: Path to ChromaDB storage
BACKUP_PATH: Path for backups
AUTO_BACKUP_INTERVAL: Backup interval in hours (default: 24)
MAX_MEMORIES_BEFORE_OPTIMIZE: Threshold for auto-optimization (default: 10000)
SIMILARITY_THRESHOLD: Default similarity threshold (default: 0.7)
MAX_RESULTS_PER_QUERY: Maximum results per query (default: 10)
BACKUP_RETENTION_DAYS: Number of days to keep backups (default: 7)
LOG_LEVEL: Logging level (default: INFO)
# Hardware-specific environment variables
PYTORCH_ENABLE_MPS_FALLBACK: Enable MPS fallback for Apple Silicon (default: 1)
MCP_MEMORY_USE_ONNX: Use ONNX Runtime for CPU-only deployments (default: 0)
MCP_MEMORY_USE_DIRECTML: Use DirectML for Windows acceleration (default: 0)
MCP_MEMORY_MODEL_NAME: Override the default embedding model
MCP_MEMORY_BATCH_SIZE: Override the default batch sizeCompatibilidad de hardware
Plataforma | Arquitectura | Acelerador | Estado |
macOS | Silicona de Apple (M1/M2/M3) | MPS | ✅ Totalmente compatible |
macOS | Apple Silicon bajo Rosetta 2 | UPC | ✅ Compatible con alternativas |
macOS | Intel | UPC | ✅ Totalmente compatible |
Ventanas | x86_64 | CUDA | ✅ Totalmente compatible |
Ventanas | x86_64 | DirectML | ✅ Compatible |
Ventanas | x86_64 | UPC | ✅ Compatible con alternativas |
Linux | x86_64 | CUDA | ✅ Totalmente compatible |
Linux | x86_64 | ROCm | ✅ Compatible |
Linux | x86_64 | UPC | ✅ Compatible con alternativas |
Linux | ARM64 | UPC | ✅ Compatible con alternativas |
Pruebas
# Install test dependencies
pip install pytest pytest-asyncio
# Run all tests
pytest tests/
# Run specific test categories
pytest tests/test_memory_ops.py
pytest tests/test_semantic_search.py
pytest tests/test_database.py
# Verify environment compatibility
python scripts/verify_environment_enhanced.py
# Verify PyTorch installation on Windows
python scripts/verify_pytorch_windows.py
# Perform comprehensive installation verification
python scripts/test_installation.pySolución de problemas
Consulte la Guía de instalación para obtener pasos detallados para la solución de problemas.
Consejos rápidos para la solución de problemas
Errores de PyTorch de Windows : utilice
python scripts/install_windows.pyConflictos de dependencia de Intel en macOS : use
python install.py --force-compatible-depsErrores de recursión : Ejecute
python scripts/fix_sitecustomize.pyVerificación del entorno : ejecutar
python scripts/verify_environment_enhanced.pyProblemas de memoria : establezca
MCP_MEMORY_BATCH_SIZE=4y pruebe un modelo más pequeñoApple Silicon : asegúrese de que Python 3.10+ esté creado para ARM64, configure
PYTORCH_ENABLE_MPS_FALLBACK=1Prueba de instalación : ejecute
python scripts/test_installation.py
Estructura del proyecto
mcp-memory-service/
├── src/mcp_memory_service/ # Core package code
│ ├── __init__.py
│ ├── config.py # Configuration utilities
│ ├── models/ # Data models
│ ├── storage/ # Storage implementations
│ ├── utils/ # Utility functions
│ └── server.py # Main MCP server
├── scripts/ # Helper scripts
├── memory_wrapper.py # Windows wrapper script
├── install.py # Enhanced installation script
└── tests/ # Test suiteDirectrices de desarrollo
Python 3.10+ con sugerencias de tipos
Utilice clases de datos para modelos
Documentstrings entre comillas triples para módulos y funciones
Patrón asíncrono/en espera para todas las operaciones de E/S
Siga las pautas de estilo de PEP 8
Incluir pruebas para nuevas funciones
Licencia
Licencia MIT: consulte el archivo de LICENCIA para obtener más detalles
Expresiones de gratitud
Equipo de ChromaDB para la base de datos vectorial
Proyecto Transformadores de Sentencias para incrustar modelos
Proyecto MCP para la especificación del protocolo
Contacto
Integraciones
El servicio de memoria MCP se puede ampliar con diversas herramientas y utilidades. Consulte Integraciones para ver una lista de las opciones disponibles, entre ellas:
Panel de memoria MCP : interfaz web para explorar y administrar memorias
Contexto de memoria de Claude : Inyectar contexto de memoria en las instrucciones del proyecto Claude
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