MemPalace vs Zep: Free Local Memory vs Temporal Knowledge Graph in 2026
Two fundamentally different approaches to AI memory. One stores everything verbatim and scores 100% on LongMemEval. The other builds a temporal knowledge graph that tracks how facts change over time. Here is the complete comparison.
MemPalace vs Zep:MemPalace is a free, local-first AI memory system that scores 100% on LongMemEval by storing conversations verbatim with AAAK compression and a 4-layer retrieval stack. Zep (and its Graphiti engine) is a VC-backed temporal knowledge graph platform scoring ~85% on LongMemEval that extracts structured entities and tracks how facts change over time using Neo4j. MemPalace costs $0/year with MIT licensing; Zep Cloud costs $0–475/month. MemPalace runs entirely locally; Zep is cloud-first with a self-hostable open-source core.
Quick Verdict (TL;DR)
Choose MemPalace if…
- ✓You want maximum accuracy— 100% LongMemEval
- ✓Privacy is paramount — fully local, no Neo4j needed
- ✓Zero cost, no cloud tiers or graph DB ops
- ✓You need verbatim storage— nothing is extracted or discarded
Choose Zep if…
- ✓You need temporal knowledge graphs with entity tracking
- ✓Entity relationships and how facts change over time matter most
- ✓You want a managed cloud platform with enterprise tiers
- ✓Your agents need structured multi-hop queries across entities
Feature-by-Feature Comparison
| Feature | MemPalace | Zep / Graphiti |
|---|---|---|
| LongMemEval Score | 100% (hybrid) / 96.6% (raw) | ~85% |
| Pricing | Free (MIT) | $0–475/mo (open-source + cloud tiers) |
| Runs Locally | Yes, fully — zero dependencies | Graphiti OSS (requires Neo4j) |
| Storage Approach | Verbatim + AAAK compression | Structured entity extraction |
| Knowledge Graph | SQLite temporal triples | Neo4j (Graphiti) |
| Temporal Tracking | Timestamp-based retrieval | First-class temporal edges |
| Entity Relationships | Implicit via semantic search | Explicit graph traversal |
| Vector DB | ChromaDB (embedded) | Integrated in Zep Cloud |
| MCP Tools | 19 tools | Basic MCP support |
| Architecture | Wings/Rooms/Halls/Closets/Drawers | Entity → Relationship → Episode |
| API Keys Required | Optional (for reranking) | Required for cloud; Neo4j for self-host |
| Language | Python | Python / TypeScript |
| License | MIT | Apache 2.0 (Graphiti) / Proprietary (Cloud) |
| Deployment Model | Local-first, pip install | Cloud-first, self-host option |
| Funding | Open-source community | VC-backed |
Cells highlighted in green indicate the stronger option for that row. Data as of April 2026.
Architecture Comparison
MemPalace — The Memory Palace
MemPalace uses the Memory Palace metaphor: Wings, Rooms, Halls, Closets, and Drawers. Every conversation is stored verbatim, then organized spatially and compressed with AAAK (30x lossless compression).
The system runs a 4-layer retrieval stack(L0–L3): from fast keyword lookup to full semantic reranking. At startup, it wakes up with roughly 170 tokensof context — just enough to orient the AI without flooding the prompt window.
Zep — Temporal Knowledge Graph
Zep's core innovation is Graphiti, a temporal knowledge graph engine that extracts structured entities from conversations and builds relationship edges between them. Instead of storing raw text, it creates a living graph that tracks how facts evolve over time.
The architecture centers on Neo4jfor graph storage and traversal, enabling multi-hop queries like “What changed about Project X since last month?” Zep Cloud adds managed infrastructure, vector search, and enterprise APIs on top of the Graphiti engine.
Key philosophical difference: MemPalace stores everything verbatim and makes it findable through spatial organization and multi-layer semantic retrieval. Zep extracts structured entities and builds explicit relationship graphs, trading raw completeness for structured queryability. The benchmark results suggest the “store everything” approach yields significantly higher recall, while Zep's graph approach excels at answering specific entity-relationship questions.
Benchmark Deep Dive
LongMemEval (500 questions)
LongMemEvaltests how well a memory system can answer questions across long conversation histories. It covers fact recall, temporal reasoning, multi-hop inference, and knowledge updates over time — areas where Zep's temporal graph should theoretically shine.
MemPalace
100%
Hybrid mode (with Haiku reranking)
96.6%
Raw mode (zero API cost)
Zep / Graphiti
~85%
Temporal knowledge graph
Why the Gap Matters
Zep's temporal knowledge graph is designed to track entity changes over time, which should give it an advantage on temporal reasoning questions. Yet MemPalace still outperforms by ~15 percentage points. The reason: entity extraction is inherently lossy. When an LLM decides which facts to extract and which to discard, it inevitably misses context that later turns out to be relevant.
MemPalace's verbatim approach sidesteps this problem entirely. By storing everything and relying on a 4-layer retrieval stack to find the right memories at query time, it achieves higher recall without needing to predict which facts will matter in the future.
Temporal Reasoning
Temporal reasoning — answering questions like “What was the user's opinion on X before they changed their mind?” — is Zep's core strength. Its knowledge graph explicitly tracks when facts were created, updated, or invalidated. MemPalace handles temporal queries through timestamp-based retrieval and conversation ordering, which is less structured but still effective: the raw conversation history naturally preserves the sequence of belief changes.
Methodology note: All benchmark numbers for MemPalace come from the project's published evaluation suite. Zep numbers are based on publicly available reports and community benchmarks. Conditions may not be perfectly identical — interpret the gap directionally rather than as an exact delta.
In head-to-head comparison, MemPalace outperforms Zep/Graphiti by approximately 15 percentage points on LongMemEval. Despite Zep's purpose-built temporal knowledge graph, MemPalace's verbatim storage and multi-layer retrieval achieves higher overall accuracy across all question categories.
Pricing Analysis
MemPalace
$0/year
- ✓MIT license, unlimited use
- ✓All 19 MCP tools included
- ✓Local embedding (no API needed)
- ✓No Neo4j or graph DB to manage
- ·Optional: ~$0.001/query for Haiku reranking
Zep
$0–$475/month
- ·Free: Graphiti open-source (self-host Neo4j)
- ·Starter: Free tier (limited usage)
- ·Growth: usage-based pricing
- ·Enterprise: up to $475/mo + custom pricing
Total Cost of Ownership: Beyond the Sticker Price
Zep's self-hosted option is free in license cost, but running Neo4j adds significant operational overhead. A production Neo4j instance typically requires 4–8 GB of RAM and dedicated maintenance. With Zep Cloud, you avoid the ops burden but pay $0–475/month depending on usage.
- MemPalace:~$0.70/year total (optional Haiku reranking). $0 if using raw mode only. No external databases to manage.
- Zep Cloud:$0–$5,700/year depending on tier, plus infrastructure costs if self-hosting Neo4j (~$50–200/month for a production instance).
When to Choose MemPalace
- 1
You want the highest benchmark scores
MemPalace leads on LongMemEval with 100% — 15 points above Zep's ~85%. If raw accuracy on memory recall is your priority, the numbers are decisive.
- 2
Privacy and data sovereignty matter
Everything stays on your local machine. SQLite databases, ChromaDB vectors, AAAK-compressed archives — no cloud, no Neo4j, no data leaving your filesystem.
- 3
You want zero operational complexity
pip install, connect to Claude Code, done. No Neo4j to deploy, no graph database to tune, no cloud credentials to rotate. MemPalace's embedded architecture means fewer moving parts.
- 4
You use Claude Code or MCP clients
MemPalace was built for MCP-native workflows. Its 19 tools integrate directly with Claude Code, Claude Desktop, and any MCP client — giving your AI fine-grained memory operations out of the box.
- 5
You want verbatim memory, not summaries
MemPalace stores everything exactly as it was said. Nothing is extracted, summarized, or discarded by an LLM. You get full-fidelity recall of exact conversations.
When to Choose Zep
- 1
You need rich entity-relationship queries
Zep's Neo4j-powered knowledge graph enables multi-hop traversal queries like 'Show me all projects related to person X that changed status in Q1.' If structured entity queries are your primary use case, Zep's graph is purpose-built for this.
- 2
Temporal fact tracking is critical
Graphiti's first-class temporal edges explicitly track when facts were created, updated, or invalidated. If your agents need to reason about how entities changed over time with structured precision, Zep has a native advantage.
- 3
You want a managed cloud platform
Zep Cloud handles Neo4j operations, scaling, and maintenance. If you don't want to manage any infrastructure and prefer a hosted API, Zep's cloud offering removes that burden.
- 4
You're building multi-agent systems
Zep's shared knowledge graph can serve as a centralized memory layer across multiple agents. Its entity-relationship model maps well to multi-agent architectures where agents need to share structured context.
- 5
You need structured data extraction
If your use case is more about extracting and querying structured facts from conversations (rather than recalling exact wording), Zep's entity extraction pipeline is designed precisely for this pattern.
Frequently Asked Questions
Is MemPalace really free compared to Zep?+
Yes. MemPalace is MIT-licensed and completely free to use with no restrictions. The only optional cost is approximately $0.001 per query if you enable Haiku reranking. Zep offers a free open-source Graphiti engine (but you need to run Neo4j yourself), while Zep Cloud tiers range from free to $475/month.
What is Graphiti and how does it relate to Zep?+
Graphiti is Zep's open-source temporal knowledge graph engine. It builds entity-relationship graphs that track how facts change over time using Neo4j as the underlying graph database. Zep Cloud is the hosted commercial platform built around Graphiti, adding managed infrastructure, cloud APIs, and enterprise features.
Which system has better benchmark scores?+
MemPalace leads with 100% on LongMemEval (hybrid mode) and 96.6% in raw mode. Zep/Graphiti scores approximately 85% on the same benchmark. Despite Zep's purpose-built temporal tracking, MemPalace's verbatim storage approach achieves higher overall recall.
Can Zep run locally like MemPalace?+
Partially. Zep's Graphiti engine is open-source (Apache 2.0) and can be self-hosted, but it requires running Neo4j as a dependency — a resource-intensive graph database. Zep Cloud features are cloud-only. MemPalace is fully local by default using embedded SQLite and ChromaDB with zero external dependencies.
Does MemPalace support knowledge graphs like Zep?+
MemPalace uses SQLite-based temporal triples for lightweight entity relationship tracking, which provides knowledge graph-like capabilities without needing Neo4j. For complex multi-hop graph traversals across thousands of entities, Zep's Neo4j-powered approach is more powerful — but it comes with significantly higher operational complexity.
What happens to my data with each system?+
With MemPalace, every conversation is stored verbatim in local SQLite and ChromaDB — your data never leaves your machine. With Zep Cloud, conversations are sent to hosted infrastructure where LLMs extract entities and relationships into a managed Neo4j graph. The self-hosted Graphiti version keeps data local but requires you to manage Neo4j yourself.
Is MemPalace better than Zep for agent memory?+
For raw accuracy and cost, yes — MemPalace scores 100% on LongMemEval versus Zep's ~85%, and costs $0 versus up to $475/month. However, Zep has genuine strengths in structured entity tracking, temporal fact management, and multi-agent knowledge sharing through its graph architecture. The best choice depends on whether you prioritize accuracy and simplicity (MemPalace) or structured entity queries and temporal reasoning (Zep).
Can I migrate from Zep to MemPalace?+
There is no official migration tool yet. Since Zep stores structured entities while MemPalace stores raw conversations, a direct entity-to-entity migration loses context. For best results, re-ingest your original conversation data through MemPalace's MCP tools rather than trying to convert Zep's extracted entities.
Ready to try MemPalace?
Get started in under 2 minutes. Install with pip, connect to Claude Code, and give your AI perfect memory — no Neo4j, no cloud, no cost.
Last updated: April 8, 2026. Data sourced from official documentation, published benchmarks, and public GitHub repositories. Zep website: getzep.com.