Compare · Zep alternatives
Top Zep Alternatives for AI Agent Memory
The best Zep alternatives for AI agent memory are Engram (Weaviate), Letta (MemGPT), Cognee, LangMem and Hindsight: compared on architecture, memory ops, temporal-graph vs vector trade-offs and fit.
Graphiti pipeline
Baseline
What is Zep?
Zep is a managed and open-source platform for temporal knowledge-graph memory in LLM agents.
Core engine: Graphiti, which builds and queries a bi-temporal knowledge graph from conversations and documents. Facts have validity over time; relationships are first-class; memory updates can invalidate or supersede older facts. Paper: “Zep: A Temporal Knowledge Graph Architecture for Agent Memory” (Rasmussen et al., 2025, arXiv:2501.13956).
Why switch
Why look for a Zep alternative at all?
Zep’s temporal knowledge graph has no real substitute, but it comes with real, specific costs 2 independent comparisons both name.
Zep’s self-hostable Community Edition has been discontinued; the only options today are Zep Cloud, a managed, credit-based service, or building directly on the open-source Graphiti engine yourself, which means provisioning and operating a separate graph database (Neo4j, FalkorDB or Kuzu) alongside it. Zep Cloud’s credit model charges for every add, search and background episode-processing operation, which one comparison notes makes cost hard to forecast for high-volume agents, and the free tier (1,000 credits) is enough to test the API but not to prototype a real workload. A separate, independently-written comparison from a competing vendor names a related concern from a different angle: the temporal graph’s conceptual overhead, entities, temporal edges, validity windows, is more than many straightforward agent use cases need, and query performance can degrade at scale with deeply nested relationship traversals. Neither of these sources questions Zep’s core capability; both agree it’s the strongest option specifically for tracking how facts and relationships change over time. The question this page actually answers is what to reach for when that specific strength isn’t what your agent needs.
Self-hosting via raw Graphiti is a bigger operational shift than it first sounds. Once the managed Community Edition is off the table, a self-hosted deployment means running the graph database itself, plus whatever embedding and LLM infrastructure the extraction pipeline needs, as 3 separate systems to provision, monitor and keep patched, rather than 1. For a team that only wanted a memory layer, that’s a meaningfully larger surface to operate than a single self-hosted process, which is exactly the gap that pushes some teams toward alternatives that bundle storage into the memory tool itself.
Mechanism
How does Zep’s temporal knowledge graph memory actually work?
Five steps, from raw conversation to a queryable, self-correcting graph of facts.
Ingest
Conversation turns or documents arrive
Extract
Entities, relationships, facts, not raw chunks
Graph write
Nodes and edges with timestamps plus validity windows
Retrieve
Graph traversal plus semantic search hybrid
Invalidate
New facts supersede or conflict-resolve old ones
Vector memory finds similar text; Zep models facts, relationships and when they were true. → Conflicting memories
Disambiguation
How does Zep differ from vector database memory?
Vector DB memory embeds text and searches by similarity; Zep adds graph semantics and temporal validity on top.
When vectors alone suffice: per-user preferences that rarely conflict. When Zep wins: CRM timelines, policy versioning, facts that change over time with audit trails.
Side by side
How do the Zep alternatives compare, side by side?
Last updated: September 2026. Architecture, ops and fit at a glance.
| Tool | Architecture | Memory ops | Temporal KG? | Best for |
|---|---|---|---|---|
| Engram (Weaviate) | Vector-native layer | Async extract, transform, commit | No | Weaviate-native stacks |
| Hindsight | 4-retriever hybrid | Extract, reflect, rerank | Partial (temporal filter) | Self-hosting without a graph DB |
| Letta | Virtual paging | Page in/out, tiered store | No | Very long conversations |
| LangMem | LangGraph store | Extract, store, retrieve | No | LangGraph teams |
| Cognee | Evolving KG | Graph write, query | Partial | Document-heavy KB agents |
Profiles
What does each alternative actually offer?
Real numbers where they exist, and each tool’s own honest weakness against Zep, not just its selling points.
Engram (Weaviate)
Vector-native memory layer
Strengths: unified vector DB and memory, per-interaction updates, no separate graph store.
Weaknesses vs Zep: no Graphiti-style bi-temporal relationship graph; temporal invalidation less explicit.
Best for: Weaviate-native apps when graph ops are unwanted.
Hindsight
4-retriever hybrid memory engine
Strengths: self-hosts with a single Docker command on embedded PostgreSQL (no separate graph database), MIT license, merges semantic search, keyword matching, entity-graph traversal and temporal filtering with a cross-encoder rerank.
Weaknesses vs Zep: a newer project (reported at roughly 4,000 GitHub stars, launched 2025), temporal modeling not as deep as Zep’s validity windows on every edge, an added reflect step introduces extra LLM-call latency.
Note: Hindsight’s own vendor reports a 94.6% LongMemEval score against a reported 63.8% for Zep (GPT-4o); treat this as that vendor’s own comparison, not an independently reproduced result.
Best for: teams that want self-hosting without operating a graph database.
Letta (MemGPT)
Virtual context paging
Strengths: unbounded effective context, a tiered memory hierarchy, agents that self-edit their own memory blocks, built on a peer-reviewed research paper, reported $10M seed funding led by Felicis Ventures.
Weaknesses vs Zep: not optimized for structured temporal fact graphs; adopting a full runtime rather than a lightweight library is a heavier commitment.
Best for: long conversation history as the bottleneck, or agents that need to actively manage their own context.
LangMem
LangGraph store + checkpointer
Strengths: native LangGraph integration.
Weaknesses vs Zep: ecosystem lock-in, no cross-framework temporal KG.
Best for: LangGraph agent teams.
Cognee
Knowledge graph + vector, embedded
Strengths: 30+ data-source connectors including multimodal ingestion (text, images, audio transcriptions), runs fully locally with embedded defaults (SQLite, LanceDB, Kuzu), no external graph database to manage, reported roughly $8.1M seed funding.
Weaknesses vs Zep: Python-only (no TypeScript or Go SDK), smaller community, no temporal validity windows.
Best for: document-heavy knowledge-base agents that want everything running locally.
Head to head
Zep vs Engram: which is actually better for your stack?
Engram wins for simpler API and faster personalization POC; Zep wins when facts evolve and relationships matter.
- Weaviate-native stack: Engram (unified vector and memory)
- Support bot user prefs: Engram (simple per-user facts)
- CRM timeline with changing account status: Zep (temporal invalidation)
- Policy versioning (“refund window changed in Q3”): Zep (validity windows)
Decision matrix
Which alternative fits your actual reason for leaving Zep?
Start with why Zep isn’t working, not with a feature checklist.
| If your issue with Zep is | Consider first |
|---|---|
| Already on Weaviate, want one unified layer | Engram |
| Can’t self-host without a graph database | Hindsight (embedded Postgres, MIT) |
| Credit-based pricing is unpredictable | Hindsight (free self-hosted) or Letta (flat tiers) |
| Need multimodal ingestion | Cognee (30+ connectors) |
| Want agents that manage their own memory | Letta (self-editing memory blocks) |
| Already standardized on LangGraph | LangMem |
Stay
When should you stick with Zep?
Five signals that its temporal graph is genuinely earning its complexity, not just adding it.
- Temporal knowledge graph is non-negotiable
- Facts change over time (CRM, policies, preferences with validity)
- Relationship traversal required
- Graphiti conflict resolution needed
- Strong cross-session recall on your workload type
Migrate
How do you migrate away from Zep?
The same 5-step sequence regardless of which alternative you’re moving to.
- Export the graph: nodes, edges, timestamps, validity windows
- Map schema to the target (vectors vs paging tiers vs LangGraph store)
- Re-embed text facts if moving vector-only
- Run a retrieval POC on conflict scenarios
- Dual-write cutover; validate invalidation behavior
FAQ
Frequently asked questions
Zep’s real limitations, how the alternatives compare, and how to migrate.
What is the best alternative to Zep?
Depends on need: Engram (Weaviate) for vector-native stacks, Mem0 for fast personalization API, Letta for long conversations, LangMem for LangGraph. Zep itself is best when temporal graph memory is required. See comparison table above.
Is Engram better than Zep?
Engram wins for simpler API and faster personalization POC on Weaviate-native stacks. Zep is better when facts change over time and you need relationship traversal and conflict resolution. See Zep vs Engram section above.
Zep vs Letta — which for long conversations?
Letta (MemGPT) for unbounded conversation history via paging. Engram or Zep for structured facts — Engram for vector-native stacks, Zep for temporal graphs. See Letta alternatives.
Can Engram replace Zep's temporal memory?
Partially — Engram handles dynamic per-user memory on Weaviate but lacks Graphiti's bi-temporal relationship graph and explicit validity windows. Choose Zep when temporal KG is non-negotiable. See Engram explained.
What is Graphiti and how does it relate to Zep?
Graphiti is Zep's temporal knowledge-graph engine — it extracts entities and relationships, stores bi-temporal edges and invalidates superseded facts. Zep is the platform; Graphiti is the graph engine (Rasmussen et al., 2025). See knowledge graphs for memory.
Is Zep open source?
Zep offers OSS Graphiti components plus managed Zep Cloud. Engram, Mem0, Letta and others also offer OSS + managed tiers. See open-source vs managed.
Zep vs RAG — do I need both?
Yes for most production agents. RAG for static org documents; Zep for dynamic agent memory with temporal facts. Engram can also serve memory on Weaviate alongside RAG. See memory vs RAG.
Is Zep good for customer-support bots?
Yes when policies change and ticket history involves evolving entity relationships. For simple per-user prefs, Engram or Mem0 may be faster to ship. See customer support use case.
Is Zep the same as a vector database?
No. Zep is a temporal knowledge-graph memory layer. Vector DBs store embeddings for similarity search. Engram adds memory semantics on Weaviate; Zep adds graph semantics and temporal validity. See vector vs knowledge graph.
How does Zep handle conflicting memories?
Graphiti invalidates or supersedes older facts when new information arrives — bi-temporal edges track when facts were valid. See conflicting memories.
How does Zep long-term memory work for LLM apps?
Conversations and docs are ingested → entities and relationships extracted → stored in a temporal graph → retrieved via traversal + search → facts invalidated when superseded. Persists across sessions. See mechanism section above.
Engram vs Zep for CRM agent memory?
Zep when account status, relationships and policy validity change over time. Engram (Weaviate) when you're on Weaviate and need dynamic user memory without graph engineering. See Zep vs Engram section above.
What are Zep's real limitations?
Its self-hostable Community Edition is discontinued, so self-hosting means running Graphiti plus your own graph database. Zep Cloud's credit-based pricing is hard to forecast, and the free tier (1,000 credits) is thin for real prototyping.
What is Hindsight, and how does it compare to Zep?
Hindsight is a memory engine that merges 4 retrieval strategies (semantic, keyword, entity-graph, temporal) and self-hosts on embedded Postgres with no separate graph database, under an MIT license. Its own vendor reports a 94.6% LongMemEval score against 63.8% for Zep; treat that as the reporting vendor's own comparison, not an independent benchmark.