Memanto Mcp

memanto-mcp

Typed semantic memory for Claude. Memory with opinions, designed for regulated B2B agents.

Most "memory MCP" servers give you save_memory(text) and call it done. This one ships an opinionated memory model — typed records (fact, decision, commitment, instruction, …), provenance and confidence on every write, tenant-aware scoping, and bi-temporal recall — together with a Claude skill that tells the model when to remember vs. recall vs. answer, and how to keep citations and tenancy clean.

If you're building B2B agents on Anthropic's platform — legal tech, finance, healthcare, customer ops, internal knowledge work — that's the audience this is built for.

What's distinctive

• Typed memory. Thirteen first-class memory types (fact, preference, goal, decision, commitment, instruction, relationship, context, observation, event, artifact, learning, error). Wrong type = noisy recall. Picking the right type is part of the API contract.
• Provenance and confidence on every record. explicit_statement / inferred / observed / validated / corrected / imported, plus a 0.0–1.0 confidence score. Filterable on recall via min_confidence. The audit trail is in the data, not bolted on.
• Bi-temporal reads. recall_as_of(date) returns memory as it stood on a date; recall_current excludes superseded/expired records. Built for "what did we know on " workflows.
• A bundled Claude skill that earns its keep. [skills/memanto-memory/SKILL.md](skills/memanto-memory/SKILL.md) tells Claude when to use each verb, how to scope memories to tenant boundaries via composite agent_id, when raw recall beats synthesized answers (drafting external-facing text → raw recall, every time), and how to treat memory bodies as untrusted on read.
• One process. Wraps the memanto Python service layer directly — no separate REST process to run.

What this is not

• Not a general-purpose vector store. Memories are short, structured, and typed; if you need to index 100k contracts, do that in your document store and use this for the decisions, commitments, and observations the agent makes about them.
• Not backend-agnostic (yet). Currently coupled to Moorcheh as the vector backend. Free tier is 100k ops/month; pluggable backends are on the [roadmap](ROADMAP.md).
• Not an enterprise audit system. The skill is opinionated about what regulated deployments need; the server doesn't yet enforce all of it. See the [roadmap](ROADMAP.md) for the gaps.

Tools

Nine MCP tools, namespaced under memanto:

| Tool | Purpose | | -------------------------- | -------------------------------------------------------- | | memanto_remember | Store a typed memory (fact, preference, goal, decision, …) | | memanto_recall | Semantic search over an agent's memory | | memanto_recall_current | Recall only currently-active (non-superseded) memories | | memanto_recall_as_of | Recall as of a specific date | | memanto_answer | RAG-grounded answer using memanto's built-in LLM | | memanto_create_agent | Provision a new agent (creates a Moorcheh namespace) | | memanto_list_agents | List known agents | | memanto_get_agent | Get a single agent's metadata | | memanto_delete_agent | Delete an agent and all its memory (destructive) |

Install

As a Cowork plugin (Anthropic's Cowork mode)

1. Download the latest memanto-mcp.plugin release.
2. Drop it into Cowork via the plugin install UI.
3. Set MOORCHEH_API_KEY in the environment Cowork inherits, then restart Cowork.

As a standalone MCP server (Claude Code, Cline, Cursor, Continue, …)

pip install memanto-mcp
export MOORCHEH_API_KEY="mch_..."

Then point your MCP host at the binary. Claude Code:

claude mcp add memanto -- memanto-mcp

Cursor / Cline / Continue: add to your MCP config as a stdio server with command memanto-mcp.

For the bundled skill to load in MCP hosts that support skills (Cowork, Claude Code with the skills plugin), copy [skills/memanto-memory/SKILL.md](skills/memanto-memory/SKILL.md) into the host's skills directory.

Get a Moorcheh API key

Sign up at . Free tier is 100k ops/month.

First run

> Create a memanto agent called acme:matter-4711:user-jdoe and remember
> that this matter has a 60-day notice period.

Claude calls memanto_create_agent then memanto_remember(memory_type="fact", content="Matter 4711 (Acme): 60-day notice period.", confidence=0.95).

> What do we know about Matter 4711?

Claude calls memanto_recall(query="Matter 4711", agent_id="acme:matter-4711:user-jdoe") and quotes the stored fact.

> What was our position on Matter 4711 before the redesign on 2026-03-01?

Claude calls memanto_recall_as_of(query="Matter 4711 position", agent_id=..., as_of_date="2026-02-28").

How the skill thinks about scoping

The server uses agent_id as the scoping primitive. The skill teaches Claude to treat it as a composite key:

agent_id = "::"

For example: acme:matter-4711:user-jdoe. Cross-tenant recall is the highest-impact failure mode in production memory systems — the skill makes Claude refuse it loudly rather than silently returning empty results when the boundary is wrong.

For axes that don't fit the composite key (jurisdiction, region, conflict-of-interest group, product line), use tags — they're filterable on recall.

Drafting rule

When the user is composing external-facing text — a contract amendment, a customer-facing email, a regulatory filing, a clinical summary, a briefing memo — the skill instructs Claude to use memanto_recall (raw hits) and quote, not memanto_answer (synthesized). The audit cost of a paraphrased citation is too high.

When the user is researching, exploring, or briefing themselves, memanto_answer is fine.

Roadmap

The honest gaps — what the skill assumes you'd want in a fully regulated deployment and what the server doesn't do yet — are documented in [ROADMAP.md](ROADMAP.md). Highlights: structured source_uri + source_span fields (citations currently get encoded inside content), versioned mutations + redact API, pluggable storage backends, and an HTTP transport for non-stdio hosts.

Repository layout

memanto-mcp/
├── .claude-plugin/plugin.json       # Cowork plugin manifest
├── .mcp.json                        # MCP server registration (Cowork)
├── server/memanto_mcp_server.py     # FastMCP server (stdio)
├── skills/memanto-memory/SKILL.md   # the bundled skill
├── pyproject.toml                   # for `pip install memanto-mcp`
├── README.md                        # this file
├── ROADMAP.md                       # what's missing, ranked
├── CONTRIBUTING.md
├── CHANGELOG.md
├── LICENSE                          # MIT
└── docs/
    └── launch-post.md               # cross-post draft

Contributing

See [CONTRIBUTING.md](CONTRIBUTING.md). The two highest-leverage contributions right now are (1) a pluggable storage backend (interface + a SQLite or pgvector implementation) and (2) a structured citation model (source_uri + source_span + quote). Both are on the [roadmap](ROADMAP.md).

License

MIT. See [LICENSE](LICENSE).

Credits

• memanto and Moorcheh — the typed memory model and vector backend this wraps.
• Anthropic's MCP and Agent Skills — the protocol and skill format.
• The teams shipping enterprise agentic systems whose published patterns informed the skill: Harvey, Hebbia, Robin AI, Clio, EvenUp, Casetext.

Not affiliated with Anthropic or Moorcheh.

Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: geoffsdesk
• Source: geoffsdesk/memanto-mcp
• License: MIT
• Homepage: https://github.com/geoffsdesk/memanto-mcp

Install and usage instructions live in the source repository linked above.