Mem0 (agent memory API)

Drop-in memory layer for LLM agents. Vector + graph memory variants (Mem0g) — the graph variant builds a directed labeled knowledge graph alongside the vector store, with conflict detection on contradictory facts. Leads the 2026 agent-memory benchmarks at 68.4% LLM Score on multi-hop questions. Works with any LLM, including local Ollama models.

Install via pip: pip install mem0ai. Requires Python 3.10+. Mem0 is a memory layer for LLM applications — it stores, retrieves, and updates personalized user memories without building the agent infrastructure yourself. Quick start: from mem0 import Memory; m = Memory(); m.add("I like pizza and live in New York", user_id="alice"); results = m.search("Where does Alice live?", user_id="alice"). The Memory class auto-configures with an in-memory vector store for development. For production: set MEM0_API_KEY to use the managed cloud service, or configure a local vector store (Qdrant, Chroma) in config.yaml. Mem0 auto-extracts memories from conversation messages: messages = [{"role": "user", "content": "I'm a vegetarian"}, {"role": "assistant", "content": "Got it, I'll remember that"}]; m.add(messages, user_id="alice") — it extracts the vegetarian preference automatically. Serve as a REST API: from mem0 import Memory; from fastapi import FastAPI wrap endpoints around m.add(), m.search(), m.get_all(). First run: ~30 seconds for package install and model download (default: all-MiniLM-L6-v2 for embeddings, GPT-4o-mini for memory extraction). Verify: run the search example above — it returns relevant memories. Time-to-first-memory: ~5 seconds including embedding computation.

Best for: adding user-level memory to LLM chatbots and applications without building memory infrastructure, personalization features where the LLM should remember user preferences across sessions, customer support bots that recall user history and context, AI companions that learn about the user over time, any application where "the chat should remember what the user said last week" is a product requirement. Not suited for: document-level RAG over files and databases (use LlamaIndex), full autonomous agents with memory-driven behavior (use Letta), applications requiring memory without API call overhead for extraction (build direct vector store + embedding integration), strict data sovereignty requirements (default extraction model is OpenAI-hosted), applications where memory should be graph-structured rather than text-embedded.

Use Mem0 when you need memory as a service — add user_id to your API calls and Mem0 handles storage, retrieval, deduplication, and memory update without you building a memory infrastructure. It's the lightest way to add user-level memory to any LLM application. Switch to Letta when you need a full agent framework with memory as one component — Letta's OS-inspired memory paging is more sophisticated but more opinionated. Use Zep for an alternative memory service with built-in conversation summarization and graph memory. Use LlamaIndex when memory is for document retrieval (RAG) not user preferences — Mem0 is user-centric memory, LlamaIndex is document-centric. Build your own memory layer with a vector DB when you need maximum control and minimal dependency. Mem0's strength: the extraction LLM automatically identifies what's worth remembering from conversations — you don't write memory extraction logic. Its weakness: the extraction model uses an API call (OpenAI by default), adding latency and cost to every .add() call.

Problem: Memory().add() hangs or fails silently. Fix: Mem0's default .add() sends messages to OpenAI for memory extraction (defaults to gpt-4o-mini). If OPENAI_API_KEY is not set, the call fails silently — set export OPENAI_API_KEY=sk-.... Or switch to a local model for extraction: configure "custom_fact_extraction_model" in the Memory config to use a local provider. Problem: Memory search returns irrelevant or empty results. Fix: Mem0's search uses semantic similarity. If memories are too generic, the embedding distance may not distinguish them. Check that filters={"user_id": "alice"} is applied — without user_id filtering, results mix across users. Adjust threshold=0.3 (lower = more results, higher = more relevant) in .search(). Problem: Duplicate or contradictory memories accumulate. Fix: Mem0's deduplication checks for near-duplicate memories at .add() time based on embedding similarity. If contradictory memories enter (e.g., "I live in New York" then "I live in Boston"), Mem0 doesn't auto-resolve — it stores both. Use m.update(memory_id, "I live in Boston") to manually update. For auto-resolution, implement a periodic memory reconciliation pipeline on your side.