Mem0 vs Zep vs Redis for Agent Memory: Which One Should You Use?

Pick Zep when the facts your agent tracks change over time and it has to know which version is current. Pick Mem0 when you want per-user memory working today, with an Apache-2.0 library you can self-host later. Pick Redis when Redis is already in your stack and you want session state, TTLs and vector recall in infrastructure you control. Each comes with a catch in October 2026: Zep’s cheapest paid plan is $125 a month, Mem0 keeps graph memory behind its $249 Pro plan and has removed it from the open-source SDK, and Redis Agent Memory, Redis’s managed memory service, is still in public preview.

The rest of this post backs that verdict with what each system stores, what it bills you for, and which benchmark claims survive a look at who ran them.

Mem0 vs Zep vs Redis at a Glance

Prices, versions and licenses checked on official pages on October 23, 2026.

Sources: Mem0 pricing, Mem0 integrations, Zep pricing, Zep framework integrations, Redis pricing, Redis licenses, PyPI: mem0ai, PyPI: graphiti-core. Benchmark and latency sources are in the benchmark section below.

What Each One Does When a User Changes Their Mind

A useful test for any memory layer: in March the user says “we’re on AWS”, in September “we moved to GCP”. What does the agent retrieve in October?

Zep answers it structurally. Graphiti, the open-source engine inside Zep, stores facts as edges between entities, each with a validity window. When new information contradicts an old fact, the old one is invalidated rather than deleted, so you can ask what is true now or what was true at any point, and every fact traces back to the raw episode that produced it (Graphiti README). Zep Cloud adds what Graphiti leaves to you: user and thread management, its own Konig graph database, policy-filtered retrieval, and SOC 2 Type II and HIPAA compliance (Zep vs Graphiti). It also ingests business records and documents next to chat, which is why Zep now calls itself “the unified context layer for enterprise data” rather than a memory store.

Mem0 went the opposite way in April 2026. Its new algorithm is single-pass and ADD-only: one LLM call extracts facts, nothing is updated or deleted, and memories accumulate. Retrieval fuses semantic search, BM25 and entity matching, with time-aware ranking meant to surface the right dated version (Mem0 README). So Mem0 keeps both the AWS and the GCP fact and trusts ranking to pick the current one. Graph memory is gone from the open-source SDK; the migration guide says it “is not being replaced by an OSS equivalent” and is now a Platform feature.

Redis gives you two tiers. Session memory stores ordered conversation events with a TTL and optional automatic summarization. Long-term memory holds facts extracted in the background as text plus embeddings, searchable by semantic, keyword or hybrid search (Agent Memory docs). Defaults are a one-hour session TTL, a 365-day long-term TTL and extraction every five minutes, and you can define up to three custom memory types (service settings). The product page promises deduplication by content hashing, but nothing we read describes contradiction handling, so expect the March and September facts to sit side by side until they expire.

When developers say “Redis for agent memory”, they often mean something smaller: the LangGraph Redis checkpointer. langgraph-checkpoint-redis (MIT, version 0.5.2) persists thread state so a graph can resume, and its RedisStore adds a key-value store with optional vector search for cross-thread memory. It needs Redis 8, or Redis Stack on older versions, because it depends on RedisJSON and RediSearch (langgraph-redis README). That is persistence, not memory: something still has to decide what is worth remembering.

Pricing and Self-Hosting: Each Vendor Meters Something Different

The sticker prices hide the real difference. Mem0 charges for reads, Zep charges for writes, Redis charges for the database.

• Mem0 (pricing): Hobby is free with 10,000 add requests and 1,000 retrieval requests a month. Starter is $19 for 50,000 adds and 5,000 retrievals. Pro is $249 for 500,000 adds and 50,000 retrievals, and it is the first tier with graph memory and “Dream” memory consolidation. Enterprise adds on-prem deployment, SSO and audit logs.
• Zep (pricing): Free gives 10,000 credits a month. Flex is $125 for 50,000 credits, then $25 per 10,000. Flex Plus is $375 for 200,000 credits, then $75 per 40,000. One credit covers an episode of up to 350 bytes, plus one credit per additional 350 bytes. Retrieval, storage and users cost nothing. Customer-managed keys and in-VPC deployment are Enterprise only.
• Redis (pricing): Agent Memory has no price of its own on Redis’s pricing page. You attach it to a Redis Cloud database, and Quick create uses the Free 30 MB tier. Essentials starts at $5 a month, Pro at a $200 monthly minimum. Extraction and embeddings run on Redis-managed model keys by default, or on your own provider key (setup guide).

A worked example: 10,000 conversations a month at five turns each is 50,000 turns. Assume one memory search and one write per turn, a short user message (one Zep credit) and an assistant reply of about 1 KB (three credits).

• Mem0: 50,000 retrievals is exactly the Pro ceiling, so $249. Search twice per turn and you are talking to sales about usage-based pricing.
• Zep: four credits per turn is 200,000 credits, so Flex Plus at $375. Searching five times per turn costs nothing extra, but ingesting a 35 KB document costs 100 credits.
• Redis: the database, plus model tokens if you bring your own key. Redis publishes no separate charge for Agent Memory or its built-in model keys during the preview.

So agents that search memory several times per turn favor Zep’s meter; agents that push large tool outputs or documents into memory favor Mem0’s.

Self-hosting is a different product in all three cases. Mem0’s library and Docker server are Apache-2.0 and run on 22 vector stores, including Redis, Valkey and pgvector (vector store list), but Mem0 says its benchmark scores reflect “proprietary optimizations not available in the open-source SDK” (evaluation docs). Zep Community Edition is deprecated (Zep repo), so self-hosted Zep means Graphiti: you bring the graph database, LLM and embedder, and build tenancy and access control yourself. Its reference MCP and REST servers have “no authentication, no authorization, and no prompt-injection protection” (Graphiti README). Redis’s original open-source Agent Memory Server now sits in a V0/ folder that “is no longer actively maintained” (V0 README); the supported self-managed version runs on Kubernetes and is in private preview. The managed preview has limits too: no Redis Flex databases, no AWS PrivateLink, no Active-Active, and only the default database user (setup guide).

Benchmarks: Every Headline Number Is Vendor-Run

None of these is independent, and no two share a setup. Zep scored itself with gpt-5.4, Redis held gpt-4o constant, and Mem0 doesn’t name its answer model. Zep’s 94.7 also depends on five client-composed searches; its single-call “auto search” scores 86.5 on LoCoMo.

Read Redis’s number carefully. Its product banner says 86.5% at about $0.07 per session, but that configuration combines two retrieval strategies, and the repository README says one of them, Remis, “is not in Redis Agent Memory in Iris yet”. It adds: “Do not treat 86.5% as a Redis Cloud product score.” In Redis’s own table, the row for its Agent Memory Server scored 64.0%. Credit to Redis for publishing that.

The same report lists Zep at 71.2% (on gpt-4o) and Mem0 at 49.0% as reported figures and reproduced neither, while Mem0’s own current claim is 94.4. Whatever explains a 45-point spread (an older algorithm, different settings), it tells you to distrust the tables. The bad blood is old, too: in May 2025 Mem0’s CTO opened a GitHub issue disputing Zep’s 84% LoCoMo score, Zep corrected it to 75.14%, and each side rejected the other’s rerun.

Two more caveats. LongMemEval’s small split is about 61 million tokens of chat across 500 questions (Redis harness docs), roughly 120K tokens per question, which a long-context model can read whole. It tests retrieval quality, not scale. BEAM at 10M tokens is closer to production volume, and only Mem0 publishes it, at 48.6. And the latency claims measure different things: Zep reports retrieval-only p50 of 87 to 104 ms on its own cloud, Mem0 reports p50 of 0.88 to 1.09 s at a top-200 budget, and Redis publishes no latency figure for Agent Memory.

Where Redis did reproduce other systems, results landed between 3 points above and 28 points below their published scores (Redis report); only Mastra’s observational memory matched exactly, at 84.2%. If memory quality decides your choice, run Redis’s open harness, which has adapters for Mem0, Zep, Graphiti, LangMem and Redis, on your own conversations.

Where Letta and LangMem Fit

Letta is not a memory layer you bolt onto your own agent loop. It is an agent runtime in which the agent edits its own memory blocks, sections of the context window that are “always visible”, so no retrieval step is needed (Letta docs). It is Apache-2.0 and self-hostable, or you use Letta’s API plan at $20 a month plus $0.10 per active agent (Letta pricing). Choose it if you want the agent to manage its own memory and you are willing to run your agents on Letta.

LangMem is LangChain’s MIT library: memory tools the agent calls in the hot path, plus a background manager that extracts and consolidates memories into LangGraph’s store. Pair it with RedisStore and you have a do-it-yourself Redis memory stack, with extraction from LangMem and storage and TTLs from Redis. The catch: the last PyPI release is 0.0.30, from October 27, 2025 (PyPI).

Which One to Pick

Choose Zep for support, CRM and account agents where state changes and “what is true now” matters. Free retrieval suits agents that search memory several times per turn, and Zep is SOC 2 Type II certified with HIPAA BAAs on Enterprise (pricing). Self-hosting means building the service layer around Graphiti yourself.

Choose Mem0 for personalization: user preferences and facts in assistants and consumer apps. It has the longest integration list of the three, and the open-source library runs on the vector store you already operate. Watch the retrieval caps, and don’t expect the open-source SDK to match the platform’s benchmark numbers.

Choose Redis if your agents already run on LangGraph and Redis. Use RedisSaver for thread checkpoints and RedisStore for long-term items, add LangMem or your own extraction, and keep everything on infrastructure you control. Try Redis Agent Memory if you want managed extraction and summarization, but treat it as a preview, and skip the V0 server for new production work.

“Mem0 vs Redis” is partly a false choice. Mem0’s open-source library can use Redis as its vector store, and Graphiti can run on FalkorDB, a Redis module licensed under SSPLv1. Mem0 and Zep store memories, not LangGraph checkpoints, so a LangGraph agent on either still needs somewhere to keep thread state. For most teams the sensible split is Redis for state and Zep or Mem0 for long-term facts.