docs/core-concepts/memory-operations/add.mdx
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.
add.infer=True, default) or stores raw messages.{"category": "movie_recommendations"}) that improve retrieval later.user_id, agent_id, app_id, or run_id that scope the memory for future searches.YYYY-MM-DD date after which the memory is treated as expired. Use expirationDate in the JavaScript SDKs. Expired memories are hidden from search and get_all unless you pass show_expired (showExpired in JavaScript); fetching by ID still returns them.Mem0 offers two flows:
Both flows take the same payload and add memories through an additive pipeline.
<Steps> <Step title="Information extraction"> Mem0 sends the messages through an LLM that pulls out key facts, decisions, or preferences to remember. </Step> <Step title="Additive storage"> New memories are added without overwriting or deleting existing memories. </Step> <Step title="Retrieval"> Future searches rank the most relevant memories for the query. </Step> </Steps> <Warning> When you switch to `infer=False`, Mem0 stores your payload exactly as provided, so duplicates can land. Mixing both modes for the same fact can save it twice. </Warning>You trigger this pipeline with a single add call: no manual orchestration needed.
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", )
```javascript JavaScript
import { MemoryClient } from "mem0ai";
const client = new MemoryClient({apiKey: "your-api-key"});
const messages = [
{ role: "user", content: "I'm planning a trip to Tokyo next month." },
{ role: "assistant", content: "Great! I’ll remember that for future suggestions." }
];
await client.add(messages, {
userId: "alice",
});
On the Platform, you only send new messages. Mem0 automatically pulls the earlier messages that share the same identifiers (user_id, and run_id if you use one) and uses them as context when extracting memories, so you never need to resend conversation history.
This means a follow-up turn is understood against what came before it:
<CodeGroup> ```python Python # First interaction client.add( [{"role": "user", "content": "My dog's name is Biscuit. He's a golden retriever."}], user_id="alice", )client.add( [{"role": "user", "content": "He turned 5 today, and I'm taking him to the vet on Friday."}], user_id="alice", )
```javascript JavaScript
// First interaction
await client.add(
[{ role: "user", content: "My dog's name is Biscuit. He's a golden retriever." }],
{ userId: "alice" },
);
// Later — send only the new turn, no history
await client.add(
[{ role: "user", content: "He turned 5 today, and I'm taking him to the vet on Friday." }],
{ userId: "alice" },
);
// Stored as: "User's dog Biscuit turned 5" — "He" is resolved against the earlier turn.
Without that earlier turn, the same message can only be stored as "User's male pet turned 5", because there is nothing to resolve "He" against. Scope each conversation with a consistent user_id (plus run_id for a distinct session) and Mem0 handles the rest.
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."} ]
result = m.add(messages, user_id="alice", metadata={"category": "movie_recommendations"})
result = m.add(messages, user_id="alice", metadata={"category": "movie_recommendations"}, infer=False)
result = m.add(messages, user_id="alice", expiration_date="2030-01-31")
```javascript JavaScript
import { Memory } from 'mem0ai/oss';
const memory = new Memory();
const messages = [
{
role: "user",
content: "I like to drink coffee in the morning and go for a walk"
}
];
const result = memory.add(messages, {
userId: "alice",
metadata: { category: "preferences" }
});
// Optionally set an expiration date (YYYY-MM-DD)
const expiring = memory.add(messages, {
userId: "alice",
expirationDate: "2030-01-31",
});
Add memory whenever your agent learns something useful:
Storing this context allows the agent to reason better in future interactions.
For full list of supported fields, required formats, and advanced options, see the Add Memory API Reference.
| Capability | Mem0 Platform | Mem0 OSS |
|---|---|---|
| Add behavior | ADD-only; memories accumulate | ADD-only; you control storage |
| Rate limits | Managed quotas per workspace | Limited by your hardware and provider APIs |
| Dashboard visibility | Yes: inspect memories visually | Inspect via CLI, logs, or custom UI |