Agent memory integration

LangGraph explicitly distinguishes thread-scoped short-term memory from cross-thread long-term memory, and its long-term store supports arbitrary namespaces.github.com

LangMem adds the particularly useful piece: a memory manager that can extract, update, consolidate, and delete memories, including both synchronous “hot path” memory and background processing.langchain-ai.github.io

Why I wouldn't just use a vector database

A vector DB is useful, but “long-term memory = embeddings” is too simplistic.

I'd model at least these three categories:

LangMem makes essentially this distinction between semantic, episodic, and procedural memory.langchain-ai.github.io

For an advanced agent, I'd also preserve the raw episode behind an extracted memory. That gives you:

That becomes extremely valuable when a user says:

“Actually, I don't work at Acme anymore.”

You don't want two equally valid embeddings saying:

You want:

This is where Zep/Graphiti becomes particularly interesting. Graphiti represents facts as temporal relationships with validity windows and maintains provenance back to the episodes that produced them. It also combines semantic, keyword, and graph retrieval.github.com

When I'd choose each framework

LangGraph + LangMem
Best starting point if you're already building an agent/workflow around LangGraph. You get a clean separation between checkpointed conversation state and persistent memory, plus memory-management primitives.langchain-ai.github.io+1

Zep / Graphiti
I'd look here when your agent needs to understand changing relationships and history:

“Who did I work with at Company X in 2024?”

“What was my previous preference before I changed it?”

“What led to this decision?”

Graphiti's temporal graph/provenance model is designed for precisely this kind of evolving knowledge.github.com

Mem0
A good choice when you primarily want a memory layer you can bolt onto an existing agent, rather than adopting a larger agent runtime. Current comparisons consistently position it as a relatively framework-agnostic memory layer.www.puppyone.ai

Letta
More appropriate when memory is fundamentally part of the agent runtime itself—the agent actively manages different memory tiers and decides what should stay in its working context versus archival memory.www.puppyone.ai

What I'd build for a production agent

I'd use this pattern:

The important design choice is not to put the entire long-term memory into every prompt. Retrieve only what is relevant to the current task. LangGraph's documentation specifically notes that long conversation histories become expensive and can actually degrade model performance even when the context window technically accommodates them.github.com

I'd also make memory writes asynchronous

Don't make every user request wait for an expensive “memory consolidation” operation.

Instead:

LangMem explicitly supports this background-memory-manager approach.langchain-ai.github.io

For particularly important facts, however, I'd allow hot-path writes:

rather than relying exclusively on an asynchronous extractor.

The stack I'd pick

If I were starting from scratch:

Simple agent

LangGraph + LangMem + Postgres

Agent with sophisticated temporal/user memory

LangGraph + LangMem + Zep/Graphiti

Existing agent framework, want memory with minimal architectural change

Mem0

Highly autonomous, persistent agent where memory is part of the runtime

Letta

One important caveat: I wouldn't blindly trust vendor benchmark rankings. Recent comparisons themselves note that many memory benchmarks are vendor-produced and aren't necessarily independently reproduced.atlan.com

The key architectural principle

The framework matters less than making these five operations explicit:

If you get those right, you can swap Mem0 ↔ Zep ↔ your own Postgres/graph implementation later without rewriting the agent.

If you tell me what kind of agent you're building (coding agent, personal assistant, customer-support agent, autonomous research agent, etc.) and your stack (Python/TypeScript, LangGraph/OpenAI/Anthropic/etc.), I can give you a concrete memory architecture and implementation, including the schema, retrieval flow, and when memories should be written.

The key architectural distinction is important: LangGraph explicitly separates short-term and long-term memory. Its checkpointer maintains thread-scoped state/conversation continuity, while its Store provides durable cross-thread information such as user preferences and facts.langchain-ai.github.io

For the memory backend itself, Zep is arguably the strongest choice if retrieval quality and temporal reasoning are your priority. Zep/Graphiti uses a temporal knowledge graph rather than just vector similarity, and its published research reports strong performance on long-term/temporal memory tasks.arxiv.org

There is, however, a major caveat: the benchmark landscape is not settled. Recent independent/reproducible testing produces substantially different rankings from vendor-published numbers—for example, one September 2026 benchmark found Letta at 52.2% recall, Mem0 at 50.0%, LangMem at 45.7%, and Zep/Graphiti at 37.0% under its particular setup. github.com So I wouldn't choose purely from a leaderboard.

What I'd choose

For a new production agent:
LangGraph → short-term checkpointer → Mem0/Zep long-term store → retrieval injected into the current context.

• Choose Mem0 if you want the simplest, broadly applicable persistent-memory layer.
• Choose Zep/Graphiti if your agent needs to understand how facts change over time.
• Choose Letta if the agent itself should decide what belongs in active memory versus archival memory.
• Choose LangMem if you're already deeply invested in LangGraph and want the most native integration.atlan.com

Bottom line: if by “framework” you mean the overall agent architecture, I'd pick LangGraph. If you mean the specialized long-term memory engine, I'd currently shortlist Zep/Graphiti and Mem0, with Zep getting the edge for sophisticated temporal retrieval and Mem0 for simplicity/general-purpose adoption.atlan.com+1