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

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

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

## Add with Mem0 Platform

<CodeGroup>
  ```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",
  });
  ```
</CodeGroup>

<Info icon="check">
  Expect a `status: "PENDING"` response with an `event_id`. Poll `GET /v1/event/{event_id}/` to confirm completion.
</Info>

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

<CodeGroup>
  ```python Python theme={null}
  # 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 theme={null}
  // 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.
  ```
</CodeGroup>

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.

<Info>
  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.
</Info>

## Add with Mem0 Open Source

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

  # Optionally set an expiration date (YYYY-MM-DD)
  result = m.add(messages, user_id="alice", expiration_date="2030-01-31")
  ```

  ```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" }
  });

  // Optionally set an expiration date (YYYY-MM-DD)
  const expiring = memory.add(messages, {
    userId: "alice",
    expirationDate: "2030-01-31",
  });
  ```
</CodeGroup>

<Tip>
  Use `infer=False` only when you need to store raw transcripts. Most workflows benefit from Mem0 extracting structured memories automatically.
</Tip>

<Warning>
  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.
</Warning>

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

<Callout type="tip" icon="plug">
  **MCP Alternative**: With <Link href="/platform/mem0-mcp">Mem0 MCP</Link>, AI agents can add memories automatically based on context.
</Callout>

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 <Link href="/platform/advanced-memory-operations">Advanced Memory Operations</Link> guide to layer metadata and rerankers.
* Explore the <Link href="/api-reference/memory/add-memories">Add Memories API reference</Link> for every request/response field.

## See it live

* <Link href="/cookbooks/operations/support-inbox">Support Inbox with Mem0</Link> shows add + search powering a support flow.
* <Link href="/cookbooks/companions/ai-tutor">AI Tutor with Mem0</Link> uses add to personalize lesson plans.

<CardGroup cols={2}>
  <Card title="Explore Search Concepts" description="See how stored memories feed retrieval in the Search guide." icon="search" href="/core-concepts/memory-operations/search" />

  <Card title="Build a Support Agent" description="Follow the cookbook to apply add/search/update in production." icon="rocket" href="/cookbooks/operations/support-inbox" />
</CardGroup>