Match each memory framework to its core abstraction

Match pairs·Medium·4.0 · 0·~2 min·Asked atDroom Netflix Qdrant

Attempt it

Drag each answer to line up with its matching prompt

Mem0

Sliding buffer of recent turns plus a running summary of older turns

Letta (formerly MemGPT)

LLM extracted user facts stored and retrieved per turn via a managed API

Zep

Typed state object that flows through nodes and supports checkpointing

LangGraph state

Temporal knowledge graph with dated facts that are invalidated, not deleted, and graph traversal at retrieval

LangChain ConversationSummaryBufferMemory

Per agent model context, optionally windowed to recent messages, that can be saved and loaded

AutoGen agent state

OS inspired memory blocks the model edits with explicit tool calls

Six frameworks cover most long-term memory designs, and each starts from a different core abstraction. **Mem0** treats memory as **extracted user facts behind a managed API**. An LLM (large language model) pass turns dialogue into short facts stored with embeddings, and the top matches are retrieved before the next turn. A hosted platform and an open-source library expose the same API. **Letta (formerly MemGPT)** treats memory as **OS-style blocks edited by the model**. Core blocks (persona, human) stay in the context window. The model calls tools to edit them or to search larger stores outside the window. **Zep** treats memory as a **temporal knowledge graph**. Its Graphiti engine stores facts as dated edges with `valid_at` and `invalid_at` timestamps, so you can ask what was true as of March. **LangGraph state** is a **typed checkpointed state object**. Each slot can have a reducer, and a checkpointer saves the state after each step for pause and resume. **LangChain ConversationSummaryBufferMemory** keeps **recent turns verbatim plus a running summary** of older turns. It is now a deprecated legacy class. **AutoGen agent state** gives each agent its own **model context**, for example only the last n messages, which can be saved and loaded.

The six frameworks start from six distinct **core abstractions**, and matching each tool to its abstraction makes selection rational. **Mem0** is **LLM-extracted facts behind a managed API**. An extraction LLM turns dialogue into short facts about the user and stores them with embeddings. At retrieval time, relevant facts are fetched by vector search and injected into the prompt: `m.add(messages, user_id=uid)`, then `m.search(query, filters={'user_id': uid})`. It runs as a hosted platform or as an open-source library with the same API. **Letta (formerly MemGPT)** is **OS-inspired memory blocks edited by the model via tool calls**. The MemGPT paper framed the context window as fast main memory and external stores as slow disk. Core blocks (`persona`, `human`) stay in context, while archival and recall memory are searched with tools. The model decides when to recall, write and evict. **Zep** is a **temporal knowledge graph with dated facts**. Its Graphiti engine stores facts as graph edges with `valid_at` and `invalid_at` timestamps, so it can answer 'what was true as of March'. A contradicted fact is invalidated, not deleted. **LangGraph state** is a **typed state object that flows through graph nodes and supports checkpointing**, with per-slot reducers. **LangChain ConversationSummaryBufferMemory** keeps **recent turns verbatim plus a running summary** of older turns once a token limit is passed. It is deprecated and now lives in `langchain-classic`. **AutoGen agent state** gives each agent a **model context** that can window its messages (for example, the last n). Agents and teams can save and load that state.

TL;DR

Mem0 stores extracted facts; Letta has model-edited memory blocks; Zep is a temporal graph; LangGraph has typed checkpointed state; LangChain summary-buffer keeps recent turns plus a summary; AutoGen windows context.

Memory aid

Easy to grasp

Imagine six different librarians, each with a different way to remember what you have asked about. One writes sticky notes after every conversation and hands you the relevant ones the next time you walk in (Mem0). One has labeled drawers they open and rearrange themselves (Letta). One draws a family tree of facts with dates so they can tell you when something was true (Zep). One keeps your whole case file in a folder with named tabs and saves a copy at every step (LangGraph). One keeps the last few pages of notes plus a one-paragraph summary of everything older (LangChain). And one gives each helper a notebook that keeps only the latest pages and can be saved and reopened later (AutoGen). Same job, six designs.

Key concepts

Context Engineering LLM Frameworks RAG

Concept explanation~2 min read

Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.

Six common memory designs each start from a different core abstraction and target a different workload. Reading them as variants of the same vector store plus retrieval pattern misses the point. They differ in who manages memory, how time is modeled, what the storage unit is, and how the model fits into the loop.

Mem0: extracted facts behind a managed API

Mem0 starts from the observation that most useful long-term memory is declarative facts about the user: 'is vegetarian', 'lives in Berlin since July', 'prefers Python over JavaScript'. Raw dialogue is noisy; facts are what the next turn needs.

The design runs an LLM extraction pass over new messages and produces candidate facts. The Mem0 paper then compares each candidate with similar stored facts and has the LLM choose ADD, UPDATE, DELETE or NOOP. Retrieval at the next turn is vector search over the fact store.

The developer interface is small: m.add(messages, user_id=uid) and m.search(query, filters={'user_id': uid}, top_k=5). Extraction lives inside the library or the hosted platform. This is Mem0's main value proposition: long-term memory without an engineering project.

The trade-offs are opacity (you do not see why a fact was kept) and, on the hosted platform, dependency on the service. The extraction prompt can be replaced through the prompt argument of add(), but the pipeline shape is fixed. Mem0 fits products that want memory without becoming experts in extraction logic: personal assistants, consumer chat products, ambient AI features.

Letta and the MemGPT lineage: OS-style blocks edited by the model

Zep: temporal knowledge graph

LangGraph state and the orchestration vs memory distinction

LangChain summary-buffer and AutoGen agent state

Situations where this technique stops working.

2–4 min · Everything important, quickly.

Real products, models, and research that use this idea.

Mem0 ships as an open-source Python library (mem0ai) and as a hosted platform, both built on the same add and search model
The Letta V1 server implemented the MemGPT design with core blocks plus archival and recall search tools

What an interviewer would ask next. Try answering before peeking at the approach.

QHow would you combine LangGraph state with Mem0 in a production agent?

LangGraph state holds the working memory of the current trajectory (plan, tool results, summary). Mem0 holds cross-session user facts. Before each trajectory starts, fetch relevant Mem0 facts and put them in a persistent state slot. During the trajectory, do not write to Mem0 inside the loop. After the trajectory ends, run a single Mem0 extraction pass over the transcript. This keeps the orchestration layer and the long-term memory layer cleanly separated.

2 more follow-ups an interviewer would ask next. Sign in to reveal them.

Red flags & common mistakes

The phrases that signal junior thinking. Click to expand.

Most common mistake

Treating all memory frameworks as variants of the same vector store plus retrieval pattern, missing that they differ in who manages eviction, how time is modeled, and where the model fits in the loop.

60 second bullets to scan on the way to the call.

Name Mem0's core abstraction (extracted facts behind a managed API)
Name Letta's lineage (MemGPT) and its core abstraction (OS-style memory blocks edited by the model)

Primary sources. Browse if you want the original framing.