Skip to main content

​
How Mem0 Adds Memory

Adding memory is how Mem0 captures useful details from a conversation so your agents can reuse them later. Think of it as saving the important sentences from a chat transcript into a structured notebook your agent can search.
Why it matters
  • Preserves user preferences, goals, and feedback across sessions.
  • Powers personalization and decision-making in downstream conversations.
  • Keeps context consistent between managed Platform and OSS deployments.

​
Key terms

  • Messages – The ordered list of user/assistant turns you send to add.
  • Infer – Controls whether Mem0 extracts structured memories (infer=True, default) or stores raw messages.
  • Metadata – Optional filters (e.g., {"category": "movie_recommendations"}) that improve retrieval later.
  • User / Session identifiers – user_id, session_id, or run_id that scope the memory for future searches.

​
How does it work?

Mem0 offers two flows:
  • Mem0 Platform – Fully managed API with dashboard, scaling, and graph features.
  • Mem0 Open Source – Local SDK that you run in your own environment.
Both flows take the same payload and pass it through the same pipeline.

Architecture diagram illustrating the process of adding memories.

1

Information extraction

Mem0 sends the messages through an LLM that pulls out key facts, decisions, or preferences to remember.
2

Conflict resolution

Existing memories are checked for duplicates or contradictions so the latest truth wins.
3

Storage

The resulting memories land in managed vector storage (and optional graph storage) so future searches return them quickly.
Duplicate protection only runs during that conflict-resolution step when you let Mem0 infer memories (infer=True, the default). If you switch to infer=False, Mem0 stores your payload exactly as provided, so duplicates will land. Mixing both modes for the same fact will save it twice.
You trigger this pipeline with a single add call—no manual orchestration needed.

​
Add with Mem0 Platform

from mem0 import MemoryClient

client = MemoryClient(api_key="your-api-key")

messages = [
    {"role": "user", "content": "I'm planning a trip to Tokyo next month."},
    {"role": "assistant", "content": "Great! I’ll remember that for future suggestions."}
]

client.add(
    messages=messages,
    user_id="alice",
    
)
Expect a memory_id (or list of IDs) in the response. Check the Mem0 dashboard to confirm the new entry under the correct user.

​
Add with Mem0 Open Source

import os
from mem0 import Memory

os.environ["OPENAI_API_KEY"] = "your-api-key"

m = Memory()

messages = [
    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
    {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
]

# Store inferred memories (default behavior)
result = m.add(messages, user_id="alice", metadata={"category": "movie_recommendations"})

# Optionally store raw messages without inference
result = m.add(messages, user_id="alice", metadata={"category": "movie_recommendations"}, infer=False)
Use infer=False only when you need to store raw transcripts. Most workflows benefit from Mem0 extracting structured memories automatically.
If you do choose infer=False, keep it consistent. Raw inserts skip conflict resolution, so a later infer=True call with the same content will create a second memory instead of updating the first.

​
When Should You Add Memory?

Add memory whenever your agent learns something useful:
  • A new user preference is shared
  • A decision or suggestion is made
  • A goal or task is completed
  • A new entity is introduced
  • A user gives feedback or clarification
Storing this context allows the agent to reason better in future interactions.

​
More Details

For full list of supported fields, required formats, and advanced options, see the Add Memory API Reference.

​
Managed vs OSS differences

CapabilityMem0 PlatformMem0 OSS
Conflict resolutionAutomatic with dashboard visibilitySDK handles merges locally; you control storage
Graph writesToggle per request (enable_graph=True)Requires configuring a graph provider
Rate limitsManaged quotas per workspaceLimited by your hardware and provider APIs
Dashboard visibilityYes — inspect memories visuallyInspect via CLI, logs, or custom UI

​
Put it into practice

​
See it live

Explore Search Concepts

Build a Support Agent