# 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.

## 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.
- **expiration_date**: Optional `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.

## 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.

1. **Information extraction**  
   Mem0 sends the messages through an LLM that pulls out key facts, decisions, or preferences to remember.

2. **Additive storage**  
   New memories are added without overwriting or deleting existing memories.

3. **Retrieval**  
   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
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
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.

### Automatic conversation context

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:

#### Python

```python
# First interaction
client.add(
    [{"role": "user", "content": "My dog's name is Biscuit. He's a golden retriever."}],
    user_id="alice",
)

# Later — send only the new turn, no history
client.add(
    [{"role": "user", "content": "He turned 5 today, and I'm taking him to the vet on Friday."}],
    user_id="alice",
)
# Stored as: "User's dog Biscuit turned 5" — "He" is resolved against the earlier turn.
```

#### 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.

This is default behavior and needs no configuration. Earlier SDK versions gated it behind a `version="v2"` argument on `add`; that argument no longer exists and is ignored if sent.

## Add with Mem0 Open Source

### Python

```python
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)

# Optionally set an expiration date (YYYY-MM-DD)
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",
});
```

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](https://docs.mem0.ai/platform/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](https://docs.mem0.ai/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](https://docs.mem0.ai/platform/advanced-memory-operations) guide to layer metadata and rerankers.
- Explore the [Add Memories API reference](https://docs.mem0.ai/api-reference/memory/add-memories) for every request/response field.