Zep alternatives for self-hosted agent memory

First, a disambiguation this search genuinely needs: this page is about Zep the AI agent memory platform (getzep.com) — not ZEP the Korean metaverse app that dominates half the results for "Zep alternative" on G2 and Capterra. If you're looking for virtual-office software, wrong page. If your agent's memory backend just lost its self-hosted option, keep reading.

Last updated: August 2026.

What happened

Zep built one of the most technically interesting memory systems in the category — a temporally-aware knowledge graph, backed by a real research paper. It also used to offer a self-hostable Community Edition. That ended: Zep announced it would stop maintaining and releasing Zep Community Edition, and the old open-source repository now carries a notice that it is not Zep's product. The commercial product is cloud-only.

To be fair about what remains open: Graphiti, the graph engine underneath Zep, is still open source and actively maintained. What's gone is the packaged, self-hostable product around it — the API server, the session management, the operational layer. More on what that distinction costs you below.

If you were running CE, or you shortlisted Zep specifically because you can't send conversation data to a third party, you now need a plan. Here's an honest map of the options — including the one where you stay with Zep.

What you're actually replacing

Zep CE gave you four things. Any replacement should be checked against all four, because they don't always travel together:

1. Session/message storage with user identity
2. Fact extraction — conversation in, structured knowledge out
3. Temporal handling — Zep's signature: facts carry validity intervals, and new information can invalidate old edges
4. A serving API — relevant context, fast, at generation time

The third one is the trap. Most "just use a vector store" advice replaces 1, 2 and 4 and silently drops 3 — and 3 is the difference between memory and a pile of embeddings. When a user changes their mind, a system without temporal handling will happily serve both versions forever.

The alternatives

Haki — if you want CE's promise, kept

Full disclosure: this is us. Haki is a self-hosted-first memory layer — Apache 2.0, one docker compose up, PostgreSQL 16 + pgvector, local embeddings, no account anywhere in the loop. On the temporal point specifically, it's built as a bitemporal ledger: facts carry validity dates and explicit statuses, a changed fact supersedes its predecessor with stored lineage, unresolved contradictions are served flagged with their dates rather than silently ranked, and every recall ships a trace explaining what was included and why. Deletion cascades with a timestamped receipt; tenant isolation is enforced by Postgres row-level security, not application code.

The honest limits: the ecosystem is young (MCP server, n8n node, OpenAI-compatible gateway, Python/TypeScript SDKs — but nothing like Zep's framework coverage at its peak), and there's no graph traversal — multi-hop entity queries are handled by entity expansion over a relational store, not Cypher.

Pick this if: the reason you chose CE was sovereignty, and you want the temporal guarantees as tested product behavior rather than a build project.

Letta — if the agent, not the memory, is your unit

Letta (the MemGPT team) is an Apache-2.0 agent runtime where memory is a first-class part of the agent: in-context memory blocks the agent edits itself, plus archival storage, on your own Postgres. It's a different philosophy — you adopt an agent framework and get its memory, rather than adding memory to agents you already have. Self-hosting is real and documented.

Pick this if: you're building agents from scratch and want memory as an agent capability, not a service your existing stack calls.

Cognee — if your problem is knowledge pipelines

Cognee is open source and self-hostable, focused on turning documents and conversations into a queryable graph+vector layer with explicit pipelines. Strong when your memory problem is really a knowledge-ingestion problem (lots of sources, structured outputs). It's a toolkit more than a drop-in memory API — expect to make pipeline decisions.

Pick this if: ingestion breadth matters more than per-user conversational memory.

Graphiti, assembled yourself — if you want Zep's engine without Zep

The engine is genuinely open: temporal knowledge graph, entity extraction, edge invalidation. What you're signing up to build around it: the serving API, user/session identity, retrieval tuning, deletion propagation, observability, and the operational layer CE used to provide. That's not a weekend. It's the right call for teams with strong infra capacity who specifically want graph semantics.

Pick this if: you have the engineering budget and the graph model is the point.

Staying with Zep Cloud — the option this page owes you

If your constraint was cost rather than sovereignty, Zep Cloud remains a serious product with the best-known temporal graph in the category. The trade is the one this whole page is about: your conversation stream transits a vendor, and your memory lives behind their roadmap — the same roadmap that ended CE.

Comparison at a glance

Migrating off CE, practically

Whatever you pick: export your sessions and messages while your CE instance still runs — messages are the ground truth, extracted facts can be regenerated. Map Zep's user_id to the new system's subject identity before re-ingesting (memory without stable identity silently fragments). Re-ingest chronologically so temporal logic sees events in order. Then run a two-session test — state a preference, contradict it, new session, ask — and check the old value is marked replaced, not just outranked. If the new system can also show you why it answered, you've replaced everything CE promised, including the part it never quite shipped.