Memoir Memoir
GitHub
All blogs
How-to

One memory, every editor: the Memoir MCP server

Memoir now ships an MCP server. Point Claude Desktop, Cursor, Cline, Windsurf, VS Code, Zed — or any MCP host — at one git-versioned store, and they all share the same memory. Recall, remember, branch, and trace provenance without writing a line of glue.

5 min read MCP server

Until now, Memoir met your agent where it lived: a Claude Code plugin, a Codex plugin, a Python SDK, a CLI. Each binding is first-class — but each is also a separate integration. The new Memoir MCP server collapses that. Speak the Model Context Protocol and any host that does too — Claude Desktop, Cursor, Cline, Windsurf, VS Code's Copilot, Zed, Continue, LibreChat — gets the same git-versioned, taxonomy-structured memory through one small server: memoir-mcp.

One server, every host

The pitch is boring in the best way: you run one process, and every MCP client you point at it sees the same store. Tell Cursor a project convention; recall it from Claude Desktop the next morning. The memory isn't trapped in one editor's sidecar — it's a shared, versioned object that travels with you across tools. Supported hosts today:

  • stdio hosts — Claude Desktop, Cursor, Cline, Windsurf, VS Code (GitHub Copilot), Zed, Continue, LibreChat.
  • HTTP connectors — ChatGPT and Claude.ai, via the server's HTTP transport.

Drop it into your host

Install the optional MCP extra — or skip installing entirely and let uvx fetch it on demand: 

pip install "memoir-ai[mcp]"   # or: pipx install "memoir-ai[mcp]"

# Run it directly:
MEMOIR_STORE=~/.memoir/mcp memoir-mcp

# Or with no install at all:
uvx --from "memoir-ai[mcp]" memoir-mcp

Most stdio hosts — Claude Desktop, Cursor, Cline, Windsurf — share one config shape. Add a memoir entry to their mcpServers block: 

{
  "mcpServers": {
    "memoir": {
      "command": "uvx",
      "args": ["--from", "memoir-ai[mcp]", "memoir-mcp"],
      "env": { "MEMOIR_STORE": "~/.memoir/mcp" }
    }
  }
}

The file each host reads differs, but the block above doesn't:

  • Claude Desktop — claude_desktop_config.json (Settings → Developer).
  • Cursor — ~/.cursor/mcp.json or a project-local .cursor/mcp.json.
  • Cline — the Cline panel → MCP Servers → Configure.
  • Windsurf — ~/.codeium/windsurf/mcp_config.json.

A few hosts use their own schema. VS Code wants a top-level servers key in .vscode/mcp.json (with "type": "stdio"); Zed uses context_servers in its settings.json; and Continue / LibreChat take the same three fields as YAML. For a remote/web connector, run the HTTP transport and point the client at http://<host>:8000/mcp: 

memoir-mcp --http --host 0.0.0.0 --port 8000

The tools it exposes

Once connected, the host sees seven tools. Reads are LLM-free and cheap by default, so a model can recall on every turn without burning tokens or calling out to a provider:

  • memoir_recall (read-only) — retrieve stored facts; LLM-free by default, or set semantic=true for vector recall.
  • memoir_remember — store a fact, auto-classified into a taxonomy path.
  • memoir_forget — delete a memory; the version stays in git history.
  • memoir_status (read-only) — branch, commit count, memory stats.
  • memoir_branches (read-only) — list versioned memory branches.
  • memoir_checkout — switch or create a branch or commit.
  • memoir_commits (read-only) — walk commit history and provenance.

Turn on classification and semantic recall

The server is useful with zero credentials — reads, status, and branching all work LLM-free. To unlock auto-classification on memoir_remember and semantic recall, hand it a provider key through the same env block: 

"env": {
  "MEMOIR_STORE": "~/.memoir/mcp",
  "ANTHROPIC_API_KEY": "sk-ant-…",
  "MEMOIR_LLM_MODEL": "claude-haiku-4-5",
  "MEMOIR_MCP_SEMANTIC_RECALL": "1"
}

MEMOIR_LLM_MODEL defaults to claude-haiku-4-5; OPENAI_API_KEY works in place of the Anthropic key; and MEMOIR_MCP_SEMANTIC_RECALL=1 makes semantic search the default for recall instead of opt-in per call.

Why it's the same memory, not just the same API

An MCP server that wrapped a flat key-value store would let your editors share data. Memoir lets them share a versioned store — which is a different thing. Every memoir_remember is a commit. That means the questions that matter for long-lived memory have answers, no matter which host asked:

  • Experiment safely. memoir_checkout a branch, let an agent fill it with a risky strategy, and throw it away — or merge it — without touching main.
  • Trace any fact. memoir_commits shows when a memory landed and what wrote it. No more "where did the agent get that?"
  • Undo without losing history. memoir_forget removes a memory from the working set; the commit that held it is still recoverable.
  • One store, many editors. Point them all at the same MEMOIR_STORE and the branch, the taxonomy, and the history are identical everywhere.

Read the MCP setup guide

The plugins meet your agent where it lives. The MCP server meets every other tool where the protocol lives — so the memory stops being a per-editor feature and starts being yours.