MCP memory: 10 memory servers compared, with prices

October 5, 2026 · 10 min read

An MCP memory server gives an AI agent tools to save things and look them up in later sessions, over the Model Context Protocol, so Claude Code, Cursor, Codex and other clients can use the same store. The real choice is what it stores: a graph of short facts (the reference Memory server, Graphiti), memories extracted by a hosted API (Mem0, Supermemory, Zep), session logs captured automatically (claude-mem), or markdown pages a person can read (Basic Memory, Obsidian servers, Dexio). We checked every server below on its repo and pricing page on 1 October 2026.

What does an MCP memory server do?

An agent starts each session with an empty context window. Memory files such as CLAUDE.md load instructions you wrote; an MCP memory server goes further and gives the agent tools such as “save this” and “search for that”, which it calls when it decides to. Our guide to agent memory covers the wider set of options, from memory files to RAG.

Which MCP memory servers are there?

1. Memory, the reference knowledge graph server

The Memory server in the modelcontextprotocol/servers repository is published by the MCP project itself, and it is the server a Cursor forum thread on Google’s first page for “mcp memory” walks through. It stores a knowledge graph of entities (a person, a project), relations between them in active voice, and observations, which are short facts attached to an entity. Its tools include create_entities, create_relations, add_observations and matching delete tools, plus tools to read and search the graph.

Everything lives in one JSONL file on your machine. MEMORY_FILE_PATH sets where; the default is memory.jsonl in the server’s directory, so set it if you want the file somewhere you back up. The README’s config:

{
  "mcpServers": {
    "memory": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-memory"],
      "env": { "MEMORY_FILE_PATH": "/path/to/your/memory.jsonl" }
    }
  }
}

In Claude Code the same server is claude mcp add memory -- npx -y @modelcontextprotocol/server-memory (our Claude Code MCP guide explains scopes and flags). The whole repository has 90,910 stars; the memory folder’s last commit was on 3 September 2026.

Suits: trying MCP memory with one agent on one machine, at no cost.

2. Basic Memory: markdown files you can open

Basic Memory writes memory as markdown files, by default in ~/basic-memory, with wikilinks and frontmatter. You can point Obsidian at the same folder and see what the AI wrote in Obsidian’s graph. Tools include write_note, read_note, edit_note, search_notes, build_context and recent_activity.

uv tool install basic-memory --prerelease=allow
claude mcp add basic-memory -- uvx --prerelease=allow basic-memory mcp

Local use is free under AGPL-3.0. Basic Memory Cloud adds sync across devices and a web app: the pricing page lists Team at $15 a seat a month ($13 at 10 seats, $12 at 20) and Business at $30, with a 7-day trial. 4,070 stars, last commit 30 September 2026, latest release v0.23.2.

Suits: one person who wants memory as readable notes, especially Obsidian users.

3. Mem0 MCP, and what happened to OpenMemory

Mem0 extracts facts, preferences and decisions from what you send it and returns the relevant ones for a query. Its MCP server is hosted at https://mcp.mem0.ai/mcp: in the docs’ words, “Nothing runs on your machine”, and memories live in your Mem0 account. You need a Mem0 Platform account. The docs’ one-line setup:

npx mcp-add --name mem0-mcp --type http --url "https://mcp.mem0.ai/mcp" \
  --clients "claude code,cursor"

Tools include add_memory and search_memories. Sign-in happens in the browser the first time a tool runs, or with an API key as a bearer token. Pricing: Hobby is free with 10,000 add requests and 1,000 retrieval requests a month, Starter is $19 a month, Pro is $249 a month (adds graph memory), Enterprise is custom. The mem0 repo has 66,410 stars and is Apache-2.0.

Many older guides recommend OpenMemory, Mem0’s local MCP server. On 1 October 2026 the openmemory folder no longer exists on the mem0 repo’s main branch (the GitHub API returns 404), and the last commit touching that path is dated 29 July 2026. The docs now point to the hosted server, and to a Claude Code plugin that captures sessions locally and exposes one local MCP tool, search_memories. If a tutorial tells you to run OpenMemory, check the repo first. More on the alternatives in Mem0 alternatives.

Suits: developers who already use Mem0 in an app and want their coding agents on the same memory.

4. Supermemory MCP: hosted memory with team spaces

Supermemory MCP is a remote server at https://mcp.supermemory.ai/mcp. It signs in with OAuth, so no API key is needed, and you choose which spaces each client can read or write. Tools include search_memory (semantic recall), get_profile and add_memory, which saves or forgets. Clients with JSON config take:

{
  "mcpServers": {
    "supermemory": { "url": "https://mcp.supermemory.ai/mcp" }
  }
}

Pricing is credit-based: Free includes $5 of credits a month, Pro is $19 a month ($20 of credits, 3 seats), Max is $100, Scale is $399 with a self-hosted option, and Enterprise is custom. The engine is MIT-licensed with 31,048 stars and a commit on 30 September 2026. The older standalone supermemory-mcp repo (1,722 stars) has not had a commit since 30 December 2025.

Suits: teams, including non-developers, who want shared memory across chat assistants with nothing to install.

5. Graphiti MCP and Zep: a knowledge graph that tracks time

Graphiti builds a knowledge graph in which facts carry time, so when something changes the graph records it. Its MCP server ships in the repo. docker compose up in the mcp_server folder starts FalkorDB and the server in one container (Neo4j is an alternative), and the endpoint is http://localhost:8000/mcp/:

claude mcp add --transport http graphiti http://localhost:8000/mcp/

It needs an LLM API key: OpenAI by default, or Anthropic, Gemini, Groq or Azure OpenAI. Tools include add_memory (an episode of text, JSON or messages), search_nodes, search_memory_facts, get_episodes, delete_episode and clear_graph. Graphiti is Apache-2.0 with 31,343 stars; the MCP folder’s last commit was on 25 September 2026.

Zep is the hosted service built on it. Zep’s pricing starts at Flex, $125 a month for 50,000 credits and 5 Memory MCP Server seats; Flex Plus is $375 for 200,000 credits and 15 seats; a free tier gives 10,000 credits a month for prototyping. An episode costs 1 credit per 350 bytes; retrieval and storage cost nothing. We compare the two hosted APIs in Mem0 vs Zep vs Supermemory.

Suits: developers who need facts that change over time and are fine running Docker and a graph database.

6. claude-mem: automatic capture for Claude Code

claude-mem is the most-starred project here, with 95,066 stars and a commit on 1 October 2026. It is a plugin more than a plain MCP server: hooks record what the agent does, it writes summaries of each session, and it stores them in SQLite with Chroma for search. The agent reads them back through three MCP tools, search, timeline and get_observations, which return a short index first and full details only for the results it picks.

npx claude-mem install

Or, inside Claude Code: /plugin marketplace add thedotmack/claude-mem, then /plugin install claude-mem. The installer offers a hosted “observer” that runs the memory work off your Anthropic plan, free for up to 14 days, after which it falls back to your plan unless you subscribe; a --provider flag skips the sign-in. It also installs for OpenCode, OpenClaw, Cursor and others. Apache-2.0.

Suits: Claude Code users who want memory without asking the agent to save anything.

7. MCP Memory Service: one self-hosted memory backend

MCP Memory Service is a Python service with MCP, a REST API, OAuth, a CLI and a dashboard. It stores memories in SQLite (local), Cloudflare (sync across devices) or a hybrid of both.

pip install mcp-memory-service
claude mcp add memory -- memory server

Apache-2.0, 1,975 stars, last commit 1 October 2026, release v11.14.0. Suits: people who self-host and want one memory store for Claude and agent frameworks such as LangGraph, CrewAI and AutoGen.

8. Qdrant MCP server: semantic memory in a vector database

Qdrant’s official MCP server has two tools, qdrant-store and qdrant-find, and runs with uvx mcp-server-qdrant against a Qdrant server (QDRANT_URL) or a local folder (QDRANT_LOCAL_PATH). Apache-2.0, 1,541 stars, last commit 11 August 2026. Suits: teams already running Qdrant who want search by meaning over many snippets.

9. Obsidian MCP servers

If your notes are already in Obsidian, a vault server turns them into agent memory. The most-starred are mcp-obsidian (4,456 stars), the Local REST API plugin with its built-in MCP endpoint (2,981) and MCPVault (1,675), all MIT. Setup for each is in our Obsidian MCP guide.

Suits: people who want their agents’ memory and their own notes in one place.

10. Dexio: one wiki for all your agents

Dexio is a hosted wiki that agents read and write over MCP at https://app.dexio.wiki/mcp. Memory is linked markdown pages, not short facts: agents use search_pages, read_page, write_page, edit_page, append_page and move_page, and every change names the agent that made it. People see what the agents know as a page graph at app.dexio.wiki, with each page’s history. Claude Code, Codex, Cursor, Hermes, OpenClaw, Claude and ChatGPT can all connect to the same wiki, so an agent on one machine reads what another wrote on a different one.

claude mcp add --transport http --scope user dexio https://app.dexio.wiki/mcp \
  --header "Authorization: Bearer dxk_..."

Agents that run commands can set themselves up from dexio.wiki/agents.md. It is free for one person (unlimited pages and agents, 100 MB of storage); Team is $10 and Business $20 a member a month. Open source under AGPL-3.0.

Pick something else when you are building per-user memory into your own app (Mem0, Zep, Supermemory), want everything offline on one machine (Basic Memory, the reference server), or want sessions captured without the agent choosing what to save (claude-mem).

Which MCP memory servers are still maintained?

MCP directories list many memory servers, and some have stopped getting updates. The top Google result for “mcp memory” today is simple-memory-mcp, which has 8 stars, a last commit on 17 April 2026, and a README note that its author now uses a different project day to day. mcp-memory-libsql, also on the first page, has 24 stars and no commit since 5 March 2025.

Last commits from the GitHub API on 1 October 2026:

How do I choose an MCP memory server?

• One agent, one machine, no cost: the reference Memory server or MCP Memory Service.
• You want to read and edit the memory yourself: Basic Memory, an Obsidian server, or Dexio.
• Claude Code only, no manual saving: claude-mem.
• Memory for the users of an app you build: Mem0, Zep or Supermemory.
• Facts that change over time: Graphiti or Zep.
• Several agents on several machines, and a team that needs to see what they know: a hosted store all of them connect to, such as Dexio or Supermemory.

FAQ

Is there an official MCP memory server? The closest is the Memory server in the modelcontextprotocol/servers repository, published by the MCP project. The others here come from companies and individual developers.

Where does the Memory server keep its data? In a JSONL file: memory.jsonl in the server’s directory unless you set MEMORY_FILE_PATH.

Can several agents share one memory server? Yes, if they all connect to the same one. A local stdio server is only reachable on its own machine; hosted servers (Mem0, Supermemory, Zep, Dexio) or a self-hosted HTTP server can be shared across machines.

Do I need MCP memory if I use CLAUDE.md? CLAUDE.md holds instructions you write and loads every session; a memory server holds what the agent learns and looks up when needed. See Claude Code memory.

Sources

• https://github.com/modelcontextprotocol/servers/tree/main/src/memory
• https://github.com/basicmachines-co/basic-memory
• https://basicmemory.com/pricing
• https://docs.mem0.ai/platform/mem0-mcp
• https://docs.mem0.ai/llms.txt
• https://mem0.ai/pricing
• https://github.com/mem0ai/mem0
• https://supermemory.ai/docs/supermemory-mcp/introduction
• https://supermemory.ai/pricing
• https://github.com/supermemoryai/supermemory
• https://github.com/getzep/graphiti/tree/main/mcp_server
• https://www.getzep.com/pricing
• https://github.com/thedotmack/claude-mem
• https://github.com/doobidoo/mcp-memory-service
• https://github.com/qdrant/mcp-server-qdrant
• https://github.com/chrisribe/simple-memory-mcp
• https://github.com/joleyline/mcp-memory-libsql
• https://github.com/MarkusPfundstein/mcp-obsidian
• https://github.com/coddingtonbear/obsidian-local-rest-api
• https://github.com/bitbonsai/mcpvault
• https://dexio.wiki/agents.md
• https://dexio.wiki/docs/
• https://dexio.wiki/pricing/