Memanto MCP
Memanto MCP gives any MCP-compatible agent persistent, typed semantic memory through 7 always-on memory tools (plus 4 opt-in admin tools).
Store memories with
remember(single, atomic, up to 10k chars) orbatch_remember(up to 100 at once), each typed (fact, preference, goal, decision, artifact, learning, event, instruction, relationship, context, observation, commitment, error) with confidence and provenance.Semantic search with
recall— natural-language query, optional type filter, similarity threshold, and top-N (1–100) results.Temporal recall:
recall_recent(newest first, no query),recall_as_of(point-in-time, e.g. "what did we know on 2025-11-01?"), andrecall_changed_since(differential, "what's new since X?").Grounded Q&A with
answer— RAG-synthesized answers over stored memories, with sources, temperature, and optional kiosk mode that refuses to answer when nothing clears the threshold.Attribute writes via
source(user/agent/tool/system or client such as cursor, codex, claude_code), defaulting to the connected MCP client.Manage agents (opt-in) when
MEMANTO_EXPOSE_ADMIN=true:create_agent,list_agents,get_agent,delete_agent.Run locally or remotely: stdio by default, or sse / streamable-http transports with configurable host/port (127.0.0.1:8765).
Persist across sessions and clients via a shared Moorcheh namespace, with auto-created default agent, JWT sessions that auto-renew, and sub-90 ms retrieval.
Provides persistent semantic memory for Windsurf (a Codeium product), enabling long-term memory for the AI coding assistant within the IDE.
Memanto MCP Server
mcp-name: io.github.moorcheh-ai/memanto
Persistent semantic memory for any MCP-compatible agent.
This package exposes Memanto's memory primitives —
remember, recall, answer, and friends — as
Model Context Protocol (MCP) tools so any
MCP client (Claude Desktop, Cursor, Windsurf, Cline, Continue, Goose,
custom agents, …) can plug into long-term memory in a single config line.
One Moorcheh API key → typed semantic memory across every agent that shares the namespace, with sub-90 ms retrieval, conflict detection, and zero ingestion latency.
Install
pip install memanto-mcpRequires Python 3.10+, memanto>=0.2.13, mcp>=1.2,<2, and a
Moorcheh API key
(free tier: 100K ops/month).
Related MCP server: Mem0 Memory MCP Server
Quick start (Claude Desktop)
Get a Moorcheh API key from the console.
Edit
claude_desktop_config.json(Settings → Developer → Edit Config):
{
"mcpServers": {
"memanto": {
"command": "memanto-mcp",
"env": {
"MOORCHEH_API_KEY": "mch_xxxxxxxxxxxxxxxxxx",
"MEMANTO_DEFAULT_AGENT_ID": "my-assistant"
}
}
}
}Restart Claude Desktop. Ask it to "remember that I prefer concise answers" — then in a brand-new chat tomorrow ask "what do I prefer?".
The first call auto-creates the my-assistant agent and namespace; every
subsequent call reuses the same persistent memory.
Quick start (Cursor / Windsurf / Cline / Continue / Goose)
Most clients consume a config file in the standard MCP shape. The same JSON snippet works almost verbatim:
{
"mcpServers": {
"memanto": {
"command": "memanto-mcp",
"env": {
"MOORCHEH_API_KEY": "mch_xxxxxxxxxxxxxxxxxx",
"MEMANTO_DEFAULT_AGENT_ID": "cursor-workspace"
}
}
}
}Client | Config path |
Claude Desktop |
|
Cursor |
|
Windsurf |
|
Cline (VS Code) |
|
Continue |
|
Goose |
|
Available tools
The server registers 7 memory tools by default. Set
MEMANTO_EXPOSE_ADMIN=true to also expose 4 agent-management tools.
Memory tools (always on)
Tool | When the agent should call it |
| Persist a single new fact/preference/decision/goal/instruction. |
| Persist up to 100 memories in one call (e.g. extracted from a document). |
| Semantic search — always check here before asking the user to repeat stable info. |
| "What did we just decide?" — newest-first, no query needed. |
| Point-in-time recall — "what did we know on 2025-11-01?" |
| Differential — "what's new since I last checked?" |
| RAG: grounded LLM answer synthesized over the agent's memories. |
Agent admin tools (opt-in)
Enabled when MEMANTO_EXPOSE_ADMIN=true:
Tool | Purpose |
| Create a new memory namespace. |
| List every agent the API key can see. |
| Look up an agent's metadata. |
| Remove an agent's local metadata. |
Memory types accepted by remember / batch_remember:
fact, preference, goal, decision, artifact, learning, event,
instruction, relationship, context, observation, commitment,
error.
Provenance values: explicit_statement, inferred, corrected,
validated, observed, imported.
Source attribution
source names who wrote a memory, so recall can be attributed and filtered
per writer. It is open: user, agent, tool, system, or a specific
writer such as cursor, codex, claude_code, mem0. Labels are limited to
64 letters, digits, ., _, or - so that #source:<value> stays a usable
filter.
When a tool call omits source, the server attributes the write to the
connected MCP client from the initialize handshake (cursor, codex,
claude-ai, …), falling back to mcp-agent when the client sends no name.
Two editors sharing one agent therefore stay distinguishable in recall without
any extra configuration.
Configuration
All config is via environment variables (load order: process env →
.env file in the working directory).
Variable | Required | Default | Description |
| yes | — | Moorcheh API key. |
| recommended | none | Default agent. When set, tool calls may omit |
| no |
| Pattern ( |
| no |
| Create the default agent on first use if missing. Explicit non-default agents must already exist. |
| no | server default (6) | Session lifetime in hours. |
| no |
| Register the 4 agent-management tools. |
| no |
|
|
| no |
| Bind host for sse/http transports. |
| no |
| Bind port for sse/http transports. |
| no |
| Log level (logs are always sent to stderr). |
CLI flags (memanto-mcp --transport sse --port 9000) override env vars.
Running over HTTP / SSE
For remote clients or multi-process setups, run the server over a network transport:
# 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 8765Then point your client at http://your-host:8765/mcp (or whatever path the
chosen transport advertises). Pair with a reverse proxy + auth for
production deployments — the server itself authenticates upstream to
Moorcheh using your API key but does not authenticate inbound MCP
clients.
How it works
┌──────────────┐ 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)On startup, settings are validated; the API key is verified lazily on first tool call.
On the first memory tool invocation for a given agent, the server ensures the agent exists (auto-creates if needed) and activates a JWT session. Sessions auto-renew before expiry, so long-running MCP connections never hit a session-expired error mid-conversation.
The server intentionally keeps the session alive on shutdown: JWT sessions are TTL-bound and other Memanto clients (CLI, REST) may want to share them.
Programmatic embedding
If you're building a custom MCP host or wiring this server into a larger process, you can construct the FastMCP instance yourself:
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")Troubleshooting
Symptom | Fix |
| Set the env var in your MCP client config's |
| Either re-enable auto-create or call |
Tools never appear in the client | Confirm the client supports MCP and the config path matches. Look at the client's MCP log: the server's stderr lines (prefixed |
Garbled output in stdio mode | Something on your side is writing to stdout — that channel is reserved for JSON-RPC. Move logs to stderr. The server itself only writes to stderr. |
Slow first call | Cold-start cost: SDK import + first session activation. Subsequent calls reuse the live session. |
License
MIT — same as the Memanto project. See LICENSE.
Links
Available Tools
7 toolsanswerA
Ask a natural-language question and get an LLM-generated answer grounded ONLY in the agent's stored memories (RAG). Prefer this over recall when you need a synthesized answer rather than a ranked list. Returns the answer text plus the supporting memory sources.
Inputs: question (required), limit, agent_id, kiosk_mode, +1 more. Returns: Outcome of a RAG ``answer`` call.
batch_rememberA
Store many memories at once (up to 100). Use this when you have a list of independent facts to persist - e.g. extracting structured data from a document. For a single item, prefer remember.
Inputs: memories (required), agent_id. Returns: Response returned by the batch_remember MCP tool.
recallA
Search the agent's memories by semantic similarity. Returns the top-N most relevant items. Use this FIRST before asking the user to repeat information - the agent may already remember it. The query should be natural language ('what does the user prefer for code style?'), not keywords.
Inputs: query (required), type, limit, agent_id, +1 more. Returns: Outcome of a recall query.
recall_as_ofA
Point-in-time recall: return only memories that were known before the given timestamp. Use this when the user asks historical questions like 'what did we know on 2025-11-01?' or to reconstruct context at a previous moment.
Inputs: as_of (required), type, limit, agent_id. Returns: Outcome of a recall query.
recall_changed_sinceA
Differential retrieval: return memories created or updated after the given timestamp. Use this for 'what's new since X?' or to catch up on activity between sessions.
Inputs: since (required), type, limit, agent_id. Returns: Outcome of a recall query.
recall_recentA
Return the most recently stored memories (newest first). Use this to surface fresh context - e.g. 'what did we just decide?' - when you don't have a specific search query.
Inputs: type, limit, agent_id. Returns: Outcome of a recall query.
rememberA
Store a single piece of information in the agent's long-term memory. Use this whenever the user shares a stable fact, preference, decision, goal, or instruction you should recall in a future conversation. Memory is typed (13 categories) and carries confidence + provenance so later retrievals can rank and filter intelligently. Content is capped at 10000 chars - store atomic, self-contained statements.
Inputs: content (required), tags, type, title, +4 more. Returns: Outcome of storing a single memory.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 7 tools
Each tool serves a clearly distinct purpose: remember for single storage, batch_remember for bulk storage, and the recall variants cover different retrieval modes (semantic, recent, point-in-time, changed-since). The 'answer' tool adds a synthesis layer that is distinct from raw retrieval. No two tools appear to do the same thing.
All tool names are lowercase with underscores, following a consistent verb-first convention. The recall_* family is uniformly prefixed, and remember/batch_remember are clearly related. The naming is predictable and intuitive.
Seven tools is well-scoped for a memory server, covering storage and retrieval without bloat. Each tool earns its place, and the count sits comfortably in the ideal 3-15 range.
The tool surface covers creating and reading memories thoroughly, but lacks update and delete operations. Agents cannot correct a wrong memory or remove outdated information, which is a notable gap for a memory system. The absence of these lifecycle operations may cause dead ends in real use.
Maintenance
Related MCP Connectors
One memory for your AI agents: scoped, expiring, revocable per-agent tokens and an audit log.
Persistent memory for AI agents: save, search and connect context across tools and sessions.
Hosted memory for AI agents: save what your agent learns and recall it in the next session.
Universal memory for AI agents and tools. Save, organize and search context anywhere.
Related MCP Servers
- FlicenseNot gradedqualityDmaintenanceProvides AI agents with persistent, searchable memory that survives across conversations using semantic search, temporal versioning, and smart organization. Enables long-term context retention and cross-session continuity for AI assistants.14-
- AlicenseNot gradedqualityDmaintenanceEnables AI agents to store and retrieve memories with user-specific context using Mem0, allowing them to maintain conversation history and make informed decisions based on past interactions.173 npm1ISC

Mnemexa MCPofficial
AlicenseAqualityDmaintenanceProvides persistent, self-optimizing memory for AI agents, enabling them to remember preferences and context across sessions and share knowledge across multiple agents.412 npmISC- AlicenseCqualityBmaintenanceMemento is a local-first, open-source MCP middleware that gives AI agents persistent memory, proactive goal enforcement, and autonomous intelligence using a SQLite temporal graph with Reciprocal Rank Fusion retrieval.16154 PyPI1AGPL 3.0