Memstate AI - MCP

👁 npm version
👁 License: MIT
👁 MCP
👁 Node
👁 memstate-mcp MCP server

Memoria versionada para agentes de IA. Almacena hechos, detecta conflictos y realiza un seguimiento de cómo cambian las decisiones con el tiempo, expuesto como un servidor MCP alojado.

Panel de control · Documentación · Precios

¿Por qué Memstate?

Otros sistemas de memoria vuelcan todo en tu ventana de contexto y esperan lo mejor. Memstate le da a tu agente una base de conocimientos estructurada y versionada que navega con precisión: carga solo lo que necesitas, sabe qué cambió y sabe cuándo los hechos entran en conflicto.

Related MCP server: PolyNeural.ai Knowledge Graph MCP Bundle

Benchmarks

Creamos un conjunto de pruebas de referencia de código abierto que evalúa lo que realmente importa para la memoria de un agente: ¿puede tu sistema almacenar hechos, recordarlos con precisión entre sesiones, detectar conflictos cuando las cosas cambian y mantener el contexto a medida que un proyecto evoluciona?

Comparativa: Memstate AI vs Mem0

Ambos sistemas fueron probados bajo condiciones idénticas usando el mismo agente (Claude Sonnet 4.6, temperatura 0), los mismos escenarios y la misma rúbrica de puntuación.

Pesos de puntuación: Precisión 40%, Detección de conflictos 25%, Continuidad del contexto 25%, Eficiencia de tokens 10%.

Desglose por escenario

El benchmark ejecuta cinco escenarios del mundo real que simulan flujos de trabajo de agentes en múltiples sesiones:

Mem0 ganó el primer escenario (seguimiento simple de arquitectura), pero tuvo serias dificultades en escenarios que requerían manejo de contradicciones, contexto entre sesiones y seguimiento de reversión de decisiones, obteniendo una puntuación cercana a cero en tres de los cinco escenarios.

Por qué gana Memstate

El benchmark revela una diferencia arquitectónica fundamental:

Mem0 utiliza búsqueda semántica basada en embeddings. Los hechos se fragmentan, se convierten en embeddings y se recuperan por similitud. Esto funciona para búsquedas simples, pero falla cuando:

• Los hechos contradicen hechos anteriores (el sistema no puede distinguir lo actual de lo obsoleto)

• Se necesita una recuperación precisa (los embeddings devuelven resultados "similares", no exactos)

• La latencia de escritura a lectura importa (las nuevas memorias tardan segundos en ser buscables)

Memstate utiliza almacenamiento clave-valor estructurado y versionado. Cada hecho vive en una ruta de clave explícita con un historial de versiones completo. Esto significa:

• La detección de conflictos está integrada: cuando un nuevo hecho contradice uno antiguo, el sistema lo sabe y conserva ambas versiones

• La recuperación es determinista: obtienes exactamente lo que se almacenó, no una coincidencia aproximada

• La continuidad entre sesiones es fiable: el agente navega por un árbol estructurado en lugar de esperar que la búsqueda semántica muestre el contexto correcto

• El costo de tokens se mantiene en O(1): el agente carga resúmenes primero y profundiza en los detalles solo cuando es necesario, en lugar de volcar todos los embeddings potencialmente relevantes en la ventana de contexto

Notas sobre la imparcialidad

• Ambos sistemas utilizaron el mismo modelo de agente, temperatura y rúbrica de evaluación

• A Mem0 se le dio un retraso de ingesta de 10 segundos entre escrituras y lecturas para tener en cuenta su canalización de embedding asíncrona

• Mem0 obtiene una puntuación más alta en eficiencia de tokens, pero esta métrica debe leerse en contexto: un menor uso de tokens puede simplemente reflejar que se devuelve menos información. Un sistema que recupera hechos incompletos o incorrectos utiliza menos tokens por respuesta, pero puede requerir más llamadas de seguimiento, lo que en última instancia cuesta más tokens para llegar a la misma respuesta

• El código fuente del benchmark se incluye en este repositorio para una reproducibilidad total

• Mem0 puede funcionar de manera diferente con una configuración personalizada o un modelo de embedding diferente

Inicio rápido

Obtén tu clave API en memstate.ai/dashboard, luego agrégala a la configuración de tu cliente MCP:

{
 "mcpServers": {
 "memstate": {
 "command": "npx",
 "args": ["-y", "@memstate/mcp"],
 "env": {
 "MEMSTATE_API_KEY": "YOUR_API_KEY_HERE"
 }
 }
 }
}

Sin Docker. Sin base de datos. Sin infraestructura. Ejecutándose en 60 segundos.

Configuración del cliente

Claude Desktop

Ubicación de la configuración:

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

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

{
 "mcpServers": {
 "memstate": {
 "command": "npx",
 "args": ["-y", "@memstate/mcp"],
 "env": { "MEMSTATE_API_KEY": "YOUR_API_KEY_HERE" }
 }
 }
}

Claude Code

claude mcp add memstate npx @memstate/mcp -e MEMSTATE_API_KEY=YOUR_API_KEY_HERE

Cursor

En Configuración de Cursor → MCP → Agregar servidor: el mismo formato JSON que Claude Desktop arriba.

Cline / Windsurf / Kilo Code / Roo Code

Todos admiten el mismo formato de configuración MCP stdio. Agrégalo al archivo de configuración MCP de tu cliente.

Herramientas principales

Cómo funcionan las rutas de clave (keypaths)

Las memorias se organizan en notación de puntos jerárquica:

project.my_app.database.schema
project.my_app.auth.provider
project.my_app.deploy.environment

Las rutas de clave tienen prefijo automático: keypath="database" con project_id="my_app" → project.my_app.database. Tu agente puede profundizar exactamente en lo que necesita: sin volcados de contexto completo.

Cómo funciona

Agent: memstate_remember(project_id="my_app", content="## Auth\nUsing SuperTokens...")
 ↓
Server extracts keypaths: [project.my_app.auth.provider, ...]
 ↓
Conflict detection: compare against existing memories at those keypaths
 ↓
New version stored — old version preserved in history chain
 ↓
Next session: memstate_get(project_id="my_app") → structured summaries only
 ↓
Agent drills into project.my_app.auth only when it needs auth details

El costo de tokens se mantiene constante independientemente de cuántas memorias totales existan.

Agregar a las instrucciones de tu agente

Copia esto en tu AGENTS.md o prompt del sistema:

## Memory (Memstate MCP)

### Before each task
- memstate_get(project_id="my_project") — browse existing knowledge
- memstate_search(query="topic", project_id="my_project") — find by meaning

### After each task
- memstate_remember(project_id="my_project", content="## Summary\n- ...", source="agent")

### Tool guide
- memstate_remember — markdown summaries, decisions, task results (preferred)
- memstate_set — single short values only (config flags, status)
- memstate_get — browse/retrieve before tasks
- memstate_search — semantic lookup when keypath unknown
- memstate_history — audit how knowledge evolved
- memstate_delete — remove outdated memories (history preserved)

Variables de entorno

Verifica tu conexión

MEMSTATE_API_KEY=your_key npx @memstate/mcp --test

Imprime todas las herramientas disponibles y confirma que tu clave API funciona.

Creado para agentes de IA que merecen saber lo que saben.

Maintenance

Resources

• NPM Package
• GitHub Repository
Need Help?Related Servers

Tools

• memstate_deleteA
• memstate_delete_projectA
• memstate_getA
• memstate_historyA
• memstate_rememberA
• memstate_searchA
• memstate_setA