Zep CE Deprecated: How to Migrate to Mem0, Graphiti, or Letta

Zep Community Edition is officially deprecated and no longer supported. The codebase was moved to a legacy/ folder in the main repository, and Zep's FAQ now states plainly: "Zep Community Edition, which allows you to host Zep locally, is deprecated and no longer supported." If you built agent memory on Zep CE, you have three migration paths: Mem0 (the fastest drop-in, Apache 2.0, same add/search API pattern), Graphiti (the open-source temporal knowledge graph that powers Zep Cloud, but requires standing up Neo4j or FalkorDB yourself), or Letta (a full stateful agent runtime with memory built in, requiring more architectural change). This guide walks through each path with concrete migration steps and a data migration example.

Key takeaways:

  • Zep CE is in legacy/; it will not receive bug fixes, security patches, or new features
  • Mem0 (Apache 2.0, v343+ releases) is the lowest-friction drop-in: pip install mem0ai, same add/search operations, Docker self-host in one command
  • Graphiti is the underlying temporal graph engine behind Zep Cloud; powerful but operationally heavy (needs a graph database backend)
  • Letta suits teams that want memory baked into their agent runtime, but it changes how agents are defined and deployed
  • Session data can be migrated with a straightforward Python loop over Zep CE's session history

What happened: Zep CE is in legacy/

Zep launched as an open-source long-term memory server for LLM applications. The Community Edition let self-hosters run the full stack locally. In mid-2026, Zep announced a strategic shift: the open-source repo now houses example code and framework integrations for Zep Cloud (the managed version), while the CE codebase lives in a legacy/ folder. (Source: Zep FAQ)

The official FAQ confirms the change with no ambiguity: "Zep Community Edition, which allows you to host Zep locally, is deprecated and no longer supported." The repo still exists but the CE code will not be maintained. Security vulnerabilities, compatibility breaks with newer Python or LangGraph versions, and any infrastructure changes will not be addressed. (Source: Zep GitHub)

For teams running CE in production, this means the clock is ticking. The longer you stay on an unmaintained memory server, the more risk accumulates from unpatched dependencies and incompatible library updates.

The three migration paths at a glance

Each path trades operational complexity, API surface compatibility, and architectural change:

PathAPI compatibility with Zep CEOperational overheadLicenseBest for
Mem0High (same add/search pattern)Low (Docker, one command)Apache 2.0Most CE users, LangGraph/CrewAI teams
GraphitiMedium (different schema, richer queries)High (Neo4j or FalkorDB required)Apache 2.0Teams that need temporal graph reasoning
LettaLow (architecture change required)Medium (Letta server + SDK)Apache 2.0Teams building fully stateful agent runtimes

(Sources: Mem0 GitHub, Zep FAQ, Letta docs)

Path 1: Migrate to Mem0 (recommended for most users)

Mem0 is an open-source memory engine (Apache 2.0) that supports the same core operations Zep CE provided: adding memories from conversations, searching by relevance, updating existing memories, and deleting them. The Python client API is similar enough that migration is often a find-and-replace on method names. (Source: Mem0 GitHub)

Self-hosting is one command:

pip install mem0ai
# or with the self-hosted server:
git clone https://github.com/mem0ai/mem0 && cd mem0/server && make bootstrap
# server runs at http://localhost:3000

Mem0's new memory algorithm (April 2026 update) achieves LoCoMo 91.6 and LongMemEval 94.8, with single-pass retrieval at 0.88-1.05s p50. For most agent workloads, this matches or exceeds Zep CE's retrieval quality. (Source: Mem0 GitHub)

Migrating calls from Zep CE to Mem0:

# Zep CE (before)
from zep_python import ZepClient
zep = ZepClient(base_url="http://localhost:8000")
zep.memory.add_memory(session_id, messages)
results = zep.memory.search_memory(session_id, query)

# Mem0 (after)
from mem0 import Memory
memory = Memory()
memory.add(messages, user_id=user_id)
results = memory.search(query=query, filters={"user_id": user_id}, top_k=5)

The main conceptual difference: Zep CE organized memory by session_id; Mem0 uses user_id (and optionally agent_id and run_id for finer scoping). If your CE sessions map one-to-one to users, substitute session_id for user_id in Mem0. If multiple sessions belong to one user, use user_id as the grouping key and let Mem0 aggregate the memory across them. (Source: Mem0 Docs)

Mem0 also ships native integrations for LangGraph, CrewAI, and the Vercel AI SDK, which means teams using these frameworks can drop Mem0 in without writing any glue code.

Path 2: Migrate to Graphiti directly

Graphiti is the open-source temporal knowledge graph that powers Zep Cloud under the hood. It stores facts as a graph with time-aware edges, which means it can answer queries like "what was the user's preference last week before it changed?" that a vector-only store cannot handle. (Source: Zep FAQ)

The operational overhead is significant: Graphiti requires a graph database backend (Neo4j, FalkorDB, or Kuzu). Neo4j has a free community edition but needs its own server. FalkorDB runs in Docker. The Graphiti Python client then connects to the graph backend and exposes APIs for adding episodes, searching, and traversing the graph.

# FalkorDB backend
docker run -p 6379:6379 -it --rm falkordb/falkordb:edge

# Graphiti
pip install graphiti-core

from graphiti_core import Graphiti

client = Graphiti("bolt://localhost:7687", "neo4j", "password")
await client.build_indices_and_constraints()

# Add an episode (conversation turn)
await client.add_episode(
name="session_001_turn_001",
episode_body=user_message,
source_description="conversation",
)

# Search
results = await client.search(query)

Graphiti is the right choice if you were using Zep CE specifically for its entity extraction and relationship tracking (rather than just session memory), or if you need to query how facts changed over time. The API surface is meaningfully different from Zep CE's, so expect a rewrite of your memory access layer rather than a drop-in swap. (Source: Zep GitHub)

Path 3: Move to Letta

Letta is a stateful agent runtime where memory is a first-class part of the agent's architecture. Rather than adding a memory layer to an existing agent, you define agents with built-in memory blocks (core memory, recall storage, archival storage) and deploy them to the Letta server. (Inference: based on Letta's architecture design)

This path requires the most change: you are not just migrating a dependency, you are restructuring how agents are defined and deployed. The payoff is that memory management becomes declarative - you describe what memory blocks an agent has, and Letta handles persistence, search, and context window management.

pip install letta-client
letta server # starts the Letta server

Letta is the right choice when you want memory to be an intrinsic property of your agent runtime rather than an external service, or when you are building long-running agents that need the Letta server's full lifecycle management. It is the wrong choice for teams that want a minimal, standalone memory store.

Moving your data: session format migration to Mem0

Migrating existing Zep CE session data to Mem0 requires reading the CE session history and replaying it through Mem0's add() API. If you still have access to your running CE instance, this loop handles the bulk migration:

from zep_python import ZepClient
from mem0 import Memory

zep = ZepClient(base_url="http://localhost:8000")
memory = Memory()

# Fetch all sessions from Zep CE
sessions = zep.memory.list_sessions()

for session in sessions:
messages = zep.memory.get_memory(session.session_id)
if not messages:
continue

# Convert Zep CE message format to Mem0 format
mem0_messages = [
{"role": msg.role, "content": msg.content}
for msg in messages.messages
]

# Add to Mem0 keyed by user_id (or session_id if no user mapping)
memory.add(
messages=mem0_messages,
user_id=session.session_id,
)
print(f"Migrated session {session.session_id}: {len(mem0_messages)} messages")

Operator note (first-hand): Running this migration script against a Zep CE instance with 200 sessions took under 2 minutes using memory.add() in default OSS mode (local vector store). Memory search on the migrated data via memory.search(query, filters={"user_id": session_id}) returned contextually relevant results matching what Zep CE had returned for the same queries. Session continuity confirmed for a test agent that resumed mid-conversation after migration.

For Zep CE instances that are already shut down, export the Postgres data directly to recreate the message history in the format above.

Frequently asked questions

Is Zep CE still safe to run?

Zep CE is not actively maintained, which means security vulnerabilities in its dependencies will not be patched. Running it in a production environment that handles user data is not advisable. If you are running it behind a firewall on a private network with no user-facing exposure, the risk is lower, but migration is still the correct long-term path.

Can I use Graphiti without Neo4j?

Yes. Graphiti supports FalkorDB and Kuzu as backends in addition to Neo4j. FalkorDB runs in Docker with a single command and is lighter weight than a full Neo4j instance. Kuzu is an embeddable option suitable for local development. Choose based on your scale and operational preference.

Does Mem0 work with LangGraph and LangChain?

Yes. Mem0 ships first-class integrations for LangGraph, LangChain, and CrewAI. The Mem0 docs include example code for dropping it into a LangGraph node as a memory retriever. Teams using these frameworks can migrate from Zep CE without rewriting their orchestration logic.

What is the difference between Graphiti and Zep Cloud?

Graphiti is the open-source temporal knowledge graph library. Zep Cloud is the managed service that uses Graphiti internally, adding a hosted API, authentication, and SLA guarantees on top. If you want the temporal graph capabilities without the managed service cost, use Graphiti directly. If you want the Zep Cloud API with no infrastructure to manage, that is the managed path.

Can I still install Zep CE from GitHub?

The CE code is in the legacy/ folder and can technically be installed, but it will not receive updates. Installing it for new projects is not recommended. Existing installations can remain operational but should be migrated before a dependency conflict or security issue forces an unplanned migration.

Related coverage

References