Mem0 vs Zep vs Letta: Memory Frameworks Compared

Architecture Overview

All four frameworks solve the same core problem: giving stateless LLMs access to persistent memory. They differ in how they store memories, how they retrieve them, and how much they manage the memory lifecycle.

Mem0 stores memories as embedded vectors with automatic extraction from conversations. When you add a conversation to Mem0, it uses an LLM to extract noteworthy facts and stores them as separate memory entries. Retrieval uses vector similarity search with optional metadata filtering. The architecture is intentionally simple: embed, store, search, return.

Zep adds a temporal knowledge graph on top of vector storage. It extracts entities and relationships from conversations and builds a graph that represents accumulated knowledge. Retrieval can traverse the graph to find related memories, not just similar ones. For example, querying about a person can surface memories connected through their projects, teams, or decisions even when the text similarity is low.

Letta (formerly MemGPT) takes inspiration from operating system memory management. It separates memory into tiers: core memory (always in the model's context), recall memory (searchable archive), and archival memory (long-term deep storage). The AI agent manages its own memory, deciding what to promote to core, what to archive, and what to update. This self-editing capability makes Letta particularly suited for autonomous agents.

Adaptive Recall combines vector storage with ACT-R cognitive scoring and a knowledge graph. Each memory has activation levels that change based on recency (when it was last accessed), frequency (how often it has been retrieved), spreading activation (how connected it is through the entity graph), and confidence (how well corroborated it is). The lifecycle system manages consolidation, decay, and forgetting automatically.

Retrieval Quality

Retrieval is the most important differentiator because it determines whether the right memories appear in the right context.

Mem0 retrieves by cosine similarity against the query embedding. This works well for direct lookups ("what database does the user use?") but struggles with indirect queries where the relevant memory uses different vocabulary. Adding metadata filters (by user, by time range) helps scope results but does not improve the fundamental similarity search.

Zep enhances retrieval with graph traversal. When the query matches an entity in the knowledge graph, Zep can follow relationship edges to find connected memories. This catches cases that pure vector search misses, like finding a memory about a database migration when the user asks about "the incident last month" (connected through the timeline, not through text similarity). The tradeoff is that graph construction requires additional LLM calls during extraction.

Letta uses tiered retrieval. Core memory is always available (no retrieval needed). Recall memory uses similarity search. Archival memory uses both similarity and metadata filtering. The agent can also actively search its memory using tool calls, choosing to look up specific information when it realizes it needs context. This active retrieval pattern is powerful for agentic applications but depends on the agent correctly recognizing when to search.

Adaptive Recall scores every candidate memory on four dimensions simultaneously. Vector similarity provides the base relevance signal. Base-level activation (derived from ACT-R theory) boosts memories that were recently accessed and frequently retrieved. Spreading activation through the entity graph boosts memories connected to the query through entity relationships. Confidence weighting promotes memories that have been corroborated across multiple interactions. The combined score produces rankings that reflect how human memory actually prioritizes information, and the rankings improve over time as access patterns update the activation scores.

Memory Lifecycle

Mem0 provides basic CRUD operations. You can add, search, update, and delete memories. There is no automatic consolidation, deduplication, or decay. You manage the memory lifecycle yourself or accept an ever-growing store of raw memories.

Zep handles some lifecycle through its graph. As new information comes in, it can update entity nodes and relationship edges. The temporal aspect means the graph reflects how knowledge evolved over time. But there is no automatic consolidation of redundant memories or confidence-based filtering.

Letta delegates lifecycle to the agent itself. The agent decides when to update its core memory, what to archive, and what to discard. This is flexible but risky: if the agent makes poor memory management decisions, the memory quality degrades without human oversight.

Adaptive Recall manages the full lifecycle automatically. Memories progress through stages: fresh (just created), established (validated by reuse), fading (not recently accessed), archived (low activation but retained). The consolidation system merges related memories, extracts lasting knowledge from episodic events, detects contradictions, and reduces the total memory count while preserving information density. Decay follows ACT-R activation curves, so memories fade naturally when they are not accessed. Protected memories (confidence above 8.0) are exempt from decay.

Integration Complexity

Mem0 is the simplest to integrate. The cloud version requires an API key and a few lines of code. The open-source version requires deploying a service with a vector database backend. Integration can be done in hours.

Zep requires more setup because of the knowledge graph component. The cloud version handles infrastructure, but you need to understand the entity extraction and graph schema to get the most value. Integration takes a day or two for basic functionality, longer to tune extraction quality.

Letta has a steeper learning curve because of the self-editing memory model. You need to configure the memory tiers, define the core memory structure, and decide how much autonomy to give the agent. The framework is powerful but requires understanding its specific programming model. Integration takes a week or more for non-trivial applications.

Adaptive Recall integrates through MCP (for AI coding assistants and IDE tools) or REST API (for any application). The MCP integration is configuration-only: add the server URL and API key to your MCP config and the seven tools are immediately available. The REST API requires standard HTTP calls for store, recall, update, and other operations. Integration takes hours to a day.

Best Use Cases

Choose Mem0 when you need simple, fast memory with minimal integration effort. Best for: chatbots that need basic user preferences, applications with small memory stores (under 10,000 memories), and prototypes where you want to add memory quickly.

Choose Zep when relationships between entities are central to your application. Best for: customer-facing applications where user relationships, history, and entity connections drive personalization. The knowledge graph adds real value when queries need to traverse relationships to find relevant context.

Choose Letta when you are building autonomous agents that need to manage their own state. Best for: long-running agent workflows, multi-step task execution, and applications where the AI needs to actively curate its own knowledge base.

Choose Adaptive Recall when retrieval quality is the primary concern and you want the system to improve with usage. Best for: applications where the relevance of retrieved memories directly impacts user experience, production systems that need lifecycle management at scale, and AI coding assistants where accumulated project knowledge needs cognitive ranking rather than simple similarity matching.