Yes. The Model Context Protocol (MCP) — an open protocol published by Anthropic in November 2024, specification version 2025-11-25 — standardizes how LLM applications connect to external tools and data sources, and several MCP servers exist specifically for agent memory. The official MCP servers repository includes a knowledge graph-based memory server (@modelcontextprotocol/server-memory), and third-party memory servers — including PLUR, Zep, Mem0’s OpenMemory, and community projects — expose persistent agent memory through the same protocol. The practical question is not whether an MCP memory server exists, but which one fits your needs, because “MCP-compatible” tells you the transport, not the memory format.
MCP is an open protocol built on JSON-RPC 2.0, inspired by the Language Server Protocol (LSP). Just as LSP standardized how editors connect to language servers (so any editor works with any language server), MCP standardizes how AI agents connect to external tools and data sources (so any agent works with any tool server). The protocol defines three things a server can offer: Resources (context and data), Prompts (templated messages), and Tools (functions the AI can execute). A memory MCP server typically exposes tools — store, recall, search, learn, forget — that the agent calls to manage what it remembers (modelcontextprotocol.io/specification/2025-11-25).
What MCP does not define is the memory format. It says how an agent talks to a memory server, not what the memories look like inside. This means two MCP memory servers can be fully protocol-compatible and store memory in completely different ways — one as a vector embedding, one as a human-readable YAML file. The protocol is open; the format is the differentiator.
The MCP servers repository (github.com/modelcontextprotocol/servers) ships a reference memory server: @modelcontextprotocol/server-memory. It is a knowledge graph-based persistent memory system. You run it locally with:
npx -y @modelcontextprotocol/server-memoryAnd configure it in your MCP client (Claude Desktop, Cursor, etc.) as:
{
"mcpServers": {
"memory": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-memory"]
}
}
}It stores entities, observations, and relations as a local knowledge graph. Good for: lightweight, local-only memory for a single agent. Limitation: the knowledge graph format is not human-readable YAML — you inspect it through the tool API, not a text editor — and it is designed for single-agent, single-machine use, not cross-runtime persistence.
PLUR (Apache-2.0, github.com/plur-ai/plur) ships an MCP server that exposes its engram engine. Each memory — an “engram” — is a human-readable YAML entry with an id, statement, type, domain, scope, confidence, and provenance. The MCP tools include plur_learn (create an engram), plur_recall (search by topic), plur_inject (get relevant engrams for a task), plur_forget (delete by id or query), and plur_feedback (rate relevance to improve injection quality).
Because it is MCP-compatible, the same memory follows an agent across Claude Code, Hermes, OpenClaw, Cursor, and any other MCP-compatible runtime. And because the format is plain-text YAML, you can open any engram in a text editor, put the memory store under version control, correct a single fact mid-conversation, and prove erasure by removing the entry — with the store under git, the diff is your audit trail.
Good for: agents that need portable, inspectable, correctable memory across multiple tools and model providers. Limitation: newer project, less production-tested than the reference server at scale.
OpenMemory (mem0.ai/openmemory) is Mem0’s official MCP memory server: a private, local memory layer that runs on your own machine and exposes standardized memory tools — add_memories, search_memory, list_memories, delete_all_memories — to any MCP-compatible client. Memories stay local; the same store is shared across every MCP client you connect to it.
Good for: sharing one local memory store across multiple MCP clients with Mem0’s simple CRUD model. Limitation: storage is vector-based (a local database, inspected through the built-in UI or API) — not human-readable files you can open in a text editor or diff in git.
Zep (docs.getzep.com) offers an MCP server for connecting coding agents to its agent memory platform. Zep builds a temporal knowledge graph from any input — chat, business data, documents — and serves prompt-ready context with sub-200ms retrieval. The MCP server exposes Zep’s memory tools to any MCP-compatible agent.
Good for: production agents that need time-aware, high-throughput memory at enterprise scale. Limitation: Zep’s memory format is a knowledge graph and Context Lake — not a human-readable file you can diff or version-control.
The awesome-mcp-servers list (github.com/punkpeye/awesome-mcp-servers) catalogs dozens of community MCP servers, several with memory capabilities:
npx @unclick/mcp-server.pip install gadgethumans-api-hub-mcp.These range from single-purpose utilities to full memory systems. The ecosystem is young and moving fast — verify current status before adopting.
| If you need… | Start with |
|---|---|
| A free, local, single-agent reference implementation | @modelcontextprotocol/server-memory |
| One local vector-based memory store shared across MCP clients | OpenMemory (Mem0) |
| Enterprise-scale temporal memory with sub-200ms retrieval | Zep’s MCP server |
| Human-readable, portable, correctable memory across runtimes | PLUR’s MCP server |
| Multi-agent shared memory in PostgreSQL | pg-mnemosyne |
| Quick utility memory without infra | Unclick or Memory Vault |
The underlying decision is the same one that runs through all of agent memory: what do you need to own? If you need memory that is portable across agent runtimes, inspectable in a text editor, correctable mid-conversation, and provably erasable — the format matters more than the transport. MCP makes the transport open; the format is the differentiator.
Is there an MCP server for AI agent memory? Yes. The official MCP servers repository includes @modelcontextprotocol/server-memory (a knowledge graph memory server). Third-party memory servers — PLUR, Zep, Mem0’s OpenMemory, and several community projects — also expose agent memory through MCP. Any MCP-compatible agent (Claude Code, Cursor, Hermes, OpenClaw) can connect to any of them.
What is the MCP memory server? The reference implementation is @modelcontextprotocol/server-memory, a knowledge graph-based persistent memory system. Run it with npx -y @modelcontextprotocol/server-memory and configure it in your MCP client. It stores entities, observations, and relations as a local knowledge graph.
Does MCP define a memory format? No. MCP defines the transport (JSON-RPC 2.0) — how an agent talks to a memory server — but not what the memories look like inside. Two MCP memory servers can be fully protocol-compatible and store memory in completely different formats (vector embeddings vs human-readable YAML, for example). The format is the differentiator.
Can I use MCP memory with Claude Code? Yes. Claude Code supports MCP servers. Add a memory server to your MCP configuration and Claude Code can call its tools — store, recall, search — to persist and retrieve memory across sessions.
What is the difference between MCP memory and CLAUDE.md? CLAUDE.md is a static file of instructions you write, loaded at the start of every Claude Code session. An MCP memory server is a dynamic system the agent can call during a conversation — it stores, searches, updates, and forgets memory items programmatically. CLAUDE.md is the simplest form of persistent context; an MCP memory server is for structured, accumulating, queryable memory.