Mem0 (pronounced "mem-zero") is a memory layer for AI agents and applications. It remembers a user's preferences and context across sessions, so a model doesn't have to start every conversation from scratch. There's an open-source version you can self-host and a managed cloud platform with a free tier.
A recent development pushed Mem0 into the spotlight: it now appears in Claude's official connector directory, meaning it can be added in a couple of clicks without touching a terminal or config files. Previously it had to be installed via the command line, so this opens persistent memory up to non-developers too.
What it actually is
Large language models don't remember past conversations. Every new request starts from zero, forcing users to re-explain context again and again. Mem0 gives an agent persistent memory: it pulls facts and preferences out of conversations, stores them, updates anything outdated, and injects the relevant pieces back in on the next interaction.
Under the hood is a hybrid storage setup combining graph, vector, and key-value databases. This mix keeps storage costs down and makes retrieving the right fragment faster. Mem0 can be used two ways: as an open-source library running on your own server, or as a cloud platform where memory works as a managed service with no infrastructure required on your end.
A memory layer, in this context, is a layer sitting between your application and the language model. It stores important facts about the user and the conversation, and automatically feeds them back into the prompt on the next request, making the agent appear to "remember."
A short history
Mem0 is a well-established, well-funded tool, and a brief timeline helps explain why it's trusted.
2023 — Founded by Taranjeet Singh (CEO, previously at Paytm and Khatabook) and Deshraj Yadav (CTO, formerly leading the Autopilot AI platform and FSD at Tesla). Mem0 grew out of their earlier RAG framework, Embedchain.
Summer 2024 — The company went through Y Combinator's S24 batch.
2025 — Launch of the managed platform and publication of memory benchmarks (LoCoMo, LongMemEval, BEAM).
October 2025 — A $24 million raise: seed funding from Kindred Ventures and a Series A led by Basis Set Ventures, with participation from Peak XV, GitHub Fund, and Y Combinator. Angel investors include Scott Belsky, Dharmesh Shah, and executives from Datadog, Supabase, PostHog, and Weights & Biases.
Today — Over 100,000 developers, more than 60,000 GitHub stars, and 14+ million downloads.
On benchmarks: Mem0 reports 92.5 points on LoCoMo and 94.4 on LongMemEval, noticeably ahead of previous approaches. These are the company's own measurements, but the benchmark methodology and code are public, so results can be independently verified. Note that these figures apply to the cloud platform; the open-source version performs similarly but not identically.
Core capabilities
Memory extraction: automatically pulls facts and preferences from a conversation, updates them, and discards outdated information — no manual tagging required.
Memory types: per-user, per-session, and per-agent memory, plus graph memory that captures relationships between entities (who is connected to what, and how).
Context compression: a Memory Compression Engine condenses history into compact memories, cutting token usage and response latency.
Search: semantic search over stored memory, so the agent retrieves relevant facts based on the meaning of a query, not just keywords.
Model neutrality: not tied to a single model or provider; memory can be exported and taken elsewhere.
Enterprise features: on-premise deployment, SSO, audit logs, private support, and SLAs.
Getting connected
There are SDKs for Python and Node.js, a REST API, and integrations with popular agent frameworks. Installation is a single line, and API keys are issued from the dashboard at app.mem0.ai.
Example in Python:
pip install mem0ai
from mem0 import MemoryClient
client = MemoryClient(api_key="...") # key from the app.mem0.ai dashboard
# store a fact about the user client.add("Prefers concise answers in English", user_id="alex")
# retrieve relevant memory before responding memories = client.search("what language and style should I use?", user_id="alex")
For a fully private setup, use the open-source library instead: memory is then stored entirely on your own infrastructure.
A five-minute quick start
If you'd rather skip the code, start with the Claude connector — the fastest route given the recent integration.
Open Claude's connector directory and find Mem0.
Connect your Mem0 account in a couple of clicks; no terminal or config files needed.
Create a free API key at app.mem0.ai if you also want to call memory from your own code.
Test it: tell the model a few facts about yourself, start a new chat, and ask a question that depends on that context. If it remembers, the integration is working.
For developers, the path is even shorter: pip install mem0ai, grab a key from the dashboard, and run your first client.add(...) as shown above.
Pricing and limits
Free (Hobby) — $0/month: 10,000 memory additions, 1,000 search queries, 1 project, unlimited end users, community support.
Starter — $19/month: 50,000 additions, 5,000 search queries, 1 project.
Growth — $79/month: 200,000 additions, 20,000 search queries, 3 projects, email support.
Pro — $249/month: 500,000 additions, 50,000 search queries, unlimited projects, private Slack channel.
Enterprise — custom pricing: usage-based billing, SLA, on-prem deployment, SSO, audit logs.
Self-hosted — free: open-source with no memory volume limits, but you cover the cost of the LLM, embeddings, and infrastructure (details below).
The free tier genuinely covers a lot: 10,000 memory additions and 1,000 retrieval calls per month is enough for a personal assistant, a side project, a prototype, or a bot with moderate traffic. There's no cap on end users even on the free plan, so you can test an idea with a real audience.
In practical terms, a memory add corresponds to a single stored fact. Mem0 extracts only meaningful information from a conversation and removes duplicates, so an exchange of messages typically results in anywhere from zero to a few additions. 10,000 per month comfortably covers a personal assistant or a bot with dozens of active users; you'd only realistically hit the limit with a service constantly ingesting new facts from hundreds of people.
Open source: what's free and what isn't
The Mem0 codebase itself is free, but self-hosting carries some less obvious costs.
What's genuinely free: the Apache 2.0 license means no licensing fees, commercial use is allowed, and you can fork and modify the code freely. Both the library (pip install mem0ai) and the self-hosted Docker server are free.
What you still pay for: LLMs and embeddings. Mem0 doesn't work standalone — it needs a model to extract facts (gpt-5-mini from OpenAI by default) and an embedding model. These are API costs, and the only way to eliminate them is by running local models (via Ollama or similar). You'll also need your own infrastructure: a vector database, storage for conversation history, and — for graph memory — a graph database like Neo4j. Server maintenance, updates, and backups are on you as well.
Limitations compared to the cloud: proprietary optimizations aren't included in the open-source release. The benchmark scores (92.5 on LoCoMo, etc.) reflect the managed platform; open-source results trend the same direction but aren't identical. Some features ship as limited previews in self-hosted mode, with the full set reserved for the cloud. Self-hosting documentation is thinner, since the team prioritizes the cloud product. Graph memory in the cloud is only available on the Pro plan; in open source you can build it yourself, but manually and with your own graph database.
Bottom line on open source: the code is free and gives you full control over your data, but the real cost comes from LLM and embedding usage, your own infrastructure, and ongoing maintenance. Going completely cost-free only works with local models and your own hardware.
Practical use cases
A personal assistant that actually remembers you. Tell it about your preferences, projects, and working context once, and the agent picks it back up automatically afterward. Benefit: no more repeating the same context in every new chat.
Customer support. A bot that remembers a customer's history and details across sessions. Benefit: customers don't have to re-explain their issue, answers are more accurate, and conversations are shorter.
An expert or consultant bot. The agent accumulates context on each user and builds a relationship over time. Benefit: personalized recommendations instead of generic, out-of-the-box responses.
Long working sessions with an agent. In large tasks, conversation history balloons and drives up costs. Memory compression keeps only what matters. Benefit: fewer tokens and a lower model bill.
Integration with your existing stack. Through the API, memory can be plugged into a Telegram bot, a Notion-based agent, or an n8n automation. Benefit: one shared memory across multiple channels instead of each one having its own amnesia.
Where it might not be the right fit
To keep things balanced, here are cases where alternatives might be worth a look.
If you need independent quality guarantees: the impressive benchmark numbers are Mem0's own measurements. The methodology is open, but independent comparisons sometimes show more modest results, particularly on tasks involving temporal reasoning (what happened before versus after).
If graph memory out of the box matters to you: in the cloud, it's only unlocked on the $249/month Pro plan, and some competitors offer graph-based relationships more cheaply or by default.
If you don't have resources for infrastructure: the fully free self-hosted route requires your own database, LLM API keys, and ongoing maintenance, and the documentation is thinner than for the cloud product.
If your use case is simple: for a short-lived bot without much long-term context, a dedicated memory layer is an unnecessary dependency and added cost — a good system prompt or the model's built-in memory may be enough.
Alternatives worth comparing
Letta (formerly MemGPT) — also focused on long-term agent memory, but leans more toward autonomous agents and its own execution environment.
Zep — memory and conversation history storage, closer to chatbot infrastructure.
A custom setup on a vector database (pgvector, Pinecone, Qdrant) — maximum flexibility, but you'll need to build fact extraction, updating, and graph relationships yourself.
Memory is what turns a one-off chatbot into an assistant that genuinely understands your context. As AI agents increasingly need to hold onto information across sessions, tools like Mem0 point to where a lot of agent infrastructure is heading — and with a functional free tier and an open-source option, it's easy enough to try before committing to a stack.