mem0-mcp-selfhosted

Self-hostedmem0MCP server for Claude Code. Run a complete memory server against self-hosted Qdrant + Neo4j + Ollama, with your choice of Anthropic (Claude) or Ollama as the main LLM.

Authentication:The default setup uses Claude (Anthropic) as the LLM for fact extraction. No API key needed, the server automatically uses your Claude Code session token. For fully local setups, setMEM0_PROVIDER=ollama. SeeAuthenticationfor advanced options.

claude mcp add --scope user --transport stdio mem0 \ --env MEM0_USER_ID=your-user-id \ -- uvx --from git+https://github.com/elvismdev/mem0-mcp-selfhosted.git mem0-mcp-selfhosted

All defaults work out of the box: Qdrant onlocalhost:6333, Ollama embeddings onlocalhost:11434withbge-m3(1024 dims). Override any default via--env(seeConfiguration).

claude mcp add --scope user --transport stdio mem0 \ --env MEM0_PROVIDER=ollama \ --env MEM0_LLM_MODEL=qwen3:14b \ --env MEM0_USER_ID=your-user-id \ -- uvx --from git+https://github.com/elvismdev/mem0-mcp-selfhosted.git mem0-mcp-selfhosted

{ "mcpServers": { "mem0": { "command": "uvx", "args": ["--from", "git+https://github.com/elvismdev/mem0-mcp-selfhosted.git", "mem0-mcp-selfhosted"], "env": { "MEM0_PROVIDER": "ollama", "MEM0_LLM_MODEL": "qwen3:14b", "MEM0_USER_ID": "your-user-id" } } } }

> Search my memories for TypeScript preferences > Remember that I prefer Hatch for Python packaging > Show me all entities in my knowledge graph

Add these rules to your project'sCLAUDE.md(or~/.claude/CLAUDE.mdfor global use) so Claude Code proactively uses memory tools throughout the session:

# MCP Servers - mem0: Persistent memory across sessions. At the start of each session, search_memories for relevant context before asking the user to re-explain anything. Use add_memory whenever you discover project architecture, coding conventions, debugging insights, key decisions, or user preferences. Use update_memory when prior context changes. Save information like: "This project uses PostgreSQL with Prisma", "Tests run with pytest -v", "Auth uses JWT validated in middleware". When in doubt, save it, future sessions benefit from over-remembering.

This gives Claude Code behavioral instructions to actively search and save memories during the session. For best results, combine withClaude Code Hooks, the CLAUDE.md rules tell Claudehow to usememory tools mid-session, while hooks handle theautomaticinjection and saving at session boundaries.

All tools use PydanticAnnotated[type, Field(description=...)]for self-documenting parameter schemas. Common patterns:

- user_iddefaults toMEM0_USER_IDenv var when not provided
- enable_graphoverrides the defaultMEM0_ENABLE_GRAPHper-call
- filterssupports structured operators:{"key": {"eq": "value"}},{"AND": [...]}
- All responses are JSON strings viajson.dumps(result, ensure_ascii=False)

All configuration is via environment variables. Create a.envfile or set them in your MCP config.

Claude Code | ├── MCP stdio/SSE/streamable-http │ | │ ├── env.py ← Centralized env var readers (whitespace-safe) │ ├── auth.py ← Hybrid token fallback chain + OAT self-refresh │ ├── llm_anthropic.py ← Custom Anthropic LLM provider (OAT + structured outputs) │ ├── llm_ollama.py ← Custom Ollama LLM provider (restored tool-calling) │ ├── config.py ← Env vars → MemoryConfig dict (provider + URL cascades) │ ├── helpers.py ← Error wrapper, concurrency lock, safe bulk-delete, monkey-patches │ ├── graph_tools.py ← Direct Neo4j Cypher queries (lazy driver) │ ├── llm_router.py ← Split-model graph LLM router (gemini_split) │ ├── __init__.py ← Telemetry suppression (before any mem0 import) │ └── server.py ← FastMCP orchestrator (11 tools + prompt) │ | │ ├── mem0ai Memory class │ │ ├── Vector: LLM fact extraction → Ollama embed → Qdrant │ │ └── Graph: LLM entity extraction (tool calls) → Neo4j │ | │ └── Infrastructure │ ├── Qdrant ← Vector store │ ├── Ollama ← Embeddings │ ├── Neo4j ← Knowledge graph (optional) │ └── Anthropic/Ollama ← Main LLM (configurable) | └── Session Hooks (subprocess, not MCP) | └── hooks.py ← Cross-session memory (SessionStart + Stop hooks) ├── context_main() → Injects memories as additionalContext on startup/compact ├── stop_main() → Saves session summary to mem0 on exit └── install_main() → CLI to patch .claude/settings.json

Graph memory isdisabled by default(MEM0_ENABLE_GRAPH=false) to protect your Claude quota. Eachadd_memorywith graph enabled triggers 3 additional LLM calls for entity extraction, relationship generation, and conflict resolution.

To eliminate Claude quota usage for graph ops, use a local Ollama model:

MEM0_ENABLE_GRAPH=true MEM0_GRAPH_LLM_PROVIDER=ollama MEM0_GRAPH_LLM_MODEL=qwen3:14b

Qwen3:14b has 0.971 tool-calling F1 (nearly matching GPT-4's 0.974) and runs in ~7-8GB VRAM with Q4_K_M quantization.

Google's Gemini 2.5 Flash Lite is the cheapest option for graph ops while maintaining strong entity extraction accuracy:

MEM0_ENABLE_GRAPH=true MEM0_GRAPH_LLM_PROVIDER=gemini MEM0_GRAPH_LLM_MODEL=gemini-2.5-flash-lite GOOGLE_API_KEY=your-google-api-key

Thegemini_splitprovider routes graph pipeline calls to different LLMs based on the operation. Entity extraction (Calls 1 & 2) goes to Gemini for speed and cost; contradiction detection (Call 3) goes to Claude for accuracy.

MEM0_ENABLE_GRAPH=true MEM0_GRAPH_LLM_PROVIDER=gemini_split GOOGLE_API_KEY=your-google-api-key MEM0_GRAPH_CONTRADICTION_LLM_PROVIDER=anthropic MEM0_GRAPH_CONTRADICTION_LLM_MODEL=claude-opus-4-6

Benchmark results across 248 test cases: Gemini scores 85.4% on entity extraction (vs Claude's 79.1%), while Claude scores 100% on contradiction detection (vs Gemini's 80%). The split-model combines the best of both.

For remote deployments, MCP SDK >= 1.23.0 enables DNS rebinding protection by default.

# Install with dev dependencies pip install -e ".[dev]" # Run unit tests python3 -m pytest tests/unit/ -v # Run contract tests (validates mem0ai internal API assumptions) python3 -m pytest tests/contract/ -v # Run integration tests (requires live Qdrant + Neo4j + Ollama) python3 -m pytest tests/integration/ -v # Run all tests python3 -m pytest tests/ -v

- tests/unit/-- Pure unit tests with mocked dependencies (env, auth, config, config matrix, concurrency, MCP protocol, helpers, hooks, LLM providers, graph tools, LLM router, server)
- tests/contract/-- Validates assumptions about mem0ai internals (schema detection invariant,vector_store.clientaccess path,LlmFactoryregistration idempotency)
- tests/integration/-- Live infrastructure tests (memory lifecycle, graph ops, bulk operations, hooks) against real Qdrant + Neo4j + Ollama. Marked with@pytest.mark.integration.

Contract tests catch breaking changes inmem0aiupgrades before they reach production.

All mem0ai telemetry is suppressed.os.environ["MEM0_TELEMETRY"] = "false"is set at package import time, before anymem0module is loaded. No PostHog events are sent.

A knowledge graph implementation with semantic search powered by the Qdrant vector database.

A server for Zero-Vector's hybrid vector-graph persona and memory management system, featuring advanced LangGraph workflow capabilities.

Implement semantic memory layer on top of the Qdrant vector search engine

Provides AI assistants with persistent memory using ChromaDB vector storage.

An MCP server for graph-based memory management, enabling AI to create, retrieve, and manage knowledge entities and their relationships.

MCP memory server with Hebbian learning — concept connections strengthen through co-activation and weaken through disuse.

Enables memory for Claude using a knowledge graph with fuzzy semantic search and persistent storage.

A knowledge graph server that provides persistent, multi-context memory for AI models.

A distributed memory bank MCP tool that stores memories in a KùzuDB graph database, with repository and branch filtering capabilities.

Provides persistent memory for AI models using a local knowledge graph.