Skip to main content
Glama

Servicio de memoria MCP

Licencia: MIT insignia de herrería

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.py

El script install.py hará lo siguiente:

  1. Detecte la arquitectura de su sistema y los aceleradores de hardware disponibles

  2. Instale las dependencias adecuadas para su plataforma

  3. Configure los ajustes óptimos para su entorno

  4. 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-service

Proporcionamos múltiples configuraciones de Docker Compose para diferentes escenarios:

  • docker-compose.yml - Configuración estándar mediante pip install

  • docker-compose.uv.yml : configuración alternativa mediante el administrador de paquetes UV

  • docker-compose.pythonpath.yml : configuración con ajustes PYTHONPATH explícitos

Para utilizar una configuración alternativa:

docker-compose -f docker-compose.uv.yml up

Instalació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.py

Este script maneja:

  1. Detección de la disponibilidad y versión de CUDA

  2. Instalar la versión adecuada de PyTorch desde la URL de índice correcta

  3. Instalar otras dependencias sin entrar en conflicto con PyTorch

  4. 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 claude

Guí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:

  1. Compruebe si PyTorch está instalado y configurado correctamente

  2. Instale PyTorch con la URL de índice correcta si es necesario

  3. 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:

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

  1. store_memory - Almacena nueva información con etiquetas opcionales

  2. retrieve_memory - Realizar una búsqueda semántica de recuerdos relevantes

  3. recall_memory - Recupera recuerdos usando expresiones de tiempo en lenguaje natural

  4. search_by_tag - Encuentra recuerdos usando etiquetas específicas

  5. exact_match_retrieve - Encuentra recuerdos con coincidencia exacta de contenido

  6. debug_retrieve - Recupera memorias con puntuaciones de similitud

Gestión de bases de datos

  1. create_backup - Crear copia de seguridad de la base de datos

  2. get_stats - Obtener estadísticas de memoria

  3. optimize_db - Optimizar el rendimiento de la base de datos

  4. check_database_health - Obtener métricas de salud de la base de datos

  5. check_embedding_model - Verificar el estado del modelo

Gestión de la memoria

  1. delete_memory - Eliminar memoria específica por hash

  2. delete_by_tag - Elimina todos los recuerdos con una etiqueta específica

  3. cleanup_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 size

Compatibilidad 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.py

Solució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.py

  • Conflictos de dependencia de Intel en macOS : use python install.py --force-compatible-deps

  • Errores de recursión : Ejecute python scripts/fix_sitecustomize.py

  • Verificación del entorno : ejecutar python scripts/verify_environment_enhanced.py

  • Problemas de memoria : establezca MCP_MEMORY_BATCH_SIZE=4 y pruebe un modelo más pequeño

  • Apple Silicon : asegúrese de que Python 3.10+ esté creado para ARM64, configure PYTORCH_ENABLE_MPS_FALLBACK=1

  • Prueba 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 suite

Directrices 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

Telegrama

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:

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