Memanto MCP

MEMANTO es un agente de memoria. Recuerda, recupera y responde, para que tus agentes puedan alcanzar objetivos a largo plazo y evitar confusiones.

GitHub

1.8k

Prueba este MCPPatrocinado

Documentación

Servidor Memanto MCP

Memoria semántica persistente para cualquier agente compatible con MCP.

Este paquete expone las primitivas de memoria de Memanto — remember, recall, answer y similares — como herramientas del Protocolo de Contexto de Modelo (MCP) para que cualquier cliente MCP (Claude Desktop, Cursor, Windsurf, Cline, Continue, Goose, agentes personalizados, …) pueda conectarse a memoria a largo plazo con una sola línea de configuración.

Una clave API de Moorcheh → memoria semántica tipada en cada agente que comparte el espacio de nombres, con recuperación en menos de 90 ms, detección de conflictos y latencia de ingesta cero.

Instalación

pip install memanto-mcp

Requiere Python 3.10+, memanto>=0.2.13, mcp>=1.2,<2 y una clave API de Moorcheh (nivel gratuito: 100K operaciones/mes).

Inicio rápido (Claude Desktop)

Obtén una clave API de Moorcheh desde la consola.
Edita claude_desktop_config.json (Configuración → Desarrollador → Editar configuración):

{
  "mcpServers": {
    "memanto": {
      "command": "memanto-mcp",
      "env": {
        "MOORCHEH_API_KEY": "mch_xxxxxxxxxxxxxxxxxx",
        "MEMANTO_DEFAULT_AGENT_ID": "my-assistant"
      }
    }
  }
}

Reinicia Claude Desktop. Pídele que "recuerde que prefiero respuestas concisas" — y luego, en un chat completamente nuevo mañana, pregúntale "¿qué prefiero?".

La primera llamada crea automáticamente el agente y el espacio de nombres my-assistant; cada llamada posterior reutiliza la misma memoria persistente.

Inicio rápido (Cursor / Windsurf / Cline / Continue / Goose)

La mayoría de los clientes consumen un archivo de configuración con el formato MCP estándar. El mismo fragmento JSON funciona casi sin cambios:

{
  "mcpServers": {
    "memanto": {
      "command": "memanto-mcp",
      "env": {
        "MOORCHEH_API_KEY": "mch_xxxxxxxxxxxxxxxxxx",
        "MEMANTO_DEFAULT_AGENT_ID": "cursor-workspace"
      }
    }
  }
}

Cliente	Ruta de configuración
Claude Desktop	`~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) / `%APPDATA%\Claude\claude_desktop_config.json` (Windows)
Cursor	`~/.cursor/mcp.json` (o `.cursor/mcp.json` por proyecto)
Windsurf	`~/.codeium/windsurf/mcp_config.json`
Cline (VS Code)	`~/.config/Code/User/globalStorage/cline.cline/settings/cline_mcp_settings.json`
Continue	`~/.continue/config.json` → `experimental.modelContextProtocolServers`
Goose	`~/.config/goose/config.yaml`

Herramientas disponibles

El servidor registra 7 herramientas de memoria de forma predeterminada. Configura MEMANTO_EXPOSE_ADMIN=true para exponer también 4 herramientas de gestión de agentes.

Herramientas de memoria (siempre activas)

Herramienta	Cuándo debe llamarla el agente
`remember`	Persistir un único hecho/preferencia/decisión/objetivo/instrucción nuevo.
`batch_remember`	Persistir hasta 100 memorias en una sola llamada (p. ej., extraídas de un documento).
`recall`	Búsqueda semántica — siempre consulta aquí antes de pedirle al usuario que repita información estable.
`recall_recent`	"¿Qué acabamos de decidir?" — de más reciente a más antiguo, sin necesidad de consulta.
`recall_as_of`	Recuerdo puntual — "¿qué sabíamos el 2025-11-01?"
`recall_changed_since`	Diferencial — "¿qué hay de nuevo desde la última vez que revisé?"
`answer`	RAG: respuesta fundamentada generada por LLM a partir de las memorias del agente.

Herramientas de administración de agentes (optativas)

Habilitadas cuando MEMANTO_EXPOSE_ADMIN=true:

Herramienta	Propósito
`create_agent`	Crear un nuevo espacio de nombres de memoria.
`list_agents`	Listar cada agente que la clave API puede ver.
`get_agent`	Consultar los metadatos de un agente.
`delete_agent`	Eliminar los metadatos locales de un agente.

Tipos de memoria aceptados por remember / batch_remember: fact, preference, goal, decision, artifact, learning, event, instruction, relationship, context, observation, commitment, error.

Valores de procedencia: explicit_statement, inferred, corrected, validated, observed, imported.

Atribución de fuente

source indica quién escribió una memoria, de modo que el recuerdo pueda atribuirse y filtrarse por escritor. Es abierto: user, agent, tool, system o un escritor específico como cursor, codex, claude_code, mem0. Las etiquetas se limitan a 64 letras, dígitos, ., _ o - para que #source:<value> siga siendo un filtro utilizable.

Cuando una llamada a herramienta omite source, el servidor atribuye la escritura al cliente MCP conectado desde el protocolo de inicio (cursor, codex, claude-ai, …), con respaldo a mcp-agent cuando el cliente no envía ningún nombre. Dos editores que comparten un agente siguen siendo distinguibles en el recuerdo sin configuración adicional.

Configuración

Toda la configuración se realiza mediante variables de entorno (orden de carga: entorno del proceso → archivo .env en el directorio de trabajo).

Variable	Obligatoria	Predeterminada	Descripción
`MOORCHEH_API_KEY`	sí	—	Clave API de Moorcheh.
`MEMANTO_DEFAULT_AGENT_ID`	recomendada	ninguna	Agente predeterminado. Cuando se configura, las llamadas a herramientas pueden omitir `agent_id`.
`MEMANTO_AGENT_PATTERN`	no	`tool`	Patrón (`support`/`project`/`tool`) utilizado al crear automáticamente el agente predeterminado.
`MEMANTO_AGENT_AUTO_CREATE`	no	`true`	Crear el agente predeterminado en el primer uso si falta. Los agentes explícitos no predeterminados deben existir previamente.
`MEMANTO_SESSION_DURATION_HOURS`	no	predeterminado del servidor (6)	Vida útil de la sesión en horas.
`MEMANTO_EXPOSE_ADMIN`	no	`false`	Registrar las 4 herramientas de gestión de agentes.
`MEMANTO_MCP_TRANSPORT`	no	`stdio`	`stdio`, `sse` o `streamable-http`.
`MEMANTO_MCP_HOST`	no	`127.0.0.1`	Host de enlace para transportes sse/http.
`MEMANTO_MCP_PORT`	no	`8765`	Puerto de enlace para transportes sse/http.
`MEMANTO_MCP_LOG_LEVEL`	no	`INFO`	Nivel de registro (los registros siempre se envían a stderr).

Las banderas de CLI (memanto-mcp --transport sse --port 9000) anulan las variables de entorno.

Ejecución sobre HTTP / SSE

Para clientes remotos o configuraciones multiproceso, ejecuta el servidor sobre un transporte de red:

# Streamable HTTP (recommended modern transport)
memanto-mcp --transport streamable-http --host 0.0.0.0 --port 8765

# Server-Sent Events (older, still widely supported)
memanto-mcp --transport sse --host 0.0.0.0 --port 8765

Luego apunta tu cliente a http://your-host:8765/mcp (o la ruta que anuncie el transporte elegido). Combínalo con un proxy inverso + autenticación para implementaciones de producción: el servidor en sí autentica la conexión ascendente hacia Moorcheh usando tu clave API, pero no autentica a los clientes MCP entrantes.

Cómo funciona

┌──────────────┐    MCP/stdio    ┌──────────────────┐    Moorcheh API    ┌─────────────┐
│ Claude / IDE │ ──────────────► │  memanto-mcp     │ ────────────────► │   Moorcheh  │
│   (client)   │ ◄────────────── │  (this package)  │ ◄──────────────── │   Service   │
└──────────────┘    tool calls   └──────────────────┘    HTTPS+API key   └─────────────┘
                                          │
                                          └─ uses memanto.cli.client.SdkClient
                                             (same client the Memanto CLI uses)

Al iniciar, se validan los ajustes; la clave API se verifica de forma diferida en la primera llamada a una herramienta.
En la primera invocación de una herramienta de memoria para un agente determinado, el servidor garantiza que el agente exista (lo crea automáticamente si es necesario) y activa una sesión JWT. Las sesiones se renuevan automáticamente antes de expirar, por lo que las conexiones MCP de larga duración nunca encuentran un error de sesión expirada a mitad de conversación.
El servidor mantiene intencionalmente la sesión activa al apagarse: las sesiones JWT están limitadas por TTL y otros clientes de Memanto (CLI, REST) pueden querer compartirlas.

Inserción programática

Si estás construyendo un host MCP personalizado o conectando este servidor a un proceso más grande, puedes construir la instancia de FastMCP tú mismo:

from memanto_mcp import MCPServerSettings, build_server

settings = MCPServerSettings()  # reads env / .env
mcp = build_server(settings)

# Add your own tools alongside Memanto's, then run.
mcp.run(transport="stdio")

Solución de problemas

Síntoma	Solución
`configuration error: MOORCHEH_API_KEY is required`	Configura la variable de entorno en el bloque `env` de la configuración de tu cliente MCP.
`Agent '…' does not exist and MEMANTO_AGENT_AUTO_CREATE is disabled`	Vuelve a habilitar la creación automática o llama a `create_agent` (herramientas de administración) / `memanto agent create <id>` una vez.
Las herramientas nunca aparecen en el cliente	Confirma que el cliente sea compatible con MCP y que la ruta de configuración coincida. Revisa el registro MCP del cliente: las líneas de stderr del servidor (con prefijo `memanto_mcp`) aparecerán allí al iniciar.
Salida distorsionada en modo stdio	Algo de tu lado está escribiendo en stdout — ese canal está reservado para JSON-RPC. Mueve los registros a stderr. El servidor en sí solo escribe en stderr.
Primera llamada lenta	Costo de arranque en frío: importación del SDK + primera activación de sesión. Las llamadas posteriores reutilizan la sesión activa.

Licencia

MIT — igual que el proyecto Memanto. Consulta LICENCIA.

Enlaces

Memanto — el agente de memoria en sí
Moorcheh — la base de datos semántica sin indexación subyacente
Especificación del Protocolo de Contexto de Modelo
SDK de Python MCP de Anthropic