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.

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

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",
)

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

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

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

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")

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

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.

Explore Search Concepts

Build a Support Agent