The Mem0 MCP Server provides long-term memory management for AI applications, enabling MCP-compatible clients (Claude Desktop, Cursor, VS Code, custom agents) to store, retrieve, search, update, and delete memories for users, agents, apps, and runs.
Add memories (add_memory): Save text, facts, conversation history, or structured messages, scoped to a user/agent/app/run, with optional metadata and graph memory support.
Search memories (search_memories): Semantic natural language search across stored memories with filters (user, agent, date range, etc.) and configurable result limits.
List memories (get_memories): Browse memories using structured filters and pagination (page number + page size).
Fetch a single memory (get_memory): Retrieve one specific memory by its memory_id.
Update a memory (update_memory): Overwrite the text of an existing memory by its memory_id.
Delete a memory (delete_memory): Remove a single memory by its memory_id.
Bulk delete memories (delete_all_memories): Delete all memories within a scope (user/agent/app/run) while keeping the entity record.
Delete entities (delete_entities): Cascade-delete a user, agent, app, or run record along with all associated memories.
List entities (list_entities): Enumerate all users, agents, apps, and runs currently stored in the system.
The server can be deployed as a Python package, Docker container, or via Smithery remote hosting.
Manages environment variables to securely store API keys, including mem0 API key configuration.
Provides demo capabilities through GitHub assets, demonstrating the coding preferences functionality in action.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Mem0 MCP Server search for my Python coding style preferences"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
mem0-mcp-server is no longer actively maintained and this repository is now a public archive.
Thank you to the 640+ stargazers, 140+ forkers, and every contributor who helped shape this project. Your support and feedback meant the world to us.
Looking for Mem0 MCP? We now offer an official cloud-hosted MCP server. Check out the docs to get started.
Quick install across all major clients:
npx mcp-add \
--name mem0-mcp \
--type http \
--url "https://mcp.mem0.ai/mcp" \
--clients "claude,claude code,cursor,windsurf,vscode,opencode"
mem0-mcp-server wraps the official Mem0 Memory API as a Model Context Protocol (MCP) server so any MCP-compatible client (Claude Desktop, Cursor, custom agents) can add, search, update, and delete long-term memories.
Related MCP server: Doclea MCP
The server exposes the following tools to your LLM:
Tool | Description |
| Save text or conversation history (or explicit message objects) for a user/agent. |
| Semantic search across existing memories (filters + limit supported). |
| List memories with structured filters and pagination. |
| Retrieve one memory by its |
| Overwrite a memory's text once the user confirms the |
| Delete a single memory by |
| Bulk delete all memories in the confirmed scope (user/agent/app/run). |
| Delete a user/agent/app/run entity (and its memories). |
| Enumerate users/agents/apps/runs stored in Mem0. |
All responses are JSON strings returned directly from the Mem0 API.
There are three ways to use the Mem0 MCP Server:
Python Package - Install and run locally using uvx with any MCP client
Docker - Containerized deployment that creates an /mcp HTTP endpoint
Smithery - Remote hosted service for managed deployments
uv pip install mem0-mcp-serverOr with pip:
pip install mem0-mcp-serverAdd this configuration to your MCP client:
{
"mcpServers": {
"mem0": {
"command": "uvx",
"args": ["mem0-mcp-server"],
"env": {
"MEM0_API_KEY": "m0-...",
"MEM0_DEFAULT_USER_ID": "your-handle"
}
}
}
}To test the server immediately, use the included Pydantic AI agent:
# Install the package
pip install mem0-mcp-server
# Or with uv
uv pip install mem0-mcp-server
# Set your API keys
export MEM0_API_KEY="m0-..."
export OPENAI_API_KEY="sk-openai-..."
# Clone and test with the agent
git clone https://github.com/mem0ai/mem0-mcp.git
cd mem0-mcp-server
python example/pydantic_ai_repl.pyUsing different server configurations:
# Use with Docker container
export MEM0_MCP_CONFIG_PATH=example/docker-config.json
export MEM0_MCP_CONFIG_SERVER=mem0-docker
python example/pydantic_ai_repl.py
# Use with Smithery remote server
export MEM0_MCP_CONFIG_PATH=example/config-smithery.json
export MEM0_MCP_CONFIG_SERVER=mem0-memory-mcp
python example/pydantic_ai_repl.pyThe Mem0 MCP server enables powerful memory capabilities for your AI applications:
Remember that I'm allergic to peanuts and shellfish - Add new health information to memory
Store these trial parameters: 200 participants, double-blind, placebo-controlled study - Save research data
What do you know about my dietary preferences? - Search and retrieve all food-related memories
Update my project status: the mobile app is now 80% complete - Modify existing memory with new info
Delete all memories from 2023, I need a fresh start - Bulk remove outdated memories
Show me everything I've saved about the Phoenix project - List all memories for a specific topic
MEM0_API_KEY (required) – Mem0 platform API key.
MEM0_DEFAULT_USER_ID (optional) – default user_id injected into filters and write requests (defaults to mem0-mcp).
MEM0_ENABLE_GRAPH_DEFAULT (optional) – Enable graph memories by default (defaults to false).
MEM0_MCP_AGENT_MODEL (optional) – default LLM for the bundled agent example (defaults to openai:gpt-4o-mini).
To run with Docker:
Build the image:
docker build -t mem0-mcp-server .Run the container:
docker run --rm -d \
--name mem0-mcp \
-e MEM0_API_KEY=m0-... \
-p 8080:8081 \
mem0-mcp-serverMonitor the container:
# View logs
docker logs -f mem0-mcp
# Check status
docker psTo connect to a Smithery-hosted server:
Install the MCP server (Smithery dependencies are now bundled):
pip install mem0-mcp-serverConfigure MCP client with Smithery:
{
"mcpServers": {
"mem0-memory-mcp": {
"command": "npx",
"args": [
"-y",
"@smithery/cli@latest",
"run",
"@mem0ai/mem0-memory-mcp",
"--key",
"your-smithery-key",
"--profile",
"your-profile-name"
],
"env": {
"MEM0_API_KEY": "m0-..."
}
}
}
}Clone and run from source:
git clone https://github.com/mem0ai/mem0-mcp.git
cd mem0-mcp-server
pip install -e ".[dev]"
# Run locally
mem0-mcp-server
# Or with uv
uv sync
uv run mem0-mcp-serverStore a new preference, fact, or conversation snippet. Requires at least one: user_id, agent_id, or run_id.
Inputs: text (required), messages, user_id, agent_id, +4 more. Returns: result
Delete every memory in the given user/agent/app/run but keep the entity.
Inputs: user_id, agent_id, app_id, run_id. Returns: result
Remove a user/agent/app/run record entirely (and cascade-delete its memories).
Inputs: user_id, agent_id, app_id, run_id. Returns: result
Delete one memory after the user confirms its memory_id.
Inputs: memory_id (required). Returns: result
Page through memories using filters instead of search.
Use filters to list specific memories. Common filter patterns:
- Single user: {"AND": [{"user_id": "john"}]}
- Agent memories: {"AND": [{"agent_id": "agent_name"}]}
- Recent memories: {"AND": [{"user_id": "john"}, {"created_at": {"gte": "2024-01-01"}}]}
- Multiple users: {"AND": [{"user_id": {"in": ["john", "jane"]}}]}
Pagination: Use page (1-indexed) and page_size for browsing results.
user_id is automatically added to filters if not provided.
Inputs: filters, page, page_size, enable_graph. Returns: result
Fetch a single memory once you know its memory_id.
Inputs: memory_id (required). Returns: result
List which users/agents/apps/runs currently hold memories.
Inputs: no named parameters. Returns: result
Run a semantic search over existing memories.
Use filters to narrow results. Common filter patterns:
- Single user: {"AND": [{"user_id": "john"}]}
- Agent memories: {"AND": [{"agent_id": "agent_name"}]}
- Recent memories: {"AND": [{"user_id": "john"}, {"created_at": {"gte": "2024-01-01"}}]}
- Multiple users: {"AND": [{"user_id": {"in": ["john", "jane"]}}]}
- Cross-entity: {"OR": [{"user_id": "john"}, {"agent_id": "agent_name"}]}
user_id is automatically added to filters if not provided.
Inputs: query (required), filters, limit, enable_graph. Returns: result
Overwrite an existing memory’s text.
Inputs: memory_id (required), text (required). Returns: result
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 9 tools
Most tools have distinct purposes, but get_memories and search_memories could cause confusion as both involve retrieving memories with filters, though search_memories adds semantic search. The other tools (add, delete, update, list) are clearly differentiated by their actions on memories or entities.
All tools follow a consistent verb_noun pattern (e.g., add_memory, delete_memory, get_memories), with clear and predictable naming. There are no deviations in style or convention across the set.
With 9 tools, this server is well-scoped for memory management, covering core operations like CRUD for memories and entities, plus search and listing. Each tool serves a clear purpose without redundancy or bloat.
The toolset provides complete coverage for memory management: create (add_memory), read (get_memory, get_memories, search_memories), update (update_memory), delete (delete_memory, delete_all_memories, delete_entities), and list (list_entities). No obvious gaps exist for the domain.
An MCP memory server. One memory your agents share — across models, devices and apps.
Persistent memory and cross-session learning for AI coding assistants (hosted remote MCP).
Cloud-hosted MCP server for durable AI memory
Team memory for AI coding agents and code reviews, reviewed by humans and served over MCP.
