Compare · Zep alternatives
Top Zep Alternatives for AI Agent Memory
The best Zep alternatives for AI agent memory are Engram (Weaviate), Letta (MemGPT), Cognee and LangMem — 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 — 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).
Mechanism
How Zep temporal knowledge graph memory works
Ingest
Conversation turns or documents arrive
Extract
Entities, relationships, facts — not raw chunks
Graph write
Nodes/edges with timestamps + validity windows
Retrieve
Graph traversal + 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
Zep vs 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
Zep alternatives compared (2026)
Last updated: July 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 |
| 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
Alternative tool profiles
Engram (Weaviate)
Strengths: unified vector DB + 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.
Letta (MemGPT)
Strengths: unbounded effective context, tiered memory hierarchy.
Weaknesses vs Zep: not optimized for structured temporal fact graphs.
Best for: long conversation history as the bottleneck.
LangMem
Strengths: native LangGraph integration.
Weaknesses vs Zep: ecosystem lock-in, no cross-framework temporal KG.
Best for: LangGraph agent teams.
Head to head
Zep vs Engram: which is better?
Engram wins for simpler API and faster personalization POC; Zep wins when facts evolve and relationships matter.
- Weaviate-native stack → Engram (unified vector + 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)
Stay
When to stick with Zep
- 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 to migrate from Zep
- Export graph — nodes, edges, timestamps, validity windows
- Map schema to target (vectors vs paging tiers vs LangGraph store)
- Re-embed text facts if moving vector-only
- Run retrieval POC on conflict scenarios
- Dual-write cutover; validate invalidation behavior
FAQ
Frequently asked questions
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.