Memory MCP — Casos de uso, Instalar & Demo en vivo

Por qué usarlo

Características clave

Modelo simple de entidad-relación-observación: fácil de entender
Archivo JSON local: inspecciona, haz diff o respalda con git
Sin servicio externo: cero costo, cero latencia, cero riesgo de privacidad
Persiste entre sesiones, clientes e intercambios de modelos
Implementación de referencia oficial del equipo de MCP

Demo en vivo

Cómo se ve en la práctica

memory.replay ▶ listo

0/0

Instalar

Elige tu cliente

~/Library/Application Support/Claude/claude_desktop_config.json · Windows: %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "memory": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-memory"
      ]
    }
  }
}

Abre Claude Desktop → Settings → Developer → Edit Config. Reinicia después de guardar.

~/.cursor/mcp.json · .cursor/mcp.json

{
  "mcpServers": {
    "memory": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-memory"
      ]
    }
  }
}

Cursor usa el mismo esquema mcpServers que Claude Desktop. La configuración del proyecto prevalece sobre la global.

VS Code → Cline → MCP Servers → Edit

{
  "mcpServers": {
    "memory": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-memory"
      ]
    }
  }
}

Haz clic en el icono MCP Servers de la barra lateral de Cline y luego en "Edit Configuration".

~/.codeium/windsurf/mcp_config.json

{
  "mcpServers": {
    "memory": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-memory"
      ]
    }
  }
}

Mismo formato que Claude Desktop. Reinicia Windsurf para aplicar.

~/.continue/config.json

{
  "mcpServers": [
    {
      "name": "memory",
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-memory"
      ]
    }
  ]
}

Continue usa un array de objetos de servidor en lugar de un mapa.

~/.config/zed/settings.json

{
  "context_servers": {
    "memory": {
      "command": {
        "path": "npx",
        "args": [
          "-y",
          "@modelcontextprotocol/server-memory"
        ]
      }
    }
  }
}

Añádelo a context_servers. Zed recarga en caliente al guardar.

claude mcp add memory -- npx -y @modelcontextprotocol/server-memory

Un solo comando. Verifica con claude mcp list. Quita con claude mcp remove.

Casos de uso

Usos del mundo real: Memory

Cómo dejar de re-explicar tu proyecto a Claude cada mañana

👤 Devs en solitario y usuarios avanzados que hablan con Claude a diario sobre el mismo repositorio ⏱ ~15 min beginner

Cuándo usarlo: Repites el mismo párrafo de contexto: 'nuestra pila es X, la BD de prod es Y, no usamos Z', al inicio de cada sesión.

Requisitos previos

Memory MCP ejecutándose con una ruta de archivo persistente — Establece MEMORY_FILE_PATH=/Users/you/.claude/memory.json para que el grafo persista entre reinicios

Flujo

Siembra el grafo con hechos básicos

Crea entidades para: mi empresa (Acme), nuestro repositorio principal (acme-corp/api) y nuestra BD de producción (api-prod-01). Añade observaciones como 'usa Postgres 16', 'alojada en AWS RDS us-east-1', 'ventana de respaldo es 03:00 UTC'. Conéctalas con relaciones.✓ Copiado

→ Entidades y relaciones creadas, visibles vía read_graph
Añade observaciones de preferencias mientras avanzas

Recuerda: cuando te pida escribir mensajes de commit para este repositorio, usa modo imperativo sin etiquetas de prefijo. Almacena esto como una observación en la entidad 'acme-corp/api'.✓ Copiado

→ Observación añadida sin recrear la entidad
Prueba el recuerdo en una nueva sesión

¿Qué sabes sobre api-prod-01?✓ Copiado

→ Claude consulta el grafo y presenta los hechos, no una respuesta genérica

Resultado: Un grafo de conocimiento personal que se vuelve más inteligente cada conversación: cuanto más uses Claude, menos código repetitivo escribes.

Errores comunes

Claude no usa la memoria automáticamente; se olvida de consultarla — Añade 'Siempre consulta el grafo de memory al inicio de cada tarea sobre este proyecto' a tu prompt de sistema/proyecto
El grafo se vuelve desorganizado: entidades duplicadas con variaciones de nombre — Elige una convención de nombres (kebab-case) y periódicamente pide a Claude que read_graph y deduplique

Combinar con: filesystem · github

Construye un CRM ligero de las preferencias de tus compañeros

👤 ICs y líderes que trabajan con muchas partes interesadas ⏱ ~10 min beginner

Cuándo usarlo: Olvidas quién prefiere Slack vs email, quién quiere puntos vs prosa, quién está en qué proyecto.

Flujo

Crea una entidad persona en la primera interacción

Crea una entidad Person 'jamie-chen'. Observaciones: 'PM en el equipo de checkout', 'prefiere Loom sobre documentos', 'las revisiones ocurren las mañanas de mar/jue PT'.✓ Copiado

→ Entidad visible vía open_nodes
Vincula personas a proyectos con relaciones

Añade relación: jamie-chen --owns--> checkout-redesign-2026. Y: alex-kim --reviews--> checkout-redesign-2026.✓ Copiado

→ Las relaciones aparecen en el grafo
Consulta antes de escribirles algo

Estoy a punto de redactar una actualización para Jamie sobre el rediseño del checkout. ¿Qué sé sobre sus preferencias de comunicación y el proyecto?✓ Copiado

→ Devuelve preferencias almacenadas, informa el tono del borrador

Resultado: Dejas de preguntar '¿quién era ese PM de nuevo?' y tus actualizaciones asincrónicas aciertan el tono a la primera.

Errores comunes

Almacenar información sensible/personal sobre compañeros reales se siente extraño y podría filtrarse — Solo almacena observaciones de preferencias de trabajo; nunca detalles personales. Trata el archivo como sensible: se sincroniza con lo que respaldes

Combinar con: linear · github

Mantén un rastro de investigación entre muchas sesiones

👤 Investigadores, escritores, cualquiera investigando un tema durante semanas ⏱ ~20 min intermediate

Cuándo usarlo: Estás investigando un tema (estudio de mercado, revisión de literatura, investigación) que abarca muchas sesiones y fuentes.

Flujo

Captura cada hallazgo como una observación en una entidad temática

Estoy investigando 'adopción de MCP en empresas'. Crea eso como una entidad. Ahora añade este hallazgo como una observación: 'Anthropic reporta que el 60% de los clientes de Claude Code usan 3+ MCPs (fuente: blog 2026-03-12)'.✓ Copiado

→ La entidad temática crece incrementalmente con observaciones citadas
Vincula temas relacionados

Crea entidad 'preocupaciones de seguridad de MCP'. Relacionala con 'adopción de MCP en empresas' con relación 'blocks-adoption-when-unaddressed'.✓ Copiado

→ El grafo muestra la conexión semántica
Pide síntesis en cualquier momento

Basándote en todas las observaciones conectadas a 'adopción de MCP en empresas', redacta un resumen de 1 página con citas.✓ Copiado

→ Síntesis con fuentes por afirmación, nada fabricado

Resultado: Un activo de investigación citable e incremental que no depende de acrobacias de ventana de contexto.

Errores comunes

Las observaciones almacenadas sin fuentes son indistinguibles de confabulación del modelo después — Requiere que cada observación incluya una fuente en el texto ('source: X, date: Y'); rechaza las que no la tienen

Combinar con: firecrawl · exa-search · fetch

Combinaciones

Combínalo con otros MCPs para multiplicar por 10

memory + filesystem

Carga documentos de investigación de forma larga, extrae hechos y almacénalos en memory para síntesis posterior

Lee cada archivo .md bajo /research/. Para cada afirmación clave, añádela como una observación en la entidad temática relevante en memory. Incluye el nombre de archivo como fuente.✓ Copiado

memory + github

Recuerda convenciones específicas del repositorio para que futuras revisiones de PR las apliquen sin re-explicación

A partir de los últimos 10 PRs fusionados en acme/api, extrae convenciones de tono, longitud y título. Almacena como observaciones en la entidad 'acme/api'.✓ Copiado

memory + sequential-thinking

Permite que sesiones de razonamiento largo persistan sus hallazgos de scratchpad entre conversaciones

Ejecuta una sesión sequential-thinking para planificar nuestra migración. Al final, escribe las conclusiones como observaciones en la entidad 'db-migration-q2'.✓ Copiado

Herramientas

Lo que expone este MCP

Herramienta	Entradas	Cuándo llamar	Coste
create_entities	entities: [{name, entityType, observations[]}]	Introduce una nueva entidad (persona, proyecto, sistema, concepto)	free
create_relations	relations: [{from, to, relationType}]	Conecta dos entidades existentes con un borde tipado	free
add_observations	observations: [{entityName, contents[]}]	Añade hechos a una entidad existente (operación más común)	free
delete_entities	entityNames: str[]	Elimina entidades obsoletas (también elimina sus relaciones)	free
delete_observations	deletions: [{entityName, observations[]}]	Elimina hechos específicos que resultaron ser incorrectos	free
delete_relations	relations: [...]	Elimina bordes sin eliminar entidades	free
read_graph	ninguno	Vuelca el grafo completo: úsalo con moderación una vez que crece	free
search_nodes	query: str	Encuentra entidades por palabra clave en nombres/tipos/observaciones	free
open_nodes	names: str[]	Extrae entidades específicas por nombre exacto	free

Coste y límites

Lo que cuesta ejecutarlo

Cuota de API: Ilimitado: JSON local
Tokens por llamada: Pequeño: operaciones de grafo devuelven solo nodos cambiados por defecto
Monetario: Gratuito
Consejo: Prefiere search_nodes y open_nodes sobre read_graph una vez que tengas >50 entidades, o pagarás por cargar el grafo entero cada turno.

Seguridad

Permisos, secretos, alcance

Almacenamiento de credenciales: Sin credenciales. El archivo de grafo es lo que apunta MEMORY_FILE_PATH.

Salida de datos: Ninguno del servidor. Las observaciones se envían a tu proveedor de LLM como contexto cuando Claude las lee.

El archivo de memory es JSON plano: no almacenes secretos, claves API ni nada que no pondrías en un archivo de texto.
Si sincronizas el archivo entre dispositivos (Dropbox/iCloud), recuerda que es parte de tu superficie de ataque.

Resolución de problemas

Errores comunes y soluciones

Memory no persiste entre reinicios

Establece la variable de entorno MEMORY_FILE_PATH a una ruta absoluta como /Users/you/.claude/memory.json. Sin ella, el servidor usa una ruta temporal.

Verificar:

Verifica tu configuración del cliente MCP para variables de entorno; después del reinicio, llama a `read_graph` y verifica que las entidades antiguas se devuelven

Claude nunca consulta memory por su cuenta

El servidor expone herramientas; el modelo todavía necesita indicaciones. Añade una instrucción a nivel de proyecto como 'Antes de responder preguntas sobre <project>, llama a search_nodes para contexto relevante.'

Entidades duplicadas como 'Jamie' y 'jamie-chen'

Adopta una convención de nombres (kebab-case o nombre completo). Ejecuta periódicamente read_graph y delete_entities en duplicados después de add_observations para fusionar hechos.

Relación falla con 'entity not found'

Ambas entidades de extremo deben existir primero. Crealas con create_entities antes de create_relations.

Alternativas

Memory vs otros

Alternativa	Cuándo usarla	Contrapartida
Qdrant MCP	Necesitas búsqueda semántica sobre miles de notas, no un grafo curado manualmente	Requiere ejecutar Qdrant; excelente para recuerdo difuso, peor para hechos estructurados explícitos
Notion MCP	Tu 'memory' es realmente una base de conocimiento compartida del equipo	Ligado a la red, más lento, necesita clave API, pero los humanos también pueden leer/editarlo
Neo4j MCP	Estás construyendo un grafo de conocimiento serio con consultas complejas	Más pesado: necesita una base de datos; excesivo para memory personal

Más

Recursos

📖 Lee el README oficial en GitHub

🐙 Ver issues abiertas

🔍 Ver todos los 400+ servidores MCP y Skills