Zep vs Mem0 vs AgentMemory

Overview

This comparison examines three persistent memory systems for AI agents: Zep, Mem0, and AgentMemory. All three enable AI agents to maintain context across sessions, remember user preferences, and build cumulative knowledge.

Each takes a different approach to the memory problem, with different strengths and trade-offs.

At a Glance

Aspect	Zep	Mem0	AgentMemory
Focus	Entity extraction & summarization	Personalization & self-improvement	Benchmark-validated performance
Storage	Vector + graph	Vector + graph	Vector + SQL
Extraction	Automatic	Automatic	Manual/Programmatic
Backends	Self-hosted, Cloud	Cloud, Self-hosted	SQLite, PostgreSQL, Redis, Chroma, Qdrant
Languages	Python, JS, Go	Python	TypeScript
Benchmark Rank	Not ranked	Not ranked	#1

Core Philosophy

Zep: Structured Memory

Zep focuses on automatic extraction of structured information from conversations. It extracts entities, facts, and relationships, then organizes them into a searchable memory graph.

Key principles:

• Automatic entity extraction
• Structured memory (not just raw text)
• Summarization with configurable windows
• Framework-agnostic

Mem0: Personalized Memory

Mem0 focuses on personalized, self-improving memory that learns about users over time. It emphasizes the "personal assistant" use case.

Key principles:

• Self-improving memory
• Personalization focus
• Hybrid vector + graph storage
• Framework-agnostic

AgentMemory: Performance-First

AgentMemory focuses on benchmark-validated performance and flexibility. It's designed for developers who need a fast, reliable memory system.

Key principles:

• Benchmark-validated (#1 in persistent memory benchmarks)
• Multiple backend options
• Flexible architecture
• Framework-agnostic

Feature Comparison

Entity Extraction

Zep:

from zep_python import EntityExtractor

client.memory.set_entity_extractors(
    session_id="user-123",
    extractors=[
        EntityExtractor(name="project", prompt="Extract project names"),
        EntityExtractor(name="technologies", prompt="Extract programming languages"),
    ],
)

Automatic extraction with custom entity types.

Mem0:

from mem0 import Memory

m = Memory()

# Automatic extraction
m.add("I work at Acme Corp as a software engineer", user_id="user-123")

# Query
results = m.search("Where does the user work?", user_id="user-123")

Automatic extraction built-in, less customization.

AgentMemory:

from agent_memory import Memory

memory = Memory()

# Manual/programmatic addition
memory.add(
    user_id="user-123",
    content="Works at Acme Corp as software engineer",
    category="work",
)

# Query
results = memory.search(user_id="user-123", query="Where does the user work?")

More manual control, less automatic extraction.

Summarization

Zep:

# Automatic summarization
session = client.memory.get_session("user-123")
print(session.summary)  # Auto-generated summary

# Configurable windows
client.memory.update_config(
    session_id="user-123",
    config={"short_term_window": 10, "long_term_window": 100},
)

Mem0:

# Implicit summarization through memory updates
m.add("User prefers morning meetings", user_id="user-123")
m.add("User likes coffee, not tea", user_id="user-123")

# Query combines relevant memories
results = m.search("What are the user's preferences?", user_id="user-123")

AgentMemory:

# Manual summarization
memory.add(
    user_id="user-123",
    content="Summary of last week's conversations",
    category="summary",
)

Search and Retrieval

Zep:

from zep_python import MemorySearchScope

# Semantic search
results = client.memory.search_memory(
    session_id="user-123",
    query="What projects is Alice working on?",
    scope=MemorySearchScope.messages,
    k=5,
)

# Entity search
results = client.memory.search_entities(
    session_id="user-123",
    query="projects",
)

Mem0:

# Semantic search with relevance scoring
results = m.search(
    query="What are the user's work preferences?",
    user_id="user-123",
    limit=5,
)

AgentMemory:

# Vector search with multiple backends
results = memory.search(
    user_id="user-123",
    query="work preferences",
    top_k=5,
)

Time Travel

Zep:

# Create snapshot
snapshot_id = client.memory.create_snapshot(session_id="user-123")

# Restore to snapshot
client.memory.restore_snapshot(session_id="user-123", snapshot_id=snapshot_id)

Mem0:

# No built-in time travel
# Memories are immutable once added

AgentMemory:

# Time-aware retrieval
results = memory.search(
    user_id="user-123",
    query="project status",
    time_range={"start": "2026-01-01", "end": "2026-05-01"},
)

Backend Options

Backend	Zep	Mem0	AgentMemory
SQLite	❌	❌	✅
PostgreSQL	✅	✅	✅
Redis	❌	❌	✅
Chroma	❌	❌	✅
Qdrant	❌	❌	✅
Cloud	✅	✅	✅

Performance

Metric	Zep	Mem0	AgentMemory
Benchmark Rank	N/A	N/A	#1
Search Speed	Fast	Fast	Very Fast
Memory Overhead	Moderate	Moderate	Low
Scalability	High	High	High

Use Case Analysis

When to Choose Zep

✅ Structured Memory Needs

• Entity-based memory organization
• Automatic extraction of facts
• Graph-based relationships

✅ Production Systems

• Proven at scale
• Self-hostable with full control
• Good documentation

✅ Time Travel Requirements

• Restore conversation state
• Debug memory issues
• Audit memory changes

✅ Framework Integration

• LangChain integration
• REST API for any framework

When to Choose Mem0

✅ Personal Assistant Use Cases

• Remember user preferences
• Build user profiles over time
• Personalized responses

✅ Self-Improving Memory

• Memory that learns and adapts
• Automatic memory updates
• Contextual relevance

✅ Quick Setup

• Simple API
• Cloud option available
• Minimal configuration

When to Choose AgentMemory

✅ Performance-Critical Applications

• #1 benchmark ranking
• Fast search and retrieval
• Low latency

✅ Flexibility

• Multiple backend options
• Choose your infrastructure
• Custom configurations

✅ TypeScript Projects

• Native TypeScript support
• Works with any agent framework
• Modern API design

Code Examples

Same Task: Remember User Preferences

Zep:

client.memory.add_memory(
    session_id="user-123",
    messages=[
        {"role": "user", "content": "I prefer morning meetings and coffee."},
    ],
)

# Retrieve
results = client.memory.search_memory(
    session_id="user-123",
    query="meeting preferences",
)

Mem0:

m.add("I prefer morning meetings and coffee", user_id="user-123")

# Retrieve
results = m.search("meeting preferences", user_id="user-123")

AgentMemory:

memory.add(
    user_id="user-123",
    content="Prefers morning meetings and coffee",
    category="preferences",
)

# Retrieve
results = memory.search(user_id="user-123", query="meeting preferences")

Pricing

Service	Free Tier	Paid Plans
Zep Cloud	Limited	Yes
Mem0 Cloud	Limited	Yes
AgentMemory	Self-hosted free	Cloud coming

Migration Path

From Zep to Mem0

# Zep
client.memory.add_memory(session_id="user-123", messages=[...])

# Mem0
m.add("User message content", user_id="user-123")

From Mem0 to AgentMemory

# Mem0
m.add("User preference", user_id="user-123")

# AgentMemory
memory.add(user_id="user-123", content="User preference", category="preferences")

Conclusion

Choose Zep If...	Choose Mem0 If...	Choose AgentMemory If...
You need structured entities	You want personalization	You need top performance
You want time travel	You want simplicity	You want flexibility
You self-host	You use cloud	You use TypeScript
You need LangChain integration	You build personal assistants	You benchmark performance

All three are excellent choices. The right decision depends on your specific needs:

• Zep for structured, production-ready memory
• Mem0 for personalized, self-improving memory
• AgentMemory for benchmark-validated performance and flexibility

Resources

• Zep Documentation
• Mem0 Documentation
• AgentMemory Documentation
• Memory Benchmarks