OpenMemory MCP
OfficialMem0's local-first memory layer: a Dockerized MCP server plus dashboard that keeps agent memories on your machine.
Add to your client
Copy the config for your MCP client and paste it into its config file.
curl -sL https://raw.githubusercontent.com/mem0ai/mem0/main/openmemory/run.sh | OPENAI_API_KEY=your_api_key bashPaste into ~/Library/Application Support/Claude/claude_desktop_config.json
{
"mcpServers": {
"openmemory-mcp": {
"command": "npx",
"args": [
"-y",
"mcp-remote",
"http://localhost:8765/mcp/<client-name>/sse/<user-id>"
]
}
}
}Claude Desktop connects to remote servers through the `mcp-remote` proxy (installed on first run via npx). Restart Claude Desktop after saving.
Step-by-step guides: Add to Claude Desktop · Add to Cursor · Add to Windsurf
Before you start
- Docker and Docker Compose
- An OpenAI API key (default LLM + embedder) — or a running Ollama for the fully local configuration
- Node.js/npx for the @openmemory/install client-setup helper and for UI development
- Python 3.9+ only if hacking on the backend outside Docker
About OpenMemory MCP
OpenMemory answers a specific annoyance: every MCP client keeping its own amnesiac context. It runs one memory store on your machine that Claude Desktop, Cursor, Windsurf, and others all plug into over SSE, each via a per-client URL (http://localhost:8765/mcp/<client-name>/sse/<user-id>). Memories written in one tool are searchable from the rest, scoped by the user id you set in the environment.
The stack is plain Docker Compose from the openmemory/ directory of the mem0 monorepo: mem0_store (Qdrant) for vectors, openmemory-mcp (FastAPI/uvicorn, port 8765) for the API + MCP server, and openmemory-ui (Next.js, port 3000) for the dashboard. The dashboard is the differentiator versus headless memory servers — you can see every stored memory, filter by app, pause or delete them, and watch what each connected client has been writing.
Extraction defaults to OpenAI's gpt-4o-mini with text-embedding-3-small, configured via api/.env. Swapping LLM_PROVIDER=ollama and EMBEDDER_PROVIDER=ollama gives a fully offline pipeline (llama3.1 + nomic-embed-text are the documented defaults), and Anthropic/Groq/Together/DeepSeek are also wired in. That flexibility is the main reason to self-host rather than use Mem0's cloud MCP.
The project's future is the caveat: the README opens with a sunsetting notice pointing at the Mem0 self-hosted server (cd server && make bootstrap) as the replacement for local memory with a dashboard. OpenMemory still works and the monorepo remains very active, but expect migration pressure rather than new OpenMemory features.
Tools & capabilities (5)
add_memoriesStore new memories whenever the user shares preferences or facts worth keeping.
search_memorySemantic search over stored memories; meant to be called before answering personal questions.
list_memoriesList everything in the user's memory store.
delete_memoriesDelete specific memories by their IDs.
delete_all_memoriesWipe the user's entire memory store.
What this server can do
OpenMemory MCP provides tools for these capabilities — tap one to see every MCP server that does the same:
When to use it
- Share one memory store across Claude Desktop, Cursor, and Windsurf so context follows you between tools
- Keep sensitive preferences and project facts on-device instead of a memory SaaS — pair with Ollama for zero external calls
- Audit and prune what your agents remember via the dashboard on localhost:3000
- Give a team member a scoped memory space by user id without provisioning any cloud service
Quick setup
- 1export OPENAI_API_KEY=sk-... then run: curl -sL https://raw.githubusercontent.com/mem0ai/mem0/main/openmemory/run.sh | bash (or clone the repo and cd openmemory)
- 2Manual route: cp api/.env.example api/.env, set OPENAI_API_KEY and USER (your user id), then `make build && make up`
- 3Confirm the MCP server at http://localhost:8765 (API docs at /docs) and the dashboard at http://localhost:3000
- 4Wire up a client: npx @openmemory/install local http://localhost:8765/mcp/claude/sse/<user-id> --client claude
- 5Optional fully-local mode: set LLM_PROVIDER=ollama and EMBEDDER_PROVIDER=ollama in api/.env
Security notes
Memories live locally in Docker volumes (Qdrant + SQLite), but memory text is sent to your configured LLM/embedder — OpenAI by default — unless you switch to Ollama for a fully local pipeline. The SSE endpoint is unauthenticated on localhost, and note the README's sunsetting notice: Mem0 now steers new users to its self-hosted server instead.
OpenMemory MCP FAQ
Is OpenMemory private and free?
Yes — Apache-2.0, self-hosted, and memories are stored locally in Qdrant/SQLite Docker volumes. The one external dependency is the LLM/embedder: the default OpenAI setup sends memory text to OpenAI, so switch both providers to Ollama if you need everything on-device.
Is OpenMemory still maintained?
It works, but the README carries an explicit sunsetting notice: Mem0 directs local self-hosted memory users to the Mem0 self-hosted server (make bootstrap in the monorepo's server/ directory) instead. Existing setups keep running; new deployments should weigh starting on the successor.
How do multiple MCP clients share the same memories?
Each client connects to its own SSE URL — http://localhost:8765/mcp/<client-name>/sse/<user-id> — but the <user-id> is what scopes the data. Use the same user id across Claude, Cursor, and Windsurf and they read and write one shared store, with per-app attribution visible in the dashboard.
Alternatives to OpenMemory MCP
Compare all alternatives →
Official MCP server providing persistent, file-backed knowledge-graph memory across sessions.
Structured step-by-step reasoning tool for breaking problems into revisable thought sequences.
Temporal knowledge-graph memory for agents: add episodes and search facts over FalkorDB or Neo4j, from Zep.
Compare OpenMemory MCP with: