Mem0 alternatives: 7 open-source and hosted options (2026)
Seven Mem0 alternatives compared from their own docs: Zep and Graphiti, Letta, Supermemory, Cognee, LangMem, Basic Memory, and native Claude Code memory.
People look for Mem0 alternatives for different reasons. Some want a fully local setup. Some need facts that change over time. Some are building on LangGraph, or want an agent platform rather than a memory component. "Alternative" means something different in each case.
This list groups seven options by the reason you'd switch, using each project's own repository and documentation, checked on 16 November 2026. For a deeper look at the four best-known, see Mem0 vs Zep vs Letta vs Supermemory.
The short answer
| Alternative | Pick it if you need | License | GitHub stars (16 Nov 2026) |
|---|---|---|---|
| Zep and Graphiti | Facts that change over time, with history | Graphiti: Apache-2.0 | Graphiti: 32,835 |
| Letta | A platform that runs stateful agents end to end | Apache-2.0 | 25,457 |
| Supermemory | One API for memory, retrieval, and profiles, hosted or self-hosted | MIT | 31,635 |
| Cognee | A free, local knowledge graph with no API key | Apache-2.0 | 33,343 |
| LangMem | Memory tools for LangGraph agents | MIT | 1,771 |
| Basic Memory | Markdown notes people and agents both edit | AGPL-3.0 | 4,594 |
| Native agent memory | A coding agent that remembers your preferences | Built in | Not applicable |
For reference, Mem0 itself is Apache-2.0 with 69,037 stars, and offers a hosted platform alongside the open-source version.
Zep and Graphiti: when facts change
Graphiti is Zep's open-source framework for temporal knowledge graphs. It stores entities and relationships with time attached, so it can tell what was true before a change and what is true now, instead of holding two conflicting notes. Zep builds a hosted context layer for enterprise data on top of it.
Graphiti runs on FalkorDB or Neo4j and needs an LLM provider for extraction. Its MCP server is labeled experimental. See temporal knowledge graph.
Letta: when you want a platform, not a component
Letta, formerly MemGPT, runs stateful agents that keep their state on the server. Each agent has core memory and archival memory and edits its own memory as it works. It runs on Letta Cloud or self-hosted. Choose it if you want the platform to run the agent; it's a bigger commitment than adding a memory component.
Supermemory: when you want one API for everything
Supermemory describes itself as context infrastructure for AI agents: memory, retrieval, and user profiles through one API. It indexes text, files, chats, and connector data into a semantic graph by namespace. It's hosted, or self-hosted as a single binary that can run offline, and it has a Claude Code plugin and an MCP server.
Cognee: when it must run locally and free
Cognee is an open-source AI memory platform that turns documents, code, and conversations into a self-hosted knowledge graph. Its README says it runs locally for free with no API key, using small models on your CPU. It suggests uses such as a company brain that connects decisions to the discussion and code behind them, and memory across agent runs.
LangMem: when you build on LangGraph
LangMem, from LangChain, helps agents extract information from conversations, refine their own prompts, and keep long-term memory. It provides memory tools agents use during a conversation, a background manager that consolidates knowledge, and native integration with LangGraph's long-term memory store. It works with any storage system through its core API.
Basic Memory: when people need to edit memory too
Basic Memory keeps knowledge as plain markdown files and builds a graph from notes and links, accessed over MCP. People can read and edit the same notes agents retrieve. It is free to run locally under AGPL-3.0, with a paid hosted workspace for syncing across devices.
Native agent memory: when it's a coding agent
If the agent is Claude Code or Codex, check what it already does before adding anything. Claude Code loads CLAUDE.md files and its own auto memory each session; Codex reads AGENTS.md and has an optional Memories feature. Both keep that memory on one machine. See how Claude Code memory works and Codex memory.
Add a memory layer when memory must cross tools, machines, or people, and connect it over MCP. See the best MCP memory server for Claude Code.
What every option shares
All seven are built for recall: return what an agent learned or was told. Some, like Graphiti, also track how facts change. None records whether a team agreed to something, who owns it, or what replaced it. For preferences, history, and user facts, that doesn't matter. For a team building against product and architecture decisions, it does.
Where Lockstep fits
Lockstep is shared team memory for Claude Code, built for decisions rather than recall. Decisions are captured from PRDs, Slack, and pull requests, become binding when their owner approves them, and are marked replaced when a newer version is approved. Claude Code is briefed on the current ones at the start of each session, and any MCP agent can query them.
It doesn't replace a memory layer for recall; many teams will use both. Session briefings work with Claude Code today. See how it works.
Sources checked 16 November 2026
- https://github.com/mem0ai/mem0
- https://github.com/getzep/graphiti
- https://help.getzep.com/overview
- https://docs.letta.com/overview
- https://supermemory.ai/docs/intro
- https://github.com/topoteretes/cognee
- https://github.com/langchain-ai/langmem
- https://github.com/basicmachines-co/basic-memory
Related reading
For the four best-known in depth, see Mem0 vs Zep vs Letta vs Supermemory. For how memory differs from the context window and RAG, see agent memory vs context window vs RAG.
Frequently asked questions
- What are the best open-source alternatives to Mem0?
- Graphiti (Apache-2.0) for temporal knowledge graphs, Letta (Apache-2.0) for stateful agents, Supermemory (MIT) for a memory and context API, Cognee (Apache-2.0) for a local knowledge graph, LangMem (MIT) for LangGraph agents, and Basic Memory (AGPL-3.0) for markdown notes shared by people and agents.
- Is Mem0 open source?
- Yes. Mem0's GitHub repository is Apache-2.0 licensed, and Mem0 also offers a hosted platform. Many teams compare the open-source version with alternatives when they need a different memory model rather than a different license.
- Which Mem0 alternative runs fully locally?
- Cognee says it runs locally for free with no API key, using small models on your CPU. Supermemory can be self-hosted as a single binary, including offline. Basic Memory keeps plain markdown files on your disk. Graphiti runs on your own graph database but needs an LLM provider key.
- Do coding agents need Mem0 or an alternative?
- Often not at first. Claude Code already loads CLAUDE.md files and its own auto memory each session, and Codex has AGENTS.md and an optional Memories feature. Add a memory layer when memory must be shared across tools, machines, or people.
- Can a memory layer track team decisions?
- It can store the text of a decision, but memory layers are built for recall, not approval. They don't record who owns a decision, whether it was approved, or what replaced it, which is what a team needs to build against it.
Keep reading