Skip to main content
Glama

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-mcp

Requires 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)

  1. Get a Moorcheh API key from the console.

  2. 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"
      }
    }
  }
}
  1. 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

~/Library/Application Support/Claude/claude_desktop_config.json (macOS) / %APPDATA%\Claude\claude_desktop_config.json (Windows)

Cursor

~/.cursor/mcp.json (or per-project .cursor/mcp.json)

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

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

remember

Persist a single new fact/preference/decision/goal/instruction.

batch_remember

Persist up to 100 memories in one call (e.g. extracted from a document).

recall

Semantic search — always check here before asking the user to repeat stable info.

recall_recent

"What did we just decide?" — newest-first, no query needed.

recall_as_of

Point-in-time recall — "what did we know on 2025-11-01?"

recall_changed_since

Differential — "what's new since I last checked?"

answer

RAG: grounded LLM answer synthesized over the agent's memories.

Agent admin tools (opt-in)

Enabled when MEMANTO_EXPOSE_ADMIN=true:

Tool

Purpose

create_agent

Create a new memory namespace.

list_agents

List every agent the API key can see.

get_agent

Look up an agent's metadata.

delete_agent

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

MOORCHEH_API_KEY

yes

—

Moorcheh API key.

MEMANTO_DEFAULT_AGENT_ID

recommended

none

Default agent. When set, tool calls may omit agent_id.

MEMANTO_AGENT_PATTERN

no

tool

Pattern (support/project/tool) used when auto-creating the default agent.

MEMANTO_AGENT_AUTO_CREATE

no

true

Create the default agent on first use if missing. Explicit non-default agents must already exist.

MEMANTO_SESSION_DURATION_HOURS

no

server default (6)

Session lifetime in hours.

MEMANTO_EXPOSE_ADMIN

no

false

Register the 4 agent-management tools.

MEMANTO_MCP_TRANSPORT

no

stdio

stdio, sse, or streamable-http.

MEMANTO_MCP_HOST

no

127.0.0.1

Bind host for sse/http transports.

MEMANTO_MCP_PORT

no

8765

Bind port for sse/http transports.

MEMANTO_MCP_LOG_LEVEL

no

INFO

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 8765

Then 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

configuration error: MOORCHEH_API_KEY is required

Set the env var in your MCP client config's env block.

Agent '…' does not exist and MEMANTO_AGENT_AUTO_CREATE is disabled

Either re-enable auto-create or call create_agent (admin tools) / memanto agent create <id> once.

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 memanto_mcp) will appear there on startup.

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.

Available Tools

7 tools
answerA

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

    A4.1/5.0

    Scored across 7 tools

    Disambiguation5/5

    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.

    Naming Consistency5/5

    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.

    Tool Count5/5

    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.

    Completeness3/5

    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

    ActivityNo data
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • F
      license
      Not graded
      quality
      D
      maintenance
      Provides 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
      -
    • A
      license
      A
      quality
      D
      maintenance
      Provides persistent, self-optimizing memory for AI agents, enabling them to remember preferences and context across sessions and share knowledge across multiple agents.
      4
      12 npm
      ISC
    • A
      license
      C
      quality
      B
      maintenance
      Memento 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.
      16
      154 PyPI
      1
      AGPL 3.0