A user finishes turn 1 and is about to send turn 2. Describe the steps Mem0 takes between those turns and what it injects into turn 2's context.
Free · 2 AI evals / day
Between two turns of the same user's session, Mem0 runs a small **extract then store then retrieve** pipeline.
**Step 1: extraction.** After turn 1 finishes (the user message plus the assistant's reply), Mem0 runs an extraction LLM pass over that pair. The extraction prompt asks the model to identify any new facts about the user that are worth remembering, expressed as discrete declarative statements: 'user is a vegetarian,' 'user is moving to Berlin in July,' 'user prefers Python over JavaScript.' These are the **candidate memories**.
**Step 2: dedup and merge.** For each candidate, Mem0 checks the existing memory store for similar entries using **embedding similarity**. If a near-duplicate exists, the new candidate is either merged with it (combining details) or discarded if it adds nothing. If the candidate contradicts an existing memory, say the store has 'user lives in NYC' and the candidate says 'user lives in Berlin', Mem0 applies a **contradiction-resolution rule**: usually 'the newer fact wins' or 'higher confidence wins.' The store is updated to reflect the new state.
**Step 3: persist.** The merged, deduped fact is stored with its embedding so future retrieval can find it.
**Step 4: retrieval at turn 2.** When the user sends turn 2, Mem0 takes the new user message as a query and runs a vector search over the memory store to find the most relevant facts (typically top-3 to top-10). These are formatted into a compact **memory block**, usually a few hundred tokens, and injected into the system prompt or context section before the model is invoked.
The agent never sees the full archive. Only the per-turn salient slice reaches the model.
Mem0 operates as an **extract on write, retrieve on read** memory layer that sits between the agent and the conversation. The work happens in three phases, with the model-facing surface staying small and stable.
**Write path (runs after turn 1 completes).** Mem0 takes the new user message plus the assistant's reply and runs an **extraction LLM** over the pair. The extraction prompt asks the model to surface declarative facts about the user, the task, or the world that are worth remembering long-term. The output is a list of candidate memories in structured form, each typically one sentence: 'user is vegetarian,' 'user is moving to Berlin in July,' 'user works at Anthropic as of 2026.'
Each candidate is compared against the existing store via **embedding similarity**. Three outcomes are possible per candidate:
- **New fact**: no near-duplicate exists, the candidate is stored as-is with its embedding.
- **Duplicate or refinement**: a near-duplicate exists, and Mem0 either discards the candidate (if it adds nothing) or merges details into the existing entry.
- **Contradiction**: a similar entry exists but the new candidate disagrees. Mem0 applies a **contradiction-resolution policy**, typically 'newer wins' with optional confidence weighting or temporal flagging. The old entry may be archived (kept with a timestamp) or replaced outright depending on configuration.
The net effect is that the memory store maintains a curated set of facts about the user, free of duplicates, with contradictions resolved.
**Read path (runs before turn 2 is sent to the model).** Mem0 takes the new user message as a query and runs **vector search** over the memory store, optionally filtered by user ID. The top-k results (commonly 3-10, tuned per workload) are formatted into a compact memory block: a labeled section in the system prompt or a user-message preamble.
Quick reference
TL;DR
Between turns Mem0 runs an extraction LLM over the latest dialogue, dedupes and merges the candidate facts against the existing store with contradiction resolution, then retrieves and injects only the top-k salient
Imagine a friend who keeps a small notebook about you. After every chat, they spend a moment writing down anything new they learned in short sentences: 'Likes hiking.' 'Allergic to peanuts.' 'Moved to Berlin in July.' They cross-check the new notes against the old ones, merge any duplicates, and update if something contradicts (you used to live in NYC, now Berlin, the entry gets updated). When you start talking again, they glance at the notebook, pull out the few entries that seem relevant to what you are about to say, and keep those in mind. They never re-read the whole notebook every time; just the relevant slice.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example.
Single-session tasks where there is no cross-session memory requirement The extraction overhead is wasted if memories will not be retrieved later. A simple message buffer is enough.
Workloads that need point in time queries or longitudinal modeling Mem0's default newest-wins policy is the wrong fit. Zep's temporal graph or a custom timestamped store handles this natively.
Regulated workloads where the extraction LLM's outputs must be audited per fact Mem0's extraction is a managed step inside the service. Heavily regulated products may need a custom extraction pipeline they own end to end.
Quick scan · 2–4 min
Everything important, quickly.
Walk through the write path: extraction LLM over the new turn pair, dedup via embedding similarity, contradiction resolution with newest-wins or temporal flagging, persistence with embedding. Then the read path: vector search over the user-scoped store, top-k formatting into a compact memory block, injection into the system prompt. Emphasize that the agent never sees the full archive, only the per-turn salient slice. Close with the failure modes to monitor: extraction quality drift, retrieval precision, contradiction policy mismatch.
Real-world examples
Real products, models, and research that use this idea.
1Mem0's hosted service is used in consumer chat products that need persistent user facts across sessions
2Inflection's Pi assistant uses extract on write memory similar in shape to the Mem0 pipeline
3OpenAI's ChatGPT memory feature follows a similar pattern: extract facts, dedupe, retrieve salient subset per turn
4LangChain integrations expose Mem0 as a memory backend behind the LangGraph state pattern for combined working plus long-term memory
5Anthropic's Claude memory tool in 2026 implements a comparable extract then retrieve flow for cross-session user facts
Interviewer follow-ups
What an interviewer would ask next. Try answering before peeking at the approach.
QHow would you customize Mem0's extraction prompt for a domain-specific assistant?
Sign in or go Pro to see the approach for this follow-up.
QWhat is the right strategy when Mem0's newest-wins contradiction policy is wrong for your product?
Sign in or go Pro to see the approach for this follow-up.
QHow does Mem0 interact with LangGraph state in a production agent?
Sign in or go Pro to see the approach for this follow-up.
Don't say this
Red flags and common mistakes that signal junior thinking. Click to expand.
Most common mistake
Imagining Mem0 stores raw conversation history and rebuilds it each turn, missing that the actual unit of storage is a discrete extracted fact and that contradiction handling is part of the write path.