Zep alternatives are other ways to give AI agents long-term memory: Graphiti (Zep’s own open-source core), Hindsight, Mem0, Letta, Cognee and Supermemory. Most people searching for one want a self-hosted, open-source option, because Zep stopped maintaining its Community Edition in 2025 and is now a managed, credit-priced service. Graphiti is the closest match to Zep’s model; Hindsight is the most complete open-source memory server, with graph and time-range recall, consolidation and reflect all in its MIT release.
This page covers what Zep does today, a comparison table, a short section per alternative, and how to choose. Facts come from each project’s README, docs and pricing page, checked in October 2026.
What Zep does, and why people look for Zep alternatives
Zep is a managed memory and context service for AI agents. It builds a temporal context graph for each user, customer or account, where facts carry dates and get updated as data changes, and returns the relevant facts to your agent in one call. It offers SDKs for Python, TypeScript and Go.
Zep’s homepage describes it as a “unified context layer for enterprise data” and claims retrieval “in under 200 milliseconds, regardless of graph size or count.” The design is described in the paper Zep: A Temporal Knowledge Graph Architecture for Agent Memory (Rasmussen et al., 2025).
Three changes drive most searches for alternatives:
- Community Edition is gone. In an April 2025 post, Zep said “we’ve decided to stop maintaining and releasing Zep Community Edition.” The getzep/zep README now says it is “not Zep’s product” and holds examples, integrations and an unsupported
legacy/folder. Old guides to running Zep with Docker describe that deprecated edition. - Self-hosting means Enterprise. Zep’s pricing page lists “Bring Your Own Cloud” (deployment in your VPC) as Enterprise only.
- Pricing is credit-based. Free gives 10,000 credits a month. Flex costs $125/month for 50,000 credits; Flex Plus is $375/month for 200,000. Each data object you send costs 1 credit per 350 bytes. Retrieval, storage and users are unmetered, so cost tracks how much you ingest.
If you’re happy with a managed service and those numbers, Zep is a strong temporal memory option. If not, read on.
Zep alternatives at a glance
| Tool | What it is | License | Self-host | Temporal facts | Hosted pricing (Oct 2026) |
|---|---|---|---|---|---|
| Graphiti | Open-source temporal graph framework (Zep’s core) | Apache 2.0 | Yes, bring Neo4j, FalkorDB or Neptune | Yes, bi-temporal with validity windows | None (library) |
| Hindsight | Memory server with retain/recall/reflect | MIT, every feature included | Yes, Docker, pip, Helm or embedded | Yes, time data extracted; time-range recall | Hindsight Cloud: pay as you go, retain $10 and recall $0.75 per 1M tokens, free credits |
| Mem0 | Memory layer for user, session and agent facts | Apache 2.0 | Yes, library or Docker server | Time-aware ranking; facts appended, not invalidated | Free (own LLM key after 30 days); Custom plans |
| Letta | Stateful agent harness | Apache 2.0 | Yes, local or App Server | No explicit fact timeline | Free; Pro $20/mo |
| Cognee | Knowledge graph memory engine | Apache 2.0 | Yes, pip or Docker | Bi-temporal memory listed for Enterprise | Free 1M tokens; $1 per 1M tokens |
| Supermemory | Memory, RAG and user-profile API | MIT (repo) | Local server; self-hosting listed on Scale plan | Handles temporal changes and expiry | Free $5 credits; Pro $19/mo |
Prices are published list prices and change often. Check each vendor’s page before deciding.
On benchmarks, Zep’s paper reports 94.8% on DMR and up to 18.5% higher accuracy on LongMemEval than its baselines. Mem0’s comparison page lists Hindsight at 94.6 and Mem0 at 94.4 on LongMemEval, and Hindsight ahead on the long-history BEAM test (73.9 vs 64.1 at 1M tokens, 64.1 vs 48.6 at 10M). All of these are vendor-run, with different setups.
Graphiti: the open-source core of Zep
Graphiti is the framework Zep uses under its service, released under Apache 2.0. It’s the most direct open-source answer to “self-hosted Zep.”
It builds a context graph: entities as nodes, facts as edges, and episodes (the raw ingested data) as provenance. Each fact has a validity window. When something changes, the old fact is invalidated, not deleted, so you can query what’s true now or what was true last March. Retrieval is hybrid: embeddings, BM25 and graph traversal. You can define custom entity and edge types with Pydantic models.
The tradeoff is scope. Graphiti’s own README compares it to Zep: with Graphiti you bring your own graph database (Neo4j, FalkorDB or Amazon Neptune), build your own user and conversation management, and tune retrieval performance yourself. It defaults to OpenAI for LLM extraction and embeddings, and works best with models that support structured output.
- Pick Graphiti if you liked Zep’s temporal model and can operate a graph database.
- Look elsewhere if you wanted Zep’s turnkey users, threads and dashboard without building them.
Hindsight
Hindsight is an MIT-licensed memory server, and the most complete open-source answer if you want a whole memory service rather than an engine. retain extracts facts, entities, relationships and time data with an LLM. recall runs semantic, BM25, graph and time-range searches in parallel and merges them with rank fusion and reranking, so a query like “what happened in June?” works. reflect reasons over the stored memories.
It also consolidates facts into observations, beliefs that keep their supporting evidence and get refined rather than overwritten when new facts arrive. That’s a different answer to the problem Zep solves with fact invalidation. Storage is PostgreSQL with pgvector, so there’s no separate graph database to run. It deploys with Docker, pip, Helm or embedded in Python, works with 25+ LLM providers including local ones like Ollama, and ships an MCP server plus plugins for Claude Code, Codex, Cursor and Copilot.
On Mem0’s own comparison page it scores 94.6 on LongMemEval and leads Mem0 by 9.8 and 15.5 points on BEAM at 1M and 10M tokens, which matters if your users build up long histories. Its README says collaborators at Virginia Tech and The Washington Post reproduced its results.
- Pick Hindsight if you want self-hosted, time-aware memory with every feature open source and no graph DB, long user histories, or memory for coding agents.
- Look elsewhere if you need Zep’s strict per-fact validity windows, or a document knowledge graph. Every retain makes LLM calls, it returns more context per retrieval than Mem0 (about 4x by Mem0’s measurement, tunable with
max_tokens), and the README says it “may be overkill” for simple automation workflows.
Mem0
Mem0 extracts facts from conversations with an LLM and stores them for user, session and agent scopes. It runs as a library, a self-hosted Docker server with dashboard and API keys, or the managed Mem0 Platform.
Its April 2026 algorithm is ADD-only: new facts are stored next to old ones instead of overwriting them, and time-aware retrieval ranks the current one higher. Graph memory was removed from the open-source SDK in that release and is now a Platform feature on Custom plans only.
- Pick Mem0 for a simple, widely integrated user-memory API you can self-host.
- Look elsewhere if you need explicit fact validity windows or graph memory in open source.
More in our Mem0 alternatives comparison.
Letta
Letta (formerly MemGPT) is an agent runtime, not a memory service. Letta Code agents store memory as Markdown files in a git-backed store (MemFS), search their own conversation history, and consolidate lessons in the background (“dreaming”). It’s Apache 2.0 and runs locally, on a self-hosted App Server, or on Letta Cloud.
- Pick Letta if you’re building the agent itself and want it to own and edit its memory.
- Look elsewhere if you need memory for an agent built in another framework, or a Python SDK. Letta’s Agent SDK is TypeScript only.
See the Letta guide for how its memory works and what it costs.
Cognee
Cognee builds a knowledge graph and vector index from documents, code and conversations, with remember, recall, improve and forget operations. It’s Apache 2.0, self-hostable with pip or Docker, and since v1.6 can run text memory on local models without an LLM key.
Cognee’s docs include a guide to importing memory from Mem0, Letta, Zep and Graphiti, which helps if you’re migrating off Zep. Bi-temporal memory with conflict resolution appears on its pricing page as an Enterprise feature, not in the free tier list.
- Pick Cognee if your memory is mostly company knowledge, documents and code.
- Look elsewhere if the main job is per-user facts that change over time.
Compare it further on our Cognee alternatives page.
Supermemory
Supermemory is a hosted memory and context API with fact extraction, auto-maintained user profiles, hybrid RAG plus memory search, and connectors for Google Drive, Gmail, Notion, OneDrive and GitHub. Its README says it handles temporal changes, contradictions and forgetting of expired information.
- Pick Supermemory if you want memory and RAG behind one API with little setup.
- Look elsewhere if open, self-run infrastructure is the whole point of leaving Zep. A local server exists, but self-hosting is listed under the $399/month Scale plan.
How to choose a Zep alternative
Start with the reason you’re leaving.
| If you’re leaving Zep because… | Look at |
|---|---|
| You need open source and self-hosting with the same temporal graph model | Graphiti |
| You need a self-hosted memory server without running a graph DB | Hindsight, Mem0 |
| You want graph, time-range recall and consolidation self-hosted, all free | Hindsight |
| Your users build up long histories | Hindsight |
| You need memory for coding agents (Claude Code, Codex, Cursor) | Hindsight, Mem0 |
| You want a simple user-memory API | Mem0, Supermemory |
| Your data is mostly documents and code | Cognee |
| You want the agent itself to manage memory | Letta |
| Credit costs grow with ingestion volume | Any self-hosted option; you pay for LLM extraction instead |
Two checks before you migrate:
- Do you rely on fact history? If your agent answers “what was true before?”, you need explicit time handling. Graphiti does it with validity windows; Hindsight with time-aware recall and evidence-backed observations. Read more on temporal reasoning in AI memory.
- Who pays for extraction? Self-hosting removes Zep’s credits but not the LLM calls. Graphiti, Mem0 and Hindsight all call an LLM on writes, so estimate tokens per message before you compare bills.