Zep keeps a temporal knowledge graph per user, built from the messages you add, and returns a context block for you to place in your prompt. Its strengths are facts that change over time and business data beside chat; it has also moved towards enterprise customers, with credit-based plans (pricing). Alternatives differ on three questions:
- Who builds the prompt? You (a store you search), the vendor (it runs the agent), or the vendor for your call (it returns the request).
- What is the scope? A user across every conversation, an agent across its conversations, or one conversation.
- Who writes the memories? The vendor's extraction model, or your own agent's model.
Facts below come from each vendor's documentation, linked, as of the date above. We make Threadless AI, one of the eight options, so read its row with that in mind; we say where it is the wrong choice too.
Short answer
- Keep the temporal graph, host it yourself: Graphiti, the Apache-2.0 graph under Zep, or Cognee.
- A simpler user-memory API: Mem0 or Supermemory.
- A platform that runs the whole agent: Letta.
- A library inside a LangGraph app: LangMem.
- History and summary returned within a token budget: Honcho.
- The whole OpenAI request managed for one long conversation: Threadless AI.
- Stay on Zep if point-in-time questions over a user's changing facts are central and the credit plans fit your volume.
Why teams leave Zep
Each reason below is confirmed against Zep's own pages on the date above.
- The self-hosted Community Edition is no longer maintained. On 2 April 2025 Zep announced it would "stop maintaining and releasing Zep Community Edition"; the code stays under Apache-2.0 without updates or support (announcement). The
getzep/zeprepository now says it is "not Zep's product or service" (GitHub). - Self-hosting the graph means running a graph database. Graphiti, which remains open source, runs on Neo4j, FalkorDB or Amazon Neptune; its Kuzu driver is marked deprecated (Graphiti). That is a database to operate, back up and size.
- Credit pricing takes modelling. Every episode you send (a chat message, a JSON payload or a block of text) costs 1 credit per 350 bytes, rounded up. Free includes 10,000 credits a month; Flex is $125 a month for 50,000; Flex Plus is $375 for 200,000. Retrieval and storage cost no credits (pricing).
- A user graph is not conversation continuity. Zep's context block tells the model what it knows about a user. The conversation's own history, and keeping it under the window, is still yours to manage.
Do you need a temporal knowledge graph?
Zep's distinctive feature is bi-temporal facts: each fact records when it held in the world and when Zep learned it (Zep paper, facts). You need that if your agent must answer questions like "what plan was this customer on in March?" or reconcile records that arrive out of order.
You may not need it if your agent mostly needs the current state of things, recent context, and a sense of what is stale. Threadless AI handles time differently: newer facts replace older ones, and recalled older messages and facts come back with their dates. It does not answer point-in-time queries across a user's history. If you need those, stay with a temporal graph.
At a glance
| What it is | Who builds the prompt | Scope | Who writes memories | Open source | External DB to run | |
|---|---|---|---|---|---|---|
| Mem0 | Memory layer you add to and search | You | User, agent, app or run | Mem0 | Apache-2.0 (no graph) | Only if self-hosting |
| Supermemory | Memory and context engine for chat, documents and files | You, or its client wrapper | Namespaces you choose | Supermemory | SDKs | No (hosted) |
| Letta | Platform that runs stateful agents | Letta, which runs the agent | Agent | The agent itself | Apache-2.0 | Only if self-hosting |
| Cognee | Knowledge-graph memory library and server | You | Datasets and sessions | Cognee's pipeline | Apache-2.0 | Only if self-hosting |
| LangMem | LangGraph memory library | You | Namespaces you choose | Your agent's model, or a background manager | MIT | Your LangGraph store |
| Honcho | Memory that reasons about users and sessions | You, from its context call | Workspace, peer, session | Honcho | AGPL-3.0 | Only if self-hosting |
| Hindsight | Memory banks with retain, recall and reflect | You | A bank per user or agent | Hindsight | MIT | Only if self-hosting |
| Threadless AI | Hosted memory that returns the OpenAI request | Threadless AI, for your call | Conversation | Your agent's model notes key facts, with a note tool | No | No (hosted only) |
The alternatives
Graphiti (self-hosted)
The Apache-2.0 temporal graph Zep is built on (Graphiti). Closest to Zep in design, because it is the same graph. Weaker in that you run the graph database, the extraction model calls and the retrieval yourself; there is no hosted context block.
Mem0
A memory layer you add messages to and search; its LLM extracts facts (how it works). Simpler than Zep to start, with a free hosted plan. Weaker on time: recency is an opt-in ranking bias at search time (changelog), and hosted graph memory is a Custom-plan feature (pricing). See Mem0 alternatives.
Supermemory
A store plus graph for chat, documents, files and connectors, where updated facts win and temporary facts expire (graph memory). Stronger than Zep when documents and connected apps belong in memory. Pricing: Free with $5 of credits a month, then $19, $100 and $399 plans (billing). See Supermemory alternatives.
Letta
A platform that runs stateful agents; the agent edits its own memory files and older messages are summarised near the limit (MemFS). Stronger than Zep if you want the context window handled by the platform. Weaker if you have your own agent loop. See Letta alternatives.
Cognee
An Apache-2.0 knowledge graph plus vectors, with a temporal search mode where dates become timestamp nodes (docs). The nearest open-source answer to Zep's temporal graph. Pricing: Cloud free for 1M tokens, then $1.00 per 1M (pricing).
LangMem
LangChain's MIT library for memory inside LangGraph, storing to LangGraph's store (LangMem). Good fit if you already run LangGraph and want the agent's own model to write memories.
Honcho
An AGPL-3.0 library and service that reasons about users and returns "a blend of summary and messages which covers the entire session history" within a token budget (get context). When a fact changes, its dreaming step deletes the outdated conclusion and writes a new one (dreaming).
Hindsight
Vectorize's MIT memory banks; it records when something happened and when it was learned, and runs temporal search alongside semantic, keyword and graph search (docs). Good fit for an open-source server with time-aware recall, without operating a separate graph database.
Threadless AI
Hosted memory for OpenAI agents. Your agent sends what is new to decorate before each model call and gets back the whole request, history managed; report sends the reply after. Your model notes key facts with a note tool, and those facts stay in view after the older messages stop being sent word for word. Stronger than Zep when the conversation itself outgrows the window. Do not choose it for memory shared across a user's conversations, point-in-time queries, non-OpenAI providers or self-hosting. Prices are being finalised (pricing). See Threadless AI vs Zep.
Pricing at a glance
Checked on the date above; confirm on each vendor's page before you decide.
| Free | Paid entry | |
|---|---|---|
| Zep | 10,000 credits a month | Flex $125 a month (pricing) |
| Mem0 | Free plan with monthly add and retrieval limits | Custom, unpriced (pricing) |
| Supermemory | $5 of credits a month | Pro $19 a month (billing) |
| Letta | Up to 3 agents | Pro $20 a month (pricing) |
| Cognee | 1M tokens | $1.00 per 1M tokens (pricing) |
| Honcho | $5 of credits | $2.00 per 1M tokens ingested (homepage) |
| Hindsight | Free self-hosted (MIT) | Cloud from $10.00 per 1M tokens retained (billing) |
| LangMem | Library, no service | None |
| Threadless AI | Yes; allowances set with the prices | Prices being finalised (pricing) |
Benchmarks, with caveats
Each figure was published by the vendor about its own system. Models, judges and metrics differ, so the rows do not rank the products.
| System | Result | Who ran it | On what |
|---|---|---|---|
| Zep | LongMemEval 71.2% (full context 60.2%) | Zep | gpt-4o (paper) |
| Zep | LoCoMo 75.14% | Zep | Zep's rerun after disputing Mem0's setup (rebuttal) |
| Mem0 | LoCoMo 92.5, LongMemEval 94.4 | Mem0 | Its managed platform (research) |
| Letta | LoCoMo 74.0% | Letta | File tools, GPT-4o mini (blog) |
| Honcho | LongMemEval-S 90.4%, LoCoMo 89.9% | Plastic Labs | (evals) |
| Threadless AI | None yet | Runs in progress; we will publish scores with the method |
Migrating from Zep
- Export first. List your users, threads and graph data while you still have access.
- Decide what survives. Separate facts about users (move them to the new store, or to your system message) from conversation history (send recent turns when seeding the new system).
- Map the scope. Zep users and threads map to Mem0 users and runs, Supermemory namespaces, Hindsight banks, or one Threadless AI memory per thread.
- Replace add-messages plus get-context. For a store, call its ingest and search. For Threadless AI, call
decoratewith what is new and submit what comes back; callreportafter each reply; add the note tool. - Check time-sensitive answers. If your agent relied on fact validity dates, test those questions specifically on the new system.
- Run both side by side on real conversations before you turn Zep off.
Questions people ask
Is Zep open source?
The graph underneath it, Graphiti, is Apache-2.0 (Graphiti). Zep's hosted platform is not, and its self-hosted Community Edition is no longer maintained.
Can I self-host Zep for free?
Not as a maintained product. Zep stopped releasing Community Edition in April 2025. You can self-host Graphiti with your own graph database, or choose an open-source alternative such as Cognee, Honcho, Hindsight or Letta.
What happened to Zep Community Edition?
Zep announced on 2 April 2025 that it would stop maintaining and releasing it; the code remains under Apache-2.0 but gets no updates or support (announcement).
What is Graphiti?
Zep's open-source temporal knowledge graph library. It extracts entities and facts from episodes, records when each fact held, and stores them in Neo4j, FalkorDB or Amazon Neptune.
What is the best free Zep alternative?
For a temporal graph you host, Graphiti itself or Cognee. For a hosted free tier, Mem0, Supermemory or Zep's own 10,000 monthly credits.
Is Mem0 better than Zep?
They suit different needs, and each disputes the other's benchmark numbers. Mem0 is simpler for user facts; Zep is stronger on facts that change. See Mem0 vs Zep vs Letta.