> ## Documentation Index
> Fetch the complete documentation index at: https://docs.mem0.ai/llms.txt
> Use this file to discover all available pages before exploring further.
# Add Memory
> Add memory into the Mem0 platform by storing user-assistant interactions and facts for later retrieval.
# 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`, `agent_id`, `app_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 and scaling.
* **Mem0 Open Source** – Local SDK that you run in your own environment.
Both flows take the same payload and add memories through an additive pipeline.
Mem0 sends the messages through an LLM that pulls out key facts, decisions, or preferences to remember.
New memories are added without overwriting or deleting existing memories.
Future searches rank the most relevant memories for the query.
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.
You trigger this pipeline with a single `add` call—no manual orchestration needed.
## Add with Mem0 Platform
```python Python theme={null}
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",
)
```
```javascript JavaScript theme={null}
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",
});
```
Expect a `status: "PENDING"` response with an `event_id`. Poll `GET /v1/event/{event_id}/` to confirm completion.
## Add with Mem0 Open Source
```python Python theme={null}
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)
```
```javascript JavaScript theme={null}
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" }
});
```
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 inference, so a later `infer=True` call with the same content can create a second memory.
## 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
**MCP Alternative**: With Mem0 MCP, AI agents can add memories automatically based on context.
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](/api-reference/memory/add-memories).
## Managed vs OSS differences
| 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 |
## Put it into practice
* Review the Advanced Memory Operations guide to layer metadata and rerankers.
* Explore the Add Memories API reference for every request/response field.
## See it live
* Support Inbox with Mem0 shows add + search powering a support flow.
* AI Tutor with Mem0 uses add to personalize lesson plans.