# Configurations
Source: https://docs.mem0.ai/components/embedders/config



Config in mem0 is a dictionary that specifies the settings for your embedding models. It allows you to customize the behavior and connection details of your chosen embedder.

## How to define configurations?

The config is defined as an object (or dictionary) with two main keys:

* `embedder`: Specifies the embedder provider and its configuration
  * `provider`: The name of the embedder (e.g., "openai", "ollama")
  * `config`: A nested object or dictionary containing provider-specific settings

## How to use configurations?

Here's a general example of how to use the config with mem0:

<CodeGroup>
  ```python Python theme={null}
  import os
  from mem0 import Memory

  os.environ["OPENAI_API_KEY"] = "sk-xx"

  config = {
      "embedder": {
          "provider": "your_chosen_provider",
          "config": {
              # Provider-specific settings go here
          }
      }
  }

  m = Memory.from_config(config)
  m.add("Your text here", user_id="user", metadata={"category": "example"})
  ```

  ```typescript TypeScript theme={null}
  import { Memory } from 'mem0ai/oss';

  const config = {
    embedder: {
      provider: 'openai',
      config: {
        apiKey: process.env.OPENAI_API_KEY || '',
        model: 'text-embedding-3-small',
        // Provider-specific settings go here
      },
    },
  };

  const memory = new Memory(config);
  await memory.add("Your text here", { userId: "user", metadata: { category: "example" } });
  ```
</CodeGroup>

## Why is Config Needed?

Config is essential for:

1. Specifying which embedding model to use.
2. Providing necessary connection details (e.g., model, api\_key, embedding\_dims).
3. Ensuring proper initialization and connection to your chosen embedder.

## Master List of All Params in Config

Here's a comprehensive list of all parameters that can be used across different embedders:

<Tabs>
  <Tab title="Python">
    | Parameter                      | Description                                                 | Provider     |
    | ------------------------------ | ----------------------------------------------------------- | ------------ |
    | `model`                        | Embedding model to use                                      | All          |
    | `api_key`                      | API key of the provider                                     | All          |
    | `embedding_dims`               | Dimensions of the embedding model                           | All          |
    | `http_client_proxies`          | Allow proxy server settings                                 | All          |
    | `ollama_base_url`              | Base URL for the Ollama embedding model                     | Ollama       |
    | `model_kwargs`                 | Key-Value arguments for the Huggingface embedding model     | Huggingface  |
    | `azure_kwargs`                 | Key-Value arguments for the AzureOpenAI embedding model     | Azure OpenAI |
    | `openai_base_url`              | Base URL for OpenAI API                                     | OpenAI       |
    | `vertex_credentials_json`      | Path to the Google Cloud credentials JSON file for VertexAI | VertexAI     |
    | `memory_add_embedding_type`    | The type of embedding to use for the add memory action      | VertexAI     |
    | `memory_update_embedding_type` | The type of embedding to use for the update memory action   | VertexAI     |
    | `memory_search_embedding_type` | The type of embedding to use for the search memory action   | VertexAI     |
    | `lmstudio_base_url`            | Base URL for LM Studio API                                  | LM Studio    |
  </Tab>

  <Tab title="TypeScript">
    | Parameter       | Description                       | Provider |
    | --------------- | --------------------------------- | -------- |
    | `model`         | Embedding model to use            | All      |
    | `apiKey`        | API key of the provider           | All      |
    | `embeddingDims` | Dimensions of the embedding model | All      |
  </Tab>
</Tabs>

## Supported Embedding Models

For detailed information on configuring specific embedders, please visit the [Embedding Models](./models) section. There you'll find information for each supported embedder with provider-specific usage examples and configuration details.


# Azure OpenAI
Source: https://docs.mem0.ai/components/embedders/models/azure_openai



To use Azure OpenAI embedding models, set the `EMBEDDING_AZURE_OPENAI_API_KEY`, `EMBEDDING_AZURE_DEPLOYMENT`, `EMBEDDING_AZURE_ENDPOINT` and `EMBEDDING_AZURE_API_VERSION` environment variables. You can obtain the Azure OpenAI API key from the Azure.

### Usage

<CodeGroup>
  ```python Python theme={null}
  import os
  from mem0 import Memory

  os.environ["EMBEDDING_AZURE_OPENAI_API_KEY"] = "your-api-key"
  os.environ["EMBEDDING_AZURE_DEPLOYMENT"] = "your-deployment-name"
  os.environ["EMBEDDING_AZURE_ENDPOINT"] = "your-api-base-url"
  os.environ["EMBEDDING_AZURE_API_VERSION"] = "version-to-use"

  os.environ["OPENAI_API_KEY"] = "your_api_key" # For LLM


  config = {
      "embedder": {
          "provider": "azure_openai",
          "config": {
              "model": "text-embedding-3-large",
              "azure_kwargs": {
                    "api_version": "",
                    "azure_deployment": "",
                    "azure_endpoint": "",
                    "api_key": "",
                    "default_headers": {
                      "CustomHeader": "your-custom-header",
                    }
                }
          }
      }
  }

  m = Memory.from_config(config)
  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."}
  ]
  m.add(messages, user_id="john")
  ```

  ```typescript TypeScript theme={null}
  import { Memory } from 'mem0ai/oss';

  const config = {
      embedder: {
          provider: "azure_openai",
          config: {
              model: "text-embedding-3-large",
              modelProperties: {
                  endpoint: "your-api-base-url",
                  deployment: "your-deployment-name",
                  apiVersion: "version-to-use",
              }
          }
      }
  }

  const memory = new Memory(config);

  const 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."}
  ]

  await memory.add(messages, { userId: "john" });
  ```
</CodeGroup>

As an alternative to using an API key, the Azure Identity credential chain can be used to authenticate with [Azure OpenAI role-based security](https://learn.microsoft.com/en-us/azure/ai-foundry/openai/how-to/role-based-access-control).

<Note> If an API key is provided, it will be used for authentication over an Azure Identity </Note>

Below is a sample configuration for using Mem0 with Azure OpenAI and Azure Identity:

```python  theme={null}
import os
from mem0 import Memory
# You can set the values directly in the config dictionary or use environment variables

os.environ["LLM_AZURE_DEPLOYMENT"] = "your-deployment-name"
os.environ["LLM_AZURE_ENDPOINT"] = "your-api-base-url"
os.environ["LLM_AZURE_API_VERSION"] = "version-to-use"

config = {
    "llm": {
        "provider": "azure_openai_structured",
        "config": {
            "model": "your-deployment-name",
            "temperature": 0.1,
            "max_tokens": 2000,
            "azure_kwargs": {
                  "azure_deployment": "<your-deployment-name>",
                  "api_version": "<version-to-use>",
                  "azure_endpoint": "<your-api-base-url>",
                  "default_headers": {
                    "CustomHeader": "your-custom-header",
                  }
              }
        }
    }
}
```

Refer to [Azure Identity troubleshooting tips](https://github.com/Azure/azure-sdk-for-python/blob/main/sdk/identity/azure-identity/TROUBLESHOOTING.md#troubleshoot-environmentcredential-authentication-issues) for setting up an Azure Identity credential.

### Config

Here are the parameters available for configuring Azure OpenAI embedder:

<Tabs>
  <Tab title="Python">
    | Parameter        | Description                            | Default Value            |
    | ---------------- | -------------------------------------- | ------------------------ |
    | `model`          | The name of the embedding model to use | `text-embedding-3-small` |
    | `embedding_dims` | Dimensions of the embedding model      | `1536`                   |
    | `azure_kwargs`   | The Azure OpenAI configs               | `config_keys`            |
  </Tab>

  <Tab title="TypeScript">
    | Parameter         | Description                                   | Default Value                |
    | ----------------- | --------------------------------------------- | ---------------------------- |
    | `model`           | The name of the embedding model to use        | `text-embedding-3-small`     |
    | `embeddingDims`   | Dimensions of the embedding model             | `1536`                       |
    | `apiKey`          | Azure OpenAI API key                          | `None`                       |
    | `modelProperties` | Object containing endpoint and other settings | `{ endpoint: "",...rest   }` |
  </Tab>
</Tabs>


# Hugging Face
Source: https://docs.mem0.ai/components/embedders/models/huggingface



You can use embedding models from Huggingface to run Mem0 locally.

### Usage

```python  theme={null}
import os
from mem0 import Memory

os.environ["OPENAI_API_KEY"] = "your_api_key" # For LLM

config = {
    "embedder": {
        "provider": "huggingface",
        "config": {
            "model": "multi-qa-MiniLM-L6-cos-v1"
        }
    }
}

m = Memory.from_config(config)
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."}
]
m.add(messages, user_id="john")
```

### Using Text Embeddings Inference (TEI)

You can also use Hugging Face's Text Embeddings Inference service for faster and more efficient embeddings:

```python  theme={null}
import os
from mem0 import Memory

os.environ["OPENAI_API_KEY"] = "your_api_key" # For LLM

# Using HuggingFace Text Embeddings Inference API
config = {
    "embedder": {
        "provider": "huggingface",
        "config": {
            "huggingface_base_url": "http://localhost:3000/v1"
        }
    }
}

m = Memory.from_config(config)
m.add("This text will be embedded using the TEI service.", user_id="john")
```

To run the TEI service, you can use Docker:

```bash  theme={null}
docker run -d -p 3000:80 -v huggingfacetei:/data --platform linux/amd64 \
    ghcr.io/huggingface/text-embeddings-inference:cpu-1.6 \
    --model-id BAAI/bge-small-en-v1.5
```

### Config

Here are the parameters available for configuring Huggingface embedder:

| Parameter              | Description                                           | Default Value               |
| ---------------------- | ----------------------------------------------------- | --------------------------- |
| `model`                | The name of the model to use                          | `multi-qa-MiniLM-L6-cos-v1` |
| `embedding_dims`       | Dimensions of the embedding model                     | `selected_model_dimensions` |
| `model_kwargs`         | Additional arguments for the model                    | `None`                      |
| `huggingface_base_url` | URL to connect to Text Embeddings Inference (TEI) API | `None`                      |


# null
Source: https://docs.mem0.ai/components/embedders/models/ollama



You can use embedding models from Ollama to run Mem0 locally.

### Usage

<CodeGroup>
  ```python Python theme={null}
  import os
  from mem0 import Memory

  os.environ["OPENAI_API_KEY"] = "your_api_key" # For LLM

  config = {
      "embedder": {
          "provider": "ollama",
          "config": {
              "model": "mxbai-embed-large"
          }
      }
  }

  m = Memory.from_config(config)
  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."}
  ]
  m.add(messages, user_id="john")
  ```

  ```typescript TypeScript theme={null}
  import { Memory } from 'mem0ai/oss';

  const config = {
    embedder: {
      provider: 'ollama',
      config: {
        model: 'nomic-embed-text:latest', // or any other Ollama embedding model
        url: 'http://localhost:11434', // Ollama server URL
      },
    },
  };

  const memory = new Memory(config);
  const 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."}
  ]
  await memory.add(messages, { userId: "john" });
  ```
</CodeGroup>

### Config

Here are the parameters available for configuring Ollama embedder:

<Tabs>
  <Tab title="Python">
    | Parameter         | Description                         | Default Value      |
    | ----------------- | ----------------------------------- | ------------------ |
    | `model`           | The name of the Ollama model to use | `nomic-embed-text` |
    | `embedding_dims`  | Dimensions of the embedding model   | `512`              |
    | `ollama_base_url` | Base URL for ollama connection      | `None`             |
  </Tab>

  <Tab title="TypeScript">
    | Parameter       | Description                         | Default Value             |
    | --------------- | ----------------------------------- | ------------------------- |
    | `model`         | The name of the Ollama model to use | `nomic-embed-text:latest` |
    | `url`           | Base URL for Ollama server          | `http://localhost:11434`  |
    | `embeddingDims` | Dimensions of the embedding model   | 768                       |
  </Tab>
</Tabs>


# OpenAI
Source: https://docs.mem0.ai/components/embedders/models/openai



To use OpenAI embedding models, set the `OPENAI_API_KEY` environment variable. You can obtain the OpenAI API key from the [OpenAI Platform](https://platform.openai.com/account/api-keys).

### Usage

<CodeGroup>
  ```python Python theme={null}
  import os
  from mem0 import Memory

  os.environ["OPENAI_API_KEY"] = "your_api_key"

  config = {
      "embedder": {
          "provider": "openai",
          "config": {
              "model": "text-embedding-3-large"
          }
      }
  }

  m = Memory.from_config(config)
  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."}
  ]
  m.add(messages, user_id="john")
  ```

  ```typescript TypeScript theme={null}
  import { Memory } from 'mem0ai/oss';

  const config = {
    embedder: {
      provider: 'openai',
      config: {
        apiKey: 'your-openai-api-key',
        model: 'text-embedding-3-large',
      },
    },
  };

  const memory = new Memory(config);
  await memory.add("I'm visiting Paris", { userId: "john" });
  ```
</CodeGroup>

### Config

Here are the parameters available for configuring OpenAI embedder:

<Tabs>
  <Tab title="Python">
    | Parameter        | Description                            | Default Value            |
    | ---------------- | -------------------------------------- | ------------------------ |
    | `model`          | The name of the embedding model to use | `text-embedding-3-small` |
    | `embedding_dims` | Dimensions of the embedding model      | `1536`                   |
    | `api_key`        | The OpenAI API key                     | `None`                   |
  </Tab>

  <Tab title="TypeScript">
    | Parameter       | Description                            | Default Value            |
    | --------------- | -------------------------------------- | ------------------------ |
    | `model`         | The name of the embedding model to use | `text-embedding-3-small` |
    | `embeddingDims` | Dimensions of the embedding model      | `1536`                   |
    | `apiKey`        | The OpenAI API key                     | `None`                   |
  </Tab>
</Tabs>


# null
Source: https://docs.mem0.ai/components/embedders/models/vertexai



### Vertex AI

To use Google Cloud's Vertex AI for text embedding models, set the `GOOGLE_APPLICATION_CREDENTIALS` environment variable to point to the path of your service account's credentials JSON file. These credentials can be created in the [Google Cloud Console](https://console.cloud.google.com/).

### Usage

```python  theme={null}
import os
from mem0 import Memory

# Set the path to your Google Cloud credentials JSON file
os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = "/path/to/your/credentials.json"
os.environ["OPENAI_API_KEY"] = "your_api_key" # For LLM

config = {
    "embedder": {
        "provider": "vertexai",
        "config": {
            "model": "text-embedding-004",
            "memory_add_embedding_type": "RETRIEVAL_DOCUMENT",
            "memory_update_embedding_type": "RETRIEVAL_DOCUMENT",
            "memory_search_embedding_type": "RETRIEVAL_QUERY"
        }
    }
}

m = Memory.from_config(config)
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."}
]
m.add(messages, user_id="john")
```

The embedding types can be one of the following:

* SEMANTIC\_SIMILARITY
* CLASSIFICATION
* CLUSTERING
* RETRIEVAL\_DOCUMENT, RETRIEVAL\_QUERY, QUESTION\_ANSWERING, FACT\_VERIFICATION
* CODE\_RETRIEVAL\_QUERY\
  Check out the [Vertex AI documentation](https://cloud.google.com/vertex-ai/generative-ai/docs/embeddings/task-types#supported_task_types) for more information.

### Config

Here are the parameters available for configuring the Vertex AI embedder:

| Parameter                      | Description                                               | Default Value        |
| ------------------------------ | --------------------------------------------------------- | -------------------- |
| `model`                        | The name of the Vertex AI embedding model to use          | `text-embedding-004` |
| `vertex_credentials_json`      | Path to the Google Cloud credentials JSON file            | `None`               |
| `embedding_dims`               | Dimensions of the embedding model                         | `256`                |
| `memory_add_embedding_type`    | The type of embedding to use for the add memory action    | `RETRIEVAL_DOCUMENT` |
| `memory_update_embedding_type` | The type of embedding to use for the update memory action | `RETRIEVAL_DOCUMENT` |
| `memory_search_embedding_type` | The type of embedding to use for the search memory action | `RETRIEVAL_QUERY`    |


# Overview
Source: https://docs.mem0.ai/components/embedders/overview



Mem0 offers support for various embedding models, allowing users to choose the one that best suits their needs.

## Supported Embedders

See the list of supported embedders below.

<Note>
  The following embedders are supported in the Python implementation. The TypeScript implementation currently only supports OpenAI.
</Note>

<CardGroup cols={4}>
  <Card title="OpenAI" href="/components/embedders/models/openai" />

  <Card title="Azure OpenAI" href="/components/embedders/models/azure_openai" />

  <Card title="Ollama" href="/components/embedders/models/ollama" />

  <Card title="Hugging Face" href="/components/embedders/models/huggingface" />

  <Card title="Google AI" href="/components/embedders/models/google_AI" />

  <Card title="Vertex AI" href="/components/embedders/models/vertexai" />

  <Card title="Together" href="/components/embedders/models/together" />

  <Card title="LM Studio" href="/components/embedders/models/lmstudio" />

  <Card title="Langchain" href="/components/embedders/models/langchain" />

  <Card title="AWS Bedrock" href="/components/embedders/models/aws_bedrock" />
</CardGroup>

## Usage

To utilize an embedding model, you must provide a configuration to customize its usage. If no configuration is supplied, a default configuration will be applied, and `OpenAI` will be used as the embedding model.

For a comprehensive list of available parameters for embedding model configuration, please refer to [Config](./config).


# Configurations
Source: https://docs.mem0.ai/components/llms/config



## How to define configurations?

<Tabs>
  <Tab title="Python">
    The `config` is defined as a Python dictionary with two main keys:

    * `llm`: Specifies the llm provider and its configuration
      * `provider`: The name of the llm (e.g., "openai", "groq")
      * `config`: A nested dictionary containing provider-specific settings
  </Tab>

  <Tab title="TypeScript">
    The `config` is defined as a TypeScript object with these keys:

    * `llm`: Specifies the LLM provider and its configuration (required)
      * `provider`: The name of the LLM (e.g., "openai", "groq")
      * `config`: A nested object containing provider-specific settings
    * `embedder`: Specifies the embedder provider and its configuration (optional)
    * `vectorStore`: Specifies the vector store provider and its configuration (optional)
    * `historyDbPath`: Path to the history database file (optional)
  </Tab>
</Tabs>

### Config Values Precedence

Config values are applied in the following order of precedence (from highest to lowest):

1. Values explicitly set in the `config` object/dictionary
2. Environment variables (e.g., `OPENAI_API_KEY`, `OPENAI_BASE_URL`)
3. Default values defined in the LLM implementation

This means that values specified in the `config` will override corresponding environment variables, which in turn override default values.

## How to Use Config

Here's a general example of how to use the config with Mem0:

<CodeGroup>
  ```python Python theme={null}
  import os
  from mem0 import Memory

  os.environ["OPENAI_API_KEY"] = "sk-xx" # for embedder

  config = {
      "llm": {
          "provider": "your_chosen_provider",
          "config": {
              # Provider-specific settings go here
          }
      }
  }

  m = Memory.from_config(config)
  m.add("Your text here", user_id="user", metadata={"category": "example"})

  ```

  ```typescript TypeScript theme={null}
  import { Memory } from 'mem0ai/oss';

  // Minimal configuration with just the LLM settings
  const config = {
    llm: {
      provider: 'your_chosen_provider',
      config: {
        // Provider-specific settings go here
      }
    }
  };

  const memory = new Memory(config);
  await memory.add("Your text here", { userId: "user123", metadata: { category: "example" } });
  ```
</CodeGroup>

## Why is Config Needed?

Config is essential for:

1. Specifying which LLM to use.
2. Providing necessary connection details (e.g., model, api\_key, temperature).
3. Ensuring proper initialization and connection to your chosen LLM.

## Master List of All Params in Config

Here's a comprehensive list of all parameters that can be used across different LLMs:

<Tabs>
  <Tab title="Python">
    | Parameter             | Description                                  | Provider    |
    | --------------------- | -------------------------------------------- | ----------- |
    | `model`               | Embedding model to use                       | All         |
    | `temperature`         | Temperature of the model                     | All         |
    | `api_key`             | API key to use                               | All         |
    | `max_tokens`          | Tokens to generate                           | All         |
    | `top_p`               | Probability threshold for nucleus sampling   | All         |
    | `top_k`               | Number of highest probability tokens to keep | All         |
    | `http_client_proxies` | Allow proxy server settings                  | AzureOpenAI |
    | `models`              | List of models                               | Openrouter  |
    | `route`               | Routing strategy                             | Openrouter  |
    | `openrouter_base_url` | Base URL for Openrouter API                  | Openrouter  |
    | `site_url`            | Site URL                                     | Openrouter  |
    | `app_name`            | Application name                             | Openrouter  |
    | `ollama_base_url`     | Base URL for Ollama API                      | Ollama      |
    | `openai_base_url`     | Base URL for OpenAI API                      | OpenAI      |
    | `azure_kwargs`        | Azure LLM args for initialization            | AzureOpenAI |
    | `deepseek_base_url`   | Base URL for DeepSeek API                    | DeepSeek    |
    | `xai_base_url`        | Base URL for XAI API                         | XAI         |
    | `sarvam_base_url`     | Base URL for Sarvam API                      | Sarvam      |
    | `reasoning_effort`    | Reasoning level (low, medium, high)          | Sarvam      |
    | `frequency_penalty`   | Penalize frequent tokens (-2.0 to 2.0)       | Sarvam      |
    | `presence_penalty`    | Penalize existing tokens (-2.0 to 2.0)       | Sarvam      |
    | `seed`                | Seed for deterministic sampling              | Sarvam      |
    | `stop`                | Stop sequences (max 4)                       | Sarvam      |
    | `lmstudio_base_url`   | Base URL for LM Studio API                   | LM Studio   |
    | `response_callback`   | LLM response callback function               | OpenAI      |
  </Tab>

  <Tab title="TypeScript">
    | Parameter       | Description                                  | Provider |
    | --------------- | -------------------------------------------- | -------- |
    | `model`         | Embedding model to use                       | All      |
    | `temperature`   | Temperature of the model                     | All      |
    | `apiKey`        | API key to use                               | All      |
    | `maxTokens`     | Tokens to generate                           | All      |
    | `topP`          | Probability threshold for nucleus sampling   | All      |
    | `topK`          | Number of highest probability tokens to keep | All      |
    | `openaiBaseUrl` | Base URL for OpenAI API                      | OpenAI   |
  </Tab>
</Tabs>

## Supported LLMs

For detailed information on configuring specific LLMs, please visit the [LLMs](./models) section. There you'll find information for each supported LLM with provider-specific usage examples and configuration details.


# Anthropic
Source: https://docs.mem0.ai/components/llms/models/anthropic



To use Anthropic's models, please set the `ANTHROPIC_API_KEY` which you find on their [Account Settings Page](https://console.anthropic.com/account/keys).

## Usage

<CodeGroup>
  ```python Python theme={null}
  import os
  from mem0 import Memory

  os.environ["OPENAI_API_KEY"] = "your-api-key" # used for embedding model
  os.environ["ANTHROPIC_API_KEY"] = "your-api-key"

  config = {
      "llm": {
          "provider": "anthropic",
          "config": {
              "model": "claude-sonnet-4-20250514",
              "temperature": 0.1,
              "max_tokens": 2000,
          }
      }
  }

  m = Memory.from_config(config)
  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."}
  ]
  m.add(messages, user_id="alice", metadata={"category": "movies"})
  ```

  ```typescript TypeScript theme={null}
  import { Memory } from 'mem0ai/oss';

  const config = {
    llm: {
      provider: 'anthropic',
      config: {
        apiKey: process.env.ANTHROPIC_API_KEY || '',
        model: 'claude-sonnet-4-20250514',
        temperature: 0.1,
        maxTokens: 2000,
      },
    },
  };

  const memory = new Memory(config);
  const 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."}
  ]
  await memory.add(messages, { userId: "alice", metadata: { category: "movies" } });
  ```
</CodeGroup>

## Config

All available parameters for the `anthropic` config are present in [Master List of All Params in Config](../config).


# AWS Bedrock
Source: https://docs.mem0.ai/components/llms/models/aws_bedrock



### Setup

* Before using the AWS Bedrock LLM, make sure you have the appropriate model access from [Bedrock Console](https://us-east-1.console.aws.amazon.com/bedrock/home?region=us-east-1#/modelaccess).
* You will also need to authenticate the `boto3` client by using a method in the [AWS documentation](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html#configuring-credentials)
* You will have to export `AWS_REGION`, `AWS_ACCESS_KEY`, and `AWS_SECRET_ACCESS_KEY` to set environment variables.

### Usage

```python  theme={null}
import os
from mem0 import Memory

os.environ['AWS_REGION'] = 'us-west-2'
os.environ["AWS_ACCESS_KEY_ID"] = "xx"
os.environ["AWS_SECRET_ACCESS_KEY"] = "xx"

config = {
    "llm": {
        "provider": "aws_bedrock",
        "config": {
            "model": "anthropic.claude-3-5-haiku-20241022-v1:0",
            "temperature": 0.2,
            "max_tokens": 2000,
        }
    }
}

m = Memory.from_config(config)
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."}
]
m.add(messages, user_id="alice", metadata={"category": "movies"})
```

### Config

All available parameters for the `aws_bedrock` config are present in [Master List of All Params in Config](../config).


# Azure OpenAI
Source: https://docs.mem0.ai/components/llms/models/azure_openai



<Note> Mem0 Now Supports Azure OpenAI Models in TypeScript SDK </Note>

To use Azure OpenAI models, you have to set the `LLM_AZURE_OPENAI_API_KEY`, `LLM_AZURE_ENDPOINT`, `LLM_AZURE_DEPLOYMENT` and `LLM_AZURE_API_VERSION` environment variables. You can obtain the Azure API key from the [Azure](https://azure.microsoft.com/).

Optionally, you can use Azure Identity to authenticate with Azure OpenAI, which allows you to use managed identities or service principals for production and Azure CLI login for development instead of an API key. If an Azure Identity is to be used, ***do not*** set the `LLM_AZURE_OPENAI_API_KEY` environment variable or the api\_key in the config dictionary.

> **Note**: The following are currently unsupported with reasoning models `Parallel tool calling`,`temperature`, `top_p`, `presence_penalty`, `frequency_penalty`, `logprobs`, `top_logprobs`, `logit_bias`, `max_tokens`

## Usage

<CodeGroup>
  ```python Python theme={null}
  import os
  from mem0 import Memory

  os.environ["OPENAI_API_KEY"] = "your-api-key" # used for embedding model

  os.environ["LLM_AZURE_OPENAI_API_KEY"] = "your-api-key"
  os.environ["LLM_AZURE_DEPLOYMENT"] = "your-deployment-name"
  os.environ["LLM_AZURE_ENDPOINT"] = "your-api-base-url"
  os.environ["LLM_AZURE_API_VERSION"] = "version-to-use"

  config = {
      "llm": {
          "provider": "azure_openai",
          "config": {
              "model": "your-deployment-name",
              "temperature": 0.1,
              "max_tokens": 2000,
              "azure_kwargs": {
                    "azure_deployment": "",
                    "api_version": "",
                    "azure_endpoint": "",
                    "api_key": "",
                    "default_headers": {
                      "CustomHeader": "your-custom-header",
                    }
                }
          }
      }
  }

  m = Memory.from_config(config)
  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."}
  ]
  m.add(messages, user_id="alice", metadata={"category": "movies"})
  ```

  ```typescript TypeScript theme={null}
  import { Memory } from 'mem0ai/oss';

  const config = {
    llm: {
      provider: 'azure_openai',
      config: {
        apiKey: process.env.AZURE_OPENAI_API_KEY || '',
        modelProperties: {
          endpoint: 'https://your-api-base-url',
          deployment: 'your-deployment-name',
          modelName: 'your-model-name',
          apiVersion: 'version-to-use',
          // Any other parameters you want to pass to the Azure OpenAI API
        },
      },
    },
  };

  const memory = new Memory(config);
  const 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."}
  ]
  await memory.add(messages, { userId: "alice", metadata: { category: "movies" } });
  ```
</CodeGroup>

We also support the new [OpenAI structured-outputs](https://platform.openai.com/docs/guides/structured-outputs/introduction) model. Typescript SDK does not support the `azure_openai_structured` model yet.

```python  theme={null}
import os
from mem0 import Memory

os.environ["LLM_AZURE_OPENAI_API_KEY"] = "your-api-key"
os.environ["LLM_AZURE_DEPLOYMENT"] = "your-deployment-name"
os.environ["LLM_AZURE_ENDPOINT"] = "your-api-base-url"
os.environ["LLM_AZURE_API_VERSION"] = "version-to-use"

config = {
    "llm": {
        "provider": "azure_openai_structured",
        "config": {
            "model": "your-deployment-name",
            "temperature": 0.1,
            "max_tokens": 2000,
            "azure_kwargs": {
                  "azure_deployment": "",
                  "api_version": "",
                  "azure_endpoint": "",
                  "api_key": "",
                  "default_headers": {
                    "CustomHeader": "your-custom-header",
                  }
              }
        }
    }
}
```

As an alternative to using an API key, the Azure Identity credential chain can be used to authenticate with [Azure OpenAI role-based security](https://learn.microsoft.com/en-us/azure/ai-foundry/openai/how-to/role-based-access-control).

<Note> If an API key is provided, it will be used for authentication over an Azure Identity </Note>

Below is a sample configuration for using Mem0 with Azure OpenAI and Azure Identity:

```python  theme={null}
import os
from mem0 import Memory
# You can set the values directly in the config dictionary or use environment variables

os.environ["LLM_AZURE_DEPLOYMENT"] = "your-deployment-name"
os.environ["LLM_AZURE_ENDPOINT"] = "your-api-base-url"
os.environ["LLM_AZURE_API_VERSION"] = "version-to-use"

config = {
    "llm": {
        "provider": "azure_openai_structured",
        "config": {
            "model": "your-deployment-name",
            "temperature": 0.1,
            "max_tokens": 2000,
            "azure_kwargs": {
                  "azure_deployment": "<your-deployment-name>",
                  "api_version": "<version-to-use>",
                  "azure_endpoint": "<your-api-base-url>",
                  "default_headers": {
                    "CustomHeader": "your-custom-header",
                  }
              }
        }
    }
}
```

Refer to [Azure Identity troubleshooting tips](https://github.com/Azure/azure-sdk-for-python/blob/main/sdk/identity/azure-identity/TROUBLESHOOTING.md#troubleshoot-environmentcredential-authentication-issues) for setting up an Azure Identity credential.

## Config

All available parameters for the `azure_openai` config are present in [Master List of All Params in Config](../config).


# DeepSeek
Source: https://docs.mem0.ai/components/llms/models/deepseek



To use DeepSeek LLM models, you have to set the `DEEPSEEK_API_KEY` environment variable. You can also optionally set `DEEPSEEK_API_BASE` if you need to use a different API endpoint (defaults to "[https://api.deepseek.com](https://api.deepseek.com)").

## Usage

```python  theme={null}
import os
from mem0 import Memory

os.environ["DEEPSEEK_API_KEY"] = "your-api-key"
os.environ["OPENAI_API_KEY"] = "your-api-key" # for embedder model

config = {
    "llm": {
        "provider": "deepseek",
        "config": {
            "model": "deepseek-chat",  # default model
            "temperature": 0.2,
            "max_tokens": 2000,
            "top_p": 1.0
        }
    }
}

m = Memory.from_config(config)
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."}
]
m.add(messages, user_id="alice", metadata={"category": "movies"})
```

You can also configure the API base URL in the config:

```python  theme={null}
config = {
    "llm": {
        "provider": "deepseek",
        "config": {
            "model": "deepseek-chat",
            "deepseek_base_url": "https://your-custom-endpoint.com",
            "api_key": "your-api-key"  # alternatively to using environment variable
        }
    }
}
```

## Config

All available parameters for the `deepseek` config are present in [Master List of All Params in Config](../config).


# Google AI
Source: https://docs.mem0.ai/components/llms/models/google_AI



To use the Gemini model, set the `GOOGLE_API_KEY` environment variable. You can obtain the Google/Gemini API key from [Google AI Studio](https://aistudio.google.com/app/apikey).

> **Note:** As of the latest release, Mem0 uses the new `google.genai` SDK instead of the deprecated `google.generativeai`. All message formatting and model interaction now use the updated `types` module from `google.genai`.

> **Note:** Some Gemini models are being deprecated and will retire soon. It is recommended to migrate to the latest stable models like `"gemini-2.0-flash-001"` or `"gemini-2.0-flash-lite-001"` to ensure ongoing support and improvements.

## Usage

<CodeGroup>
  ```python Python theme={null}
  import os
  from mem0 import Memory

  os.environ["OPENAI_API_KEY"] = "your-openai-api-key"  # Used for embedding model
  os.environ["GOOGLE_API_KEY"] = "your-gemini-api-key"

  config = {
      "llm": {
          "provider": "gemini",
          "config": {
              "model": "gemini-2.0-flash-001",
              "temperature": 0.2,
              "max_tokens": 2000,
              "top_p": 1.0
          }
      }
  }

  m = Memory.from_config(config)

  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 thrillers, but I love sci-fi movies."},
      {"role": "assistant", "content": "Got it! I'll avoid thrillers and suggest sci-fi movies instead."}
  ]

  m.add(messages, user_id="alice", metadata={"category": "movies"})

  ```

  ```typescript TypeScript theme={null}
  import { Memory } from "mem0ai/oss";

  const config = {
      llm: {
          // You can also use "google" as provider ( for backward compatibility )
          provider: "gemini",
          config: {
              model: "gemini-2.0-flash-001",
              temperature: 0.1
          }
      }
  }

  const memory = new Memory(config);

  const 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 thrillers, but I love sci-fi movies." },
      { role: "assistant", content: "Got it! I'll avoid thrillers and suggest sci-fi movies instead." }
  ]

  await memory.add(messages, { userId: "alice", metadata: { category: "movies" } });
  ```
</CodeGroup>

## Config

All available parameters for the `Gemini` config are present in [Master List of All Params in Config](../config).


# Groq
Source: https://docs.mem0.ai/components/llms/models/groq



[Groq](https://groq.com/) is the creator of the world's first Language Processing Unit (LPU), providing exceptional speed performance for AI workloads running on their LPU Inference Engine.

In order to use LLMs from Groq, go to their [platform](https://console.groq.com/keys) and get the API key. Set the API key as `GROQ_API_KEY` environment variable to use the model as given below in the example.

## Usage

<CodeGroup>
  ```python Python theme={null}
  import os
  from mem0 import Memory

  os.environ["OPENAI_API_KEY"] = "your-api-key" # used for embedding model
  os.environ["GROQ_API_KEY"] = "your-api-key"

  config = {
      "llm": {
          "provider": "groq",
          "config": {
              "model": "mixtral-8x7b-32768",
              "temperature": 0.1,
              "max_tokens": 2000,
          }
      }
  }

  m = Memory.from_config(config)
  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."}
  ]
  m.add(messages, user_id="alice", metadata={"category": "movies"})
  ```

  ```typescript TypeScript theme={null}
  import { Memory } from 'mem0ai/oss';

  const config = {
    llm: {
      provider: 'groq',
      config: {
        apiKey: process.env.GROQ_API_KEY || '',
        model: 'mixtral-8x7b-32768',
        temperature: 0.1,
        maxTokens: 1000,
      },
    },
  };

  const memory = new Memory(config);
  const 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."}
  ]
  await memory.add(messages, { userId: "alice", metadata: { category: "movies" } });
  ```
</CodeGroup>

## Config

All available parameters for the `groq` config are present in [Master List of All Params in Config](../config).


# LangChain
Source: https://docs.mem0.ai/components/llms/models/langchain



Mem0 supports LangChain as a provider to access a wide range of LLM models. LangChain is a framework for developing applications powered by language models, making it easy to integrate various LLM providers through a consistent interface.

For a complete list of available chat models supported by LangChain, refer to the [LangChain Chat Models documentation](https://python.langchain.com/docs/integrations/chat).

## Usage

<CodeGroup>
  ```python Python theme={null}
  import os
  from mem0 import Memory
  from langchain_openai import ChatOpenAI

  # Set necessary environment variables for your chosen LangChain provider
  os.environ["OPENAI_API_KEY"] = "your-api-key"

  # Initialize a LangChain model directly
  openai_model = ChatOpenAI(
      model="gpt-4.1-nano-2025-04-14",
      temperature=0.2,
      max_tokens=2000
  )

  # Pass the initialized model to the config
  config = {
      "llm": {
          "provider": "langchain",
          "config": {
              "model": openai_model
          }
      }
  }

  m = Memory.from_config(config)
  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."}
  ]
  m.add(messages, user_id="alice", metadata={"category": "movies"})
  ```

  ```typescript TypeScript theme={null}
  import { Memory } from 'mem0ai/oss';
  import { ChatOpenAI } from "@langchain/openai";

  // Initialize a LangChain model directly
  const openaiModel = new ChatOpenAI({
      modelName: "gpt-4",
      temperature: 0.2,
      maxTokens: 2000,
      apiKey: process.env.OPENAI_API_KEY,
  });

  const config = {
    llm: {
      provider: 'langchain',
      config: {
        model: openaiModel,
      },
    },
  };

  const memory = new Memory(config);
  const 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."}
  ]
  await memory.add(messages, { userId: "alice", metadata: { category: "movies" } });
  ```
</CodeGroup>

## Supported LangChain Providers

LangChain supports a wide range of LLM providers, including:

* OpenAI (`ChatOpenAI`)
* Anthropic (`ChatAnthropic`)
* Google (`ChatGoogleGenerativeAI`, `ChatGooglePalm`)
* Mistral (`ChatMistralAI`)
* Ollama (`ChatOllama`)
* Azure OpenAI (`AzureChatOpenAI`)
* HuggingFace (`HuggingFaceChatEndpoint`)
* And many more

You can use any of these model instances directly in your configuration. For a complete and up-to-date list of available providers, refer to the [LangChain Chat Models documentation](https://python.langchain.com/docs/integrations/chat).

## Provider-Specific Configuration

When using LangChain as a provider, you'll need to:

1. Set the appropriate environment variables for your chosen LLM provider
2. Import and initialize the specific model class you want to use
3. Pass the initialized model instance to the config

<Note>
  Make sure to install the necessary LangChain packages and any provider-specific dependencies.
</Note>

## Config

All available parameters for the `langchain` config are present in [Master List of All Params in Config](../config).


# null
Source: https://docs.mem0.ai/components/llms/models/litellm



[Litellm](https://litellm.vercel.app/docs/) is compatible with over 100 large language models (LLMs), all using a standardized input/output format. You can explore the [available models](https://litellm.vercel.app/docs/providers) to use with Litellm. Ensure you set the `API_KEY` for the model you choose to use.

## Usage

```python  theme={null}
import os
from mem0 import Memory

os.environ["OPENAI_API_KEY"] = "your-api-key"

config = {
    "llm": {
        "provider": "litellm",
        "config": {
            "model": "gpt-4.1-nano-2025-04-14",
            "temperature": 0.2,
            "max_tokens": 2000,
        }
    }
}

m = Memory.from_config(config)
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."}
]
m.add(messages, user_id="alice", metadata={"category": "movies"})
```

## Config

All available parameters for the `litellm` config are present in [Master List of All Params in Config](../config).


# LM Studio
Source: https://docs.mem0.ai/components/llms/models/lmstudio



To use LM Studio with Mem0, you'll need to have LM Studio running locally with its server enabled. LM Studio provides a way to run local LLMs with an OpenAI-compatible API.

## Usage

<CodeGroup>
  ```python Python theme={null}
  import os
  from mem0 import Memory

  os.environ["OPENAI_API_KEY"] = "your-api-key" # used for embedding model

  config = {
      "llm": {
          "provider": "lmstudio",
          "config": {
              "model": "lmstudio-community/Meta-Llama-3.1-70B-Instruct-GGUF/Meta-Llama-3.1-70B-Instruct-IQ2_M.gguf",
              "temperature": 0.2,
              "max_tokens": 2000,
              "lmstudio_base_url": "http://localhost:1234/v1", # default LM Studio API URL
              "lmstudio_response_format": {"type": "json_schema", "json_schema": {"type": "object", "schema": {}}},
          }
      }
  }

  m = Memory.from_config(config)
  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."}
  ]
  m.add(messages, user_id="alice", metadata={"category": "movies"})
  ```
</CodeGroup>

### Running Completely Locally

You can also use LM Studio for both LLM and embedding to run Mem0 entirely locally:

```python  theme={null}
from mem0 import Memory

# No external API keys needed!
config = {
    "llm": {
        "provider": "lmstudio"
    },
    "embedder": {
        "provider": "lmstudio"
    }
}

m = Memory.from_config(config)
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."}
]
m.add(messages, user_id="alice123", metadata={"category": "movies"})
```

<Note>
  When using LM Studio for both LLM and embedding, make sure you have:

  1. An LLM model loaded for generating responses
  2. An embedding model loaded for vector embeddings
  3. The server enabled with the correct endpoints accessible
</Note>

<Note>
  To use LM Studio, you need to:

  1. Download and install [LM Studio](https://lmstudio.ai/)
  2. Start a local server from the "Server" tab
  3. Set the appropriate `lmstudio_base_url` in your configuration (default is usually [http://localhost:1234/v1](http://localhost:1234/v1))
</Note>

## Config

All available parameters for the `lmstudio` config are present in [Master List of All Params in Config](../config).


# Mistral AI
Source: https://docs.mem0.ai/components/llms/models/mistral_AI



To use mistral's models, please obtain the Mistral AI api key from their [console](https://console.mistral.ai/). Set the `MISTRAL_API_KEY` environment variable to use the model as given below in the example.

## Usage

<CodeGroup>
  ```python Python theme={null}
  import os
  from mem0 import Memory

  os.environ["OPENAI_API_KEY"] = "your-api-key" # used for embedding model
  os.environ["MISTRAL_API_KEY"] = "your-api-key"

  config = {
      "llm": {
          "provider": "litellm",
          "config": {
              "model": "open-mixtral-8x7b",
              "temperature": 0.1,
              "max_tokens": 2000,
          }
      }
  }

  m = Memory.from_config(config)
  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."}
  ]
  m.add(messages, user_id="alice", metadata={"category": "movies"})
  ```

  ```typescript TypeScript theme={null}
  import { Memory } from 'mem0ai/oss';

  const config = {
    llm: {
      provider: 'mistral',
      config: {
        apiKey: process.env.MISTRAL_API_KEY || '',
        model: 'mistral-tiny-latest', // Or 'mistral-small-latest', 'mistral-medium-latest', etc.
        temperature: 0.1,
        maxTokens: 2000,
      },
    },
  };

  const memory = new Memory(config);
  const 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."}
  ]
  await memory.add(messages, { userId: "alice", metadata: { category: "movies" } });
  ```
</CodeGroup>

## Config

All available parameters for the `litellm` config are present in [Master List of All Params in Config](../config).


# Ollama
Source: https://docs.mem0.ai/components/llms/models/ollama



You can use LLMs from Ollama to run Mem0 locally. These [models](https://ollama.com/search?c=tools) support tool calling.

## Usage

<CodeGroup>
  ```python Python theme={null}
  import os
  from mem0 import Memory

  os.environ["OPENAI_API_KEY"] = "your-api-key" # for embedder

  config = {
      "llm": {
          "provider": "ollama",
          "config": {
              "model": "mixtral:8x7b",
              "temperature": 0.1,
              "max_tokens": 2000,
          }
      }
  }

  m = Memory.from_config(config)
  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."}
  ]
  m.add(messages, user_id="alice", metadata={"category": "movies"})
  ```

  ```typescript TypeScript theme={null}
  import { Memory } from 'mem0ai/oss';

  const config = {
    llm: {
      provider: 'ollama',
      config: {
        model: 'llama3.1:8b', // or any other Ollama model
        url: 'http://localhost:11434', // Ollama server URL
        temperature: 0.1,
      },
    },
  };

  const memory = new Memory(config);
  const 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."}
  ]
  await memory.add(messages, { userId: "alice", metadata: { category: "movies" } });
  ```
</CodeGroup>

## Config

All available parameters for the `ollama` config are present in [Master List of All Params in Config](../config).


# OpenAI
Source: https://docs.mem0.ai/components/llms/models/openai



To use OpenAI LLM models, you have to set the `OPENAI_API_KEY` environment variable. You can obtain the OpenAI API key from the [OpenAI Platform](https://platform.openai.com/account/api-keys).

> **Note**: The following are currently unsupported with reasoning models `Parallel tool calling`,`temperature`, `top_p`, `presence_penalty`, `frequency_penalty`, `logprobs`, `top_logprobs`, `logit_bias`, `max_tokens`

## Usage

<CodeGroup>
  ```python Python theme={null}
  import os
  from mem0 import Memory

  os.environ["OPENAI_API_KEY"] = "your-api-key"

  config = {
      "llm": {
          "provider": "openai",
          "config": {
              "model": "gpt-4.1-nano-2025-04-14",
              "temperature": 0.2,
              "max_tokens": 2000,
          }
      }
  }

  # Use Openrouter by passing it's api key
  # os.environ["OPENROUTER_API_KEY"] = "your-api-key"
  # config = {
  #    "llm": {
  #        "provider": "openai",
  #        "config": {
  #            "model": "meta-llama/llama-3.1-70b-instruct",
  #        }
  #    }
  # }

  m = Memory.from_config(config)
  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."}
  ]
  m.add(messages, user_id="alice", metadata={"category": "movies"})
  ```

  ```typescript TypeScript theme={null}
  import { Memory } from 'mem0ai/oss';

  const config = {
    llm: {
      provider: 'openai',
      config: {
        apiKey: process.env.OPENAI_API_KEY || '',
        model: 'gpt-4-turbo-preview',
        temperature: 0.2,
        maxTokens: 1500,
      },
    },
  };

  const memory = new Memory(config);
  const 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."}
  ]
  await memory.add(messages, { userId: "alice", metadata: { category: "movies" } });
  ```
</CodeGroup>

We also support the new [OpenAI structured-outputs](https://platform.openai.com/docs/guides/structured-outputs/introduction) model.

```python  theme={null}
import os
from mem0 import Memory

os.environ["OPENAI_API_KEY"] = "your-api-key"

config = {
    "llm": {
        "provider": "openai_structured",
        "config": {
            "model": "gpt-4.1-nano-2025-04-14",
            "temperature": 0.0,
        }
    }
}

m = Memory.from_config(config)
```

## Config

All available parameters for the `openai` config are present in [Master List of All Params in Config](../config).


# Sarvam AI
Source: https://docs.mem0.ai/components/llms/models/sarvam



**Sarvam AI** is an Indian AI company developing language models with a focus on Indian languages and cultural context. Their latest model **Sarvam-M** is designed to understand and generate content in multiple Indian languages while maintaining high performance in English.

To use Sarvam AI's models, please set the `SARVAM_API_KEY` which you can get from their [platform](https://dashboard.sarvam.ai/).

## Usage

```python  theme={null}
import os
from mem0 import Memory

os.environ["OPENAI_API_KEY"] = "your-api-key" # used for embedding model
os.environ["SARVAM_API_KEY"] = "your-api-key"

config = {
    "llm": {
        "provider": "sarvam",
        "config": {
            "model": "sarvam-m",
            "temperature": 0.7,
        }
    }
}

m = Memory.from_config(config)
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."}
]
m.add(messages, user_id="alex")
```

## Advanced Usage with Sarvam-Specific Features

```python  theme={null}
import os
from mem0 import Memory

config = {
    "llm": {
        "provider": "sarvam",
        "config": {
            "model": {
                "name": "sarvam-m",
                "reasoning_effort": "high",  # Enable advanced reasoning
                "frequency_penalty": 0.1,    # Reduce repetition
                "seed": 42                   # For deterministic outputs
            },
            "temperature": 0.3,
            "max_tokens": 2000,
            "api_key": "your-sarvam-api-key"
        }
    }
}

m = Memory.from_config(config)

# Example with Hindi conversation
messages = [
    {"role": "user", "content": "मैं SBI में joint account खोलना चाहता हूँ।"},
    {"role": "assistant", "content": "SBI में joint account खोलने के लिए आपको कुछ documents की जरूरत होगी। क्या आप जानना चाहते हैं कि कौन से documents चाहिए?"}
]
m.add(messages, user_id="rajesh", metadata={"language": "hindi", "topic": "banking"})
```

## Config

All available parameters for the `sarvam` config are present in [Master List of All Params in Config](../config).


# Together
Source: https://docs.mem0.ai/components/llms/models/together



To use Together LLM models, you have to set the `TOGETHER_API_KEY` environment variable. You can obtain the Together API key from their [Account settings page](https://api.together.xyz/settings/api-keys).

## Usage

```python  theme={null}
import os
from mem0 import Memory

os.environ["OPENAI_API_KEY"] = "your-api-key" # used for embedding model
os.environ["TOGETHER_API_KEY"] = "your-api-key"

config = {
    "llm": {
        "provider": "together",
        "config": {
            "model": "mistralai/Mixtral-8x7B-Instruct-v0.1",
            "temperature": 0.2,
            "max_tokens": 2000,
        }
    }
}

m = Memory.from_config(config)
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."}
]
m.add(messages, user_id="alice", metadata={"category": "movies"})
```

## Config

All available parameters for the `together` config are present in [Master List of All Params in Config](../config).


# vLLM
Source: https://docs.mem0.ai/components/llms/models/vllm



[vLLM](https://docs.vllm.ai/) is a high-performance inference engine for large language models that provides significant performance improvements for local inference. It's designed to maximize throughput and memory efficiency for serving LLMs.

## Prerequisites

1. **Install vLLM**:

   ```bash  theme={null}
   pip install vllm
   ```

2. **Start vLLM server**:

   ```bash  theme={null}
   # For testing with a small model
   vllm serve microsoft/DialoGPT-medium --port 8000

   # For production with a larger model (requires GPU)
   vllm serve Qwen/Qwen2.5-32B-Instruct --port 8000
   ```

## Usage

```python  theme={null}
import os
from mem0 import Memory

os.environ["OPENAI_API_KEY"] = "your-api-key"  # used for embedding model

config = {
    "llm": {
        "provider": "vllm",
        "config": {
            "model": "Qwen/Qwen2.5-32B-Instruct",
            "vllm_base_url": "http://localhost:8000/v1",
            "temperature": 0.1,
            "max_tokens": 2000,
        }
    }
}

m = Memory.from_config(config)
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 thrillers, but I love sci-fi movies."},
    {"role": "assistant", "content": "Got it! I'll avoid thrillers and suggest sci-fi movies instead."}
]
m.add(messages, user_id="alice", metadata={"category": "movies"})
```

## Configuration Parameters

| Parameter       | Description                       | Default                       | Environment Variable |
| --------------- | --------------------------------- | ----------------------------- | -------------------- |
| `model`         | Model name running on vLLM server | `"Qwen/Qwen2.5-32B-Instruct"` | -                    |
| `vllm_base_url` | vLLM server URL                   | `"http://localhost:8000/v1"`  | `VLLM_BASE_URL`      |
| `api_key`       | API key (dummy for local)         | `"vllm-api-key"`              | `VLLM_API_KEY`       |
| `temperature`   | Sampling temperature              | `0.1`                         | -                    |
| `max_tokens`    | Maximum tokens to generate        | `2000`                        | -                    |

## Environment Variables

You can set these environment variables instead of specifying them in config:

```bash  theme={null}
export VLLM_BASE_URL="http://localhost:8000/v1"
export VLLM_API_KEY="your-vllm-api-key"
export OPENAI_API_KEY="your-openai-api-key"  # for embeddings
```

## Benefits

* **High Performance**: 2-24x faster inference than standard implementations
* **Memory Efficient**: Optimized memory usage with PagedAttention
* **Local Deployment**: Keep your data private and reduce API costs
* **Easy Integration**: Drop-in replacement for other LLM providers
* **Flexible**: Works with any model supported by vLLM

## Troubleshooting

1. **Server not responding**: Make sure vLLM server is running

   ```bash  theme={null}
   curl http://localhost:8000/health
   ```

2. **404 errors**: Ensure correct base URL format

   ```python  theme={null}
   "vllm_base_url": "http://localhost:8000/v1"  # Note the /v1
   ```

3. **Model not found**: Check model name matches server

4. **Out of memory**: Try smaller models or reduce `max_model_len`

   ```bash  theme={null}
   vllm serve Qwen/Qwen2.5-32B-Instruct --max-model-len 4096
   ```

## Config

All available parameters for the `vllm` config are present in [Master List of All Params in Config](../config).


# xAI
Source: https://docs.mem0.ai/components/llms/models/xAI



[xAI](https://x.ai/) is a new AI company founded by Elon Musk that develops large language models, including Grok. Grok is trained on real-time data from X (formerly Twitter) and aims to provide accurate, up-to-date responses with a touch of wit and humor.

In order to use LLMs from xAI, go to their [platform](https://console.x.ai) and get the API key. Set the API key as `XAI_API_KEY` environment variable to use the model as given below in the example.

## Usage

```python  theme={null}
import os
from mem0 import Memory

os.environ["OPENAI_API_KEY"] = "your-api-key" # used for embedding model
os.environ["XAI_API_KEY"] = "your-api-key"

config = {
    "llm": {
        "provider": "xai",
        "config": {
            "model": "grok-3-beta",
            "temperature": 0.1,
            "max_tokens": 2000,
        }
    }
}

m = Memory.from_config(config)
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."}
]
m.add(messages, user_id="alice", metadata={"category": "movies"})
```

## Config

All available parameters for the `xai` config are present in [Master List of All Params in Config](../config).


# Overview
Source: https://docs.mem0.ai/components/llms/overview



Mem0 includes built-in support for various popular large language models. Memory can utilize the LLM provided by the user, ensuring efficient use for specific needs.

## Usage

To use a llm, you must provide a configuration to customize its usage. If no configuration is supplied, a default configuration will be applied, and `OpenAI` will be used as the llm.

For a comprehensive list of available parameters for llm configuration, please refer to [Config](./config).

## Supported LLMs

See the list of supported LLMs below.

<Note>
  All LLMs are supported in Python. The following LLMs are also supported in TypeScript: **OpenAI**, **Anthropic**, and **Groq**.
</Note>

<CardGroup cols={4}>
  <Card title="OpenAI" href="/components/llms/models/openai" />

  <Card title="Ollama" href="/components/llms/models/ollama" />

  <Card title="Azure OpenAI" href="/components/llms/models/azure_openai" />

  <Card title="Anthropic" href="/components/llms/models/anthropic" />

  <Card title="Together" href="/components/llms/models/together" />

  <Card title="Groq" href="/components/llms/models/groq" />

  <Card title="Litellm" href="/components/llms/models/litellm" />

  <Card title="Mistral AI" href="/components/llms/models/mistral_AI" />

  <Card title="Google AI" href="/components/llms/models/google_AI" />

  <Card title="AWS bedrock" href="/components/llms/models/aws_bedrock" />

  <Card title="DeepSeek" href="/components/llms/models/deepseek" />

  <Card title="xAI" href="/components/llms/models/xAI" />

  <Card title="Sarvam AI" href="/components/llms/models/sarvam" />

  <Card title="LM Studio" href="/components/llms/models/lmstudio" />

  <Card title="Langchain" href="/components/llms/models/langchain" />
</CardGroup>

## Structured vs Unstructured Outputs

Mem0 supports two types of OpenAI LLM formats, each with its own strengths and use cases:

### Structured Outputs

Structured outputs are LLMs that align with OpenAI's structured outputs model:

* **Optimized for:** Returning structured responses (e.g., JSON objects)
* **Benefits:** Precise, easily parseable data
* **Ideal for:** Data extraction, form filling, API responses
* **Learn more:** [OpenAI Structured Outputs Guide](https://platform.openai.com/docs/guides/structured-outputs/introduction)

### Unstructured Outputs

Unstructured outputs correspond to OpenAI's standard, free-form text model:

* **Flexibility:** Returns open-ended, natural language responses
* **Customization:** Use the `response_format` parameter to guide output
* **Trade-off:** Less efficient than structured outputs for specific data needs
* **Best for:** Creative writing, explanations, general conversation

Choose the format that best suits your application's requirements for optimal performance and usability.


# Configurations
Source: https://docs.mem0.ai/components/vectordbs/config



## How to define configurations?

The `config` is defined as an object with two main keys:

* `vector_store`: Specifies the vector database provider and its configuration
  * `provider`: The name of the vector database (e.g., "chroma", "pgvector", "qdrant", "milvus", "upstash\_vector", "azure\_ai\_search", "vertex\_ai\_vector\_search", "valkey")
  * `config`: A nested dictionary containing provider-specific settings

## How to Use Config

Here's a general example of how to use the config with mem0:

<CodeGroup>
  ```python Python theme={null}
  import os
  from mem0 import Memory

  os.environ["OPENAI_API_KEY"] = "sk-xx"

  config = {
      "vector_store": {
          "provider": "your_chosen_provider",
          "config": {
              # Provider-specific settings go here
          }
      }
  }

  m = Memory.from_config(config)
  m.add("Your text here", user_id="user", metadata={"category": "example"})
  ```

  ```typescript TypeScript theme={null}
  // Example for in-memory vector database (Only supported in TypeScript)
  import { Memory } from 'mem0ai/oss';

  const configMemory = {
    vector_store: {
      provider: 'memory',
      config: {
        collectionName: 'memories',
        dimension: 1536,
      },
    },
  };

  const memory = new Memory(configMemory);
  await memory.add("Your text here", { userId: "user", metadata: { category: "example" } });
  ```
</CodeGroup>

<Note>
  The in-memory vector database is only supported in the TypeScript implementation.
</Note>

## Why is Config Needed?

Config is essential for:

1. Specifying which vector database to use.
2. Providing necessary connection details (e.g., host, port, credentials).
3. Customizing database-specific settings (e.g., collection name, path).
4. Ensuring proper initialization and connection to your chosen vector store.

## Master List of All Params in Config

Here's a comprehensive list of all parameters that can be used across different vector databases:

<Tabs>
  <Tab title="Python">
    | Parameter                    | Description                                             |
    | ---------------------------- | ------------------------------------------------------- |
    | `collection_name`            | Name of the collection                                  |
    | `embedding_model_dims`       | Dimensions of the embedding model                       |
    | `client`                     | Custom client for the database                          |
    | `path`                       | Path for the database                                   |
    | `host`                       | Host where the server is running                        |
    | `port`                       | Port where the server is running                        |
    | `user`                       | Username for database connection                        |
    | `password`                   | Password for database connection                        |
    | `dbname`                     | Name of the database                                    |
    | `url`                        | Full URL for the server                                 |
    | `api_key`                    | API key for the server                                  |
    | `on_disk`                    | Enable persistent storage                               |
    | `endpoint_id`                | Endpoint ID (vertex\_ai\_vector\_search)                |
    | `index_id`                   | Index ID (vertex\_ai\_vector\_search)                   |
    | `deployment_index_id`        | Deployment index ID (vertex\_ai\_vector\_search)        |
    | `project_id`                 | Project ID (vertex\_ai\_vector\_search)                 |
    | `project_number`             | Project number (vertex\_ai\_vector\_search)             |
    | `vector_search_api_endpoint` | Vector search API endpoint (vertex\_ai\_vector\_search) |
    | `connection_string`          | PostgreSQL connection string (for Supabase/PGVector)    |
    | `index_method`               | Vector index method (for Supabase)                      |
    | `index_measure`              | Distance measure for similarity search (for Supabase)   |
  </Tab>

  <Tab title="TypeScript">
    | Parameter            | Description                                             |
    | -------------------- | ------------------------------------------------------- |
    | `collectionName`     | Name of the collection                                  |
    | `embeddingModelDims` | Dimensions of the embedding model                       |
    | `dimension`          | Dimensions of the embedding model (for memory provider) |
    | `host`               | Host where the server is running                        |
    | `port`               | Port where the server is running                        |
    | `url`                | URL for the server                                      |
    | `apiKey`             | API key for the server                                  |
    | `path`               | Path for the database                                   |
    | `onDisk`             | Enable persistent storage                               |
    | `redisUrl`           | URL for the Redis server                                |
    | `username`           | Username for database connection                        |
    | `password`           | Password for database connection                        |
  </Tab>
</Tabs>

## Customizing Config

Each vector database has its own specific configuration requirements. To customize the config for your chosen vector store:

1. Identify the vector database you want to use from [supported vector databases](./dbs).
2. Refer to the `Config` section in the respective vector database's documentation.
3. Include only the relevant parameters for your chosen database in the `config` dictionary.

## Supported Vector Databases

For detailed information on configuring specific vector databases, please visit the [Supported Vector Databases](./dbs) section. There you'll find individual pages for each supported vector store with provider-specific usage examples and configuration details.


# Azure AI Search
Source: https://docs.mem0.ai/components/vectordbs/dbs/azure



[Azure AI Search](https://learn.microsoft.com/azure/search/search-what-is-azure-search/) (formerly known as "Azure Cognitive Search") provides secure information retrieval at scale over user-owned content in traditional and generative AI search applications.

## Usage

```python  theme={null}
import os
from mem0 import Memory

os.environ["OPENAI_API_KEY"] = "sk-xx"   # This key is used for embedding purpose

config = {
    "vector_store": {
        "provider": "azure_ai_search",
        "config": {
            "service_name": "<your-azure-ai-search-service-name>",
            "api_key": "<your-api-key>",
            "collection_name": "mem0", 
            "embedding_model_dims": 1536
        }
    }
}

m = Memory.from_config(config)
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."}
]
m.add(messages, user_id="alice", metadata={"category": "movies"})
```

## Using binary compression for large vector collections

```python  theme={null}
config = {
    "vector_store": {
        "provider": "azure_ai_search",
        "config": {
            "service_name": "<your-azure-ai-search-service-name>",
            "api_key": "<your-api-key>",
            "collection_name": "mem0", 
            "embedding_model_dims": 1536,
            "compression_type": "binary",
            "use_float16": True  # Use half precision for storage efficiency
        }
    }
}
```

## Using hybrid search

```python  theme={null}
config = {
    "vector_store": {
        "provider": "azure_ai_search",
        "config": {
            "service_name": "<your-azure-ai-search-service-name>",
            "api_key": "<your-api-key>",
            "collection_name": "mem0", 
            "embedding_model_dims": 1536,
            "hybrid_search": True,
            "vector_filter_mode": "postFilter"
        }
    }
}
```

## Using Azure Identity for Authentication

As an alternative to using an API key, the Azure Identity credential chain can be used to authenticate with Azure OpenAI. The list below shows the order of precedence for credential application:

1. **Environment Credential:**
   Azure client ID, secret, tenant ID, or certificate in environment variables for service principal authentication.

2. **Workload Identity Credential:**
   Utilizes Azure Workload Identity (relevant for Kubernetes and Azure workloads).

3. **Managed Identity Credential:**
   Authenticates as a Managed Identity (for apps/services hosted in Azure with Managed Identity enabled), this is the most secure production credential.

4. **Shared Token Cache Credential / Visual Studio Credential (Windows only):**
   Uses cached credentials from Visual Studio sign-ins (and sometimes VS Code if SSO is enabled).

5. **Azure CLI Credential:**
   Uses the currently logged-in user from the Azure CLI (`az login`), this is the most common development credential.

6. **Azure PowerShell Credential:**
   Uses the identity from Azure PowerShell (`Connect-AzAccount`).

7. **Azure Developer CLI Credential:**
   Uses the session from Azure Developer CLI (`azd auth login`).

<Note> If an API is provided, it will be used for authentication over an Azure Identity </Note>
To enable Role-Based Access Control (RBAC) for Azure AI Search, follow these steps:

1. In the Azure Portal, navigate to your **Azure AI Search** service.
2. In the left menu, select **Settings** > **Keys**.
3. Change the authentication setting to **Role-based access control**, or **Both** if you need API key compatibility. The default is “Key-based authentication”—you must switch it to use Azure roles.
4. **Go to Access Control (IAM):**
   * In the Azure Portal, select your Search service.
   * Click **Access Control (IAM)** on the left.
5. **Add a Role Assignment:**
   * Click **Add** > **Add role assignment**.
6. **Choose Role:**
   * Mem0 requires the **Search Index Data Contributor** and **Search Service Contributor** role.
7. **Choose Member**
   * To assign to a User, Group, Service Principal or Managed Identity:
     * For production it is recommended to use a service principal or managed identity.
       * For a service principal: select **User, group, or service principal** and search for the service principal.
       * For a managed identity: select **Managed identity** and choose the managed identity.
     * For development, you can assign the role to a user account.
       * For development: select **User, group, or service principal** and pick an Azure Entra ID account (the same used with `az login`).
8. **Complete the Assignment:**
   * Click **Review + Assign**.

If you are using Azure Identity, do not set the `api_key` in the configuration.

```python  theme={null}
config = {
    "vector_store": {
        "provider": "azure_ai_search",
        "config": {
            "service_name": "<your-azure-ai-search-service-name>",
            "collection_name": "mem0", 
            "embedding_model_dims": 1536,
            "compression_type": "binary",
            "use_float16": True  # Use half precision for storage efficiency
        }
    }
}
```

### Environment Variables to Use Azure Identity Credential

* For an Environment Credential, you will need to setup a Service Principal and set the following environment variables:
  * `AZURE_TENANT_ID`: Your Azure Active Directory tenant ID.
  * `AZURE_CLIENT_ID`: The client ID of your service principal or managed identity.
  * `AZURE_CLIENT_SECRET`: The client secret of your service principal.
* For a User-Assigned Managed Identity, you will need to set the following environment variable:
  * `AZURE_CLIENT_ID`: The client ID of the user-assigned managed identity.
* For a System-Assigned Managed Identity, no additional environment variables are needed.

### Developer Logins for Azure Identity Credential

* For an Azure CLI Credential, you need to have the Azure CLI installed and logged in with `az login`.
* For an Azure PowerShell Credential, you need to have the Azure PowerShell module installed and logged in with `Connect-AzAccount`.
* For an Azure Developer CLI Credential, you need to have the Azure Developer CLI installed and logged in with `azd auth login`.

Troubleshooting tips for [Azure Identity](https://github.com/Azure/azure-sdk-for-python/blob/main/sdk/identity/azure-identity/TROUBLESHOOTING.md#troubleshoot-environmentcredential-authentication-issues).

## Configuration Parameters

| Parameter              | Description                                       | Default Value | Options                                                                                                      |
| ---------------------- | ------------------------------------------------- | ------------- | ------------------------------------------------------------------------------------------------------------ |
| `service_name`         | Azure AI Search service name                      | Required      | -                                                                                                            |
| `api_key`              | API key of the Azure AI Search service            | Optional      | If not present, the [Azure Identity](#using-azure-identity-for-authentication) credential chain will be used |
| `collection_name`      | The name of the collection/index to store vectors | `mem0`        | Any valid index name                                                                                         |
| `embedding_model_dims` | Dimensions of the embedding model                 | `1536`        | Any integer value                                                                                            |
| `compression_type`     | Type of vector compression to use                 | `none`        | `none`, `scalar`, `binary`                                                                                   |
| `use_float16`          | Store vectors in half precision (Edm.Half)        | `False`       | `True`, `False`                                                                                              |
| `vector_filter_mode`   | Vector filter mode to use                         | `preFilter`   | `postFilter`, `preFilter`                                                                                    |
| `hybrid_search`        | Use hybrid search                                 | `False`       | `True`, `False`                                                                                              |

## Notes on Configuration Options

* **compression\_type**:
  * `none`: No compression, uses full vector precision
  * `scalar`: Scalar quantization with reasonable balance of speed and accuracy
  * `binary`: Binary quantization for maximum compression with some accuracy trade-off

* **vector\_filter\_mode**:
  * `preFilter`: Applies filters before vector search (faster)
  * `postFilter`: Applies filters after vector search (may provide better relevance)

* **use\_float16**: Using half precision (float16) reduces storage requirements but may slightly impact accuracy. Useful for very large vector collections.

* **Filterable Fields**: The implementation automatically extracts `user_id`, `run_id`, and `agent_id` fields from payloads for filtering.


# Azure MySQL
Source: https://docs.mem0.ai/components/vectordbs/dbs/azure_mysql



[Azure Database for MySQL](https://azure.microsoft.com/products/mysql) is a fully managed relational database service that provides enterprise-grade reliability and security. It supports JSON-based vector storage for semantic search capabilities in AI applications.

### Usage

```python  theme={null}
import os
from mem0 import Memory

os.environ["OPENAI_API_KEY"] = "sk-xx"

config = {
    "vector_store": {
        "provider": "azure_mysql",
        "config": {
            "host": "your-server.mysql.database.azure.com",
            "port": 3306,
            "user": "your_username",
            "password": "your_password",
            "database": "mem0_db",
            "collection_name": "memories",
        }
    }
}

m = Memory.from_config(config)
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."}
]
m.add(messages, user_id="alice", metadata={"category": "movies"})
```

#### Using Azure Managed Identity

For production deployments, use Azure Managed Identity instead of passwords:

```python  theme={null}
config = {
    "vector_store": {
        "provider": "azure_mysql",
        "config": {
            "host": "your-server.mysql.database.azure.com",
            "user": "your_username",
            "database": "mem0_db",
            "collection_name": "memories",
            "use_azure_credential": True,  # Uses DefaultAzureCredential
            "ssl_disabled": False
        }
    }
}
```

<Note>
  When `use_azure_credential` is enabled, the password is obtained via Azure DefaultAzureCredential (supports Managed Identity, Azure CLI, etc.)
</Note>

### Config

Here are the parameters available for configuring Azure MySQL:

| Parameter              | Description                                        | Default Value |
| ---------------------- | -------------------------------------------------- | ------------- |
| `host`                 | MySQL server hostname                              | Required      |
| `port`                 | MySQL server port                                  | `3306`        |
| `user`                 | Database user                                      | Required      |
| `password`             | Database password (optional with Azure credential) | `None`        |
| `database`             | Database name                                      | Required      |
| `collection_name`      | Table name for storing vectors                     | `"mem0"`      |
| `embedding_model_dims` | Dimensions of embedding vectors                    | `1536`        |
| `use_azure_credential` | Use Azure DefaultAzureCredential                   | `False`       |
| `ssl_ca`               | Path to SSL CA certificate                         | `None`        |
| `ssl_disabled`         | Disable SSL (not recommended)                      | `False`       |
| `minconn`              | Minimum connections in pool                        | `1`           |
| `maxconn`              | Maximum connections in pool                        | `5`           |

### Setup

#### Create MySQL Flexible Server using Azure CLI:

```bash  theme={null}
# Create resource group
az group create --name mem0-rg --location eastus

# Create MySQL Flexible Server
az mysql flexible-server create \
    --resource-group mem0-rg \
    --name mem0-mysql-server \
    --location eastus \
    --admin-user myadmin \
    --admin-password <YourPassword> \
    --version 8.0.21

# Create database
az mysql flexible-server db create \
    --resource-group mem0-rg \
    --server-name mem0-mysql-server \
    --database-name mem0_db

# Configure firewall
az mysql flexible-server firewall-rule create \
    --resource-group mem0-rg \
    --name mem0-mysql-server \
    --rule-name AllowMyIP \
    --start-ip-address <YourIP> \
    --end-ip-address <YourIP>
```

#### Enable Azure AD Authentication:

1. In Azure Portal, navigate to your MySQL Flexible Server
2. Go to **Security** > **Authentication** and enable Azure AD
3. Add your application's managed identity as a MySQL user:

```sql  theme={null}
CREATE AADUSER 'your-app-identity' IDENTIFIED BY 'your-client-id';
GRANT ALL PRIVILEGES ON mem0_db.* TO 'your-app-identity'@'%';
FLUSH PRIVILEGES;
```

<Tip>
  For production, use [Managed Identity](https://learn.microsoft.com/azure/active-directory/managed-identities-azure-resources/) to eliminate password management.
</Tip>


# Baidu VectorDB (Mochow)
Source: https://docs.mem0.ai/components/vectordbs/dbs/baidu



[Baidu VectorDB](https://cloud.baidu.com/doc/VDB/index.html) is an enterprise-level distributed vector database service developed by Baidu Intelligent Cloud. It is powered by Baidu's proprietary "Mochow" vector database kernel, providing high performance, availability, and security for vector search.

### Usage

```python  theme={null}
import os
from mem0 import Memory

config = {
    "vector_store": {
        "provider": "baidu",
        "config": {
            "endpoint": "http://your-mochow-endpoint:8287",
            "account": "root",
            "api_key": "your-api-key",
            "database_name": "mem0",
            "table_name": "mem0_table",
            "embedding_model_dims": 1536,
            "metric_type": "COSINE"
        }
    }
}

m = Memory.from_config(config)
messages = [
    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
    {"role": "assistant", "content": "How about a thriller movie? 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."}
]
m.add(messages, user_id="alice", metadata={"category": "movies"})
```

### Config

Here are the parameters available for configuring Baidu VectorDB:

| Parameter              | Description                                   | Default Value |
| ---------------------- | --------------------------------------------- | ------------- |
| `endpoint`             | Endpoint URL for your Baidu VectorDB instance | Required      |
| `account`              | Baidu VectorDB account name                   | `root`        |
| `api_key`              | API key for accessing Baidu VectorDB          | Required      |
| `database_name`        | Name of the database                          | `mem0`        |
| `table_name`           | Name of the table                             | `mem0_table`  |
| `embedding_model_dims` | Dimensions of the embedding model             | `1536`        |
| `metric_type`          | Distance metric for similarity search         | `L2`          |

### Distance Metrics

The following distance metrics are supported:

* `L2`: Euclidean distance (default)
* `IP`: Inner product
* `COSINE`: Cosine similarity

### Index Configuration

The vector index is automatically configured with the following HNSW parameters:

* `m`: 16 (number of connections per element)
* `efconstruction`: 200 (size of the dynamic candidate list)
* `auto_build`: true (automatically build index)
* `auto_build_index_policy`: Incremental build with 10000 rows increment


# Apache Cassandra
Source: https://docs.mem0.ai/components/vectordbs/dbs/cassandra



[Apache Cassandra](https://cassandra.apache.org/) is a highly scalable, distributed NoSQL database designed for handling large amounts of data across many commodity servers with no single point of failure. It supports vector storage for semantic search capabilities in AI applications and can scale to massive datasets with linear performance improvements.

### Usage

```python  theme={null}
import os
from mem0 import Memory

os.environ["OPENAI_API_KEY"] = "sk-xx"

config = {
    "vector_store": {
        "provider": "cassandra",
        "config": {
            "contact_points": ["127.0.0.1"],
            "port": 9042,
            "username": "cassandra",
            "password": "cassandra",
            "keyspace": "mem0",
            "collection_name": "memories",
        }
    }
}

m = Memory.from_config(config)
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."}
]
m.add(messages, user_id="alice", metadata={"category": "movies"})
```

#### Using DataStax Astra DB

For managed Cassandra with DataStax Astra DB:

```python  theme={null}
config = {
    "vector_store": {
        "provider": "cassandra",
        "config": {
            "contact_points": ["dummy"],  # Not used with secure connect bundle
            "username": "token",
            "password": "AstraCS:...",  # Your Astra DB application token
            "keyspace": "mem0",
            "collection_name": "memories",
            "secure_connect_bundle": "/path/to/secure-connect-bundle.zip"
        }
    }
}
```

<Note>
  When using DataStax Astra DB, provide the secure connect bundle path. The contact\_points parameter is ignored when a secure connect bundle is provided.
</Note>

### Config

Here are the parameters available for configuring Apache Cassandra:

| Parameter               | Description                            | Default Value |
| ----------------------- | -------------------------------------- | ------------- |
| `contact_points`        | List of contact point IP addresses     | Required      |
| `port`                  | Cassandra port                         | `9042`        |
| `username`              | Database username                      | `None`        |
| `password`              | Database password                      | `None`        |
| `keyspace`              | Keyspace name                          | `"mem0"`      |
| `collection_name`       | Table name for storing vectors         | `"memories"`  |
| `embedding_model_dims`  | Dimensions of embedding vectors        | `1536`        |
| `secure_connect_bundle` | Path to Astra DB secure connect bundle | `None`        |
| `protocol_version`      | CQL protocol version                   | `4`           |
| `load_balancing_policy` | Custom load balancing policy           | `None`        |

### Setup

#### Option 1: Local Cassandra Setup using Docker:

```bash  theme={null}
# Pull and run Cassandra container
docker run --name mem0-cassandra \
    -p 9042:9042 \
    -e CASSANDRA_CLUSTER_NAME="Mem0Cluster" \
    -d cassandra:latest

# Wait for Cassandra to start (may take 1-2 minutes)
docker exec -it mem0-cassandra cqlsh

# Create keyspace
CREATE KEYSPACE IF NOT EXISTS mem0
WITH replication = {'class': 'SimpleStrategy', 'replication_factor': 1};
```

#### Option 2: DataStax Astra DB (Managed Cloud):

1. Sign up at [DataStax Astra](https://astra.datastax.com/)
2. Create a new database
3. Download the secure connect bundle
4. Generate an application token

<Tip>
  For production deployments, use DataStax Astra DB for fully managed Cassandra with automatic scaling, backups, and security.
</Tip>

#### Option 3: Install Cassandra Locally:

**Ubuntu/Debian:**

```bash  theme={null}
# Add Apache Cassandra repository
echo "deb https://downloads.apache.org/cassandra/debian 40x main" | sudo tee -a /etc/apt/sources.list.d/cassandra.sources.list
curl https://downloads.apache.org/cassandra/KEYS | sudo apt-key add -

# Install Cassandra
sudo apt-get update
sudo apt-get install cassandra

# Start Cassandra
sudo systemctl start cassandra

# Verify installation
nodetool status
```

**macOS:**

```bash  theme={null}
# Using Homebrew
brew install cassandra

# Start Cassandra
brew services start cassandra

# Connect to CQL shell
cqlsh
```

### Python Client Installation

Install the required Python package:

```bash  theme={null}
pip install cassandra-driver
```

### Performance Considerations

* **Replication Factor**: For production, use replication factor of at least 3
* **Consistency Level**: Balance between consistency and performance (QUORUM recommended)
* **Partitioning**: Cassandra automatically distributes data across nodes
* **Scaling**: Add nodes to linearly increase capacity and performance

### Advanced Configuration

```python  theme={null}
from cassandra.policies import DCAwareRoundRobinPolicy

config = {
    "vector_store": {
        "provider": "cassandra",
        "config": {
            "contact_points": ["node1.example.com", "node2.example.com", "node3.example.com"],
            "port": 9042,
            "username": "mem0_user",
            "password": "secure_password",
            "keyspace": "mem0_prod",
            "collection_name": "memories",
            "protocol_version": 4,
            "load_balancing_policy": DCAwareRoundRobinPolicy(local_dc='DC1')
        }
    }
}
```

<Warning>
  For production use, configure appropriate replication strategies and consistency levels based on your availability and consistency requirements.
</Warning>


# null
Source: https://docs.mem0.ai/components/vectordbs/dbs/chroma



[Chroma](https://www.trychroma.com/) is an AI-native open-source vector database that simplifies building LLM apps by providing tools for storing, embedding, and searching embeddings with a focus on simplicity and speed. It supports both local deployment and cloud hosting through ChromaDB Cloud.

### Usage

#### Local Installation

```python  theme={null}
import os
from mem0 import Memory

os.environ["OPENAI_API_KEY"] = "sk-xx"

config = {
    "vector_store": {
        "provider": "chroma",
        "config": {
            "collection_name": "test",
            "path": "db",
            # Optional: ChromaDB Cloud configuration
            # "api_key": "your-chroma-cloud-api-key",
            # "tenant": "your-chroma-cloud-tenant-id",
        }
    }
}

m = Memory.from_config(config)
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."}
]
m.add(messages, user_id="alice", metadata={"category": "movies"})
```

### Config

Here are the parameters available for configuring Chroma:

| Parameter         | Description                                 | Default Value |
| ----------------- | ------------------------------------------- | ------------- |
| `collection_name` | The name of the collection                  | `mem0`        |
| `client`          | Custom client for Chroma                    | `None`        |
| `path`            | Path for the Chroma database                | `db`          |
| `host`            | The host where the Chroma server is running | `None`        |
| `port`            | The port where the Chroma server is running | `None`        |
| `api_key`         | ChromaDB Cloud API key (for cloud usage)    | `None`        |
| `tenant`          | ChromaDB Cloud tenant ID (for cloud usage)  | `None`        |


# null
Source: https://docs.mem0.ai/components/vectordbs/dbs/databricks



[Databricks Vector Search](https://docs.databricks.com/en/generative-ai/vector-search.html) is a serverless similarity search engine that allows you to store a vector representation of your data, including metadata, in a vector database. With Vector Search, you can create auto-updating vector search indexes from Delta tables managed by Unity Catalog and query them with a simple API to return the most similar vectors.

### Usage

```python  theme={null}
import os
from mem0 import Memory

config = {
    "vector_store": {
        "provider": "databricks",
        "config": {
            "workspace_url": "https://your-workspace.databricks.com",
            "access_token": "your-access-token",
            "endpoint_name": "your-vector-search-endpoint",
            "index_name": "catalog.schema.index_name",
            "source_table_name": "catalog.schema.source_table",
            "embedding_dimension": 1536
        }
    }
}

m = Memory.from_config(config)
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."}
]
m.add(messages, user_id="alice", metadata={"category": "movies"})
```

### Config

Here are the parameters available for configuring Databricks Vector Search:

| Parameter                         | Description                                                                 | Default Value |
| --------------------------------- | --------------------------------------------------------------------------- | ------------- |
| `workspace_url`                   | The URL of your Databricks workspace                                        | **Required**  |
| `access_token`                    | Personal Access Token for authentication                                    | `None`        |
| `service_principal_client_id`     | Service principal client ID (alternative to access\_token)                  | `None`        |
| `service_principal_client_secret` | Service principal client secret (required with client\_id)                  | `None`        |
| `endpoint_name`                   | Name of the Vector Search endpoint                                          | **Required**  |
| `index_name`                      | Name of the vector index (Unity Catalog format: catalog.schema.index)       | **Required**  |
| `source_table_name`               | Name of the source Delta table (Unity Catalog format: catalog.schema.table) | **Required**  |
| `embedding_dimension`             | Dimension of self-managed embeddings                                        | `1536`        |
| `embedding_source_column`         | Column name for text when using Databricks-computed embeddings              | `None`        |
| `embedding_model_endpoint_name`   | Databricks serving endpoint for embeddings                                  | `None`        |
| `embedding_vector_column`         | Column name for self-managed embedding vectors                              | `embedding`   |
| `endpoint_type`                   | Type of endpoint (`STANDARD` or `STORAGE_OPTIMIZED`)                        | `STANDARD`    |
| `sync_computed_embeddings`        | Whether to sync computed embeddings automatically                           | `True`        |

### Authentication

Databricks Vector Search supports two authentication methods:

#### Service Principal (Recommended for Production)

```python  theme={null}
config = {
    "vector_store": {
        "provider": "databricks",
        "config": {
            "workspace_url": "https://your-workspace.databricks.com",
            "service_principal_client_id": "your-service-principal-id",
            "service_principal_client_secret": "your-service-principal-secret",
            "endpoint_name": "your-endpoint",
            "index_name": "catalog.schema.index_name",
            "source_table_name": "catalog.schema.source_table"
        }
    }
}
```

#### Personal Access Token (for Development)

```python  theme={null}
config = {
    "vector_store": {
        "provider": "databricks",
        "config": {
            "workspace_url": "https://your-workspace.databricks.com",
            "access_token": "your-personal-access-token",
            "endpoint_name": "your-endpoint",
            "index_name": "catalog.schema.index_name",
            "source_table_name": "catalog.schema.source_table"
        }
    }
}
```

### Embedding Options

#### Self-Managed Embeddings (Default)

Use your own embedding model and provide vectors directly:

```python  theme={null}
config = {
    "vector_store": {
        "provider": "databricks",
        "config": {
            # ... authentication config ...
            "embedding_dimension": 768,  # Match your embedding model
            "embedding_vector_column": "embedding"
        }
    }
}
```

#### Databricks-Computed Embeddings

Let Databricks compute embeddings from text using a serving endpoint:

```python  theme={null}
config = {
    "vector_store": {
        "provider": "databricks",
        "config": {
            # ... authentication config ...
            "embedding_source_column": "text",
            "embedding_model_endpoint_name": "e5-small-v2"
        }
    }
}
```

### Important Notes

* **Delta Sync Index**: This implementation uses Delta Sync Index, which automatically syncs with your source Delta table. Direct vector insertion/deletion/update operations will log warnings as they're not supported with Delta Sync.
* **Unity Catalog**: Both the source table and index must be in Unity Catalog format (`catalog.schema.table_name`).
* **Endpoint Auto-Creation**: If the specified endpoint doesn't exist, it will be created automatically.
* **Index Auto-Creation**: If the specified index doesn't exist, it will be created automatically with the provided configuration.
* **Filter Support**: Supports filtering by metadata fields, with different syntax for STANDARD vs STORAGE\_OPTIMIZED endpoints.


# null
Source: https://docs.mem0.ai/components/vectordbs/dbs/elasticsearch



[Elasticsearch](https://www.elastic.co/) is a distributed, RESTful search and analytics engine that can efficiently store and search vector data using dense vectors and k-NN search.

### Installation

Elasticsearch support requires additional dependencies. Install them with:

```bash  theme={null}
pip install elasticsearch>=8.0.0
```

### Usage

```python  theme={null}
import os
from mem0 import Memory

os.environ["OPENAI_API_KEY"] = "sk-xx"

config = {
    "vector_store": {
        "provider": "elasticsearch",
        "config": {
            "collection_name": "mem0",
            "host": "localhost",
            "port": 9200,
            "embedding_model_dims": 1536
        }
    }
}

m = Memory.from_config(config)
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."}
]
m.add(messages, user_id="alice", metadata={"category": "movies"})
```

### Config

Here are the parameters available for configuring Elasticsearch:

| Parameter              | Description                                        | Default Value |
| ---------------------- | -------------------------------------------------- | ------------- |
| `collection_name`      | The name of the index to store the vectors         | `mem0`        |
| `embedding_model_dims` | Dimensions of the embedding model                  | `1536`        |
| `host`                 | The host where the Elasticsearch server is running | `localhost`   |
| `port`                 | The port where the Elasticsearch server is running | `9200`        |
| `cloud_id`             | Cloud ID for Elastic Cloud deployment              | `None`        |
| `api_key`              | API key for authentication                         | `None`        |
| `user`                 | Username for basic authentication                  | `None`        |
| `password`             | Password for basic authentication                  | `None`        |
| `verify_certs`         | Whether to verify SSL certificates                 | `True`        |
| `auto_create_index`    | Whether to automatically create the index          | `True`        |
| `custom_search_query`  | Function returning a custom search query           | `None`        |
| `headers`              | Custom headers to include in requests              | `None`        |

### Features

* Efficient vector search using Elasticsearch's native k-NN search
* Support for both local and cloud deployments (Elastic Cloud)
* Multiple authentication methods (Basic Auth, API Key)
* Automatic index creation with optimized mappings for vector search
* Memory isolation through payload filtering
* Custom search query function to customize the search query

### Custom Search Query

The `custom_search_query` parameter allows you to customize the search query when `Memory.search` is called.

**Example**

```python  theme={null}
import os
from typing import List, Optional, Dict
from mem0 import Memory

def custom_search_query(query: List[float], limit: int, filters: Optional[Dict]) -> Dict:
    return {
        "knn": {
            "field": "vector", 
            "query_vector": query, 
            "k": limit, 
            "num_candidates": limit * 2
        }
    }

os.environ["OPENAI_API_KEY"] = "sk-xx"

config = {
    "vector_store": {
        "provider": "elasticsearch",
        "config": {
            "collection_name": "mem0",
            "host": "localhost",
            "port": 9200,
            "embedding_model_dims": 1536,
            "custom_search_query": custom_search_query
        }
    }
}
```

It should be a function that takes the following parameters:

* `query`: a query vector used in `Memory.search`
* `limit`: a number of results used in `Memory.search`
* `filters`: a dictionary of key-value pairs used in `Memory.search`. You can add custom pairs for the custom search query.

The function should return a query body for the Elasticsearch search API.


# null
Source: https://docs.mem0.ai/components/vectordbs/dbs/faiss



[FAISS](https://github.com/facebookresearch/faiss) is a library for efficient similarity search and clustering of dense vectors. It is designed to work with large-scale datasets and provides a high-performance search engine for vector data. FAISS is optimized for memory usage and search speed, making it an excellent choice for production environments.

### Usage

```python  theme={null}
import os
from mem0 import Memory

os.environ["OPENAI_API_KEY"] = "sk-xx"

config = {
    "vector_store": {
        "provider": "faiss",
        "config": {
            "collection_name": "test",
            "path": "/tmp/faiss_memories",
            "distance_strategy": "euclidean"
        }
    }
}

m = Memory.from_config(config)
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."}
]
m.add(messages, user_id="alice", metadata={"category": "movies"})
```

### Installation

To use FAISS in your mem0 project, you need to install the appropriate FAISS package for your environment:

```bash  theme={null}
# For CPU version
pip install faiss-cpu

# For GPU version (requires CUDA)
pip install faiss-gpu
```

### Config

Here are the parameters available for configuring FAISS:

| Parameter           | Description                                                                        | Default Value                  |
| ------------------- | ---------------------------------------------------------------------------------- | ------------------------------ |
| `collection_name`   | The name of the collection                                                         | `mem0`                         |
| `path`              | Path to store FAISS index and metadata                                             | `/tmp/faiss/<collection_name>` |
| `distance_strategy` | Distance metric strategy to use (options: 'euclidean', 'inner\_product', 'cosine') | `euclidean`                    |
| `normalize_L2`      | Whether to normalize L2 vectors (only applicable for euclidean distance)           | `False`                        |

### Performance Considerations

FAISS offers several advantages for vector search:

1. **Efficiency**: FAISS is optimized for memory usage and speed, making it suitable for large-scale applications.
2. **Offline Support**: FAISS works entirely locally, with no need for external servers or API calls.
3. **Storage Options**: Vectors can be stored in-memory for maximum speed or persisted to disk.
4. **Multiple Index Types**: FAISS supports different index types optimized for various use cases (though mem0 currently uses the basic flat index).

### Distance Strategies

FAISS in mem0 supports three distance strategies:

* **euclidean**: L2 distance, suitable for most embedding models
* **inner\_product**: Dot product similarity, useful for some specialized embeddings
* **cosine**: Cosine similarity, best for comparing semantic similarity regardless of vector magnitude

When using `cosine` or `inner_product` with normalized vectors, you may want to set `normalize_L2=True` for better results.


# LangChain
Source: https://docs.mem0.ai/components/vectordbs/dbs/langchain



Mem0 supports LangChain as a provider for vector store integration. LangChain provides a unified interface to various vector databases, making it easy to integrate different vector store providers through a consistent API.

<Note>
  When using LangChain as your vector store provider, you must set the collection name to "mem0". This is a required configuration for proper integration with Mem0.
</Note>

## Usage

<CodeGroup>
  ```python Python theme={null}
  import os
  from mem0 import Memory
  from langchain_community.vectorstores import Chroma
  from langchain_openai import OpenAIEmbeddings

  # Initialize a LangChain vector store
  embeddings = OpenAIEmbeddings()
  vector_store = Chroma(
      persist_directory="./chroma_db",
      embedding_function=embeddings,
      collection_name="mem0"  # Required collection name
  )

  # Pass the initialized vector store to the config
  config = {
      "vector_store": {
          "provider": "langchain",
          "config": {
              "client": vector_store
          }
      }
  }

  m = Memory.from_config(config)
  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."}
  ]
  m.add(messages, user_id="alice", metadata={"category": "movies"})
  ```

  ```typescript TypeScript theme={null}
  import { Memory } from "mem0ai";
  import { OpenAIEmbeddings } from "@langchain/openai";
  import { MemoryVectorStore as LangchainMemoryStore } from "langchain/vectorstores/memory";

  const embeddings = new OpenAIEmbeddings();
  const vectorStore = new LangchainVectorStore(embeddings);

  const config = {
      "vector_store": {
          "provider": "langchain",
          "config": { "client": vectorStore }
      }
  }

  const memory = new Memory(config);

  const 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." }
  ]

  await memory.add(messages, { userId: "alice", metadata: { category: "movies" } });
  ```
</CodeGroup>

## Supported LangChain Vector Stores

LangChain supports a wide range of vector store providers, including:

* Chroma
* FAISS
* Pinecone
* Weaviate
* Milvus
* Qdrant
* And many more

You can use any of these vector store instances directly in your configuration. For a complete and up-to-date list of available providers, refer to the [LangChain Vector Stores documentation](https://python.langchain.com/docs/integrations/vectorstores).

## Limitations

When using LangChain as a vector store provider, there are some limitations to be aware of:

1. **Bulk Operations**: The `get_all` and `delete_all` operations are not supported when using LangChain as the vector store provider. This is because LangChain's vector store interface doesn't provide standardized methods for these bulk operations across all providers.

2. **Provider-Specific Features**: Some advanced features may not be available depending on the specific vector store implementation you're using through LangChain.

## Provider-Specific Configuration

When using LangChain as a vector store provider, you'll need to:

1. Set the appropriate environment variables for your chosen vector store provider
2. Import and initialize the specific vector store class you want to use
3. Pass the initialized vector store instance to the config

<Note>
  Make sure to install the necessary LangChain packages and any provider-specific dependencies.
</Note>

## Config

All available parameters for the `langchain` vector store config are present in [Master List of All Params in Config](../config).


# null
Source: https://docs.mem0.ai/components/vectordbs/dbs/milvus



[Milvus](https://milvus.io/) is an open-source vector database that suits AI applications of every size, from running a demo chatbot in a Jupyter notebook to building web-scale search that serves billions of users.

### Usage

```python  theme={null}
import os
from mem0 import Memory

config = {
    "vector_store": {
        "provider": "milvus",
        "config": {
            "collection_name": "test",
            "embedding_model_dims": 1536,
            "url": "127.0.0.1",
            "token": "8e4b8ca8cf2c67",
            "db_name": "my_database",
        }
    }
}

m = Memory.from_config(config)
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."}
]
m.add(messages, user_id="alice", metadata={"category": "movies"})
```

### Config

Here are the parameters available for configuring Milvus:

| Parameter              | Description                                                 | Default Value            |
| ---------------------- | ----------------------------------------------------------- | ------------------------ |
| `url`                  | Full URL/Uri for Milvus/Zilliz server                       | `http://localhost:19530` |
| `token`                | Token for Zilliz server / for local setup defaults to None. | `None`                   |
| `collection_name`      | The name of the collection                                  | `mem0`                   |
| `embedding_model_dims` | Dimensions of the embedding model                           | `1536`                   |
| `metric_type`          | Metric type for similarity search                           | `L2`                     |
| `db_name`              | Name of the database                                        | `""`                     |


# null
Source: https://docs.mem0.ai/components/vectordbs/dbs/mongodb



# MongoDB

[MongoDB](https://www.mongodb.com/) is a versatile document database that supports vector search capabilities, allowing for efficient high-dimensional similarity searches over large datasets with robust scalability and performance.

## Usage

```python  theme={null}
import os
from mem0 import Memory

os.environ["OPENAI_API_KEY"] = "sk-xx"

config = {
    "vector_store": {
        "provider": "mongodb",
        "config": {
            "db_name": "mem0-db",
            "collection_name": "mem0-collection",
            "mongo_uri":"mongodb://username:password@localhost:27017"
        }
    }
}

m = Memory.from_config(config)
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."}
]
m.add(messages, user_id="alice", metadata={"category": "movies"})
```

## Config

Here are the parameters available for configuring MongoDB:

| Parameter              | Description                         | Default Value                                 |
| ---------------------- | ----------------------------------- | --------------------------------------------- |
| db\_name               | Name of the MongoDB database        | `"mem0_db"`                                   |
| collection\_name       | Name of the MongoDB collection      | `"mem0_collection"`                           |
| embedding\_model\_dims | Dimensions of the embedding vectors | `1536`                                        |
| mongo\_uri             | The MongoDB URI connection string   | `mongodb://username:password@localhost:27017` |

> **Note**: If `mongo_uri` is not provided, it will default to `mongodb://username:password@localhost:27017`.


# null
Source: https://docs.mem0.ai/components/vectordbs/dbs/neptune_analytics



# Neptune Analytics Vector Store

[Neptune Analytics](https://docs.aws.amazon.com/neptune-analytics/latest/userguide/what-is-neptune-analytics.html/) is a memory-optimized graph database engine for analytics. With Neptune Analytics, you can get insights and find trends by processing large amounts of graph data in seconds, including vector search.

## Installation

```bash  theme={null}
pip install mem0ai[vector_stores]
```

## Usage

```python  theme={null}
config = {
    "vector_store": {
        "provider": "neptune",
        "config": {
            "collection_name": "mem0",
            "endpoint": f"neptune-graph://my-graph-identifier",
        },
    },
}

m = Memory.from_config(config)
messages = [
    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
    {"role": "assistant", "content": "How about a 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."}
]
m.add(messages, user_id="alice", metadata={"category": "movies"})
```

## Parameters

Let's see the available parameters for the `neptune` config:

| Parameter         | Description                                      | Default Value                         |
| ----------------- | ------------------------------------------------ | ------------------------------------- |
| `collection_name` | The name of the collection to store the vectors  | `mem0`                                |
| `endpoint`        | Connection URL for the Neptune Analytics service | `neptune-graph://my-graph-identifier` |


# null
Source: https://docs.mem0.ai/components/vectordbs/dbs/opensearch



[OpenSearch](https://opensearch.org/) is an enterprise-grade search and observability suite that brings order to unstructured data at scale. OpenSearch supports k-NN (k-Nearest Neighbors) and allows you to store and retrieve high-dimensional vector embeddings efficiently.

### Installation

OpenSearch support requires additional dependencies. Install them with:

```bash  theme={null}
pip install opensearch-py
```

### Prerequisites

Before using OpenSearch with Mem0, you need to set up a collection in AWS OpenSearch Service.

#### AWS OpenSearch Service

You can create a collection through the AWS Console:

* Navigate to [OpenSearch Service Console](https://console.aws.amazon.com/aos/home)
* Click "Create collection"
* Select "Serverless collection" and then enable "Vector search" capabilities
* Once created, note the endpoint URL (host) for your configuration

### Usage

```python  theme={null}
import os
from mem0 import Memory
import boto3
from opensearchpy import OpenSearch, RequestsHttpConnection, AWSV4SignerAuth

# For AWS OpenSearch Service with IAM authentication
region = 'us-west-2'
service = 'aoss'
credentials = boto3.Session().get_credentials()
auth = AWSV4SignerAuth(credentials, region, service)

config = {
    "vector_store": {
        "provider": "opensearch",
        "config": {
            "collection_name": "mem0",
            "host": "your-domain.us-west-2.aoss.amazonaws.com",
            "port": 443,
            "http_auth": auth,
            "embedding_model_dims": 1024,
            "connection_class": RequestsHttpConnection,
            "pool_maxsize": 20,
            "use_ssl": True,
            "verify_certs": True
        }
    }
}
```

### Add Memories

```python  theme={null}
m = Memory.from_config(config)
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."}
]
m.add(messages, user_id="alice", metadata={"category": "movies"})
```

### Search Memories

```python  theme={null}
results = m.search("What kind of movies does Alice like?", user_id="alice")
```

### Features

* Fast and Efficient Vector Search
* Can be deployed on-premises, in containers, or on cloud platforms like AWS OpenSearch Service
* Multiple authentication and security methods (Basic Authentication, API Keys, LDAP, SAML, and OpenID Connect)
* Automatic index creation with optimized mappings for vector search
* Memory optimization through disk-based vector search and quantization
* Real-time analytics and observability


# null
Source: https://docs.mem0.ai/components/vectordbs/dbs/pgvector



[pgvector](https://github.com/pgvector/pgvector) is an open-source vector similarity search extension for Postgres. After connecting to Postgres, run `CREATE EXTENSION IF NOT EXISTS vector;` to create the vector extension.

### Usage

<CodeGroup>
  ```python Python theme={null}
  import os
  from mem0 import Memory

  os.environ["OPENAI_API_KEY"] = "sk-xx"

  config = {
      "vector_store": {
          "provider": "pgvector",
          "config": {
              "user": "test",
              "password": "123",
              "host": "127.0.0.1",
              "port": "5432",
          }
      }
  }

  m = Memory.from_config(config)
  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."}
  ]
  m.add(messages, user_id="alice", metadata={"category": "movies"})
  ```

  ```typescript TypeScript theme={null}
  import { Memory } from 'mem0ai/oss';

  const config = {
    vectorStore: {
      provider: 'pgvector',
      config: {
        collectionName: 'memories',
        embeddingModelDims: 1536,
        user: 'test',
        password: '123',
        host: '127.0.0.1',
        port: 5432,
        dbname: 'vector_store', // Optional, defaults to 'postgres'
        diskann: false, // Optional, requires pgvectorscale extension
        hnsw: false, // Optional, for HNSW indexing
      },
    },
  };

  const memory = new Memory(config);
  const 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."}
  ]
  await memory.add(messages, { userId: "alice", metadata: { category: "movies" } });
  ```
</CodeGroup>

### Config

Here are the parameters available for configuring pgvector:

| Parameter              | Description                                                                             | Default Value |
| ---------------------- | --------------------------------------------------------------------------------------- | ------------- |
| `dbname`               | The name of the database                                                                | `postgres`    |
| `collection_name`      | The name of the collection                                                              | `mem0`        |
| `embedding_model_dims` | Dimensions of the embedding model                                                       | `1536`        |
| `user`                 | User name to connect to the database                                                    | `None`        |
| `password`             | Password to connect to the database                                                     | `None`        |
| `host`                 | The host where the Postgres server is running                                           | `None`        |
| `port`                 | The port where the Postgres server is running                                           | `None`        |
| `diskann`              | Whether to use diskann for vector similarity search (requires pgvectorscale)            | `True`        |
| `hnsw`                 | Whether to use hnsw for vector similarity search                                        | `False`       |
| `sslmode`              | SSL mode for PostgreSQL connection (e.g., 'require', 'prefer', 'disable')               | `None`        |
| `connection_string`    | PostgreSQL connection string (overrides individual connection parameters)               | `None`        |
| `connection_pool`      | psycopg2 connection pool object (overrides connection string and individual parameters) | `None`        |

**Note**: The connection parameters have the following priority:

1. `connection_pool` (highest priority)
2. `connection_string`
3. Individual connection parameters (`user`, `password`, `host`, `port`, `sslmode`)


# null
Source: https://docs.mem0.ai/components/vectordbs/dbs/pinecone



[Pinecone](https://www.pinecone.io/) is a fully managed vector database designed for machine learning applications, offering high performance vector search with low latency at scale. It's particularly well-suited for semantic search, recommendation systems, and other AI-powered applications.

> **New**: Pinecone integration now supports custom namespaces! Use the `namespace` parameter to logically separate data within the same index. This is especially useful for multi-tenant or multi-user applications.

> **Note**: Before configuring Pinecone, you need to select an embedding model (e.g., OpenAI, Cohere, or custom models) and ensure the `embedding_model_dims` in your config matches your chosen model's dimensions. For example, OpenAI's text-embedding-3-small uses 1536 dimensions.

### Usage

```python  theme={null}
import os
from mem0 import Memory

os.environ["OPENAI_API_KEY"] = "sk-xx"
os.environ["PINECONE_API_KEY"] = "your-api-key"

# Example using serverless configuration
config = {
    "vector_store": {
        "provider": "pinecone",
        "config": {
            "collection_name": "testing",
            "embedding_model_dims": 1536,  # Matches OpenAI's text-embedding-3-small
            "namespace": "my-namespace", # Optional: specify a namespace for multi-tenancy
            "serverless_config": {
                "cloud": "aws",  # Choose between 'aws' or 'gcp' or 'azure'
                "region": "us-east-1"
            },
            "metric": "cosine"
        }
    }
}

m = Memory.from_config(config)
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."}
]
m.add(messages, user_id="alice", metadata={"category": "movies"})
```

### Config

Here are the parameters available for configuring Pinecone:

| Parameter              | Description                                                                | Default Value                            |
| ---------------------- | -------------------------------------------------------------------------- | ---------------------------------------- |
| `collection_name`      | Name of the index/collection                                               | Required                                 |
| `embedding_model_dims` | Dimensions of the embedding model (must match your chosen embedding model) | Required                                 |
| `client`               | Existing Pinecone client instance                                          | `None`                                   |
| `api_key`              | API key for Pinecone                                                       | Environment variable: `PINECONE_API_KEY` |
| `environment`          | Pinecone environment                                                       | `None`                                   |
| `serverless_config`    | Configuration for serverless deployment (AWS or GCP or Azure)              | `None`                                   |
| `pod_config`           | Configuration for pod-based deployment                                     | `None`                                   |
| `hybrid_search`        | Whether to enable hybrid search                                            | `False`                                  |
| `metric`               | Distance metric for vector similarity                                      | `"cosine"`                               |
| `batch_size`           | Batch size for operations                                                  | `100`                                    |
| `namespace`            | Namespace for the collection, useful for multi-tenancy.                    | `None`                                   |

> **Important**: You must choose either `serverless_config` or `pod_config` for your deployment, but not both.

#### Serverless Config Example

```python  theme={null}
config = {
    "vector_store": {
        "provider": "pinecone",
        "config": {
            "collection_name": "memory_index",
            "embedding_model_dims": 1536,  # For OpenAI's text-embedding-3-small
            "namespace": "my-namespace",  # Optional: custom namespace
            "serverless_config": {
                "cloud": "aws",  # or "gcp" or "azure"
                "region": "us-east-1"  # Choose appropriate region
            }
        }
    }
}
```

#### Pod Config Example

```python  theme={null}
config = {
    "vector_store": {
        "provider": "pinecone",
        "config": {
            "collection_name": "memory_index",
            "embedding_model_dims": 1536,  # For OpenAI's text-embedding-ada-002
            "namespace": "my-namespace",  # Optional: custom namespace
            "pod_config": {
                "environment": "gcp-starter",
                "replicas": 1,
                "pod_type": "starter"
            }
        }
    }
}
```


# null
Source: https://docs.mem0.ai/components/vectordbs/dbs/qdrant



[Qdrant](https://qdrant.tech/) is an open-source vector search engine. It is designed to work with large-scale datasets and provides a high-performance search engine for vector data.

### Usage

<CodeGroup>
  ```python Python theme={null}
  import os
  from mem0 import Memory

  os.environ["OPENAI_API_KEY"] = "sk-xx"

  config = {
      "vector_store": {
          "provider": "qdrant",
          "config": {
              "collection_name": "test",
              "host": "localhost",
              "port": 6333,
          }
      }
  }

  m = Memory.from_config(config)
  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."}
  ]
  m.add(messages, user_id="alice", metadata={"category": "movies"})
  ```

  ```typescript TypeScript theme={null}
  import { Memory } from 'mem0ai/oss';

  const config = {
    vectorStore: {
      provider: 'qdrant',
      config: {
        collectionName: 'memories',
        embeddingModelDims: 1536,
        host: 'localhost',
        port: 6333,
      },
    },
  };

  const memory = new Memory(config);
  const 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."}
  ]
  await memory.add(messages, { userId: "alice", metadata: { category: "movies" } });
  ```
</CodeGroup>

### Config

Let's see the available parameters for the `qdrant` config:

<Tabs>
  <Tab title="Python">
    | Parameter              | Description                                     | Default Value |
    | ---------------------- | ----------------------------------------------- | ------------- |
    | `collection_name`      | The name of the collection to store the vectors | `mem0`        |
    | `embedding_model_dims` | Dimensions of the embedding model               | `1536`        |
    | `client`               | Custom client for qdrant                        | `None`        |
    | `host`                 | The host where the qdrant server is running     | `None`        |
    | `port`                 | The port where the qdrant server is running     | `None`        |
    | `path`                 | Path for the qdrant database                    | `/tmp/qdrant` |
    | `url`                  | Full URL for the qdrant server                  | `None`        |
    | `api_key`              | API key for the qdrant server                   | `None`        |
    | `on_disk`              | For enabling persistent storage                 | `False`       |
  </Tab>

  <Tab title="TypeScript">
    | Parameter            | Description                                     | Default Value |
    | -------------------- | ----------------------------------------------- | ------------- |
    | `collectionName`     | The name of the collection to store the vectors | `mem0`        |
    | `embeddingModelDims` | Dimensions of the embedding model               | `1536`        |
    | `host`               | The host where the Qdrant server is running     | `None`        |
    | `port`               | The port where the Qdrant server is running     | `None`        |
    | `path`               | Path for the Qdrant database                    | `/tmp/qdrant` |
    | `url`                | Full URL for the Qdrant server                  | `None`        |
    | `apiKey`             | API key for the Qdrant server                   | `None`        |
    | `onDisk`             | For enabling persistent storage                 | `False`       |
  </Tab>
</Tabs>


# null
Source: https://docs.mem0.ai/components/vectordbs/dbs/redis



[Redis](https://redis.io/) is a scalable, real-time database that can store, search, and analyze vector data.

### Installation

```bash  theme={null}
pip install redis redisvl
```

Redis Stack using Docker:

```bash  theme={null}
docker run -d --name redis-stack -p 6379:6379 -p 8001:8001 redis/redis-stack:latest
```

### Usage

<CodeGroup>
  ```python Python theme={null}
  import os
  from mem0 import Memory

  os.environ["OPENAI_API_KEY"] = "sk-xx"

  config = {
      "vector_store": {
          "provider": "redis",
          "config": {
              "collection_name": "mem0",
              "embedding_model_dims": 1536,
              "redis_url": "redis://localhost:6379"
          }
      },
      "version": "v1.1"
  }

  m = Memory.from_config(config)
  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."}
  ]
  m.add(messages, user_id="alice", metadata={"category": "movies"})
  ```

  ```typescript TypeScript theme={null}
  import { Memory } from 'mem0ai/oss';

  const config = {
    vectorStore: {
      provider: 'redis',
      config: {
        collectionName: 'memories',
        embeddingModelDims: 1536,
        redisUrl: 'redis://localhost:6379',
        username: 'your-redis-username',
        password: 'your-redis-password',
      },
    },
  };

  const memory = new Memory(config);
  const 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."}
  ]
  await memory.add(messages, { userId: "alice", metadata: { category: "movies" } });
  ```
</CodeGroup>

### Config

Let's see the available parameters for the `redis` config:

<Tabs>
  <Tab title="Python">
    | Parameter              | Description                                     | Default Value |
    | ---------------------- | ----------------------------------------------- | ------------- |
    | `collection_name`      | The name of the collection to store the vectors | `mem0`        |
    | `embedding_model_dims` | Dimensions of the embedding model               | `1536`        |
    | `redis_url`            | The URL of the Redis server                     | `None`        |
  </Tab>

  <Tab title="TypeScript">
    | Parameter            | Description                                     | Default Value |
    | -------------------- | ----------------------------------------------- | ------------- |
    | `collectionName`     | The name of the collection to store the vectors | `mem0`        |
    | `embeddingModelDims` | Dimensions of the embedding model               | `1536`        |
    | `redisUrl`           | The URL of the Redis server                     | `None`        |
    | `username`           | Username for Redis connection                   | `None`        |
    | `password`           | Password for Redis connection                   | `None`        |
  </Tab>
</Tabs>


# Amazon S3 Vectors
Source: https://docs.mem0.ai/components/vectordbs/dbs/s3_vectors



[Amazon S3 Vectors](https://aws.amazon.com/s3/features/vectors/) is a purpose-built, cost-optimized vector storage and query service for semantic search and AI applications. It provides S3-level elasticity and durability with sub-second query performance.

### Installation

S3 Vectors support requires additional dependencies. Install them with:

```bash  theme={null}
pip install boto3
```

### Usage

To use Amazon S3 Vectors with Mem0, you need to have an AWS account and the necessary IAM permissions (`s3vectors:*`). Ensure your environment is configured with AWS credentials (e.g., via `~/.aws/credentials` or environment variables).

```python  theme={null}
import os
from mem0 import Memory

# Ensure your AWS credentials are configured in your environment
# e.g., by setting AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, and AWS_DEFAULT_REGION

config = {
    "vector_store": {
        "provider": "s3_vectors",
        "config": {
            "vector_bucket_name": "my-mem0-vector-bucket",
            "collection_name": "my-memories-index",
            "embedding_model_dims": 1536,
            "distance_metric": "cosine",
            "region_name": "us-east-1"
        }
    }
}

m = Memory.from_config(config)
messages = [
    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
    {"role": "assistant", "content": "How about a thriller movie? 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."}
]
m.add(messages, user_id="alice", metadata={"category": "movies"})
```

### Config

Here are the parameters available for configuring Amazon S3 Vectors:

| Parameter              | Description                                                                      | Default Value                         |
| ---------------------- | -------------------------------------------------------------------------------- | ------------------------------------- |
| `vector_bucket_name`   | The name of the S3 Vector bucket to use. It will be created if it doesn't exist. | Required                              |
| `collection_name`      | The name of the vector index within the bucket.                                  | `mem0`                                |
| `embedding_model_dims` | Dimensions of the embedding model. Must match your embedder.                     | `1536`                                |
| `distance_metric`      | Distance metric for similarity search. Options: `cosine`, `euclidean`.           | `cosine`                              |
| `region_name`          | The AWS region where the bucket and index reside.                                | `None` (uses default from AWS config) |

### IAM Permissions

Your AWS identity (user or role) needs permissions to perform actions on S3 Vectors. A minimal policy would look like this:

```json  theme={null}
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": "s3vectors:*",
      "Resource": "*"
    }
  ]
}
```

For production, it is recommended to scope down the resource ARN to your specific buckets and indexes.


# null
Source: https://docs.mem0.ai/components/vectordbs/dbs/supabase



[Supabase](https://supabase.com/) is an open-source Firebase alternative that provides a PostgreSQL database with pgvector extension for vector similarity search. It offers a powerful and scalable solution for storing and querying vector embeddings.

Create a [Supabase](https://supabase.com/dashboard/projects) account and project, then get your connection string from Project Settings > Database. See the [docs](https://supabase.github.io/vecs/hosting/) for details.

### Usage

<CodeGroup>
  ```python Python theme={null}
  import os
  from mem0 import Memory

  os.environ["OPENAI_API_KEY"] = "sk-xx"

  config = {
      "vector_store": {
          "provider": "supabase",
          "config": {
              "connection_string": "postgresql://user:password@host:port/database",
              "collection_name": "memories",
              "index_method": "hnsw",  # Optional: defaults to "auto"
              "index_measure": "cosine_distance"  # Optional: defaults to "cosine_distance"
          }
      }
  }

  m = Memory.from_config(config)
  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."}
  ]
  m.add(messages, user_id="alice", metadata={"category": "movies"})
  ```

  ```typescript Typescript theme={null}
  import { Memory } from "mem0ai/oss";

  const config = {
      vectorStore: {
        provider: "supabase",
        config: {
          collectionName: "memories",
          embeddingModelDims: 1536,
          supabaseUrl: process.env.SUPABASE_URL || "",
          supabaseKey: process.env.SUPABASE_KEY || "",
          tableName: "memories",
        },
      },
  }

  const memory = new Memory(config);

  const 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."}
  ]

  await memory.add(messages, { userId: "alice", metadata: { category: "movies" } });
  ```
</CodeGroup>

### SQL Migrations for TypeScript Implementation

The following SQL migrations are required to enable the vector extension and create the memories table:

```sql  theme={null}
-- Enable the vector extension
create extension if not exists vector;

-- Create the memories table
create table if not exists memories (
  id text primary key,
  embedding vector(1536),
  metadata jsonb,
  created_at timestamp with time zone default timezone('utc', now()),
  updated_at timestamp with time zone default timezone('utc', now())
);

-- Create the vector similarity search function
create or replace function match_vectors(
  query_embedding vector(1536),
  match_count int,
  filter jsonb default '{}'::jsonb
)
returns table (
  id text,
  similarity float,
  metadata jsonb
)
language plpgsql
as $$
begin
  return query
  select
    t.id::text,
    1 - (t.embedding <=> query_embedding) as similarity,
    t.metadata
  from memories t
  where case
    when filter::text = '{}'::text then true
    else t.metadata @> filter
  end
  order by t.embedding <=> query_embedding
  limit match_count;
end;
$$;
```

Go to [Supabase](https://supabase.com/dashboard/projects) and run the above SQL migrations in the SQL Editor.

### Config

Here are the parameters available for configuring Supabase:

<Tabs>
  <Tab title="Python">
    | Parameter              | Description                             | Default Value     |
    | ---------------------- | --------------------------------------- | ----------------- |
    | `connection_string`    | PostgreSQL connection string (required) | None              |
    | `collection_name`      | Name for the vector collection          | `mem0`            |
    | `embedding_model_dims` | Dimensions of the embedding model       | `1536`            |
    | `index_method`         | Vector index method to use              | `auto`            |
    | `index_measure`        | Distance measure for similarity search  | `cosine_distance` |
  </Tab>

  <Tab title="TypeScript">
    | Parameter            | Description                       | Default Value |
    | -------------------- | --------------------------------- | ------------- |
    | `collectionName`     | Name for the vector collection    | `mem0`        |
    | `embeddingModelDims` | Dimensions of the embedding model | `1536`        |
    | `supabaseUrl`        | Supabase URL                      | None          |
    | `supabaseKey`        | Supabase key                      | None          |
    | `tableName`          | Name for the vector table         | `memories`    |
  </Tab>
</Tabs>

### Index Methods

The following index methods are supported:

* `auto`: Automatically selects the best available index method
* `hnsw`: Hierarchical Navigable Small World graph index (faster search, more memory usage)
* `ivfflat`: Inverted File Flat index (good balance of speed and memory)

### Distance Measures

Available distance measures for similarity search:

* `cosine_distance`: Cosine similarity (recommended for most embedding models)
* `l2_distance`: Euclidean distance
* `l1_distance`: Manhattan distance
* `max_inner_product`: Maximum inner product similarity

### Best Practices

1. **Index Method Selection**:
   * Use `hnsw` for fastest search performance when memory is not a constraint
   * Use `ivfflat` for a good balance of search speed and memory usage
   * Use `auto` if unsure, it will select the best method based on your data

2. **Distance Measure Selection**:
   * Use `cosine_distance` for most embedding models (OpenAI, Hugging Face, etc.)
   * Use `max_inner_product` if your vectors are normalized
   * Use `l2_distance` or `l1_distance` if working with raw feature vectors

3. **Connection String**:
   * Always use environment variables for sensitive information in the connection string
   * Format: `postgresql://user:password@host:port/database`


# null
Source: https://docs.mem0.ai/components/vectordbs/dbs/upstash-vector



[Upstash Vector](https://upstash.com/docs/vector) is a serverless vector database with built-in embedding models.

### Usage with Upstash embeddings

You can enable the built-in embedding models by setting `enable_embeddings` to `True`. This allows you to use Upstash's embedding models for vectorization.

```python  theme={null}
import os
from mem0 import Memory

os.environ["UPSTASH_VECTOR_REST_URL"] = "..."
os.environ["UPSTASH_VECTOR_REST_TOKEN"] = "..."

config = {
    "vector_store": {
        "provider": "upstash_vector",
        "enable_embeddings": True,
    }
}

m = Memory.from_config(config)
m.add("Likes to play cricket on weekends", user_id="alice", metadata={"category": "hobbies"})
```

<Note>
  Setting `enable_embeddings` to `True` will bypass any external embedding provider you have configured.
</Note>

### Usage with external embedding providers

```python  theme={null}
import os
from mem0 import Memory

os.environ["OPENAI_API_KEY"] = "..."
os.environ["UPSTASH_VECTOR_REST_URL"] = "..."
os.environ["UPSTASH_VECTOR_REST_TOKEN"] = "..."

config = {
    "vector_store": {
        "provider": "upstash_vector",
    },
    "embedder": {
        "provider": "openai",
        "config": {
            "model": "text-embedding-3-large"
        },
    }
}

m = Memory.from_config(config)
m.add("Likes to play cricket on weekends", user_id="alice", metadata={"category": "hobbies"})
```

### Config

Here are the parameters available for configuring Upstash Vector:

| Parameter           | Description                        | Default Value |
| ------------------- | ---------------------------------- | ------------- |
| `url`               | URL for the Upstash Vector index   | `None`        |
| `token`             | Token for the Upstash Vector index | `None`        |
| `client`            | An `upstash_vector.Index` instance | `None`        |
| `collection_name`   | The default namespace used         | `""`          |
| `enable_embeddings` | Whether to use Upstash embeddings  | `False`       |

<Note>
  When `url` and `token` are not provided, the `UPSTASH_VECTOR_REST_URL` and
  `UPSTASH_VECTOR_REST_TOKEN` environment variables are used.
</Note>


# null
Source: https://docs.mem0.ai/components/vectordbs/dbs/valkey



# Valkey Vector Store

[Valkey](https://valkey.io/) is an open source (BSD) high-performance key/value datastore that supports a variety of workloads and rich datastructures including vector search.

## Installation

```bash  theme={null}
pip install mem0ai[vector_stores]
```

## Usage

```python  theme={null}
config = {
    "vector_store": {
        "provider": "valkey",
        "config": {
            "collection_name": "test",
            "valkey_url": "valkey://localhost:6379",
            "embedding_model_dims": 1536,
            "index_type": "flat"
        }
    }
}

m = Memory.from_config(config)
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."}
]
m.add(messages, user_id="alice", metadata={"category": "movies"})
```

## Parameters

Here are the parameters available for configuring Valkey:

| Parameter              | Description                                     | Default Value             |
| ---------------------- | ----------------------------------------------- | ------------------------- |
| `collection_name`      | The name of the collection to store the vectors | `mem0`                    |
| `valkey_url`           | Connection URL for the Valkey server            | `valkey://localhost:6379` |
| `embedding_model_dims` | Dimensions of the embedding model               | `1536`                    |
| `index_type`           | Vector index algorithm (`hnsw` or `flat`)       | `hnsw`                    |
| `hnsw_m`               | Number of bi-directional links for HNSW         | `16`                      |
| `hnsw_ef_construction` | Size of dynamic candidate list for HNSW         | `200`                     |
| `hnsw_ef_runtime`      | Size of dynamic candidate list for search       | `10`                      |
| `distance_metric`      | Distance metric for vector similarity           | `cosine`                  |


# null
Source: https://docs.mem0.ai/components/vectordbs/dbs/vectorize



[Cloudflare Vectorize](https://developers.cloudflare.com/vectorize/) is a vector database offering from Cloudflare, allowing you to build AI-powered applications with vector embeddings.

### Usage

<CodeGroup>
  ```typescript TypeScript theme={null}
  import { Memory } from 'mem0ai/oss';

  const config = {
    vectorStore: {
      provider: 'vectorize',
      config: {
        indexName: 'my-memory-index',
        accountId: 'your-cloudflare-account-id',
        apiKey: 'your-cloudflare-api-key',
        dimension: 1536, // Optional: defaults to 1536
      },
    },
  };

  const memory = new Memory(config);
  const messages = [
      {"role": "user", "content": "I'm looking for a good book to read."},
      {"role": "assistant", "content": "Sure, what genre are you interested in?"},
      {"role": "user", "content": "I enjoy fantasy novels with strong world-building."},
      {"role": "assistant", "content": "Great! I'll keep that in mind for future recommendations."}
  ]
  await memory.add(messages, { userId: "bob", metadata: { interest: "books" } });
  ```
</CodeGroup>

### Config

Here are the parameters available for configuring Vectorize:

<Tabs>
  <Tab title="TypeScript">
    | Parameter   | Description                       | Default Value     |
    | ----------- | --------------------------------- | ----------------- |
    | `indexName` | The name of the Vectorize index   | `None` (Required) |
    | `accountId` | Your Cloudflare account ID        | `None` (Required) |
    | `apiKey`    | Your Cloudflare API token         | `None` (Required) |
    | `dimension` | Dimensions of the embedding model | `1536`            |
  </Tab>
</Tabs>


# Vertex AI Vector Search
Source: https://docs.mem0.ai/components/vectordbs/dbs/vertex_ai



### Usage

To use Google Cloud Vertex AI Vector Search with `mem0`, you need to configure the `vector_store` in your `mem0` config:

```python  theme={null}
import os
from mem0 import Memory

os.environ["GOOGLE_API_KEY"] = "sk-xx"

config = {
    "vector_store": {
        "provider": "vertex_ai_vector_search",
        "config": {
            "endpoint_id": "YOUR_ENDPOINT_ID",            # Required: Vector Search endpoint ID
            "index_id": "YOUR_INDEX_ID",                  # Required: Vector Search index ID 
            "deployment_index_id": "YOUR_DEPLOYMENT_INDEX_ID",  # Required: Deployment-specific ID
            "project_id": "YOUR_PROJECT_ID",              # Required: Google Cloud project ID
            "project_number": "YOUR_PROJECT_NUMBER",      # Required: Google Cloud project number
            "region": "YOUR_REGION",                      # Optional: Defaults to GOOGLE_CLOUD_REGION
            "credentials_path": "path/to/credentials.json", # Optional: Defaults to GOOGLE_APPLICATION_CREDENTIALS
            "vector_search_api_endpoint": "YOUR_API_ENDPOINT" # Required for get operations
        }
    }
}
m = Memory.from_config(config)
m.add("Your text here", user_id="user", metadata={"category": "example"})
```

### Required Parameters

| Parameter                    | Description                         | Required                                          |
| ---------------------------- | ----------------------------------- | ------------------------------------------------- |
| `endpoint_id`                | Vector Search endpoint ID           | Yes                                               |
| `index_id`                   | Vector Search index ID              | Yes                                               |
| `deployment_index_id`        | Deployment-specific index ID        | Yes                                               |
| `project_id`                 | Google Cloud project ID             | Yes                                               |
| `project_number`             | Google Cloud project number         | Yes                                               |
| `vector_search_api_endpoint` | Vector search API endpoint          | Yes (for get operations)                          |
| `region`                     | Google Cloud region                 | No (defaults to GOOGLE\_CLOUD\_REGION)            |
| `credentials_path`           | Path to service account credentials | No (defaults to GOOGLE\_APPLICATION\_CREDENTIALS) |


# null
Source: https://docs.mem0.ai/components/vectordbs/dbs/weaviate



[Weaviate](https://weaviate.io/) is an open-source vector search engine. It allows efficient storage and retrieval of high-dimensional vector embeddings, enabling powerful search and retrieval capabilities.

### Installation

```bash  theme={null}
pip install weaviate weaviate-client
```

### Usage

```python Python theme={null}
import os
from mem0 import Memory

os.environ["OPENAI_API_KEY"] = "sk-xx"

config = {
    "vector_store": {
        "provider": "weaviate",
        "config": {
            "collection_name": "test",
            "cluster_url": "http://localhost:8080",
            "auth_client_secret": None,
        }
    }
}

m = Memory.from_config(config)
messages = [
    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
    {"role": "assistant", "content": "How about a thriller movie? 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."}
]
m.add(messages, user_id="alice", metadata={"category": "movies"})
```

### Config

Here are the parameters available for configuring Weaviate:

| Parameter              | Description                                     | Default Value |
| ---------------------- | ----------------------------------------------- | ------------- |
| `collection_name`      | The name of the collection to store the vectors | `mem0`        |
| `embedding_model_dims` | Dimensions of the embedding model               | `1536`        |
| `cluster_url`          | URL for the Weaviate server                     | `None`        |
| `auth_client_secret`   | API key for Weaviate authentication             | `None`        |


# Overview
Source: https://docs.mem0.ai/components/vectordbs/overview



Mem0 includes built-in support for various popular databases. Memory can utilize the database provided by the user, ensuring efficient use for specific needs.

## Supported Vector Databases

See the list of supported vector databases below.

<Note>
  The following vector databases are supported in the Python implementation. The TypeScript implementation currently only supports Qdrant, Redis, Valkey, Vectorize and in-memory vector database.
</Note>

<CardGroup cols={3}>
  <Card title="Qdrant" href="/components/vectordbs/dbs/qdrant" />

  <Card title="Chroma" href="/components/vectordbs/dbs/chroma" />

  <Card title="PGVector" href="/components/vectordbs/dbs/pgvector" />

  <Card title="Upstash Vector" href="/components/vectordbs/dbs/upstash-vector" />

  <Card title="Milvus" href="/components/vectordbs/dbs/milvus" />

  <Card title="Pinecone" href="/components/vectordbs/dbs/pinecone" />

  <Card title="MongoDB" href="/components/vectordbs/dbs/mongodb" />

  <Card title="Azure" href="/components/vectordbs/dbs/azure" />

  <Card title="Redis" href="/components/vectordbs/dbs/redis" />

  <Card title="Valkey" href="/components/vectordbs/dbs/valkey" />

  <Card title="Elasticsearch" href="/components/vectordbs/dbs/elasticsearch" />

  <Card title="OpenSearch" href="/components/vectordbs/dbs/opensearch" />

  <Card title="Supabase" href="/components/vectordbs/dbs/supabase" />

  <Card title="Vertex AI" href="/components/vectordbs/dbs/vertex_ai" />

  <Card title="Weaviate" href="/components/vectordbs/dbs/weaviate" />

  <Card title="FAISS" href="/components/vectordbs/dbs/faiss" />

  <Card title="LangChain" href="/components/vectordbs/dbs/langchain" />

  <Card title="Amazon S3 Vectors" href="/components/vectordbs/dbs/s3_vectors" />

  <Card title="Databricks" href="/components/vectordbs/dbs/databricks" />
</CardGroup>

## Usage

To utilize a vector database, you must provide a configuration to customize its usage. If no configuration is supplied, a default configuration will be applied, and `Qdrant` will be used as the vector database.

For a comprehensive list of available parameters for vector database configuration, please refer to [Config](./config).

## Common issues

### Using Model with Different Dimensions

If you are using a customized model with different dimensions other than 1536 (for example, 768), you may encounter the following error:

`ValueError: shapes (0,1536) and (768,) not aligned: 1536 (dim 1) != 768 (dim 0)`

You can add `"embedding_model_dims": 768,` to the config of the vector\_store to resolve this issue.


# Add Memory
Source: https://docs.mem0.ai/core-concepts/memory-operations/add

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.

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

## 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`, `session_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, scaling, and graph features.
* **Mem0 Open Source** – Local SDK that you run in your own environment.

Both flows take the same payload and pass it through the same pipeline.

<Frame caption="Architecture diagram illustrating the process of adding memories.">
  <img src="https://mintcdn.com/mem0/k4LG2Flv5533NbwL/images/add_architecture.png?fit=max&auto=format&n=k4LG2Flv5533NbwL&q=85&s=c9a5ae97b634120b1235fe1d756d5355" data-og-width="1440" width="1440" data-og-height="632" height="632" data-path="images/add_architecture.png" data-optimize="true" data-opv="3" srcset="https://mintcdn.com/mem0/k4LG2Flv5533NbwL/images/add_architecture.png?w=280&fit=max&auto=format&n=k4LG2Flv5533NbwL&q=85&s=d253764a4df6229cf37e5a78d09a2383 280w, https://mintcdn.com/mem0/k4LG2Flv5533NbwL/images/add_architecture.png?w=560&fit=max&auto=format&n=k4LG2Flv5533NbwL&q=85&s=ba37decf970204b83d1846b496ae963b 560w, https://mintcdn.com/mem0/k4LG2Flv5533NbwL/images/add_architecture.png?w=840&fit=max&auto=format&n=k4LG2Flv5533NbwL&q=85&s=d099b83f91fdf36bfab4566d16295e92 840w, https://mintcdn.com/mem0/k4LG2Flv5533NbwL/images/add_architecture.png?w=1100&fit=max&auto=format&n=k4LG2Flv5533NbwL&q=85&s=189486cc03b285297a0b9d3eadc7069c 1100w, https://mintcdn.com/mem0/k4LG2Flv5533NbwL/images/add_architecture.png?w=1650&fit=max&auto=format&n=k4LG2Flv5533NbwL&q=85&s=6d26a820f1b7b9e2dd7517b7b3ec2aa4 1650w, https://mintcdn.com/mem0/k4LG2Flv5533NbwL/images/add_architecture.png?w=2500&fit=max&auto=format&n=k4LG2Flv5533NbwL&q=85&s=396c6538e8fca41d3bcb28c27e9f51e1 2500w" />
</Frame>

<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="Conflict resolution">
    Existing memories are checked for duplicates or contradictions so the latest truth wins.
  </Step>

  <Step title="Storage">
    The resulting memories land in managed vector storage (and optional graph storage) so future searches return them quickly.
  </Step>
</Steps>

<Warning>
  Duplicate protection only runs during that conflict-resolution step when you let Mem0 infer memories (`infer=True`, the default). If you switch to `infer=False`, Mem0 stores your payload exactly as provided, so duplicates will land. Mixing both modes for the same fact will 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,
    user_id: "alice",
    version: "v2",
  });
  ```
</CodeGroup>

<Info icon="check">
  Expect a `memory_id` (or list of IDs) in the response. Check the Mem0 dashboard to confirm the new entry under the correct user.
</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)
  ```

  ```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" }
  });
  ```
</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 conflict resolution, so a later `infer=True` call with the same content will create a second memory instead of updating the first.
</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

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                                        |
| -------------------- | ---------------------------------------- | ----------------------------------------------- |
| Conflict resolution  | Automatic with dashboard visibility      | SDK handles merges locally; you control storage |
| Graph writes         | Toggle per request (`enable_graph=True`) | Requires configuring a graph provider           |
| 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, rerankers, and graph toggles.
* 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>


# Delete Memory
Source: https://docs.mem0.ai/core-concepts/memory-operations/delete

Remove memories from Mem0 either individually, in bulk, or via filters.

# Remove Memories Safely

Deleting memories is how you honor compliance requests, undo bad data, or clean up expired sessions. Mem0 lets you delete a specific memory, a list of IDs, or everything that matches a filter.

<Info>
  **Why it matters**

  * Satisfies user erasure (GDPR/CCPA) without touching the rest of your data.
  * Keeps knowledge bases accurate by removing stale or incorrect facts.
  * Works for both the managed Platform API and the OSS SDK.
</Info>

## Key terms

* **memory\_id** – Unique ID returned by `add`/`search` identifying the record to delete.
* **batch\_delete** – API call that removes up to 1000 memories in one request.
* **delete\_all** – Filter-based deletion by user, agent, run, or metadata.
* **immutable** – Flagged memories that cannot be updated; delete + re-add instead.

## How the delete flow works

<Steps>
  <Step title="Choose the scope">
    Decide whether you’re removing a single memory, a list, or everything that matches a filter.
  </Step>

  <Step title="Submit the delete call">
    Call `delete`, `batch_delete`, or `delete_all` with the required IDs or filters.
  </Step>

  <Step title="Verify">
    Confirm the response message, then re-run `search` or check the dashboard/logs to ensure the memory is gone.
  </Step>
</Steps>

## Delete a single memory (Platform)

<CodeGroup>
  ```python Python theme={null}
  from mem0 import MemoryClient

  client = MemoryClient(api_key="your-api-key")

  memory_id = "your_memory_id"
  client.delete(memory_id=memory_id)
  ```

  ```javascript JavaScript theme={null}
  import MemoryClient from 'mem0ai';

  const client = new MemoryClient({ apiKey: "your-api-key" });

  client.delete("your_memory_id")
    .then(result => console.log(result))
    .catch(error => console.error(error));
  ```
</CodeGroup>

<Info icon="check">
  You’ll receive a confirmation payload. The dashboard reflects the removal within seconds.
</Info>

## Batch delete multiple memories (Platform)

<CodeGroup>
  ```python Python theme={null}
  from mem0 import MemoryClient

  client = MemoryClient(api_key="your-api-key")

  delete_memories = [
      {"memory_id": "id1"},
      {"memory_id": "id2"}
  ]

  response = client.batch_delete(delete_memories)
  print(response)
  ```

  ```javascript JavaScript theme={null}
  import MemoryClient from 'mem0ai';

  const client = new MemoryClient({ apiKey: "your-api-key" });

  const deleteMemories = [
    { memory_id: "id1" },
    { memory_id: "id2" }
  ];

  client.batchDelete(deleteMemories)
    .then(response => console.log('Batch delete response:', response))
    .catch(error => console.error(error));
  ```
</CodeGroup>

## Delete memories by filter (Platform)

<CodeGroup>
  ```python Python theme={null}
  from mem0 import MemoryClient

  client = MemoryClient(api_key="your-api-key")

  # Delete all memories for a specific user
  client.delete_all(user_id="alice")
  ```

  ```javascript JavaScript theme={null}
  import MemoryClient from 'mem0ai';

  const client = new MemoryClient({ apiKey: "your-api-key" });

  client.deleteAll({ user_id: "alice" })
    .then(result => console.log(result))
    .catch(error => console.error(error));
  ```
</CodeGroup>

You can also filter by other parameters such as:

* `agent_id`
* `run_id`
* `metadata` (as JSON string)

<Warning>
  `delete_all` requires at least one filter (user, agent, run, or metadata). Calling it with no filters raises an error to prevent accidental data loss.
</Warning>

## Delete with Mem0 OSS

<CodeGroup>
  ```python Python theme={null}
  from mem0 import Memory

  memory = Memory()

  memory.delete(memory_id="mem_123")
  memory.delete_all(user_id="alice")
  ```
</CodeGroup>

<Note>
  The OSS JavaScript SDK does not yet expose deletion helpers—use the REST API or Python SDK when self-hosting.
</Note>

## Use cases recap

* Forget a user’s preferences at their request.
* Remove outdated or incorrect facts before they spread.
* Clean up memories after session expiration or retention deadlines.
* Comply with privacy legislation (GDPR, CCPA) and internal policies.

## Method comparison

| Method                | Use when                            | IDs required | Filters |
| --------------------- | ----------------------------------- | ------------ | ------- |
| `delete(memory_id)`   | You know the exact record           | ✔️           | ✖️      |
| `batch_delete([...])` | You have a list of IDs to purge     | ✔️           | ✖️      |
| `delete_all(...)`     | You need to forget a user/agent/run | ✖️           | ✔️      |

## Put it into practice

* Review the <Link href="/api-reference/memory/delete-memory">Delete Memory API reference</Link>, plus <Link href="/api-reference/memory/batch-delete">Batch Delete</Link> and <Link href="/api-reference/memory/delete-memories">Filtered Delete</Link>.
* Pair deletes with <Link href="/platform/features/expiration-date">Expiration Policies</Link> to automate retention.

## See it live

* <Link href="/cookbooks/operations/support-inbox">Support Inbox with Mem0</Link> demonstrates compliance-driven deletes.
* <Link href="/platform/features/direct-import">Data Management tooling</Link> shows how deletes fit into broader lifecycle flows.

<CardGroup cols={2}>
  <Card title="Review Add Concepts" description="Ensure the memories you keep are structured from the start." icon="circle-check" href="/core-concepts/memory-operations/add" />

  <Card title="Enable Expiration Policies" description="Automate retention with the platform’s expiration feature." icon="clock" href="/platform/features/expiration-date" />
</CardGroup>


# Search Memory
Source: https://docs.mem0.ai/core-concepts/memory-operations/search

Retrieve relevant memories from Mem0 using powerful semantic and filtered search capabilities.

# How Mem0 Searches Memory

Mem0's search operation lets agents ask natural-language questions and get back the memories that matter most. Like a smart librarian, it finds exactly what you need from everything you've stored.

<Info>
  **Why it matters**

  * Retrieves the right facts without rebuilding prompts from scratch.
  * Supports both managed Platform and OSS so you can test locally and deploy at scale.
  * Keeps results relevant with filters, rerankers, and thresholds.
</Info>

## Key terms

* **Query** – Natural-language question or statement you pass to `search`.
* **Filters** – JSON logic (AND/OR, comparison operators) that narrows results by user, categories, dates, etc.
* **top\_k / threshold** – Controls how many memories return and the minimum similarity score.
* **Rerank** – Optional second pass that boosts precision when a reranker is configured.

## Architecture

<Frame caption="Architecture diagram illustrating the memory search process.">
  <img src="https://mintcdn.com/mem0/k4LG2Flv5533NbwL/images/search_architecture.png?fit=max&auto=format&n=k4LG2Flv5533NbwL&q=85&s=38d4fb38d163738e2709b5e4a5f2be1d" data-og-width="1440" width="1440" data-og-height="545" height="545" data-path="images/search_architecture.png" data-optimize="true" data-opv="3" srcset="https://mintcdn.com/mem0/k4LG2Flv5533NbwL/images/search_architecture.png?w=280&fit=max&auto=format&n=k4LG2Flv5533NbwL&q=85&s=f4ffb31910ce495dadebd98a752292f8 280w, https://mintcdn.com/mem0/k4LG2Flv5533NbwL/images/search_architecture.png?w=560&fit=max&auto=format&n=k4LG2Flv5533NbwL&q=85&s=99138f0d43f2b4a3f5da1855d18a7b22 560w, https://mintcdn.com/mem0/k4LG2Flv5533NbwL/images/search_architecture.png?w=840&fit=max&auto=format&n=k4LG2Flv5533NbwL&q=85&s=7634bc87c3a7adc283d22bf73d8e7530 840w, https://mintcdn.com/mem0/k4LG2Flv5533NbwL/images/search_architecture.png?w=1100&fit=max&auto=format&n=k4LG2Flv5533NbwL&q=85&s=5a51803baa7210a7b51a1d5d3290e1f5 1100w, https://mintcdn.com/mem0/k4LG2Flv5533NbwL/images/search_architecture.png?w=1650&fit=max&auto=format&n=k4LG2Flv5533NbwL&q=85&s=212621d763823c161088a9b8ef26410a 1650w, https://mintcdn.com/mem0/k4LG2Flv5533NbwL/images/search_architecture.png?w=2500&fit=max&auto=format&n=k4LG2Flv5533NbwL&q=85&s=7efed52d10bbb87a56803000eda29562 2500w" />
</Frame>

<Steps>
  <Step title="Query processing">
    Mem0 cleans and enriches your natural-language query so the downstream embedding search is accurate.
  </Step>

  <Step title="Vector search">
    Embeddings locate the closest memories using cosine similarity across your scoped dataset.
  </Step>

  <Step title="Filtering & reranking">
    Logical filters narrow candidates; rerankers or thresholds fine-tune ordering.
  </Step>

  <Step title="Results delivery">
    Formatted memories (with metadata and timestamps) return to your agent or calling service.
  </Step>
</Steps>

This pipeline runs the same way for the hosted Platform API and the OSS SDK.

## How does it work?

Search converts your natural language question into a vector embedding, then finds memories with similar embeddings in your database. The results are ranked by similarity score and can be further refined with filters or reranking.

```python  theme={null}
# Minimal example that shows the concept in action
# Platform API
client.search("What are Alice's hobbies?", filters={"user_id": "alice"})

# OSS
m.search("What are Alice's hobbies?", user_id="alice")
```

<Tip>
  Always provide at least a `user_id` filter to scope searches to the right user's memories. This prevents cross-contamination between users.
</Tip>

## When should you use it?

* **Context retrieval** - When your agent needs past context to generate better responses
* **Personalization** - To recall user preferences, history, or past interactions
* **Fact checking** - To verify information against stored memories before responding
* **Decision support** - When agents need relevant background information to make decisions

## Platform vs OSS usage

| Capability            | Mem0 Platform                                                        | Mem0 OSS                                            |
| --------------------- | -------------------------------------------------------------------- | --------------------------------------------------- |
| **user\_id usage**    | In `filters={"user_id": "alice"}` for search/get\_all                | As parameter `user_id="alice"` for all operations   |
| **Filter syntax**     | Logical operators (`AND`, `OR`, comparisons) with field-level access | Basic field filters, extend via Python hooks        |
| **Reranking**         | Toggle `rerank=True` with managed reranker catalog                   | Requires configuring local or third-party rerankers |
| **Thresholds**        | Request-level configuration (`threshold`, `top_k`)                   | Controlled via SDK parameters                       |
| **Response metadata** | Includes confidence scores, timestamps, dashboard visibility         | Determined by your storage backend                  |

## Search with Mem0 Platform

<CodeGroup>
  ```python Python theme={null}
  from mem0 import MemoryClient

  client = MemoryClient(api_key="your-api-key")

  query = "What do you know about me?"
  filters = {
     "OR": [
        {"user_id": "alice"},
        {"agent_id": {"in": ["travel-assistant", "customer-support"]}}
     ]
  }

  results = client.search(query, filters=filters)
  ```

  ```javascript JavaScript theme={null}
  import { MemoryClient } from "mem0ai";

  const client = new MemoryClient({apiKey: "your-api-key"});

  const query = "I'm craving some pizza. Any recommendations?";
  const filters = {
    AND: [
      { user_id: "alice" }
    ]
  };

  const results = await client.search(query, {
    filters
  });
  ```
</CodeGroup>

## Search with Mem0 Open Source

<CodeGroup>
  ```python Python theme={null}
  from mem0 import Memory

  m = Memory()

  # Simple search
  related_memories = m.search("Should I drink coffee or tea?", user_id="alice")

  # Search with filters
  memories = m.search(
      "food preferences",
      user_id="alice",
      filters={"categories": {"contains": "diet"}}
  )
  ```

  ```javascript JavaScript theme={null}
  import { Memory } from 'mem0ai/oss';

  const memory = new Memory();

  // Simple search
  const relatedMemories = memory.search("Should I drink coffee or tea?", { userId: "alice" });

  // Search with filters (if supported)
  const memories = memory.search("food preferences", {
      userId: "alice",
      filters: { categories: { contains: "diet" } }
  });
  ```
</CodeGroup>

<Info icon="check">
  Expect an array of memory documents. Platform responses include vectors, metadata, and timestamps; OSS returns your stored schema.
</Info>

## Filter patterns

Filters help narrow down search results. Common use cases:

**Filter by Session Context:**

*Platform API:*

```python  theme={null}
# Get memories from a specific agent session
client.search("query", filters={
    "AND": [
        {"user_id": "alice"},
        {"agent_id": "chatbot"},
        {"run_id": "session-123"}
    ]
})
```

*OSS:*

```python  theme={null}
# Get memories from a specific agent session
m.search("query", user_id="alice", agent_id="chatbot", run_id="session-123")
```

**Filter by Date Range:**

```python  theme={null}
# Platform only - date filtering
client.search("recent memories", filters={
    "AND": [
        {"user_id": "alice"},
        {"created_at": {"gte": "2024-07-01"}}
    ]
})
```

**Filter by Categories:**

```python  theme={null}
# Platform only - category filtering
client.search("preferences", filters={
    "AND": [
        {"user_id": "alice"},
        {"categories": {"contains": "food"}}
    ]
})
```

## Tips for better search

* **Use natural language**: Mem0 understands intent, so describe what you're looking for naturally
* **Scope with user ID**: Always provide `user_id` to scope search to relevant memories
  * **Platform API**: Use `filters={"user_id": "alice"}`
  * **OSS**: Use `user_id="alice"` as parameter
* **Combine filters**: Use AND/OR logic to create precise queries (Platform)
* **Consider wildcard filters**: Use wildcard filters (e.g., `run_id: "*"`) for broader matches
* **Tune parameters**: Adjust `top_k` for result count, `threshold` for relevance cutoff
* **Enable reranking**: Use `rerank=True` (default) when you have a reranker configured

### More Details

For the full list of filter logic, comparison operators, and optional search parameters, see the
[Search Memory API Reference](/api-reference/memory/search-memories).

## Put it into practice

* Revisit the <Link href="/core-concepts/memory-operations/add">Add Memory</Link> guide to ensure you capture the context you expect to retrieve.
* Configure rerankers and filters in <Link href="/platform/features/advanced-retrieval">Advanced Retrieval</Link> for higher precision.

## See it live

* <Link href="/cookbooks/operations/support-inbox">Support Inbox with Mem0</Link> demonstrates scoped search with rerankers.
* <Link href="/cookbooks/integrations/tavily-search">Tavily Search with Mem0</Link> shows hybrid search in action.

<CardGroup cols={2}>
  <Card title="Search Memory API" description="Complete API reference with all filter operators and parameters." icon="book" href="/api-reference/memory/search-memories" />

  <Card title="Support Inbox Cookbook" description="Build a complete support system with scoped search and reranking." icon="rocket" href="/cookbooks/operations/support-inbox" />
</CardGroup>


# Update Memory
Source: https://docs.mem0.ai/core-concepts/memory-operations/update

Modify an existing memory by updating its content or metadata.

# Keep Memories Accurate with Update

Mem0’s update operation lets you fix or enrich an existing memory without deleting it. When a user changes their preference or clarifies a fact, use update to keep the knowledge base fresh.

<Info>
  **Why it matters**

  * Corrects outdated or incorrect memories immediately.
  * Adds new metadata so filters and rerankers stay sharp.
  * Works for both one-off edits and large batches (up to 1000 memories).
</Info>

## Key terms

* **memory\_id** – Unique identifier returned by `add` or `search` results.
* **text** / **data** – New content that replaces the stored memory value.
* **metadata** – Optional key-value pairs you update alongside the text.
* **batch\_update** – Platform API that edits multiple memories in a single request.
* **immutable** – Flagged memories that must be deleted and re-added instead of updated.

## How the update flow works

<Steps>
  <Step title="Locate the memory">
    Use `search` or dashboard inspection to capture the `memory_id` you want to change.
  </Step>

  <Step title="Submit the update">
    Call `update` (or `batch_update`) with new text and optional metadata. Mem0 overwrites the stored value and adjusts indexes.
  </Step>

  <Step title="Verify">
    Check the response or re-run `search` to ensure the revised memory appears with the new content.
  </Step>
</Steps>

## Single memory update (Platform)

<CodeGroup>
  ```python Python theme={null}
  from mem0 import MemoryClient

  client = MemoryClient(api_key="your-api-key")

  memory_id = "your_memory_id"
  client.update(
      memory_id=memory_id,
      text="Updated memory content about the user",
      metadata={"category": "profile-update"}
  )
  ```

  ```javascript JavaScript theme={null}
  import MemoryClient from 'mem0ai';

  const client = new MemoryClient({ apiKey: "your-api-key" });
  const memory_id = "your_memory_id";

  await client.update(memory_id, {
    text: "Updated memory content about the user",
    metadata: { category: "profile-update" }
  });
  ```
</CodeGroup>

<Info icon="check">
  Expect a confirmation message and the updated memory to appear in the dashboard almost instantly.
</Info>

## Batch update (Platform)

Update up to 1000 memories in one call.

<CodeGroup>
  ```python Python theme={null}
  from mem0 import MemoryClient

  client = MemoryClient(api_key="your-api-key")

  update_memories = [
      {"memory_id": "id1", "text": "Watches football"},
      {"memory_id": "id2", "text": "Likes to travel"}
  ]

  response = client.batch_update(update_memories)
  print(response)
  ```

  ```javascript JavaScript theme={null}
  import MemoryClient from 'mem0ai';

  const client = new MemoryClient({ apiKey: "your-api-key" });

  const updateMemories = [
    { memoryId: "id1", text: "Watches football" },
    { memoryId: "id2", text: "Likes to travel" }
  ];

  client.batchUpdate(updateMemories)
    .then(response => console.log('Batch update response:', response))
    .catch(error => console.error(error));
  ```
</CodeGroup>

## Update with Mem0 OSS

<CodeGroup>
  ```python Python theme={null}
  from mem0 import Memory

  memory = Memory()

  memory.update(
      memory_id="mem_123",
      data="Alex now prefers decaf coffee",
  )
  ```

  ```
  ```
</CodeGroup>

<Note>
  OSS JavaScript SDK does not expose `update` yet—use the REST API or Python SDK when self-hosting.
</Note>

## Tips

* Update both `text` **and** `metadata` together to keep filters accurate.
* Batch updates are ideal after large imports or when syncing CRM corrections.
* Immutable memories must be deleted and re-added instead of updated.
* Pair updates with feedback signals (thumbs up/down) to self-heal memories automatically.

## Managed vs OSS differences

| Capability           | Mem0 Platform                               | Mem0 OSS                             |
| -------------------- | ------------------------------------------- | ------------------------------------ |
| Update call          | `client.update(memory_id, {...})`           | `memory.update(memory_id, data=...)` |
| Batch updates        | `client.batch_update` (up to 1000 memories) | Script your own loop or bulk job     |
| Dashboard visibility | Inspect updates in the UI                   | Inspect via logs or custom tooling   |
| Immutable handling   | Returns descriptive error                   | Raises exception—delete and re-add   |

## Put it into practice

* Review the <Link href="/api-reference/memory/update-memory">Update Memory API reference</Link> for request/response details.
* Combine updates with <Link href="/platform/features/feedback-mechanism">Feedback Mechanism</Link> to automate corrections.

## See it live

* <Link href="/cookbooks/operations/support-inbox">Support Inbox with Mem0</Link> uses updates to refine customer profiles.
* <Link href="/cookbooks/companions/ai-tutor">AI Tutor with Mem0</Link> demonstrates user preference corrections mid-course.

<CardGroup cols={2}>
  <Card title="Learn Delete Concepts" description="Understand when to remove memories instead of editing them." icon="trash" href="/core-concepts/memory-operations/delete" />

  <Card title="Automate Corrections" description="See how feedback loops trigger updates in production." icon="rocket" href="/platform/features/feedback-mechanism" />
</CardGroup>


# Memory Types
Source: https://docs.mem0.ai/core-concepts/memory-types

See how Mem0 layers conversation, session, and user memories to keep agents contextual.

# How Mem0 Organizes Memory

Mem0 separates memory into layers so agents remember the right detail at the right time. Think of it like a notebook: a sticky note for the current task, a daily journal for the session, and an archive for everything a user has shared.

<Info>
  **Why it matters**

  * Keeps conversations coherent without repeating instructions.
  * Lets agents personalize responses based on long-term preferences.
  * Avoids over-fetching data by scoping memory to the correct layer.
</Info>

## Key terms

* **Conversation memory** – In-flight messages inside a single turn (what was just said).
* **Session memory** – Short-lived facts that apply for the current task or channel.
* **User memory** – Long-lived knowledge tied to a person, account, or workspace.
* **Organizational memory** – Shared context available to multiple agents or teams.

```mermaid  theme={null}
graph LR
  A[Conversation turn] --> B[Session memory]
  B --> C[User memory]
  C --> D[Org memory]
  C --> E[Mem0 retrieval layer]
```

## Short-term vs long-term memory

Short-term memory keeps the current conversation coherent. It includes:

* **Conversation history** – recent turns in order so the agent remembers what was just said.
* **Working memory** – temporary state such as tool outputs or intermediate calculations.
* **Attention context** – the immediate focus of the assistant, similar to what a person holds in mind mid-sentence.

Long-term memory preserves knowledge across sessions. It captures:

* **Factual memory** – user preferences, account details, and domain facts.
* **Episodic memory** – summaries of past interactions or completed tasks.
* **Semantic memory** – relationships between concepts so agents can reason about them later.

Mem0 maps these classic categories onto its layered storage so you can decide what should fade quickly versus what should last for months.

## How does it work?

Mem0 stores each layer separately and merges them when you query:

1. **Capture** – Messages enter the conversation layer while the turn is active.
2. **Promote** – Relevant details persist to session or user memory based on your `user_id`, `session_id`, and metadata.
3. **Retrieve** – The search pipeline pulls from all layers, ranking user memories first, then session notes, then raw history.

```python  theme={null}
import os

from mem0 import Memory

memory = Memory(api_key=os.environ["MEM0_API_KEY"])

# Sticky note: conversation memory
memory.add(
    ["I'm Alex and I prefer boutique hotels."],
    user_id="alex",
    session_id="trip-planning-2025",
)

# Later in the session, pull long-term + session context
results = memory.search(
    "Any hotel preferences?",
    user_id="alex",
    session_id="trip-planning-2025",
)
```

<Tip>
  Use `session_id` when you want short-term context to expire automatically; rely on `user_id` for lasting personalization.
</Tip>

## When should you use each layer?

* **Conversation memory** – Tool calls or chain-of-thought that only matter within the current turn.
* **Session memory** – Multi-step tasks (onboarding flows, debugging sessions) that should reset once complete.
* **User memory** – Personal preferences, account state, or compliance details that must persist across interactions.
* **Organizational memory** – Shared FAQs, product catalogs, or policies that every agent should recall.

## How it compares

| Layer        | Lifetime            | Short or long term | Best for              | Trade-offs                   |
| ------------ | ------------------- | ------------------ | --------------------- | ---------------------------- |
| Conversation | Single response     | Short-term         | Tool execution detail | Lost after the turn finishes |
| Session      | Minutes to hours    | Short-term         | Multi-step flows      | Clear it manually when done  |
| User         | Weeks to forever    | Long-term          | Personalization       | Requires consent/governance  |
| Org          | Configured globally | Long-term          | Shared knowledge      | Needs owner to keep current  |

<Warning>
  Avoid storing secrets or unredacted PII in user or org memories—Mem0 is retrievable by design. Encrypt or hash sensitive values first.
</Warning>

## Put it into practice

* Use the <Link href="/core-concepts/memory-operations/add">Add Memory</Link> guide to persist user preferences.
* Follow <Link href="/platform/advanced-memory-operations">Advanced Memory Operations</Link> to tune metadata and graph writes.

## See it live

* <Link href="/cookbooks/companions/ai-tutor">AI Tutor with Mem0</Link> shows session vs user memories in action.
* <Link href="/cookbooks/operations/support-inbox">Support Inbox with Mem0</Link> demonstrates shared org memory.

<CardGroup cols={2}>
  <Card title="Explore Memory Operations" description="Dive into the add/search/update/delete concepts next." icon="circle-check" href="/core-concepts/memory-operations/add" />

  <Card title="See a Cookbook" description="Apply layered memories inside a customer support agent." icon="rocket" href="/cookbooks/operations/support-inbox" />
</CardGroup>


# Welcome to Mem0
Source: https://docs.mem0.ai/introduction

Memory layer for AI agents

<div className="px-4 pt-16 pb-12 lg:pt-20 max-w-4xl mx-auto text-center space-y-6">
  <h1 className="text-3xl lg:text-4xl font-bold text-gray-900 dark:text-zinc-50 tracking-tight mb-3">
    Build with <span className="text-primary">mem0</span>
  </h1>

  <p className="max-w-2xl mx-auto text-base text-gray-600 dark:text-zinc-400 leading-relaxed">
    Universal, Self-improving memory layer for LLM applications.
  </p>

  <a href="/platform/quickstart" className="inline-flex items-center gap-1 text-sm text-gray-500 dark:text-zinc-500 hover:text-primary dark:hover:text-primary transition-colors">
    Write your first memory
    <span className="group-hover:translate-x-0.5 transition-transform">→</span>
  </a>
</div>

<section className="px-4 max-w-6xl mx-auto space-y-4">
  <div className="text-center">
    <h2 className="text-xl font-semibold text-gray-900 dark:text-zinc-100">
      Mem0 Products
    </h2>
  </div>

  <div className="grid gap-6 sm:grid-cols-2 lg:grid-cols-3">
    <a href="/platform/overview" className="group flex h-full flex-col overflow-hidden rounded-2xl border border-zinc-800/40 bg-zinc-900/40 transition hover:border-primary/60 hover:bg-zinc-900">
      <img src="https://mintcdn.com/mem0/IgK_-_LC-m9nelcL/images/docs%20thumbnails/Mem0%20Platform.png?fit=max&auto=format&n=IgK_-_LC-m9nelcL&q=85&s=2fb09167a56e99e50fb87dacd3bf2f35" alt="Mem0 Platform thumbnail" className="aspect-[4/3] w-full object-cover" style={{pointerEvents: "none"}} data-og-width="1208" width="1208" data-og-height="604" height="604" data-path="images/docs thumbnails/Mem0 Platform.png" data-optimize="true" data-opv="3" srcset="https://mintcdn.com/mem0/IgK_-_LC-m9nelcL/images/docs%20thumbnails/Mem0%20Platform.png?w=280&fit=max&auto=format&n=IgK_-_LC-m9nelcL&q=85&s=6b5f1d3d84cdb754efe4848babd730ce 280w, https://mintcdn.com/mem0/IgK_-_LC-m9nelcL/images/docs%20thumbnails/Mem0%20Platform.png?w=560&fit=max&auto=format&n=IgK_-_LC-m9nelcL&q=85&s=22fc2164395f07ed8857b106224b2956 560w, https://mintcdn.com/mem0/IgK_-_LC-m9nelcL/images/docs%20thumbnails/Mem0%20Platform.png?w=840&fit=max&auto=format&n=IgK_-_LC-m9nelcL&q=85&s=c5a14ef19af16344ed995966cb5e55bc 840w, https://mintcdn.com/mem0/IgK_-_LC-m9nelcL/images/docs%20thumbnails/Mem0%20Platform.png?w=1100&fit=max&auto=format&n=IgK_-_LC-m9nelcL&q=85&s=2c80e41753f71294bbe58db8fab8c837 1100w, https://mintcdn.com/mem0/IgK_-_LC-m9nelcL/images/docs%20thumbnails/Mem0%20Platform.png?w=1650&fit=max&auto=format&n=IgK_-_LC-m9nelcL&q=85&s=9a60a5e005930407cb8efaea4f66f43c 1650w, https://mintcdn.com/mem0/IgK_-_LC-m9nelcL/images/docs%20thumbnails/Mem0%20Platform.png?w=2500&fit=max&auto=format&n=IgK_-_LC-m9nelcL&q=85&s=1a1e0317d467b1e26bc9fedd00ef4bf4 2500w" />

      <div className="flex flex-1 flex-col gap-3 px-5 pb-6 pt-5 text-left">
        <h3 className="text-base font-semibold text-zinc-100 group-hover:text-primary">
          Mem0 Platform
        </h3>

        <p className="text-sm text-zinc-400">
          Managed memory with production-scale infrastructure, ready in minutes.
        </p>
      </div>
    </a>

    <a href="/open-source/overview" className="group flex h-full flex-col overflow-hidden rounded-2xl border border-zinc-800/40 bg-zinc-900/40 transition hover:border-primary/60 hover:bg-zinc-900">
      <img src="https://mintcdn.com/mem0/IgK_-_LC-m9nelcL/images/docs%20thumbnails/Mem0%20Open%20Source.png?fit=max&auto=format&n=IgK_-_LC-m9nelcL&q=85&s=f2fca50ad337460f88086931d4933e75" alt="Mem0 Open Source thumbnail" className="aspect-[4/3] w-full object-cover" style={{pointerEvents: "none"}} data-og-width="1208" width="1208" data-og-height="604" height="604" data-path="images/docs thumbnails/Mem0 Open Source.png" data-optimize="true" data-opv="3" srcset="https://mintcdn.com/mem0/IgK_-_LC-m9nelcL/images/docs%20thumbnails/Mem0%20Open%20Source.png?w=280&fit=max&auto=format&n=IgK_-_LC-m9nelcL&q=85&s=59d1ea6b1f81189b8850c61ce4907756 280w, https://mintcdn.com/mem0/IgK_-_LC-m9nelcL/images/docs%20thumbnails/Mem0%20Open%20Source.png?w=560&fit=max&auto=format&n=IgK_-_LC-m9nelcL&q=85&s=f7b61f9c358943c7bfaaa68a567199ba 560w, https://mintcdn.com/mem0/IgK_-_LC-m9nelcL/images/docs%20thumbnails/Mem0%20Open%20Source.png?w=840&fit=max&auto=format&n=IgK_-_LC-m9nelcL&q=85&s=a31c3af97e5b7f75963e18c54376b991 840w, https://mintcdn.com/mem0/IgK_-_LC-m9nelcL/images/docs%20thumbnails/Mem0%20Open%20Source.png?w=1100&fit=max&auto=format&n=IgK_-_LC-m9nelcL&q=85&s=22972014040b3168cf538e2b82ca80cf 1100w, https://mintcdn.com/mem0/IgK_-_LC-m9nelcL/images/docs%20thumbnails/Mem0%20Open%20Source.png?w=1650&fit=max&auto=format&n=IgK_-_LC-m9nelcL&q=85&s=b1b0499d968678f2c3f2452c02c5c3ff 1650w, https://mintcdn.com/mem0/IgK_-_LC-m9nelcL/images/docs%20thumbnails/Mem0%20Open%20Source.png?w=2500&fit=max&auto=format&n=IgK_-_LC-m9nelcL&q=85&s=aeae6e602dd74e84d37475f51e6c830c 2500w" />

      <div className="flex flex-1 flex-col gap-3 px-5 pb-6 pt-5 text-left">
        <h3 className="text-base font-semibold text-zinc-100 group-hover:text-primary">
          Mem0 Open Source
        </h3>

        <p className="text-sm text-zinc-400">
          Self-host the Mem0 stack for full control over data, deployment, and customization.
        </p>
      </div>
    </a>

    <a href="/openmemory/overview" className="group flex h-full flex-col overflow-hidden rounded-2xl border border-zinc-800/40 bg-zinc-900/40 transition hover:border-primary/60 hover:bg-zinc-900">
      <img src="https://mintcdn.com/mem0/IgK_-_LC-m9nelcL/images/docs%20thumbnails/Mem0%20OpenMemory.png?fit=max&auto=format&n=IgK_-_LC-m9nelcL&q=85&s=0195beb19ad6ae0ada957620b9fb75a3" alt="OpenMemory thumbnail" className="aspect-[4/3] w-full object-cover" style={{pointerEvents: "none"}} data-og-width="1208" width="1208" data-og-height="604" height="604" data-path="images/docs thumbnails/Mem0 OpenMemory.png" data-optimize="true" data-opv="3" srcset="https://mintcdn.com/mem0/IgK_-_LC-m9nelcL/images/docs%20thumbnails/Mem0%20OpenMemory.png?w=280&fit=max&auto=format&n=IgK_-_LC-m9nelcL&q=85&s=788dcee4df3928104dc6a15a5cd1705d 280w, https://mintcdn.com/mem0/IgK_-_LC-m9nelcL/images/docs%20thumbnails/Mem0%20OpenMemory.png?w=560&fit=max&auto=format&n=IgK_-_LC-m9nelcL&q=85&s=184efda16c22bfa7a111ab4ab6e21b76 560w, https://mintcdn.com/mem0/IgK_-_LC-m9nelcL/images/docs%20thumbnails/Mem0%20OpenMemory.png?w=840&fit=max&auto=format&n=IgK_-_LC-m9nelcL&q=85&s=84a00265791c0077001a0b8a6c22e545 840w, https://mintcdn.com/mem0/IgK_-_LC-m9nelcL/images/docs%20thumbnails/Mem0%20OpenMemory.png?w=1100&fit=max&auto=format&n=IgK_-_LC-m9nelcL&q=85&s=a64d6a2a2579d9f79b4ed88bc9052f55 1100w, https://mintcdn.com/mem0/IgK_-_LC-m9nelcL/images/docs%20thumbnails/Mem0%20OpenMemory.png?w=1650&fit=max&auto=format&n=IgK_-_LC-m9nelcL&q=85&s=13a337725e0819d88f49a127bee61aa3 1650w, https://mintcdn.com/mem0/IgK_-_LC-m9nelcL/images/docs%20thumbnails/Mem0%20OpenMemory.png?w=2500&fit=max&auto=format&n=IgK_-_LC-m9nelcL&q=85&s=505a099209f77e0b5dbd362d1e298571 2500w" />

      <div className="flex flex-1 flex-col gap-3 px-5 pb-6 pt-5 text-left">
        <h3 className="text-base font-semibold text-zinc-100 group-hover:text-primary">
          OpenMemory
        </h3>

        <p className="text-sm text-zinc-400">
          Workspace-based memory for teams collaborating across agents and projects.
        </p>
      </div>
    </a>
  </div>
</section>

<section className="px-4 pt-12 pb-20 max-w-6xl mx-auto space-y-4">
  <div className="text-center">
    <h2 className="text-xl font-semibold text-gray-900 dark:text-zinc-100">
      Developer Resources
    </h2>
  </div>

  <div className="grid gap-6 sm:grid-cols-2 lg:grid-cols-3">
    <a href="/cookbooks/overview" className="group flex h-full flex-col overflow-hidden rounded-2xl border border-zinc-800/40 bg-zinc-900/40 transition hover:border-primary/60 hover:bg-zinc-900">
      <img src="https://mintcdn.com/mem0/IgK_-_LC-m9nelcL/images/docs%20thumbnails/Cookbooks.png?fit=max&auto=format&n=IgK_-_LC-m9nelcL&q=85&s=a8b37c1d14bc59af7fcb8f9fc31a5fd0" alt="Cookbooks thumbnail" className="aspect-[4/3] w-full object-cover" style={{pointerEvents: "none"}} data-og-width="1208" width="1208" data-og-height="604" height="604" data-path="images/docs thumbnails/Cookbooks.png" data-optimize="true" data-opv="3" srcset="https://mintcdn.com/mem0/IgK_-_LC-m9nelcL/images/docs%20thumbnails/Cookbooks.png?w=280&fit=max&auto=format&n=IgK_-_LC-m9nelcL&q=85&s=c276229de6233816095281361ef308e5 280w, https://mintcdn.com/mem0/IgK_-_LC-m9nelcL/images/docs%20thumbnails/Cookbooks.png?w=560&fit=max&auto=format&n=IgK_-_LC-m9nelcL&q=85&s=85a3a49516ecf8c0e596fa661368a872 560w, https://mintcdn.com/mem0/IgK_-_LC-m9nelcL/images/docs%20thumbnails/Cookbooks.png?w=840&fit=max&auto=format&n=IgK_-_LC-m9nelcL&q=85&s=83a048b50bfe745edd893049aec32a9b 840w, https://mintcdn.com/mem0/IgK_-_LC-m9nelcL/images/docs%20thumbnails/Cookbooks.png?w=1100&fit=max&auto=format&n=IgK_-_LC-m9nelcL&q=85&s=da55fd584e6d66a636bad6c48871ad13 1100w, https://mintcdn.com/mem0/IgK_-_LC-m9nelcL/images/docs%20thumbnails/Cookbooks.png?w=1650&fit=max&auto=format&n=IgK_-_LC-m9nelcL&q=85&s=ca192c22c66bb3866f45832482ed6194 1650w, https://mintcdn.com/mem0/IgK_-_LC-m9nelcL/images/docs%20thumbnails/Cookbooks.png?w=2500&fit=max&auto=format&n=IgK_-_LC-m9nelcL&q=85&s=bd3b83e12ef995022f76a55b819fddf8 2500w" />

      <div className="flex flex-1 flex-col gap-3 px-5 pb-6 pt-5 text-left">
        <h3 className="text-base font-semibold text-zinc-100 group-hover:text-primary">
          Cookbooks
        </h3>

        <p className="text-sm text-zinc-400">
          Production-ready tutorials that show how to ship memorable AI experiences.
        </p>
      </div>
    </a>

    <a href="/integrations" className="group flex h-full flex-col overflow-hidden rounded-2xl border border-zinc-800/40 bg-zinc-900/40 transition hover:border-primary/60 hover:bg-zinc-900">
      <img src="https://mintcdn.com/mem0/IgK_-_LC-m9nelcL/images/docs%20thumbnails/Integrations.png?fit=max&auto=format&n=IgK_-_LC-m9nelcL&q=85&s=9e7fb7f9b6dc7fe147d023792326ad43" alt="Integrations thumbnail" className="aspect-[4/3] w-full object-cover" style={{pointerEvents: "none"}} data-og-width="1208" width="1208" data-og-height="604" height="604" data-path="images/docs thumbnails/Integrations.png" data-optimize="true" data-opv="3" srcset="https://mintcdn.com/mem0/IgK_-_LC-m9nelcL/images/docs%20thumbnails/Integrations.png?w=280&fit=max&auto=format&n=IgK_-_LC-m9nelcL&q=85&s=9d140dceb102c6f1ad8b47268e0a2f74 280w, https://mintcdn.com/mem0/IgK_-_LC-m9nelcL/images/docs%20thumbnails/Integrations.png?w=560&fit=max&auto=format&n=IgK_-_LC-m9nelcL&q=85&s=f627daabde495c0b6940be7760218f7f 560w, https://mintcdn.com/mem0/IgK_-_LC-m9nelcL/images/docs%20thumbnails/Integrations.png?w=840&fit=max&auto=format&n=IgK_-_LC-m9nelcL&q=85&s=687a3ceaac750918159ade2a7dc89f11 840w, https://mintcdn.com/mem0/IgK_-_LC-m9nelcL/images/docs%20thumbnails/Integrations.png?w=1100&fit=max&auto=format&n=IgK_-_LC-m9nelcL&q=85&s=c640899131c9a2f4d0d7e921a6b26c17 1100w, https://mintcdn.com/mem0/IgK_-_LC-m9nelcL/images/docs%20thumbnails/Integrations.png?w=1650&fit=max&auto=format&n=IgK_-_LC-m9nelcL&q=85&s=4960a9a6c659cd3580139724cf9916f8 1650w, https://mintcdn.com/mem0/IgK_-_LC-m9nelcL/images/docs%20thumbnails/Integrations.png?w=2500&fit=max&auto=format&n=IgK_-_LC-m9nelcL&q=85&s=dfab433cb24092eab7f458381a2f7191 2500w" />

      <div className="flex flex-1 flex-col gap-3 px-5 pb-6 pt-5 text-left">
        <h3 className="text-base font-semibold text-zinc-100 group-hover:text-primary">
          Integrations
        </h3>

        <p className="text-sm text-zinc-400">
          Connect Mem0 to LangChain, CrewAI, Vercel AI SDK, and 20+ partner frameworks.
        </p>
      </div>
    </a>

    <a href="/api-reference" className="group flex h-full flex-col overflow-hidden rounded-2xl border border-zinc-800/40 bg-zinc-900/40 transition hover:border-primary/60 hover:bg-zinc-900">
      <img src="https://mintcdn.com/mem0/IgK_-_LC-m9nelcL/images/docs%20thumbnails/API.png?fit=max&auto=format&n=IgK_-_LC-m9nelcL&q=85&s=ea2804e8f433680aa451ecf67e03ef62" alt="API reference thumbnail" className="aspect-[4/3] w-full object-cover" style={{pointerEvents: "none"}} data-og-width="1208" width="1208" data-og-height="604" height="604" data-path="images/docs thumbnails/API.png" data-optimize="true" data-opv="3" srcset="https://mintcdn.com/mem0/IgK_-_LC-m9nelcL/images/docs%20thumbnails/API.png?w=280&fit=max&auto=format&n=IgK_-_LC-m9nelcL&q=85&s=bedbfd23e050704ce14053ab95cdc67e 280w, https://mintcdn.com/mem0/IgK_-_LC-m9nelcL/images/docs%20thumbnails/API.png?w=560&fit=max&auto=format&n=IgK_-_LC-m9nelcL&q=85&s=c07ef71d1c5058740b3b20fae0e5ee7d 560w, https://mintcdn.com/mem0/IgK_-_LC-m9nelcL/images/docs%20thumbnails/API.png?w=840&fit=max&auto=format&n=IgK_-_LC-m9nelcL&q=85&s=ac2f2674e1a32063f89109a11ff503a5 840w, https://mintcdn.com/mem0/IgK_-_LC-m9nelcL/images/docs%20thumbnails/API.png?w=1100&fit=max&auto=format&n=IgK_-_LC-m9nelcL&q=85&s=71a195bc67812762198a124aa4e2eed0 1100w, https://mintcdn.com/mem0/IgK_-_LC-m9nelcL/images/docs%20thumbnails/API.png?w=1650&fit=max&auto=format&n=IgK_-_LC-m9nelcL&q=85&s=37d3d344316a1200c02b2e24e3ab0cf4 1650w, https://mintcdn.com/mem0/IgK_-_LC-m9nelcL/images/docs%20thumbnails/API.png?w=2500&fit=max&auto=format&n=IgK_-_LC-m9nelcL&q=85&s=494fb835fd3912375fa2ca1d78c235af 2500w" />

      <div className="flex flex-1 flex-col gap-3 px-5 pb-6 pt-5 text-left">
        <h3 className="text-base font-semibold text-zinc-100 group-hover:text-primary">
          API reference
        </h3>

        <p className="text-sm text-zinc-400">
          Explore every REST endpoint with payload examples and usage guidance.
        </p>
      </div>
    </a>
  </div>
</section>


# API Reference Changes
Source: https://docs.mem0.ai/migration/api-changes

Complete API changes between v0.x and v1.0.0 Beta

## Overview

This page documents all API changes between Mem0 v0.x and v1.0.0 Beta, organized by component and method.

## Memory Class Changes

### Constructor

#### v0.x

```python  theme={null}
from mem0 import Memory

# Basic initialization
m = Memory()

# With configuration
config = {
    "version": "v1.0",  # Supported in v0.x
    "vector_store": {...}
}
m = Memory.from_config(config)
```

#### v1.0.0

```python  theme={null}
from mem0 import Memory

# Basic initialization (same)
m = Memory()

# With configuration
config = {
    "version": "v1.1",  # v1.1+ only
    "vector_store": {...},
    # New optional features
    "reranker": {
        "provider": "cohere",
        "config": {...}
    }
}
m = Memory.from_config(config)
```

### add() Method

#### v0.x Signature

```python  theme={null}
def add(
    self,
    messages,
    user_id: str = None,
    agent_id: str = None,
    run_id: str = None,
    metadata: dict = None,
    filters: dict = None,
    output_format: str = None,  # ❌ REMOVED
    version: str = None         # ❌ REMOVED
) -> Union[List[dict], dict]
```

#### v1.0.0  Signature

```python  theme={null}
def add(
    self,
    messages,
    user_id: str = None,
    agent_id: str = None,
    run_id: str = None,
    metadata: dict = None,
    filters: dict = None,
    infer: bool = True          # ✅ NEW: Control memory inference
) -> dict  # Always returns dict with "results" key
```

#### Changes Summary

| Parameter       | v0.x | v1.0.0 | Change      |
| --------------- | ---- | ------ | ----------- |
| `messages`      | ✅    | ✅      | Unchanged   |
| `user_id`       | ✅    | ✅      | Unchanged   |
| `agent_id`      | ✅    | ✅      | Unchanged   |
| `run_id`        | ✅    | ✅      | Unchanged   |
| `metadata`      | ✅    | ✅      | Unchanged   |
| `filters`       | ✅    | ✅      | Unchanged   |
| `output_format` | ✅    | ❌      | **REMOVED** |
| `version`       | ✅    | ❌      | **REMOVED** |
| `infer`         | ❌    | ✅      | **NEW**     |

#### Response Format Changes

**v0.x Response (variable format):**

```python  theme={null}
# With output_format="v1.0"
[
    {
        "id": "mem_123",
        "memory": "User loves pizza",
        "event": "ADD"
    }
]

# With output_format="v1.1"
{
    "results": [
        {
            "id": "mem_123",
            "memory": "User loves pizza",
            "event": "ADD"
        }
    ]
}
```

**v1.0.0  Response (standardized):**

```python  theme={null}
# Always returns this format
{
    "results": [
        {
            "id": "mem_123",
            "memory": "User loves pizza",
            "metadata": {...},
            "event": "ADD"
        }
    ]
}
```

### search() Method

#### v0.x Signature

```python  theme={null}
def search(
    self,
    query: str,
    user_id: str = None,
    agent_id: str = None,
    run_id: str = None,
    limit: int = 100,
    filters: dict = None,       # Basic key-value only
    output_format: str = None,  # ❌ REMOVED
    version: str = None         # ❌ REMOVED
) -> Union[List[dict], dict]
```

#### v1.0.0  Signature

```python  theme={null}
def search(
    self,
    query: str,
    user_id: str = None,
    agent_id: str = None,
    run_id: str = None,
    limit: int = 100,
    filters: dict = None,       # ✅ ENHANCED: Advanced operators
    rerank: bool = True         # ✅ NEW: Reranking support
) -> dict  # Always returns dict with "results" key
```

#### Enhanced Filtering

**v0.x Filters (basic):**

```python  theme={null}
# Simple key-value filtering only
filters = {
    "category": "food",
    "user_id": "alice"
}
```

**v1.0.0  Filters (enhanced):**

```python  theme={null}
# Advanced filtering with operators
filters = {
    "AND": [
        {"category": "food"},
        {"score": {"gte": 0.8}},
        {
            "OR": [
                {"priority": "high"},
                {"urgent": True}
            ]
        }
    ]
}

# Comparison operators
filters = {
    "score": {"gt": 0.5},      # Greater than
    "priority": {"gte": 5},     # Greater than or equal
    "rating": {"lt": 3},        # Less than
    "confidence": {"lte": 0.9}, # Less than or equal
    "status": {"eq": "active"}, # Equal
    "archived": {"ne": True},   # Not equal
    "tags": {"in": ["work", "personal"]},     # In list
    "category": {"nin": ["spam", "deleted"]}  # Not in list
}
```

### get\_all() Method

#### v0.x Signature

```python  theme={null}
def get_all(
    self,
    user_id: str = None,
    agent_id: str = None,
    run_id: str = None,
    filters: dict = None,
    output_format: str = None,  # ❌ REMOVED
    version: str = None         # ❌ REMOVED
) -> Union[List[dict], dict]
```

#### v1.0.0  Signature

```python  theme={null}
def get_all(
    self,
    user_id: str = None,
    agent_id: str = None,
    run_id: str = None,
    filters: dict = None        # ✅ ENHANCED: Advanced operators
) -> dict  # Always returns dict with "results" key
```

### update() Method

#### No Breaking Changes

```python  theme={null}
# Same signature in both versions
def update(
    self,
    memory_id: str,
    data: str
) -> dict
```

### delete() Method

#### No Breaking Changes

```python  theme={null}
# Same signature in both versions
def delete(
    self,
    memory_id: str
) -> dict
```

### delete\_all() Method

#### No Breaking Changes

```python  theme={null}
# Same signature in both versions
def delete_all(
    self,
    user_id: str
) -> dict
```

## Platform Client (MemoryClient) Changes

### async\_mode Default Changed

#### v0.x

```python  theme={null}
from mem0 import MemoryClient

client = MemoryClient(api_key="your-key")

# async_mode had to be explicitly set or had different default
result = client.add("content", user_id="alice", async_mode=True)
```

#### v1.0.0

```python  theme={null}
from mem0 import MemoryClient

client = MemoryClient(api_key="your-key")

# async_mode defaults to True now (better performance)
result = client.add("content", user_id="alice")  # Uses async_mode=True by default

# Can still override if needed
result = client.add("content", user_id="alice", async_mode=False)
```

## Configuration Changes

### Memory Configuration

#### v0.x Config Options

```python  theme={null}
config = {
    "vector_store": {...},
    "llm": {...},
    "embedder": {...},
    "graph_store": {...},
    "version": "v1.0",              # ❌ v1.0 no longer supported
    "history_db_path": "...",
    "custom_fact_extraction_prompt": "..."
}
```

#### v1.0.0  Config Options

```python  theme={null}
config = {
    "vector_store": {...},
    "llm": {...},
    "embedder": {...},
    "graph_store": {...},
    "reranker": {                   # ✅ NEW: Reranker support
        "provider": "cohere",
        "config": {...}
    },
    "version": "v1.1",              # ✅ v1.1+ only
    "history_db_path": "...",
    "custom_fact_extraction_prompt": "...",
    "custom_update_memory_prompt": "..."  # ✅ NEW: Custom update prompt
}
```

### New Configuration Options

#### Reranker Configuration

```python  theme={null}
# Cohere reranker
"reranker": {
    "provider": "cohere",
    "config": {
        "model": "rerank-english-v3.0",
        "api_key": "your-api-key",
        "top_k": 10
    }
}

# Sentence Transformer reranker
"reranker": {
    "provider": "sentence_transformer",
    "config": {
        "model": "cross-encoder/ms-marco-MiniLM-L-6-v2",
        "device": "cuda"
    }
}

# Hugging Face reranker
"reranker": {
    "provider": "huggingface",
    "config": {
        "model": "BAAI/bge-reranker-base",
        "device": "cuda"
    }
}

# LLM-based reranker
"reranker": {
    "provider": "llm_reranker",
    "config": {
        "llm": {
            "provider": "openai",
            "config": {
                "model": "gpt-4",
                "api_key": "your-api-key"
            }
        }
    }
}
```

## Error Handling Changes

### New Error Types

#### v0.x Errors

```python  theme={null}
# Generic exceptions
try:
    result = m.add("content", user_id="alice", version="v1.0")
except Exception as e:
    print(f"Error: {e}")
```

#### v1.0.0  Errors

```python  theme={null}
# More specific error handling
try:
    result = m.add("content", user_id="alice")
except ValueError as e:
    if "v1.0 API format is no longer supported" in str(e):
        # Handle version compatibility error
        pass
    elif "Invalid filter operator" in str(e):
        # Handle filter syntax error
        pass
except TypeError as e:
    # Handle parameter errors
    pass
except Exception as e:
    # Handle unexpected errors
    pass
```

### Validation Changes

#### Stricter Parameter Validation

**v0.x (Lenient):**

```python  theme={null}
# Unknown parameters might be ignored
result = m.add("content", user_id="alice", unknown_param="value")
```

**v1.0.0  (Strict):**

```python  theme={null}
# Unknown parameters raise TypeError
try:
    result = m.add("content", user_id="alice", unknown_param="value")
except TypeError as e:
    print(f"Invalid parameter: {e}")
```

## Response Schema Changes

### Memory Object Schema

#### v0.x Schema

```python  theme={null}
{
    "id": "mem_123",
    "memory": "User loves pizza",
    "user_id": "alice",
    "metadata": {...},
    "created_at": "2024-01-01T00:00:00Z",
    "updated_at": "2024-01-01T00:00:00Z",
    "score": 0.95  # In search results
}
```

#### v1.0.0  Schema (Enhanced)

```python  theme={null}
{
    "id": "mem_123",
    "memory": "User loves pizza",
    "user_id": "alice",
    "agent_id": "assistant",     # ✅ More context
    "run_id": "session_001",     # ✅ More context
    "metadata": {...},
    "categories": ["food"],      # ✅ NEW: Auto-categorization
    "immutable": false,          # ✅ NEW: Immutability flag
    "created_at": "2024-01-01T00:00:00Z",
    "updated_at": "2024-01-01T00:00:00Z",
    "score": 0.95,              # In search results
    "rerank_score": 0.98        # ✅ NEW: If reranking used
}
```

## Migration Code Examples

### Simple Migration

#### Before (v0.x)

```python  theme={null}
from mem0 import Memory

m = Memory()

# Add with deprecated parameters
result = m.add(
    "I love pizza",
    user_id="alice",
    output_format="v1.1",
    version="v1.0"
)

# Handle variable response format
if isinstance(result, list):
    memories = result
else:
    memories = result.get("results", [])

for memory in memories:
    print(memory["memory"])
```

#### After (v1.0.0 )

```python  theme={null}
from mem0 import Memory

m = Memory()

# Add without deprecated parameters
result = m.add(
    "I love pizza",
    user_id="alice"
)

# Always dict format with "results" key
for memory in result["results"]:
    print(memory["memory"])
```

### Advanced Migration

#### Before (v0.x)

```python  theme={null}
# Basic filtering
results = m.search(
    "food preferences",
    user_id="alice",
    filters={"category": "food"},
    output_format="v1.1"
)
```

#### After (v1.0.0 )

```python  theme={null}
# Enhanced filtering with reranking
results = m.search(
    "food preferences",
    user_id="alice",
    filters={
        "AND": [
            {"category": "food"},
            {"score": {"gte": 0.8}}
        ]
    },
    rerank=True
)
```

## Summary

| Component          | v0.x              | v1.0.0                         | Status        |
| ------------------ | ----------------- | ------------------------------ | ------------- |
| `add()` method     | Variable response | Standardized response          | ⚠️ Breaking   |
| `search()` method  | Basic filtering   | Enhanced filtering + reranking | ⚠️ Breaking   |
| `get_all()` method | Variable response | Standardized response          | ⚠️ Breaking   |
| Response format    | Variable          | Always `{"results": [...]}`    | ⚠️ Breaking   |
| Reranking          | ❌ Not available   | ✅ Full support                 | ✅ New feature |
| Advanced filtering | ❌ Basic only      | ✅ Full operators               | ✅ Enhancement |
| Error handling     | Generic           | Specific error types           | ✅ Improvement |

<Info>
  Use this reference to systematically update your codebase. Test each change thoroughly before deploying to production.
</Info>


# Breaking Changes in v1.0.0
Source: https://docs.mem0.ai/migration/breaking-changes

Complete list of breaking changes when upgrading from v0.x to v1.0.0 

<Warning>
  **Important:** This page lists all breaking changes. Please review carefully before upgrading.
</Warning>

## API Version Changes

### Removed v1.0 API Support

**Breaking Change:** The v1.0 API format is completely removed and no longer supported.

#### Before (v0.x)

```python  theme={null}
# This was supported in v0.x
config = {
    "version": "v1.0"  # ❌ No longer supported
}

result = m.add(
    "memory content",
    user_id="alice"
)
```

#### After (v1.0.0 )

```python  theme={null}
# v1.1 is the minimum supported version
config = {
    "version": "v1.1"  # ✅ Required minimum
}

result = m.add(
    "memory content",
    user_id="alice"
)
```

**Error Message:**

```
ValueError: The v1.0 API format is no longer supported in mem0ai 1.0.0+.
Please use v1.1 format which returns a dict with 'results' key.
```

## Parameter Removals

### 1. version Parameter in Method Calls

**Breaking Change:** Version parameter removed from method calls.

#### Before (v0.x)

```python  theme={null}
result = m.add("content", user_id="alice", version="v1.0")
```

#### After (v1.0.0 )

```python  theme={null}
result = m.add("content", user_id="alice")
```

### 2. async\_mode Parameter (Platform Client)

**Change:** For `MemoryClient` (Platform API), `async_mode` now defaults to `True` but can still be configured.

#### Before (v0.x)

```python  theme={null}
from mem0 import MemoryClient

client = MemoryClient(api_key="your-key")
result = client.add("content", user_id="alice", async_mode=True)
result = client.add("content", user_id="alice", async_mode=False)
```

#### After (v1.0.0 )

```python  theme={null}
from mem0 import MemoryClient

client = MemoryClient(api_key="your-key")

# async_mode now defaults to True, but you can still override it
result = client.add("content", user_id="alice")  # Uses async_mode=True by default

# You can still explicitly set it to False if needed
result = client.add("content", user_id="alice", async_mode=False)
```

## Response Format Changes

### Standardized Response Structure

**Breaking Change:** All responses now return a standardized dictionary format.

#### Before (v0.x)

```python  theme={null}
# Could return different formats based on version configuration
result = m.add("content", user_id="alice")
# With v1.0: Returns [{"id": "...", "memory": "...", "event": "ADD"}]
# With v1.1: Returns {"results": [{"id": "...", "memory": "...", "event": "ADD"}]}
```

#### After (v1.0.0 )

```python  theme={null}
# Always returns standardized format
result = m.add("content", user_id="alice")
# Always returns: {"results": [{"id": "...", "memory": "...", "event": "ADD"}]}

# Access results consistently
for memory in result["results"]:
    print(memory["memory"])
```

## Configuration Changes

### Version Configuration

**Breaking Change:** Default API version changed.

#### Before (v0.x)

```python  theme={null}
# v1.0 was supported
config = {
    "version": "v1.0"  # ❌ No longer supported
}
```

#### After (v1.0.0 )

```python  theme={null}
# v1.1 is minimum, v1.1 is default
config = {
    "version": "v1.1"  # ✅ Minimum supported
}

# Or omit for default
config = {
    # version defaults to v1.1
}
```

### Memory Configuration

**Breaking Change:** Some configuration options have changed defaults.

#### Before (v0.x)

```python  theme={null}
from mem0 import Memory

# Default configuration in v0.x
m = Memory()  # Used default settings suitable for v0.x
```

#### After (v1.0.0 )

```python  theme={null}
from mem0 import Memory

# Default configuration optimized for v1.0.0 
m = Memory()  # Uses v1.1+ optimized defaults

# Explicit configuration recommended
config = {
    "version": "v1.1",
    "vector_store": {
        "provider": "qdrant",
        "config": {
            "host": "localhost",
            "port": 6333
        }
    }
}
m = Memory.from_config(config)
```

## Method Signature Changes

### Search Method

**Enhanced but backward compatible:**

#### Before (v0.x)

```python  theme={null}
results = m.search(
    "query",
    user_id="alice",
    filters={"key": "value"}  # Simple key-value only
)
```

#### After (v1.0.0 )

```python  theme={null}
# Basic usage remains the same
results = m.search("query", user_id="alice")

# Enhanced filtering available (optional)
results = m.search(
    "query",
    user_id="alice",
    filters={
        "AND": [
            {"key": "value"},
            {"score": {"gte": 0.8}}
        ]
    },
    rerank=True  # New parameter
)
```

## Error Handling Changes

### New Error Types

**Breaking Change:** More specific error types and messages.

#### Before (v0.x)

```python  theme={null}
try:
    result = m.add("content", user_id="alice", version="v1.0")
except Exception as e:
    print(f"Generic error: {e}")
```

#### After (v1.0.0 )

```python  theme={null}
try:
    result = m.add("content", user_id="alice")
except ValueError as e:
    if "v1.0 API format is no longer supported" in str(e):
        # Handle version error specifically
        print("Please upgrade your code to use v1.1+ format")
    else:
        print(f"Value error: {e}")
except Exception as e:
    print(f"Unexpected error: {e}")
```

### Validation Changes

**Breaking Change:** Stricter parameter validation.

#### Before (v0.x)

```python  theme={null}
# Some invalid parameters might have been ignored
result = m.add(
    "content",
    user_id="alice",
    invalid_param="ignored"  # Might have been silently ignored
)
```

#### After (v1.0.0 )

```python  theme={null}
# Strict validation - unknown parameters cause errors
try:
    result = m.add(
        "content",
        user_id="alice",
        invalid_param="value"  # ❌ Will raise TypeError
    )
except TypeError as e:
    print(f"Invalid parameter: {e}")
```

## Import Changes

### No Breaking Changes in Imports

**Good News:** Import statements remain the same.

```python  theme={null}
# These imports work in both v0.x and v1.0.0 
from mem0 import Memory, AsyncMemory
from mem0 import MemoryConfig
```

## Dependency Changes

### Minimum Python Version

**Potential Breaking Change:** Check Python version requirements.

#### Before (v0.x)

* Python 3.8+ supported

#### After (v1.0.0 )

* Python 3.9+ required (check current requirements)

### Package Dependencies

**Breaking Change:** Some dependencies updated with potential breaking changes.

```bash  theme={null}
# Check for conflicts after upgrade
pip install --upgrade mem0ai
pip check  # Verify no dependency conflicts
```

## Data Migration

### Database Schema

**Good News:** No database schema changes required.

* Existing memories remain compatible
* No data migration required
* Vector store data unchanged

### Memory Format

**Good News:** Memory storage format unchanged.

* Existing memories work with v1.0.0
* Search continues to work with old memories
* No re-indexing required

## Testing Changes

### Test Updates Required

**Breaking Change:** Update tests for new response format.

#### Before (v0.x)

```python  theme={null}
def test_add_memory():
    result = m.add("content", user_id="alice")
    assert isinstance(result, list)  # ❌ No longer true
    assert len(result) > 0
```

#### After (v1.0.0 )

```python  theme={null}
def test_add_memory():
    result = m.add("content", user_id="alice")
    assert isinstance(result, dict)  # ✅ Always dict
    assert "results" in result       # ✅ Always has results key
    assert len(result["results"]) > 0
```

## Rollback Considerations

### Safe Rollback Process

If you need to rollback:

```bash  theme={null}
# 1. Rollback package
pip install mem0ai==0.1.20  # Last stable v0.x

# 2. Revert code changes
git checkout previous_commit

# 3. Test functionality
python test_mem0_functionality.py
```

### Data Safety

* **Safe:** Memories stored in v0.x format work with v1.0.0
* **Safe:** Rollback doesn't lose data
* **Safe:** Vector store data remains intact

## Next Steps

1. **Review all breaking changes** in your codebase
2. **Update method calls** to remove deprecated parameters
3. **Update response handling** to use standardized format
4. **Test thoroughly** with your existing data
5. **Update error handling** for new error types

<CardGroup cols={2}>
  <Card title="Migration Guide" icon="arrow-right" href="/migration/v0-to-v1">
    Step-by-step migration instructions
  </Card>

  <Card title="API Changes" icon="code" href="/migration/api-changes">
    Complete API reference changes
  </Card>
</CardGroup>

<Warning>
  **Need Help?** If you encounter issues during migration, check our [GitHub Discussions](https://github.com/mem0ai/mem0/discussions) or community support channels.
</Warning>


# Migrating from v0.x to v1.0.0
Source: https://docs.mem0.ai/migration/v0-to-v1

Complete guide to upgrade your Mem0 implementation to version 1.0.0 

<Warning>
  **Breaking Changes Ahead!** Mem0 1.0.0  introduces several breaking changes. Please read this guide carefully before upgrading.
</Warning>

## Overview

Mem0 1.0.0  is a major release that modernizes the API, improves performance, and adds powerful new features. This guide will help you migrate your existing v0.x implementation to the new version.

## Key Changes Summary

| Feature                      | v0.x            | v1.0.0                           | Migration Required |
| ---------------------------- | --------------- | -------------------------------- | ------------------ |
| API Version                  | v1.0 supported  | v1.0 **removed**, v1.1+ only     | ✅ Yes              |
| Async Mode (Platform Client) | Optional/manual | Defaults to `True`, configurable | ⚠️ Partial         |
| Metadata Filtering           | Basic           | Enhanced with operators          | ⚠️ Optional        |
| Reranking                    | Not available   | Full support                     | ⚠️ Optional        |

## Step-by-Step Migration

### 1. Update Installation

```bash  theme={null}
# Update to the latest version
pip install --upgrade mem0ai
```

### 2. Remove Deprecated Parameters

#### Before (v0.x)

```python  theme={null}
from mem0 import Memory

# These parameters are no longer supported
m = Memory()
result = m.add(
    "I love pizza",
    user_id="alice",
    version="v1.0"         # ❌ REMOVED
)
```

#### After (v1.0.0 )

```python  theme={null}
from mem0 import Memory

# Clean, simplified API
m = Memory()
result = m.add(
    "I love pizza",
    user_id="alice"
    # version parameter removed
)
```

### 3. Update Configuration

#### Before (v0.x)

```python  theme={null}
config = {
    "vector_store": {
        "provider": "qdrant",
        "config": {
            "host": "localhost",
            "port": 6333
        }
    },
    "version": "v1.0"  # ❌ No longer supported
}

m = Memory.from_config(config)
```

#### After (v1.0.0 )

```python  theme={null}
config = {
    "vector_store": {
        "provider": "qdrant",
        "config": {
            "host": "localhost",
            "port": 6333
        }
    },
    "version": "v1.1"  # ✅ v1.1 is the minimum supported version
}

m = Memory.from_config(config)
```

### 4. Handle Response Format Changes

#### Before (v0.x)

```python  theme={null}
# Response could be a list or dict depending on version
result = m.add("I love coffee", user_id="alice")

if isinstance(result, list):
    # Handle list format
    for item in result:
        print(item["memory"])
else:
    # Handle dict format
    print(result["results"])
```

#### After (v1.0.0 )

```python  theme={null}
# Response is always a standardized dict with "results" key
result = m.add("I love coffee", user_id="alice")

# Always access via "results" key
for item in result["results"]:
    print(item["memory"])
```

### 5. Update Search Operations

#### Before (v0.x)

```python  theme={null}
# Basic search
results = m.search("What do I like?", user_id="alice")

# With filters
results = m.search(
    "What do I like?",
    user_id="alice",
    filters={"category": "food"}
)
```

#### After (v1.0.0 )

```python  theme={null}
# Same basic search API
results = m.search("What do I like?", user_id="alice")

# Enhanced filtering with operators (optional upgrade)
results = m.search(
    "What do I like?",
    user_id="alice",
    filters={
        "AND": [
            {"category": "food"},
            {"rating": {"gte": 8}}
        ]
    }
)

# New: Reranking support (optional)
results = m.search(
    "What do I like?",
    user_id="alice",
    rerank=True  # Requires reranker configuration
)
```

### 6. Platform Client async\_mode Default Changed

**Change:** For `MemoryClient`, the `async_mode` parameter now defaults to `True` for better performance.

#### Before (v0.x)

```python  theme={null}
from mem0 import MemoryClient

client = MemoryClient(api_key="your-key")

# Had to explicitly set async_mode
result = client.add("I enjoy hiking", user_id="alice", async_mode=True)
```

#### After (v1.0.0 )

```python  theme={null}
from mem0 import MemoryClient

client = MemoryClient(api_key="your-key")

# async_mode now defaults to True (best performance)
result = client.add("I enjoy hiking", user_id="alice")

# You can still override if needed for synchronous processing
result = client.add("I enjoy hiking", user_id="alice", async_mode=False)
```

## Configuration Migration

### Basic Configuration

#### Before (v0.x)

```python  theme={null}
config = {
    "vector_store": {
        "provider": "qdrant",
        "config": {
            "host": "localhost",
            "port": 6333
        }
    },
    "llm": {
        "provider": "openai",
        "config": {
            "model": "gpt-3.5-turbo",
            "api_key": "your-key"
        }
    },
    "version": "v1.0"
}
```

#### After (v1.0.0 )

```python  theme={null}
config = {
    "vector_store": {
        "provider": "qdrant",
        "config": {
            "host": "localhost",
            "port": 6333
        }
    },
    "llm": {
        "provider": "openai",
        "config": {
            "model": "gpt-3.5-turbo",
            "api_key": "your-key"
        }
    },
    "version": "v1.1",  # Minimum supported version

    # New optional features
    "reranker": {
        "provider": "cohere",
        "config": {
            "model": "rerank-english-v3.0",
            "api_key": "your-cohere-key"
        }
    }
}
```

### Enhanced Features (Optional)

```python  theme={null}
# Take advantage of new features
config = {
    "vector_store": {
        "provider": "qdrant",
        "config": {
            "host": "localhost",
            "port": 6333
        }
    },
    "llm": {
        "provider": "openai",
        "config": {
            "model": "gpt-4",
            "api_key": "your-key"
        }
    },
    "embedder": {
        "provider": "openai",
        "config": {
            "model": "text-embedding-3-small",
            "api_key": "your-key"
        }
    },
    "reranker": {
        "provider": "sentence_transformer",
        "config": {
            "model": "cross-encoder/ms-marco-MiniLM-L-6-v2"
        }
    },
    "version": "v1.1"
}
```

## Error Handling Migration

### Before (v0.x)

```python  theme={null}
try:
    result = m.add("memory", user_id="alice", version="v1.0")
except Exception as e:
    print(f"Error: {e}")
```

### After (v1.0.0 )

```python  theme={null}
try:
    result = m.add("memory", user_id="alice")
except ValueError as e:
    if "v1.0 API format is no longer supported" in str(e):
        print("Please upgrade your code to use v1.1+ format")
    else:
        print(f"Error: {e}")
except Exception as e:
    print(f"Unexpected error: {e}")
```

## Testing Your Migration

### 1. Basic Functionality Test

```python  theme={null}
def test_basic_functionality():
    m = Memory()

    # Test add
    result = m.add("I love testing", user_id="test_user")
    assert "results" in result
    assert len(result["results"]) > 0

    # Test search
    search_results = m.search("testing", user_id="test_user")
    assert "results" in search_results

    # Test get_all
    all_memories = m.get_all(user_id="test_user")
    assert "results" in all_memories

    print("✅ Basic functionality test passed")

test_basic_functionality()
```

### 2. Enhanced Features Test

```python  theme={null}
def test_enhanced_features():
    config = {
        "reranker": {
            "provider": "sentence_transformer",
            "config": {
                "model": "cross-encoder/ms-marco-MiniLM-L-6-v2"
            }
        }
    }

    m = Memory.from_config(config)

    # Test reranking
    m.add("I love advanced features", user_id="test_user")
    results = m.search("features", user_id="test_user", rerank=True)
    assert "results" in results

    # Test enhanced filtering
    results = m.search(
        "features",
        user_id="test_user",
        filters={"user_id": {"eq": "test_user"}}
    )
    assert "results" in results

    print("✅ Enhanced features test passed")

test_enhanced_features()
```

## Common Migration Issues

### Issue 1: Version Error

**Error:**

```
ValueError: The v1.0 API format is no longer supported in mem0ai 1.0.0+
```

**Solution:**

```python  theme={null}
# Remove version parameters or set to v1.1+
config = {
    # ... other config
    "version": "v1.1"  # or remove entirely for default
}
```

### Issue 2: Response Format Error

**Error:**

```
KeyError: 'results'
```

**Solution:**

```python  theme={null}
# Always access response via "results" key
result = m.add("memory", user_id="alice")
memories = result["results"]  # Not result directly
```

### Issue 3: Parameter Error

**Error:**

```
TypeError: add() got an unexpected keyword argument 'output_format'
```

**Solution:**

```python  theme={null}
# Remove deprecated parameters
result = m.add(
    "memory",
    user_id="alice"
    # Remove: version
)
```

## Rollback Plan

If you encounter issues during migration:

### 1. Immediate Rollback

```bash  theme={null}
# Downgrade to last v0.x version
pip install mem0ai==0.1.20  # Replace with your last working version
```

### 2. Gradual Migration

```python  theme={null}
# Test both versions side by side
import mem0_v0  # Your old version
import mem0     # New version

def compare_results(query, user_id):
    old_results = mem0_v0.search(query, user_id=user_id)
    new_results = mem0.search(query, user_id=user_id)

    print("Old format:", old_results)
    print("New format:", new_results["results"])
```

## Performance Improvements

### Before (v0.x)

```python  theme={null}
# Sequential operations
result1 = m.add("memory 1", user_id="alice")
result2 = m.add("memory 2", user_id="alice")
result3 = m.search("query", user_id="alice")
```

### After (v1.0.0 )

```python  theme={null}
# Better async performance
async def batch_operations():
    async_memory = AsyncMemory()

    # Concurrent operations
    results = await asyncio.gather(
        async_memory.add("memory 1", user_id="alice"),
        async_memory.add("memory 2", user_id="alice"),
        async_memory.search("query", user_id="alice")
    )
    return results
```

## Next Steps

1. **Complete the migration** using this guide
2. **Test thoroughly** with your existing data
3. **Explore new features** like enhanced filtering and reranking
4. **Update your documentation** to reflect the new API
5. **Monitor performance** and optimize as needed

<CardGroup cols={2}>
  <Card title="Breaking Changes" icon="triangle-exclamation" href="/migration/breaking-changes">
    Detailed list of all breaking changes
  </Card>

  <Card title="API Changes" icon="code" href="/migration/api-changes">
    Complete API reference changes
  </Card>
</CardGroup>

<Info>
  Need help with migration? Check our [GitHub Discussions](https://github.com/mem0ai/mem0/discussions) or reach out to our community for support.
</Info>


# Configure the OSS Stack
Source: https://docs.mem0.ai/open-source/configuration

Wire up Mem0 OSS with your preferred LLM, vector store, embedder, and reranker.

# Configure Mem0 OSS Components

<Info>
  **Prerequisites**

  * Python 3.10+ with `pip` available
  * Running vector database (e.g., Qdrant, Postgres + pgvector) or access credentials for a managed store
  * API keys for your chosen LLM, embedder, and reranker providers
</Info>

<Tip>
  Start from the <Link href="/open-source/python-quickstart">Python quickstart</Link> if you still need the base CLI and repository.
</Tip>

## Install dependencies

<Tabs>
  <Tab title="Python">
    <Steps>
      <Step title="Install Mem0 OSS">
        ```bash  theme={null}
        pip install mem0ai
        ```
      </Step>

      <Step title="Add provider SDKs (example: Qdrant + OpenAI)">
        ```bash  theme={null}
        pip install qdrant-client openai
        ```
      </Step>
    </Steps>
  </Tab>

  <Tab title="Docker Compose">
    <Steps>
      <Step title="Clone the repo and copy the compose file">
        ```bash  theme={null}
        git clone https://github.com/mem0ai/mem0.git
        cd mem0/examples/docker-compose
        ```
      </Step>

      <Step title="Install dependencies for local overrides">
        ```bash  theme={null}
        pip install -r requirements.txt
        ```
      </Step>
    </Steps>
  </Tab>
</Tabs>

## Define your configuration

<Tabs>
  <Tab title="Python">
    <Steps>
      <Step title="Create a configuration dictionary">
        ```python  theme={null}
        from mem0 import Memory

        config = {
            "vector_store": {
                "provider": "qdrant",
                "config": {"host": "localhost", "port": 6333},
            },
            "llm": {
                "provider": "openai",
                "config": {"model": "gpt-4.1-mini", "temperature": 0.1},
            },
            "embedder": {
                "provider": "vertexai",
                "config": {"model": "textembedding-gecko@003"},
            },
            "reranker": {
                "provider": "cohere",
                "config": {"model": "rerank-english-v3.0"},
            },
        }

        memory = Memory.from_config(config)
        ```
      </Step>

      <Step title="Store secrets as environment variables">
        ```bash  theme={null}
        export QDRANT_API_KEY="..."
        export OPENAI_API_KEY="..."
        export COHERE_API_KEY="..."
        ```
      </Step>
    </Steps>
  </Tab>

  <Tab title="config.yaml">
    <Steps>
      <Step title="Create a `config.yaml` file">
        ```yaml  theme={null}
        vector_store:
          provider: qdrant
          config:
            host: localhost
            port: 6333

        llm:
          provider: azure_openai
          config:
            api_key: ${AZURE_OPENAI_KEY}
            deployment_name: gpt-4.1-mini

        embedder:
          provider: ollama
          config:
            model: nomic-embed-text

        reranker:
          provider: zero_entropy
          config:
            api_key: ${ZERO_ENTROPY_KEY}
        ```
      </Step>

      <Step title="Load the config file at runtime">
        ```python  theme={null}
        from mem0 import Memory

        memory = Memory.from_config_file("config.yaml")
        ```
      </Step>
    </Steps>
  </Tab>
</Tabs>

<Info icon="check">
  Run `memory.add(["Remember my favorite cafe in Tokyo."], user_id="alex")` and then `memory.search("favorite cafe", user_id="alex")`. You should see the Qdrant collection populate and the reranker mark the memory as a top hit.
</Info>

## Tune component settings

<AccordionGroup>
  <Accordion title="Vector store collections">
    Name collections explicitly in production (`collection_name`) to isolate tenants and enable per-tenant retention policies.
  </Accordion>

  <Accordion title="LLM extraction temperature">
    Keep extraction temperatures ≤0.2 so advanced memories stay deterministic. Raise it only when you see missing facts.
  </Accordion>

  <Accordion title="Reranker depth">
    Limit `top_k` to 10–20 results; sending more adds latency without meaningful gains.
  </Accordion>
</AccordionGroup>

<Warning>
  Mixing managed and self-hosted components? Make sure every outbound provider call happens through a secure network path. Managed rerankers often require outbound internet even if your vector store is on-prem.
</Warning>

## Quick recovery

* Qdrant connection errors → confirm port `6333` is exposed and API key (if set) matches.
* Empty search results → verify the embedder model name; a mismatch causes dimension errors.
* `Unknown reranker` → update the SDK (`pip install --upgrade mem0ai`) to load the latest provider registry.

<CardGroup cols={2}>
  <Card title="Pick Providers" description="Review the LLM, vector store, embedder, and reranker catalogs." icon="sitemap" href="/components/llms/overview" />

  <Card title="Deploy with Docker Compose" description="Follow the end-to-end OSS deployment walkthrough." icon="server" href="/cookbooks/companions/local-companion-ollama" />
</CardGroup>


# Async Memory
Source: https://docs.mem0.ai/open-source/features/async-memory

Run Mem0 operations without blocking your event loop.

`AsyncMemory` gives you a non-blocking interface to Mem0’s storage layer so Python applications can add, search, and manage memories directly from async code. Use it when you embed Mem0 inside FastAPI services, background workers, or any workflow that relies on `asyncio`.

<Info>
  **You’ll use this when…**

  * Your agent already runs in an async framework and you need memory calls to await cleanly.
  * You want to embed Mem0’s storage locally without sending requests through the synchronous client.
  * You plan to mix memory operations with other async APIs (OpenAI, HTTP calls, databases).
</Info>

<Warning>
  `AsyncMemory` expects a running event loop. Always call it inside `async def` functions or through helpers like `asyncio.run()` to avoid runtime errors.
</Warning>

<Note>
  Working in TypeScript? The Node SDK still uses synchronous calls—use `Memory` there and rely on Python’s `AsyncMemory` when you need awaited operations.
</Note>

## Feature anatomy

* **Direct storage access:** `AsyncMemory` talks to the same backends as the synchronous client but keeps everything in-process for lower latency.
* **Method parity:** Each memory operation (`add`, `search`, `get_all`, `delete`, etc.) mirrors the synchronous API, letting you reuse payload shapes.
* **Concurrent execution:** Non-blocking I/O lets you schedule multiple memory tasks with `asyncio.gather`.
* **Scoped organization:** Continue using `user_id`, `agent_id`, and `run_id` to separate memories across sessions and agents.

<AccordionGroup>
  <Accordion title="Async method parity">
    | Operation       | Async signature                                | Notes                                         |
    | --------------- | ---------------------------------------------- | --------------------------------------------- |
    | Create memories | `await memory.add(...)`                        | Same arguments as synchronous `Memory.add`.   |
    | Search memories | `await memory.search(...)`                     | Returns dict with `results`, identical shape. |
    | List memories   | `await memory.get_all(...)`                    | Filter by `user_id`, `agent_id`, `run_id`.    |
    | Retrieve memory | `await memory.get(memory_id=...)`              | Raises `ValueError` if ID is invalid.         |
    | Update memory   | `await memory.update(memory_id=..., data=...)` | Accepts partial updates.                      |
    | Delete memory   | `await memory.delete(memory_id=...)`           | Returns confirmation payload.                 |
    | Delete in bulk  | `await memory.delete_all(...)`                 | Requires at least one scope filter.           |
    | History         | `await memory.history(memory_id=...)`          | Fetches change log for auditing.              |
  </Accordion>
</AccordionGroup>

***

## Configure it

### Initialize the client

```python  theme={null}
import asyncio
from mem0 import AsyncMemory

# Default configuration
memory = AsyncMemory()

# Custom configuration
from mem0.configs.base import MemoryConfig
custom_config = MemoryConfig(
    # Your custom configuration here
)
memory = AsyncMemory(config=custom_config)
```

<Info icon="check">
  Run `await memory.search(...)` once right after initialization. If it returns memories without errors, your configuration works.
</Info>

<Tip>
  Keep configuration objects close to the async client so you can reuse them across workers without recreating vector store connections.
</Tip>

### Manage lifecycle and concurrency

```python  theme={null}
import asyncio
from contextlib import asynccontextmanager
from mem0 import AsyncMemory

@asynccontextmanager
async def get_memory():
    memory = AsyncMemory()
    try:
        yield memory
    finally:
        # Clean up resources if needed
        pass

async def safe_memory_usage():
    async with get_memory() as memory:
        return await memory.search("test query", user_id="alice")
```

<Tip>
  Wrap the client in an async context manager when you need a clean shutdown (for example, inside FastAPI startup/shutdown hooks).
</Tip>

```python  theme={null}
async def batch_operations():
    memory = AsyncMemory()

    tasks = [
        memory.add(
            messages=[{"role": "user", "content": f"Message {i}"}],
            user_id=f"user_{i}"
        )
        for i in range(5)
    ]

    results = await asyncio.gather(*tasks, return_exceptions=True)
    for i, result in enumerate(results):
        if isinstance(result, Exception):
            print(f"Task {i} failed: {result}")
        else:
            print(f"Task {i} completed successfully")
```

<Info icon="check">
  When concurrency works correctly, successful tasks return memory IDs while failures surface as exceptions in the `results` list.
</Info>

### Add resilience with retries

```python  theme={null}
import asyncio
from mem0 import AsyncMemory

async def with_timeout_and_retry(operation, max_retries=3, timeout=10.0):
    for attempt in range(max_retries):
        try:
            return await asyncio.wait_for(operation(), timeout=timeout)
        except asyncio.TimeoutError:
            print(f"Timeout on attempt {attempt + 1}")
        except Exception as exc:
            print(f"Error on attempt {attempt + 1}: {exc}")

        if attempt < max_retries - 1:
            await asyncio.sleep(2 ** attempt)

    raise Exception(f"Operation failed after {max_retries} attempts")

async def robust_memory_search():
    memory = AsyncMemory()

    async def search_operation():
        return await memory.search("test query", user_id="alice")

    return await with_timeout_and_retry(search_operation)
```

<Warning>
  Always cap retries—runaway loops can keep the event loop busy and block other tasks.
</Warning>

***

## See it in action

### Core operations

```python  theme={null}
# Create memories
result = await memory.add(
    messages=[
        {"role": "user", "content": "I'm travelling to SF"},
        {"role": "assistant", "content": "That's great to hear!"}
    ],
    user_id="alice"
)

# Search memories
results = await memory.search(
    query="Where am I travelling?",
    user_id="alice"
)

# List memories
all_memories = await memory.get_all(user_id="alice")

# Get a specific memory
specific_memory = await memory.get(memory_id="memory-id-here")

# Update a memory
updated_memory = await memory.update(
    memory_id="memory-id-here",
    data="I'm travelling to Seattle"
)

# Delete a memory
await memory.delete(memory_id="memory-id-here")

# Delete scoped memories
await memory.delete_all(user_id="alice")
```

<Info icon="check">
  Confirm each call returns the same response fields as the synchronous client (IDs, `results`, or confirmation objects). Missing keys usually mean the coroutine wasn’t awaited.
</Info>

<Note>
  `delete_all` requires at least one of `user_id`, `agent_id`, or `run_id`. Provide all three to narrow deletion to a single session.
</Note>

### Scoped organization

```python  theme={null}
await memory.add(
    messages=[{"role": "user", "content": "I prefer vegetarian food"}],
    user_id="alice",
    agent_id="diet-assistant",
    run_id="consultation-001"
)

all_user_memories = await memory.get_all(user_id="alice")
agent_memories = await memory.get_all(user_id="alice", agent_id="diet-assistant")
session_memories = await memory.get_all(user_id="alice", run_id="consultation-001")
specific_memories = await memory.get_all(
    user_id="alice",
    agent_id="diet-assistant",
    run_id="consultation-001"
)

history = await memory.history(memory_id="memory-id-here")
```

<Tip>
  Use `history` when you need audit trails for compliance or debugging update logic.
</Tip>

### Blend with other async APIs

```python  theme={null}
import asyncio
from openai import AsyncOpenAI
from mem0 import AsyncMemory

async_openai_client = AsyncOpenAI()
async_memory = AsyncMemory()

async def chat_with_memories(message: str, user_id: str = "default_user") -> str:
    search_result = await async_memory.search(query=message, user_id=user_id, limit=3)
    relevant_memories = search_result["results"]
    memories_str = "\n".join(f"- {entry['memory']}" for entry in relevant_memories)

    system_prompt = (
        "You are a helpful AI. Answer the question based on query and memories.\n"
        f"User Memories:\n{memories_str}"
    )

    messages = [
        {"role": "system", "content": system_prompt},
        {"role": "user", "content": message},
    ]

    response = await async_openai_client.chat.completions.create(
        model="gpt-4.1-nano-2025-04-14",
        messages=messages
    )

    assistant_response = response.choices[0].message.content
    messages.append({"role": "assistant", "content": assistant_response})
    await async_memory.add(messages, user_id=user_id)

    return assistant_response
```

<Info icon="check">
  When everything is wired correctly, the OpenAI response should incorporate recent memories and the follow-up `add` call should persist the new assistant turn.
</Info>

### Handle errors gracefully

```python  theme={null}
from mem0 import AsyncMemory
from mem0.configs.base import MemoryConfig

async def handle_initialization_errors():
    try:
        config = MemoryConfig(
            vector_store={"provider": "chroma", "config": {"path": "./chroma_db"}},
            llm={"provider": "openai", "config": {"model": "gpt-4.1-nano-2025-04-14"}}
        )
        AsyncMemory(config=config)
        print("AsyncMemory initialized successfully")
    except ValueError as err:
        print(f"Configuration error: {err}")
    except ConnectionError as err:
        print(f"Connection error: {err}")

async def handle_memory_operation_errors():
    memory = AsyncMemory()
    try:
        await memory.get(memory_id="non-existent-id")
    except ValueError as err:
        print(f"Invalid memory ID: {err}")

    try:
        await memory.search(query="", user_id="alice")
    except ValueError as err:
        print(f"Invalid search query: {err}")
```

<Warning>
  Catch and log `ValueError` exceptions from invalid inputs—async stack traces can otherwise disappear inside background tasks.
</Warning>

### Serve through FastAPI

```python  theme={null}
from fastapi import FastAPI, HTTPException
from mem0 import AsyncMemory

app = FastAPI()
memory = AsyncMemory()

@app.post("/memories/")
async def add_memory(messages: list, user_id: str):
    try:
        result = await memory.add(messages=messages, user_id=user_id)
        return {"status": "success", "data": result}
    except Exception as exc:
        raise HTTPException(status_code=500, detail=str(exc))

@app.get("/memories/search")
async def search_memories(query: str, user_id: str, limit: int = 10):
    try:
        result = await memory.search(query=query, user_id=user_id, limit=limit)
        return {"status": "success", "data": result}
    except Exception as exc:
        raise HTTPException(status_code=500, detail=str(exc))
```

<Tip>
  Create one `AsyncMemory` instance per process when using FastAPI—startup hooks are a good place to configure and reuse it.
</Tip>

### Instrument logging

```python  theme={null}
import logging
import time
from functools import wraps

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

def log_async_operation(operation_name):
    def decorator(func):
        @wraps(func)
        async def wrapper(*args, **kwargs):
            start_time = time.time()
            logger.info(f"Starting {operation_name}")
            try:
                result = await func(*args, **kwargs)
                duration = time.time() - start_time
                logger.info(f"{operation_name} completed in {duration:.2f}s")
                return result
            except Exception as exc:
                duration = time.time() - start_time
                logger.error(f"{operation_name} failed after {duration:.2f}s: {exc}")
                raise
        return wrapper
    return decorator

@log_async_operation("Memory Add")
async def logged_memory_add(memory, messages, user_id):
    return await memory.add(messages=messages, user_id=user_id)
```

<Info icon="check">
  Logged durations give you the baseline needed to spot regressions once AsyncMemory is in production.
</Info>

***

## Verify the feature is working

* Run a quick add/search cycle and confirm the returned memory content matches your input.
* Inspect application logs to ensure async tasks complete without blocking the event loop.
* In FastAPI or other frameworks, hit health endpoints to verify the shared client handles concurrent requests.
* Monitor retry counters—unexpected spikes indicate configuration or connectivity issues.

***

## Best practices

1. **Keep operations awaited:** Forgetting `await` is the fastest way to miss writes—lint for it or add helper wrappers.
2. **Scope deletions carefully:** Always supply `user_id`, `agent_id`, or `run_id` to avoid purging too much data.
3. **Batch writes thoughtfully:** Use `asyncio.gather` for throughput but cap concurrency based on backend capacity.
4. **Log errors with context:** Capture user and agent scopes to triage failures quickly.
5. **Reuse clients:** Instantiate `AsyncMemory` once per worker to avoid repeated backend handshakes.

***

## Troubleshooting

| Issue                | Possible causes                      | Fix                                                         |
| -------------------- | ------------------------------------ | ----------------------------------------------------------- |
| Initialization fails | Missing dependencies, invalid config | Validate `MemoryConfig` settings and environment variables. |
| Slow operations      | Large datasets, network latency      | Cache heavy queries and tune vector store parameters.       |
| Memory not found     | Invalid ID or deleted record         | Check ID source and handle soft-deleted states.             |
| Connection timeouts  | Network issues, overloaded backend   | Apply retries/backoff and inspect infrastructure health.    |
| Out-of-memory errors | Oversized batches                    | Reduce concurrency or chunk operations into smaller sets.   |

***

<CardGroup cols={2}>
  <Card title="Master Memory Operations" icon="layers" href="/core-concepts/memory-operations/add">
    Review how add, search, update, and delete behave across synchronous and async clients.
  </Card>

  <Card title="Connect Async Agents" icon="plug" href="/cookbooks/integrations/openai-tool-calls">
    Follow a full workflow that mixes AsyncMemory with OpenAI tool-call automation.
  </Card>
</CardGroup>


# Custom Fact Extraction Prompt
Source: https://docs.mem0.ai/open-source/features/custom-fact-extraction-prompt

Tailor fact extraction so Mem0 stores only the details you care about.

Custom fact extraction prompts let you decide exactly which facts Mem0 records from a conversation. Define a focused prompt, give a few examples, and Mem0 will add only the memories that match your use case.

<Info>
  **You’ll use this when…**

  * A project needs domain-specific facts (order numbers, customer info) without storing casual chatter.
  * You already have a clear schema for memories and want the LLM to follow it.
  * You must prevent irrelevant details from entering long-term storage.
</Info>

<Warning>
  Prompts that are too broad cause unrelated facts to slip through. Keep instructions tight and test them with real transcripts.
</Warning>

***

## Feature anatomy

* **Prompt instructions:** Describe which entities or phrases to keep. Specific guidance keeps the extractor focused.
* **Few-shot examples:** Show positive and negative cases so the model copies the right format.
* **Structured output:** Responses return JSON with a `facts` array that Mem0 converts into individual memories.
* **LLM configuration:** `custom_fact_extraction_prompt` (Python) or `customPrompt` (TypeScript) lives alongside your model settings.

<AccordionGroup>
  <Accordion title="Prompt blueprint">
    1. State the allowed fact types.
    2. Include short examples that mirror production messages.
    3. Show both empty (`[]`) and populated outputs.
    4. Remind the model to return JSON with a `facts` key only.
  </Accordion>
</AccordionGroup>

***

## Configure it

### Write the custom prompt

<CodeGroup>
  ```python Python theme={null}
  custom_fact_extraction_prompt = """
  Please only extract entities containing customer support information, order details, and user information. 
  Here are some few shot examples:

  Input: Hi.
  Output: {"facts" : []}

  Input: The weather is nice today.
  Output: {"facts" : []}

  Input: My order #12345 hasn't arrived yet.
  Output: {"facts" : ["Order #12345 not received"]}

  Input: I'm John Doe, and I'd like to return the shoes I bought last week.
  Output: {"facts" : ["Customer name: John Doe", "Wants to return shoes", "Purchase made last week"]}

  Input: I ordered a red shirt, size medium, but received a blue one instead.
  Output: {"facts" : ["Ordered red shirt, size medium", "Received blue shirt instead"]}

  Return the facts and customer information in a json format as shown above.
  """
  ```

  ```ts TypeScript theme={null}
  const customPrompt = `
  Please only extract entities containing customer support information, order details, and user information. 
  Here are some few shot examples:

  Input: Hi.
  Output: {"facts" : []}

  Input: The weather is nice today.
  Output: {"facts" : []}

  Input: My order #12345 hasn't arrived yet.
  Output: {"facts" : ["Order #12345 not received"]}

  Input: I am John Doe, and I would like to return the shoes I bought last week.
  Output: {"facts" : ["Customer name: John Doe", "Wants to return shoes", "Purchase made last week"]}

  Input: I ordered a red shirt, size medium, but received a blue one instead.
  Output: {"facts" : ["Ordered red shirt, size medium", "Received blue shirt instead"]}

  Return the facts and customer information in a json format as shown above.
  `;
  ```
</CodeGroup>

<Tip>
  Keep example pairs short and mirror the capitalization, punctuation, and tone you see in real user messages.
</Tip>

### Load the prompt in configuration

<CodeGroup>
  ```python Python theme={null}
  from mem0 import Memory

  config = {
      "llm": {
          "provider": "openai",
          "config": {
              "model": "gpt-4.1-nano-2025-04-14",
              "temperature": 0.2,
              "max_tokens": 2000,
          }
      },
      "custom_fact_extraction_prompt": custom_fact_extraction_prompt,
      "version": "v1.1"
  }

  m = Memory.from_config(config_dict=config)
  ```

  ```ts TypeScript theme={null}
  import { Memory } from "mem0ai/oss";

  const config = {
    version: "v1.1",
    llm: {
      provider: "openai",
      config: {
        apiKey: process.env.OPENAI_API_KEY ?? "",
        model: "gpt-4-turbo-preview",
        temperature: 0.2,
        maxTokens: 1500,
      },
    },
    customPrompt: customPrompt,
  };

  const memory = new Memory(config);
  ```
</CodeGroup>

<Info icon="check">
  After initialization, run a quick `add` call with a known example and confirm the response splits into separate facts.
</Info>

***

## See it in action

### Example: Order support memory

<CodeGroup>
  ```python Python theme={null}
  m.add("Yesterday, I ordered a laptop, the order id is 12345", user_id="alice")
  ```

  ```ts TypeScript theme={null}
  await memory.add("Yesterday, I ordered a laptop, the order id is 12345", { userId: "user123" });
  ```

  ```json Output theme={null}
  {
    "results": [
      {"memory": "Ordered a laptop", "event": "ADD"},
      {"memory": "Order ID: 12345", "event": "ADD"},
      {"memory": "Order placed yesterday", "event": "ADD"}
    ],
    "relations": []
  }
  ```
</CodeGroup>

<Info icon="check">
  The output contains only the facts described in your prompt, each stored as a separate memory entry.
</Info>

### Example: Irrelevant message filtered out

<CodeGroup>
  ```python Python theme={null}
  m.add("I like going to hikes", user_id="alice")
  ```

  ```ts TypeScript theme={null}
  await memory.add("I like going to hikes", { userId: "user123" });
  ```

  ```json Output theme={null}
  {
    "results": [],
    "relations": []
  }
  ```
</CodeGroup>

<Tip>
  Empty `results` show the prompt successfully ignored content outside your target domain.
</Tip>

***

## Verify the feature is working

* Log every call during rollout and confirm the `facts` array matches your schema.
* Check that unrelated messages return an empty `results` array.
* Run regression samples whenever you edit the prompt to ensure previously accepted facts still pass.

***

## Best practices

1. **Be precise:** Call out the exact categories or fields you want to capture.
2. **Show negative cases:** Include examples that should produce `[]` so the model learns to skip them.
3. **Keep JSON strict:** Avoid extra keys; only return `facts` to simplify downstream parsing.
4. **Version prompts:** Track prompt changes with a version number so you can roll back quickly.
5. **Review outputs regularly:** Spot-check stored memories to catch drift early.

***

<CardGroup cols={2}>
  <Card title="Review Add Operations" icon="list" href="/core-concepts/memory-operations/add">
    Refresh how Mem0 stores memories and how prompts influence fact creation.
  </Card>

  <Card title="Automate Support Triage" icon="inbox" href="/cookbooks/operations/support-inbox">
    Apply custom extraction to route customer requests in a full workflow.
  </Card>
</CardGroup>


# Custom Update Memory Prompt
Source: https://docs.mem0.ai/open-source/features/custom-update-memory-prompt

Decide how Mem0 adds, updates, or deletes memories using your own rules.

The custom update memory prompt tells Mem0 how to handle changes when new facts arrive. Craft the prompt so the LLM can compare incoming facts with existing memories and choose the right action.

<Info>
  **You’ll use this when…**

  * Stored memories need to stay consistent as users change preferences or correct past statements.
  * Your product has clear rules for when to add, update, delete, or leave a memory untouched.
  * You want traceable decisions (ADD, UPDATE, DELETE, NONE) for auditing or compliance.
</Info>

<Warning>
  Prompts that mix instructions or omit examples can lead to wrong actions like deleting valid memories. Keep the language simple and test each action path.
</Warning>

***

## Feature anatomy

* **Action verbs:** The prompt teaches the model to return `ADD`, `UPDATE`, `DELETE`, or `NONE` for every memory entry.
* **ID retention:** Updates reuse the original memory ID so downstream systems maintain history.
* **Old vs. new text:** Updates include `old_memory` so you can track what changed.
* **Decision table:** Your prompt should explain when to use each action and show concrete examples.

<AccordionGroup>
  <Accordion title="Decision guide">
    | Action   | When to choose it                                              | Output details                              |
    | -------- | -------------------------------------------------------------- | ------------------------------------------- |
    | `ADD`    | Fact is new and not stored yet                                 | Generate a new ID and set `event: "ADD"`.   |
    | `UPDATE` | Fact replaces older info about the same topic                  | Keep the original ID, include `old_memory`. |
    | `DELETE` | Fact contradicts the stored memory or you explicitly remove it | Keep ID, set `event: "DELETE"`.             |
    | `NONE`   | Fact matches existing memory or is irrelevant                  | Keep ID with `event: "NONE"`.               |
  </Accordion>
</AccordionGroup>

***

## Configure it

### Author the prompt

<CodeGroup>
  ```python Python theme={null}
  UPDATE_MEMORY_PROMPT = """You are a smart memory manager which controls the memory of a system.
  You can perform four operations: (1) add into the memory, (2) update the memory, (3) delete from the memory, and (4) no change.

  Based on the above four operations, the memory will change.

  Compare newly retrieved facts with the existing memory. For each new fact, decide whether to:
  - ADD: Add it to the memory as a new element
  - UPDATE: Update an existing memory element
  - DELETE: Delete an existing memory element
  - NONE: Make no change (if the fact is already present or irrelevant)

  There are specific guidelines to select which operation to perform:

  1. **Add**: If the retrieved facts contain new information not present in the memory, then you have to add it by generating a new ID in the id field.
  - **Example**:
      - Old Memory:
          [
              {
                  "id" : "0",
                  "text" : "User is a software engineer"
              }
          ]
      - Retrieved facts: ["Name is John"]
      - New Memory:
          {
              "memory" : [
                  {
                      "id" : "0",
                      "text" : "User is a software engineer",
                      "event" : "NONE"
                  },
                  {
                      "id" : "1",
                      "text" : "Name is John",
                      "event" : "ADD"
                  }
              ]

          }

  2. **Update**: If the retrieved facts contain information that is already present in the memory but the information is totally different, then you have to update it. 
  If the retrieved fact contains information that conveys the same thing as the elements present in the memory, then you have to keep the fact which has the most information. 
  Example (a) -- if the memory contains "User likes to play cricket" and the retrieved fact is "Loves to play cricket with friends", then update the memory with the retrieved facts.
  Example (b) -- if the memory contains "Likes cheese pizza" and the retrieved fact is "Loves cheese pizza", then you do not need to update it because they convey the same information.
  If the direction is to update the memory, then you have to update it.
  Please keep in mind while updating you have to keep the same ID.
  Please note to return the IDs in the output from the input IDs only and do not generate any new ID.
  - **Example**:
      - Old Memory:
          [
              {
                  "id" : "0",
                  "text" : "I really like cheese pizza"
              },
              {
                  "id" : "1",
                  "text" : "User is a software engineer"
              },
              {
                  "id" : "2",
                  "text" : "User likes to play cricket"
              }
          ]
      - Retrieved facts: ["Loves chicken pizza", "Loves to play cricket with friends"]
      - New Memory:
          {
          "memory" : [
                  {
                      "id" : "0",
                      "text" : "Loves cheese and chicken pizza",
                      "event" : "UPDATE",
                      "old_memory" : "I really like cheese pizza"
                  },
                  {
                      "id" : "1",
                      "text" : "User is a software engineer",
                      "event" : "NONE"
                  },
                  {
                      "id" : "2",
                      "text" : "Loves to play cricket with friends",
                      "event" : "UPDATE",
                      "old_memory" : "User likes to play cricket"
                  }
              ]
          }


  3. **Delete**: If the retrieved facts contain information that contradicts the information present in the memory, then you have to delete it. Or if the direction is to delete the memory, then you have to delete it.
  Please note to return the IDs in the output from the input IDs only and do not generate any new ID.
  - **Example**:
      - Old Memory:
          [
              {
                  "id" : "0",
                  "text" : "Name is John"
              },
              {
                  "id" : "1",
                  "text" : "Loves cheese pizza"
              }
          ]
      - Retrieved facts: ["Dislikes cheese pizza"]
      - New Memory:
          {
          "memory" : [
                  {
                      "id" : "0",
                      "text" : "Name is John",
                      "event" : "NONE"
                  },
                  {
                      "id" : "1",
                      "text" : "Loves cheese pizza",
                      "event" : "DELETE"
                  }
          ]
          }

  4. **No Change**: If the retrieved facts contain information that is already present in the memory, then you do not need to make any changes.
  - **Example**:
      - Old Memory:
          [
              {
                  "id" : "0",
                  "text" : "Name is John"
              },
              {
                  "id" : "1",
                  "text" : "Loves cheese pizza"
              }
          ]
      - Retrieved facts: ["Name is John"]
      - New Memory:
          {
          "memory" : [
                  {
                      "id" : "0",
                      "text" : "Name is John",
                      "event" : "NONE"
                  },
                  {
                      "id" : "1",
                      "text" : "Loves cheese pizza",
                      "event" : "NONE"
                  }
              ]
          }
  """
  ```
</CodeGroup>

### Define the expected output format

<CodeGroup>
  ```json Add theme={null}
  {
    "memory": [
      {
        "id": "0",
        "text": "This information is new",
        "event": "ADD"
      }
    ]
  }
  ```

  ```json Update theme={null}
  {
    "memory": [
      {
        "id": "0",
        "text": "This information replaces the old information",
        "event": "UPDATE",
        "old_memory": "Old information"
      }
    ]
  }
  ```

  ```json Delete theme={null}
  {
    "memory": [
      {
        "id": "0",
        "text": "This information will be deleted",
        "event": "DELETE"
      }
    ]
  }
  ```

  ```json No Change theme={null}
  {
    "memory": [
      {
        "id": "0",
        "text": "No changes for this information",
        "event": "NONE"
      }
    ]
  }
  ```
</CodeGroup>

<Info icon="check">
  Consistent JSON structure makes it easy to parse decisions downstream or log them for auditing.
</Info>

***

## See it in action

* Run reconciliation jobs that compare retrieved facts to existing memories.
* Feed both sources into the custom prompt, then apply the returned actions (add new entries, update text, delete outdated facts).
* Log each decision so product teams can review why a change happened.

<Note>
  The prompt works alongside `custom_fact_extraction_prompt`—fact extraction identifies candidate facts, and the update prompt decides how to merge them into long-term storage.
</Note>

***

## Verify the feature is working

* Test all four actions with targeted examples, including edge cases where facts differ only slightly.
* Confirm update responses keep the original IDs and include `old_memory`.
* Ensure delete actions only trigger when contradictions appear or when you explicitly request removal.

***

## Best practices

1. **Keep instructions brief:** Remove redundant wording so the LLM focuses on the decision logic.
2. **Document your schema:** Share the prompt and examples with your team so everyone knows how memories evolve.
3. **Track prompt versions:** When rules change, bump a version number and archive the prior prompt.
4. **Review outputs regularly:** Skim audit logs weekly to spot drift or repeated mistakes.
5. **Pair with monitoring:** Visualize counts of each action to detect spikes in deletes or updates.

***

## Compare prompts

| Feature     | `custom_update_memory_prompt`                  | `custom_fact_extraction_prompt`             |
| ----------- | ---------------------------------------------- | ------------------------------------------- |
| Primary job | Decide memory actions (ADD/UPDATE/DELETE/NONE) | Pull facts from user and assistant messages |
| Inputs      | Retrieved facts + existing memory entries      | Raw conversation turns                      |
| Output      | Structured memory array with events            | Array of extracted facts                    |

***

<CardGroup cols={2}>
  <Card title="Design Fact Extraction" icon="sparkles" href="/open-source/features/custom-fact-extraction-prompt">
    Coordinate both prompts so fact extraction feeds clean inputs into the update flow.
  </Card>

  <Card title="Build Email Automations" icon="inbox" href="/cookbooks/operations/email-automation">
    See how update prompts keep customer profiles current in a working automation.
  </Card>
</CardGroup>


# Graph Memory
Source: https://docs.mem0.ai/open-source/features/graph-memory

Layer relationships onto Mem0 search so agents remember who did what, when, and with whom.

Graph Memory extends Mem0 by persisting nodes and edges alongside embeddings, so recalls stitch together people, places, and events instead of just keywords.

<Info icon="sparkles">
  **You’ll use this when…**

  * Conversation history mixes multiple actors and objects that vectors alone blur together
  * Compliance or auditing demands a graph of who said what and when
  * Agent teams need shared context without duplicating every memory in each run
</Info>

## How Graph Memory Maps Context

Mem0 extracts entities and relationships from every memory write, stores embeddings in your vector database, and mirrors relationships in a graph backend. On retrieval, vector search narrows candidates while the graph returns related context alongside the results.

```mermaid  theme={null}
graph LR
    A[Conversation] --> B(Extraction LLM)
    B --> C[Vector Store]
    B --> D[Graph Store]
    E[Query] --> C
    C --> F[Candidate Memories]
    F --> D
    D --> G[Contextual Recall]
```

## How It Works

<Steps>
  <Step title="Extract people, places, and facts">
    Mem0’s extraction LLM identifies entities, relationships, and timestamps from the conversation payload you send to `memory.add`.
  </Step>

  <Step title="Store vectors and edges together">
    Embeddings land in your configured vector database while nodes and edges flow into a Bolt-compatible graph backend (Neo4j, Memgraph, Neptune, or Kuzu).
  </Step>

  <Step title="Expose graph context at search time">
    `memory.search` performs vector similarity (optionally reranked by your configured reranker) and returns the results list. Graph Memory runs in parallel and adds related entities in the `relations` array—it does not reorder the vector hits automatically.
  </Step>
</Steps>

## Quickstart (Neo4j Aura)

<Info icon="clock">
  **Time to implement:** \~10 minutes · **Prerequisites:** Python 3.10+, Node.js 18+, Neo4j Aura DB (free tier)
</Info>

Provision a free [Neo4j Aura](https://neo4j.com/product/auradb/) instance, copy the Bolt URI, username, and password, then follow the language tab that matches your stack.

<Tabs>
  <Tab title="Python">
    <Steps>
      <Step title="Install Mem0 with graph extras">
        ```bash  theme={null}
        pip install "mem0ai[graph]"
        ```
      </Step>

      <Step title="Export Neo4j credentials">
        ```bash  theme={null}
        export NEO4J_URL="neo4j+s://<your-instance>.databases.neo4j.io"
        export NEO4J_USERNAME="neo4j"
        export NEO4J_PASSWORD="your-password"
        ```
      </Step>

      <Step title="Add and recall a relationship">
        ```python  theme={null}
        import os
        from mem0 import Memory

        config = {
            "graph_store": {
                "provider": "neo4j",
                "config": {
                    "url": os.environ["NEO4J_URL"],
                    "username": os.environ["NEO4J_USERNAME"],
                    "password": os.environ["NEO4J_PASSWORD"],
                    "database": "neo4j",
                }
            }
        }

        memory = Memory.from_config(config)

        conversation = [
            {"role": "user", "content": "Alice met Bob at GraphConf 2025 in San Francisco."},
            {"role": "assistant", "content": "Great! Logging that connection."},
        ]

        memory.add(conversation, user_id="demo-user")

        results = memory.search(
            "Who did Alice meet at GraphConf?",
            user_id="demo-user",
            limit=3,
            rerank=True,
        )

        for hit in results["results"]:
            print(hit["memory"])
        ```
      </Step>
    </Steps>
  </Tab>

  <Tab title="TypeScript">
    <Steps>
      <Step title="Install the OSS SDK">
        ```bash  theme={null}
        npm install mem0ai
        ```
      </Step>

      <Step title="Load Neo4j credentials">
        ```bash  theme={null}
        export NEO4J_URL="neo4j+s://<your-instance>.databases.neo4j.io"
        export NEO4J_USERNAME="neo4j"
        export NEO4J_PASSWORD="your-password"
        ```
      </Step>

      <Step title="Enable graph memory and query it">
        ```typescript  theme={null}
        import { Memory } from "mem0ai/oss";

        const config = {
          enableGraph: true,
          graphStore: {
            provider: "neo4j",
            config: {
              url: process.env.NEO4J_URL!,
              username: process.env.NEO4J_USERNAME!,
              password: process.env.NEO4J_PASSWORD!,
              database: "neo4j",
            },
          },
        };

        const memory = new Memory(config);

        const conversation = [
          { role: "user", content: "Alice met Bob at GraphConf 2025 in San Francisco." },
          { role: "assistant", content: "Great! Logging that connection." },
        ];

        await memory.add(conversation, { userId: "demo-user" });

        const results = await memory.search(
          "Who did Alice meet at GraphConf?",
          { userId: "demo-user", limit: 3, rerank: true }
        );

        results.results.forEach((hit) => {
          console.log(hit.memory);
        });
        ```
      </Step>
    </Steps>
  </Tab>
</Tabs>

<Info icon="check">
  Expect to see **Alice met Bob at GraphConf 2025** in the output. In Neo4j Browser run `MATCH (p:Person)-[r]->(q:Person) RETURN p,r,q LIMIT 5;` to confirm the edge exists.
</Info>

<Note>
  Graph Memory enriches responses by adding related entities in the `relations` key. The ordering of `results` always comes from vector search (plus any reranker you configure); graph edges do not reorder those hits automatically.
</Note>

## Operate Graph Memory Day-to-Day

<AccordionGroup>
  <Accordion title="Refine extraction prompts">
    Guide which relationships become nodes and edges.

    <CodeGroup>
      ```python Python theme={null}
      import os
      from mem0 import Memory

      config = {
          "graph_store": {
              "provider": "neo4j",
              "config": {
                  "url": os.environ["NEO4J_URL"],
                  "username": os.environ["NEO4J_USERNAME"],
                  "password": os.environ["NEO4J_PASSWORD"],
              },
              "custom_prompt": "Please only capture people, organisations, and project links.",
          }
      }

      memory = Memory.from_config(config_dict=config)
      ```

      ```typescript TypeScript theme={null}
      import { Memory } from "mem0ai/oss";

      const config = {
        enableGraph: true,
        graphStore: {
          provider: "neo4j",
          config: {
            url: process.env.NEO4J_URL!,
            username: process.env.NEO4J_USERNAME!,
            password: process.env.NEO4J_PASSWORD!,
          },
          customPrompt: "Please only capture people, organisations, and project links.",
        }
      };

      const memory = new Memory(config);
      ```
    </CodeGroup>
  </Accordion>

  <Accordion title="Raise the confidence threshold">
    Keep noisy edges out of the graph by demanding higher extraction confidence.

    ```python  theme={null}
    config["graph_store"]["config"]["threshold"] = 0.75
    ```
  </Accordion>

  <Accordion title="Toggle graph writes per request">
    Disable graph writes or reads when you only want vector behaviour.

    ```python  theme={null}
    memory.add(messages, user_id="demo-user", enable_graph=False)
    results = memory.search("marketing partners", user_id="demo-user", enable_graph=False)
    ```
  </Accordion>

  <Accordion title="Organize multi-agent graphs">
    Separate or share context across agents and sessions with `user_id`, `agent_id`, and `run_id`.

    <CodeGroup>
      ```typescript TypeScript theme={null}
      memory.add("I prefer Italian cuisine", { userId: "bob", agentId: "food-assistant" });
      memory.add("I'm allergic to peanuts", { userId: "bob", agentId: "health-assistant" });
      memory.add("I live in Seattle", { userId: "bob" });

      const food = await memory.search("What food do I like?", { userId: "bob", agentId: "food-assistant" });
      const allergies = await memory.search("What are my allergies?", { userId: "bob", agentId: "health-assistant" });
      const location = await memory.search("Where do I live?", { userId: "bob" });
      ```
    </CodeGroup>
  </Accordion>
</AccordionGroup>

<Note>
  Monitor graph growth, especially on free tiers, by periodically cleaning dormant nodes: `MATCH (n) WHERE n.lastSeen < date() - duration('P90D') DETACH DELETE n`.
</Note>

## Troubleshooting

<AccordionGroup>
  <Accordion title="Neo4j connection refused">
    Confirm Bolt connectivity is enabled, credentials match Aura, and your IP is allow-listed. Retry after confirming the URI format is `neo4j+s://...`.
  </Accordion>

  <Accordion title="Neptune Analytics rejects requests">
    Ensure the graph identifier matches the vector dimension used by your embedder and that the IAM role allows `neptune-graph:*DataViaQuery` actions.
  </Accordion>

  <Accordion title="Graph store outage fallback">
    Catch the provider error and retry with `enable_graph=False` so vector-only search keeps serving responses while the graph backend recovers.
  </Accordion>
</AccordionGroup>

## Decision Points

* Select the graph store that fits your deployment (managed Aura vs. self-hosted Neo4j vs. AWS Neptune vs. local Kuzu).
* Decide when to enable graph writes per request; routine conversations may stay vector-only to save latency.
* Set a policy for pruning stale relationships so your graph stays fast and affordable.

## Provider setup

Choose your backend and expand the matching panel for configuration details and links.

<AccordionGroup>
  <Accordion title="Neo4j Aura or self-hosted">
    Install the APOC plugin for self-hosted deployments, then configure Mem0:

    ```typescript  theme={null}
    import { Memory } from "mem0ai/oss";

    const config = {
        enableGraph: true,
        graphStore: {
            provider: "neo4j",
            config: {
                url: "neo4j+s://<HOST>",
                username: "neo4j",
                password: "<PASSWORD>",
            }
        }
    };

    const memory = new Memory(config);
    ```

    Additional docs: [Neo4j Aura Quickstart](https://neo4j.com/docs/aura/), [APOC installation](https://neo4j.com/docs/apoc/current/installation/).
  </Accordion>

  <Accordion title="Memgraph (Docker)">
    Run Memgraph Mage locally with schema introspection enabled:

    ```bash  theme={null}
    docker run -p 7687:7687 memgraph/memgraph-mage:latest --schema-info-enabled=True
    ```

    Then point Mem0 at the instance:

    ```python  theme={null}
    from mem0 import Memory

    config = {
        "graph_store": {
            "provider": "memgraph",
            "config": {
                "url": "bolt://localhost:7687",
                "username": "memgraph",
                "password": "your-password",
            },
        },
    }

    m = Memory.from_config(config_dict=config)
    ```

    Learn more: [Memgraph Docs](https://memgraph.com/docs).
  </Accordion>

  <Accordion title="Amazon Neptune Analytics">
    Match vector dimensions between Neptune and your embedder, enable public connectivity (if needed), and grant IAM permissions:

    ```python  theme={null}
    from mem0 import Memory

    config = {
        "graph_store": {
            "provider": "neptune",
            "config": {
                "endpoint": "neptune-graph://<GRAPH_ID>",
            },
        },
    }

    m = Memory.from_config(config_dict=config)
    ```

    Reference: [Neptune Analytics Guide](https://docs.aws.amazon.com/neptune/latest/analytics/).
  </Accordion>

  <Accordion title="Amazon Neptune DB (with external vectors)">
    Create a Neptune cluster, enable the public endpoint if you operate outside the VPC, and point Mem0 at the host:

    ```python  theme={null}
    from mem0 import Memory

    config = {
        "graph_store": {
            "provider": "neptunedb",
            "config": {
                "collection_name": "<VECTOR_COLLECTION_NAME>",
                "endpoint": "neptune-graph://<HOST_ENDPOINT>",
            },
        },
    }

    m = Memory.from_config(config_dict=config)
    ```

    Reference: [Accessing Data in Neptune DB](https://docs.aws.amazon.com/neptune/latest/userguide/).
  </Accordion>

  <Accordion title="Kuzu (embedded)">
    Kuzu runs in-process, so supply a path (or `:memory:`) for the database file:

    ```python  theme={null}
    config = {
        "graph_store": {
            "provider": "kuzu",
            "config": {
                "db": "/tmp/mem0-example.kuzu"
            }
        }
    }
    ```

    Kuzu will clear its state when using `:memory:` once the process exits. See the [Kuzu documentation](https://kuzudb.com/docs/) for advanced settings.
  </Accordion>
</AccordionGroup>

<CardGroup cols={2}>
  <Card title="Enhanced Metadata Filtering" description="Blend field-level filters with graph context to zero in on the right memories." icon="funnel" href="/open-source/features/metadata-filtering" />

  <Card title="Reranker-Enhanced Search" description="Layer rerankers on top of vectors and graphs for the cleanest results." icon="sparkles" href="/open-source/features/reranker-search" />
</CardGroup>


# Enhanced Metadata Filtering
Source: https://docs.mem0.ai/open-source/features/metadata-filtering

Fine-grained metadata queries for precise OSS memory retrieval.

Enhanced metadata filtering in Mem0 1.0.0 lets you run complex queries across memory metadata. Combine comparisons, logical operators, and wildcard matches to zero in on the exact memories your agent needs.

<Info>
  **You’ll use this when…**

  * Retrieval must respect multiple metadata conditions before returning context.
  * You need to mix numeric, boolean, and string filters in a single query.
  * Agents rely on deterministic filtering instead of broad semantic search alone.
</Info>

<Warning>
  Enhanced filtering requires Mem0 1.0.0 or later and a vector store that supports the operators you enable. Unsupported operators fall back to simple equality filters.
</Warning>

<Note>
  The TypeScript SDK accepts the same filter shape shown here—transpose the dictionaries to objects and reuse the keys unchanged.
</Note>

***

## Feature anatomy

<AccordionGroup>
  <Accordion title="Operator quick reference">
    | Operator                 | Meaning                                           | When to use it                                                         |
    | ------------------------ | ------------------------------------------------- | ---------------------------------------------------------------------- |
    | `eq` / `ne`              | Equals / not equals                               | Exact matches on strings, numbers, or booleans.                        |
    | `gt` / `gte`             | Greater than / greater than or equal              | Rank results by score, confidence, or any numeric field.               |
    | `lt` / `lte`             | Less than / less than or equal                    | Cap numeric values (e.g., ratings, timestamps).                        |
    | `in` / `nin`             | In list / not in list                             | Pre-approve or block sets of values without chaining multiple filters. |
    | `contains` / `icontains` | Case-sensitive / case-insensitive substring match | Scan text fields for keywords.                                         |
    | `*`                      | Wildcard                                          | Require that a field exists, regardless of value.                      |
    | `AND` / `OR` / `NOT`     | Combine filters                                   | Build logic trees so multiple conditions work together.                |
  </Accordion>
</AccordionGroup>

### Metadata selectors

Start with key-value filters when you need direct matches on metadata fields.

```python  theme={null}
from mem0 import Memory

m = Memory()

# Search with simple metadata filters
results = m.search(
    "What are my preferences?",
    user_id="alice",
    filters={"category": "preferences"}
)
```

<Info icon="check">
  Expect only memories tagged with `category="preferences"` to return for the given `user_id`.
</Info>

### Comparison operators

Layer greater-than/less-than comparisons to rank results by score, confidence, or any numeric field. Equality helpers (`eq`, `ne`) keep string and boolean checks explicit.

```python  theme={null}
# Greater than / Less than
results = m.search(
    "recent activities",
    user_id="alice",
    filters={
        "score": {"gt": 0.8},
        "priority": {"gte": 5},
        "confidence": {"lt": 0.9},
        "rating": {"lte": 3}
    }
)

# Equality operators
results = m.search(
    "specific content",
    user_id="alice",
    filters={
        "status": {"eq": "active"},
        "archived": {"ne": True}
    }
)
```

### List-based operators

Use `in` and `nin` when you want to pre-approve or exclude specific values without writing multiple equality checks.

```python  theme={null}
# In / Not in operators
results = m.search(
    "multi-category search",
    user_id="alice",
    filters={
        "category": {"in": ["food", "travel", "entertainment"]},
        "status": {"nin": ["deleted", "archived"]}
    }
)
```

<Info icon="check">
  Verify the response includes only memories in the whitelisted categories and omits any with archived or deleted status.
</Info>

### String operators

`contains` and `icontains` capture substring matches, making it easy to scan descriptions or tags for keywords without retrieving irrelevant memories.

```python  theme={null}
# Text matching operators
results = m.search(
    "content search",
    user_id="alice",
    filters={
        "title": {"contains": "meeting"},
        "description": {"icontains": "important"},
        "tags": {"contains": "urgent"}
    }
)
```

### Wildcard matching

Allow any value for a field while still requiring the field to exist—handy when the mere presence of a field matters.

```python  theme={null}
# Match any value for a field
results = m.search(
    "all with category",
    user_id="alice",
    filters={
        "category": "*"
    }
)
```

### Logical combinations

Combine filters with `AND`, `OR`, and `NOT` to express complex decision trees. Nest logical operators to encode multi-branch workflows.

```python  theme={null}
# Logical AND
results = m.search(
    "complex query",
    user_id="alice",
    filters={
        "AND": [
            {"category": "work"},
            {"priority": {"gte": 7}},
            {"status": {"ne": "completed"}}
        ]
    }
)

# Logical OR
results = m.search(
    "flexible query",
    user_id="alice",
    filters={
        "OR": [
            {"category": "urgent"},
            {"priority": {"gte": 9}},
            {"deadline": {"contains": "today"}}
        ]
    }
)

# Logical NOT
results = m.search(
    "exclusion query",
    user_id="alice",
    filters={
        "NOT": [
            {"category": "archived"},
            {"status": "deleted"}
        ]
    }
)

# Complex nested logic
results = m.search(
    "advanced query",
    user_id="alice",
    filters={
        "AND": [
            {
                "OR": [
                    {"category": "work"},
                    {"category": "personal"}
                ]
            },
            {"priority": {"gte": 5}},
            {
                "NOT": [
                    {"status": "archived"}
                ]
            }
        ]
    }
)
```

<Info icon="check">
  Inspect the response metadata—each returned memory should satisfy the combined logic tree exactly. If results look too broad, log the raw filters sent to your vector store.
</Info>

***

## Configure it

Tune your vector store so filter-heavy queries stay fast. Index fields you frequently filter on and keep complex checks for later in the evaluation order.

```python  theme={null}
# Ensure your vector store supports indexing on filtered fields
config = {
    "vector_store": {
        "provider": "qdrant",
        "config": {
            "host": "localhost",
            "port": 6333,
            "indexed_fields": ["category", "priority", "status", "user_id"]
        }
    }
}
```

<Info icon="check">
  After enabling indexing, benchmark the same query—latency should drop once the store can prune documents on indexed fields before vector scoring.
</Info>

<Tip>
  Put simple key=value filters on indexed fields before your range or text conditions so the store trims results early.
</Tip>

```python  theme={null}
# More efficient: Filter on indexed fields first
good_filters = {
    "AND": [
        {"user_id": "alice"},
        {"category": "work"},
        {"content": {"contains": "meeting"}}
    ]
}

# Less efficient: Complex operations first
avoid_filters = {
    "AND": [
        {"description": {"icontains": "complex text search"}},
        {"user_id": "alice"}
    ]
}
```

<Info icon="check">
  When you reorder filters so indexed fields come first (`good_filters` example), queries typically return faster than the `avoid_filters` pattern where expensive text searches run before simple checks.
</Info>

Vector store support varies. Confirm operator coverage before shipping:

<AccordionGroup>
  <Accordion title="Qdrant">
    Full comparison, list, and logical support. Handles deeply nested boolean logic efficiently.
  </Accordion>

  <Accordion title="Chroma">
    Equality and basic comparisons only. Limited nesting—break large trees into smaller calls.
  </Accordion>

  <Accordion title="Pinecone">
    Comparisons plus `in`/`nin`. Text operators are constrained; rely on tags where possible.
  </Accordion>

  <Accordion title="Weaviate">
    Full operator coverage with advanced text filters. Best option when you need hybrid text + metadata queries.
  </Accordion>
</AccordionGroup>

<Warning>
  If an operator is unsupported, most stores silently ignore that branch. Add validation before execution so you can fall back to simpler queries instead of returning empty results.
</Warning>

### Migrate from earlier filters

```python  theme={null}
# Before (v0.x) - simple key-value filtering only
results = m.search(
    "query",
    user_id="alice",
    filters={"category": "work", "status": "active"}
)

# After (v1.0.0) - enhanced filtering with operators
results = m.search(
    "query",
    user_id="alice",
    filters={
        "AND": [
            {"category": "work"},
            {"status": {"ne": "archived"}},
            {"priority": {"gte": 5}}
        ]
    }
)
```

<Note>
  Existing equality filters continue to work; add new operator branches gradually so agents can adopt richer queries without downtime.
</Note>

***

## See it in action

### Project management filtering

```python  theme={null}
# Find high-priority active tasks
results = m.search(
    "What tasks need attention?",
    user_id="project_manager",
    filters={
        "AND": [
            {"project": {"in": ["alpha", ""]}},
            {"priority": {"gte": 8}},
            {"status": {"ne": "completed"}},
            {
                "OR": [
                    {"assignee": "alice"},
                    {"assignee": "bob"}
                ]
            }
        ]
    }
)
```

<Info icon="check">
  Tasks returned should belong to the targeted projects, remain incomplete, and be assigned to one of the listed teammates.
</Info>

### Customer support filtering

```python  theme={null}
# Find recent unresolved tickets
results = m.search(
    "pending support issues",
    agent_id="support_bot",
    filters={
        "AND": [
            {"ticket_status": {"ne": "resolved"}},
            {"priority": {"in": ["high", "critical"]}},
            {"created_date": {"gte": "2024-01-01"}},
            {
                "NOT": [
                    {"category": "spam"}
                ]
            }
        ]
    }
)
```

<Tip>
  Pair `agent_id` filters with ticket-specific metadata so shared support bots return only the tickets they can act on in the current session.
</Tip>

### Content recommendation filtering

```python  theme={null}
# Personalized content filtering
results = m.search(
    "recommend content",
    user_id="reader123",
    filters={
        "AND": [
            {
                "OR": [
                    {"genre": {"in": ["sci-fi", "fantasy"]}},
                    {"author": {"contains": "favorite"}}
                ]
            },
            {"rating": {"gte": 4.0}},
            {"read_status": {"ne": "completed"}},
            {"language": "english"}
        ]
    }
)
```

<Info icon="check">
  Confirm personalized feeds show only unread titles that meet the rating and language criteria.
</Info>

### Handle invalid operators

```python  theme={null}
try:
    results = m.search(
        "test query",
        user_id="alice",
        filters={
            "invalid_operator": {"unknown": "value"}
        }
    )
except ValueError as e:
    print(f"Filter error: {e}")
    results = m.search(
        "test query",
        user_id="alice",
        filters={"category": "general"}
    )
```

<Warning>
  Validate filters before executing searches so you can catch typos or unsupported operators during development instead of at runtime.
</Warning>

***

## Verify the feature is working

* Log the filters sent to your vector store and confirm the response metadata matches every clause.
* Benchmark queries before and after indexing to ensure latency improvements materialize.
* Add analytics or debug logging to track how often fallbacks execute when operators fail validation.

***

## Best practices

1. **Use indexed fields first:** Order filters so equality checks run before complex string operations.
2. **Combine operators intentionally:** Keep logical trees readable—large nests are harder to debug.
3. **Test performance regularly:** Benchmark critical queries with production-like payloads.
4. **Plan graceful degradation:** Provide fallback filters when an operator isn’t available.
5. **Validate syntax early:** Catch malformed filters during development to protect agents at runtime.

***

<CardGroup cols={2}>
  <Card title="Explore Vector Store Options" icon="database" href="/components/vectordbs/overview">
    Compare operator coverage and indexing strategies across supported stores.
  </Card>

  <Card title="Tag and Organize Memories" icon="tag" href="/cookbooks/essentials/tagging-and-organizing-memories">
    Practice building workflows that label and retrieve memories with clear metadata filters.
  </Card>
</CardGroup>


# Multimodal Support
Source: https://docs.mem0.ai/open-source/features/multimodal-support

Capture and recall memories from both text and images.

Multimodal support lets Mem0 extract facts from images alongside regular text. Add screenshots, receipts, or product photos and Mem0 will store the insights as searchable memories so agents can recall them later.

<Info>
  **You’ll use this when…**

  * Users share screenshots, menus, or documents and you want the details to become memories.
  * You already collect text conversations but need visual context for better answers.
  * You want a single workflow that handles both URLs and local image files.
</Info>

<Warning>
  Images larger than 20 MB are rejected. Compress or resize files before sending them to avoid errors.
</Warning>

***

## Feature anatomy

* **Vision processing:** Mem0 runs the image through a vision model that extracts text and key details.
* **Memory creation:** Extracted information is stored as standard memories so search, filters, and analytics continue to work.
* **Context linking:** Visual and textual turns in the same conversation stay linked, giving agents richer context.
* **Flexible inputs:** Accept publicly accessible URLs or base64-encoded local files in both Python and JavaScript SDKs.

<AccordionGroup>
  <Accordion title="Supported formats">
    | Format     | Used for                    | Notes                                      |
    | ---------- | --------------------------- | ------------------------------------------ |
    | JPEG / JPG | Photos and screenshots      | Default option for camera captures.        |
    | PNG        | Images with transparency    | Keeps sharp text and UI elements crisp.    |
    | WebP       | Web-optimized images        | Smaller payloads for faster uploads.       |
    | GIF        | Static or animated graphics | Works for simple graphics and short loops. |
  </Accordion>
</AccordionGroup>

***

## Configure it

### Add image messages from URLs

<CodeGroup>
  ```python Python theme={null}
  from mem0 import Memory

  client = Memory()

  messages = [
      {"role": "user", "content": "Hi, my name is Alice."},
      {
          "role": "user",
          "content": {
              "type": "image_url",
              "image_url": {
                  "url": "https://example.com/menu.jpg"
              }
          }
      }
  ]

  client.add(messages, user_id="alice")
  ```

  ```ts TypeScript theme={null}
  import { Memory } from "mem0ai";

  const client = new Memory();

  const messages = [
    { role: "user", content: "Hi, my name is Alice." },
    {
      role: "user",
      content: {
        type: "image_url",
        image_url: { url: "https://example.com/menu.jpg" }
      }
    }
  ];

  await client.add(messages, { user_id: "alice" });
  ```
</CodeGroup>

<Info icon="check">
  Inspect the response payload—the memories list should include entries extracted from the menu image as well as the text turns.
</Info>

### Upload local images as base64

<CodeGroup>
  ```python Python theme={null}
  import base64
  from mem0 import Memory

  def encode_image(image_path):
      with open(image_path, "rb") as image_file:
          return base64.b64encode(image_file.read()).decode("utf-8")

  client = Memory()
  base64_image = encode_image("path/to/your/image.jpg")

  messages = [
      {
          "role": "user",
          "content": [
              {"type": "text", "text": "What's in this image?"},
              {
                  "type": "image_url",
                  "image_url": {
                      "url": f"data:image/jpeg;base64,{base64_image}"
                  }
              }
          ]
      }
  ]

  client.add(messages, user_id="alice")
  ```

  ```ts TypeScript theme={null}
  import fs from "fs";
  import { Memory } from "mem0ai";

  function encodeImage(imagePath: string) {
    const buffer = fs.readFileSync(imagePath);
    return buffer.toString("base64");
  }

  const client = new Memory();
  const base64Image = encodeImage("path/to/your/image.jpg");

  const messages = [
    {
      role: "user",
      content: [
        { type: "text", text: "What's in this image?" },
        {
          type: "image_url",
          image_url: {
            url: `data:image/jpeg;base64,${base64Image}`
          }
        }
      ]
    }
  ];

  await client.add(messages, { user_id: "alice" });
  ```
</CodeGroup>

<Tip>
  Keep base64 payloads under 5 MB to speed up uploads and avoid hitting the 20 MB limit.
</Tip>

***

## See it in action

### Restaurant menu memory

```python  theme={null}
from mem0 import Memory

client = Memory()

messages = [
    {
        "role": "user",
        "content": "Help me remember which dishes I liked."
    },
    {
        "role": "user",
        "content": {
            "type": "image_url",
            "image_url": {
                "url": "https://example.com/restaurant-menu.jpg"
            }
        }
    },
    {
        "role": "user",
        "content": "I’m allergic to peanuts and prefer vegetarian meals."
    }
]

result = client.add(messages, user_id="user123")
print(result)
```

<Info icon="check">
  The response should capture both the allergy note and menu items extracted from the photo so future searches can combine them.
</Info>

### Document capture

```python  theme={null}
messages = [
    {
        "role": "user",
        "content": "Store this receipt information for expenses."
    },
    {
        "role": "user",
        "content": {
            "type": "image_url",
            "image_url": {
                "url": "https://example.com/receipt.jpg"
            }
        }
    }
]

client.add(messages, user_id="user123")
```

<Tip>
  Combine the receipt upload with structured metadata (tags, categories) if you need to filter expenses later.
</Tip>

### Error handling

<CodeGroup>
  ```python Python theme={null}
  from mem0 import Memory
  from mem0.exceptions import InvalidImageError, FileSizeError

  client = Memory()

  try:
      messages = [{
          "role": "user",
          "content": {
              "type": "image_url",
              "image_url": {"url": "https://example.com/image.jpg"}
          }
      }]

      client.add(messages, user_id="user123")
      print("Image processed successfully")

  except InvalidImageError:
      print("Invalid image format or corrupted file")
  except FileSizeError:
      print("Image file too large")
  except Exception as exc:
      print(f"Unexpected error: {exc}")
  ```

  ```ts TypeScript theme={null}
  import { Memory } from "mem0ai";

  const client = new Memory();

  try {
    const messages = [{
      role: "user",
      content: {
        type: "image_url",
        image_url: { url: "https://example.com/image.jpg" }
      }
    }];

    await client.add(messages, { user_id: "user123" });
    console.log("Image processed successfully");
  } catch (error: any) {
    if (error.type === "invalid_image") {
      console.log("Invalid image format or corrupted file");
    } else if (error.type === "file_size_exceeded") {
      console.log("Image file too large");
    } else {
      console.log(`Unexpected error: ${error.message}`);
    }
  }
  ```
</CodeGroup>

<Warning>
  Fail fast on invalid formats so you can prompt users to re-upload before losing their context.
</Warning>

***

## Verify the feature is working

* After calling `add`, inspect the returned memories and confirm they include image-derived text (menu items, receipt totals, etc.).
* Run a follow-up `search` for a detail from the image; the memory should surface alongside related text.
* Monitor image upload latency—large files should still complete under your acceptable response time.
* Log file size and URL sources to troubleshoot repeated failures.

***

## Best practices

1. **Ask for intent:** Prompt users to explain why they sent an image so the memory includes the right context.
2. **Keep images readable:** Encourage clear photos without heavy filters or shadows for better extraction.
3. **Split bulk uploads:** Send multiple images as separate `add` calls to isolate failures and improve reliability.
4. **Watch privacy:** Avoid uploading sensitive documents unless your environment is secured for that data.
5. **Validate file size early:** Check file size before encoding to save bandwidth and time.

***

## Troubleshooting

| Issue                     | Cause                        | Fix                                                                    |
| ------------------------- | ---------------------------- | ---------------------------------------------------------------------- |
| Upload rejected           | File larger than 20 MB       | Compress or resize before sending.                                     |
| Memory missing image data | Low-quality or blurry image  | Retake the photo with better lighting.                                 |
| Invalid format error      | Unsupported file type        | Convert to JPEG or PNG first.                                          |
| Slow processing           | High-resolution images       | Downscale or compress to under 5 MB.                                   |
| Base64 errors             | Incorrect prefix or encoding | Ensure `data:image/<type>;base64,` is present and the string is valid. |

***

<CardGroup cols={2}>
  <Card title="Connect Vision Models" icon="circle-dot" href="/components/llms/models/openai">
    Review supported vision-capable models and configuration details.
  </Card>

  <Card title="Build Multimodal Retrieval" icon="image" href="/cookbooks/frameworks/multimodal-retrieval">
    Follow an end-to-end workflow pairing text and image memories.
  </Card>
</CardGroup>


# OpenAI Compatibility
Source: https://docs.mem0.ai/open-source/features/openai_compatibility

Use Mem0 with the same chat-completions flow you already built for OpenAI.

Mem0 mirrors the OpenAI client interface so you can plug memories into existing chat-completion code with minimal changes. Point your OpenAI-compatible client at Mem0, keep the same request shape, and gain persistent memory between calls.

<Info>
  **You’ll use this when…**

  * Your app already relies on OpenAI chat completions and you want Mem0 to feel familiar.
  * You need to reuse existing middleware that expects OpenAI-compatible responses.
  * You plan to switch between Mem0 Platform and the self-hosted client without rewriting code.
</Info>

## Feature

* **Drop-in client:** `client.chat.completions.create(...)` works the same as OpenAI’s method signatures.
* **Shared parameters:** Mem0 accepts `messages`, `model`, and optional memory-scoping fields (`user_id`, `agent_id`, `run_id`).
* **Memory-aware responses:** Each call saves relevant facts so future prompts automatically reflect past conversations.
* **OSS parity:** Use the same API surface whether you call the hosted proxy or the OSS configuration.

<Info icon="check">
  Run one request with `user_id` set. If the next call references that ID and its reply uses the stored memory, compatibility is confirmed.
</Info>

***

## Configure it

### Call the managed Mem0 proxy

```python  theme={null}
from mem0.proxy.main import Mem0

client = Mem0(api_key="m0-xxx")

messages = [
    {"role": "user", "content": "I love Indian food but I cannot eat pizza since I'm allergic to cheese."}
]

chat_completion = client.chat.completions.create(
    messages=messages,
    model="gpt-4.1-nano-2025-04-14",
    user_id="alice"
)
```

<Tip>
  Reuse the same identifiers your OpenAI client already sends so you can switch between providers without branching logic.
</Tip>

### Use the OpenAI-compatible OSS client

```python  theme={null}
from mem0.proxy.main import Mem0

config = {
    "vector_store": {
        "provider": "qdrant",
        "config": {
            "host": "localhost",
            "port": 6333
        }
    }
}

client = Mem0(config=config)

chat_completion = client.chat.completions.create(
    messages=[{"role": "user", "content": "What's the capital of France?"}],
    model="gpt-4.1-nano-2025-04-14"
)
```

## See it in action

### Memory-aware restaurant recommendation

```python  theme={null}
from mem0.proxy.main import Mem0

client = Mem0(api_key="m0-xxx")

# Store preferences
client.chat.completions.create(
    messages=[{"role": "user", "content": "I love Indian food but I'm allergic to cheese."}],
    model="gpt-4.1-nano-2025-04-14",
    user_id="alice"
)

# Later conversation reuses the memory
response = client.chat.completions.create(
    messages=[{"role": "user", "content": "Suggest dinner options in San Francisco."}],
    model="gpt-4.1-nano-2025-04-14",
    user_id="alice"
)

print(response.choices[0].message.content)
```

<Info icon="check">
  The second response should call out Indian restaurants and avoid cheese, proving Mem0 recalled the stored preference.
</Info>

***

## Verify the feature is working

* Compare responses from Mem0 vs. OpenAI for identical prompts—both should return the same structure (`choices`, `usage`, etc.).
* Inspect stored memories after each request to confirm the fact extraction captured the right details.
* Test switching between hosted (`Mem0(api_key=...)`) and OSS configurations to ensure both respect the same request body.

***

## Best practices

1. **Scope context intentionally:** Pass identifiers only when you want conversations to persist; skip them for one-off calls.
2. **Log memory usage:** Inspect `response.metadata.memories` (if enabled) to see which facts the model recalled.
3. **Reuse middleware:** Point your existing OpenAI client wrappers to the Mem0 proxy URL to avoid code drift.
4. **Handle fallbacks:** Keep a code path for plain OpenAI calls in case Mem0 is unavailable, then resync memory later.

***

## Parameter reference

| Parameter  | Type   | Purpose                                                         |
| ---------- | ------ | --------------------------------------------------------------- |
| `user_id`  | `str`  | Associates the conversation with a user so memories persist.    |
| `agent_id` | `str`  | Optional agent or bot identifier for multi-agent scenarios.     |
| `run_id`   | `str`  | Optional session/run identifier for short-lived flows.          |
| `metadata` | `dict` | Store extra fields alongside each memory entry.                 |
| `filters`  | `dict` | Restrict retrieval to specific memories while responding.       |
| `limit`    | `int`  | Cap how many memories Mem0 pulls into the context (default 10). |

Other request fields mirror OpenAI’s chat completion API.

***

<CardGroup cols={2}>
  <Card title="Connect Vision Models" icon="circle-dot" href="/components/llms/models/openai">
    Review LLM options that support OpenAI-compatible calls in Mem0.
  </Card>

  <Card title="Automate OpenAI Tool Calls" icon="plug" href="/cookbooks/integrations/openai-tool-calls">
    See a full workflow that layers Mem0 memories on top of tool-calling agents.
  </Card>
</CardGroup>


# Overview
Source: https://docs.mem0.ai/open-source/features/overview

Self-hosting features that extend Mem0 beyond basic memory storage

# Self-Hosting Features Overview

Mem0 Open Source ships with capabilities that adapt memory behavior for production workloads—async operations, graph relationships, multimodal inputs, and fine-tuned retrieval. Configure these features with code or YAML to match your application's needs.

<Info>
  Start with the <Link href="/open-source/python-quickstart">Python quickstart</Link> to validate basic memory operations, then enable the features below when you need them.
</Info>

## Choose your path

<CardGroup cols={3}>
  <Card title="Graph Memory" icon="network-wired" href="/open-source/features/graph-memory">
    Store entity relationships for multi-hop recall.
  </Card>

  <Card title="Advanced Metadata Filtering" icon="filter" href="/open-source/features/metadata-filtering">
    Query with logical operators and nested conditions.
  </Card>

  <Card title="Search with Reranking" icon="ranking-star" href="/open-source/features/reranker-search">
    Boost search relevance with specialized models.
  </Card>

  <Card title="Async Memory Operations" icon="bolt" href="/open-source/features/async-memory">
    Non-blocking operations for high-throughput apps.
  </Card>

  <Card title="Multimodal Support" icon="image" href="/open-source/features/multimodal-support">
    Process images, audio, and video memories.
  </Card>

  <Card title="Custom Fact Extraction" icon="wand-magic-sparkles" href="/open-source/features/custom-fact-extraction-prompt">
    Tailor how facts are extracted from text.
  </Card>
</CardGroup>

<CardGroup cols={3}>
  <Card title="Custom Memory Updates" icon="arrows-rotate" href="/open-source/features/custom-update-memory-prompt">
    Control memory refinement with custom instructions.
  </Card>

  <Card title="REST API" icon="code" href="/open-source/features/rest-api">
    HTTP endpoints for language-agnostic integrations.
  </Card>

  <Card title="OpenAI Compatibility" icon="message-bot" href="/open-source/features/openai_compatibility">
    Drop-in replacement for OpenAI chat endpoints.
  </Card>
</CardGroup>

<Tip>
  Looking for managed features instead? Compare self-hosting vs managed in the <Link href="/platform/platform-vs-oss">Platform vs OSS guide</Link>.
</Tip>

## Keep going

<CardGroup cols={2}>
  <Card title="Configure Components" description="Choose your LLM, embedder, vector store, and reranker with YAML or code." icon="sliders" href="/open-source/configuration" />

  <Card title="Explore Cookbooks" description="Follow production-ready examples that combine multiple features." icon="book" href="/cookbooks/overview" />
</CardGroup>


# Reranker-Enhanced Search
Source: https://docs.mem0.ai/open-source/features/reranker-search

Boost relevance by reordering vector hits with reranking models.

Reranker-enhanced search adds a second scoring pass after vector retrieval so Mem0 can return the most relevant memories first. Enable it when keyword similarity alone misses nuance or when you need the highest-confidence context for an agent decision.

<Info>
  **You’ll use this when…**

  * Queries are nuanced and require semantic understanding beyond vector distance.
  * Large memory collections produce too many near matches to review manually.
  * You want consistent scoring across providers by delegating ranking to a dedicated model.
</Info>

<Warning>
  Reranking raises latency and, for hosted models, API spend. Benchmark with production traffic and define a fallback path for latency-sensitive requests.
</Warning>

<Note>
  All configuration snippets translate directly to the TypeScript SDK—swap dictionaries for objects while keeping the same keys (`provider`, `config`, `rerank` flags).
</Note>

***

## Feature anatomy

* **Initial vector search:** Retrieve candidate memories by similarity.
* **Reranker pass:** A specialized model scores each candidate against the original query.
* **Reordered results:** Mem0 sorts responses using the reranker’s scores before returning them.
* **Optional fallbacks:** Toggle reranking per request or disable it entirely if performance or cost becomes a concern.

<AccordionGroup>
  <Accordion title="Supported providers">
    - **[Cohere](/components/rerankers/models/cohere)** – Multilingual hosted reranker with API-based scoring.
    - **[Sentence Transformer](/components/rerankers/models/sentence_transformer)** – Local Hugging Face cross-encoders for GPU or CPU.
    - **[Hugging Face](/components/rerankers/models/huggingface)** – Bring any hosted or on-prem reranker model ID.
    - **[LLM Reranker](/components/rerankers/models/llm_reranker)** – Use your preferred LLM (OpenAI, etc.) for prompt-driven scoring.
    - **[Zero Entropy](/components/rerankers/models/zero_entropy)** – High-quality neural reranking tuned for retrieval tasks.
  </Accordion>

  <Accordion title="Provider comparison">
    | Provider             | Latency    | Quality   | Cost     | Local deploy |
    | -------------------- | ---------- | --------- | -------- | ------------ |
    | Cohere               | Medium     | High      | API cost | ❌            |
    | Sentence Transformer | Low        | Good      | Free     | ✅            |
    | Hugging Face         | Low–Medium | Variable  | Free     | ✅            |
    | LLM Reranker         | High       | Very high | API cost | Depends      |
  </Accordion>
</AccordionGroup>

***

## Configure it

### Basic setup

```python  theme={null}
from mem0 import Memory

config = {
    "reranker": {
        "provider": "cohere",
        "config": {
            "model": "rerank-english-v3.0",
            "api_key": "your-cohere-api-key"
        }
    }
}

m = Memory.from_config(config)
```

<Info icon="check">
  Confirm `results["results"][0]["score"]` reflects the reranker output—if the field is missing, the reranker was not applied.
</Info>

<Tip>
  Set `top_k` to the smallest candidate pool that still captures relevant hits. Smaller pools keep reranking costs down.
</Tip>

### Provider-specific options

```python  theme={null}
# Cohere reranker
config = {
    "reranker": {
        "provider": "cohere",
        "config": {
            "model": "rerank-english-v3.0",
            "api_key": "your-cohere-api-key",
            "top_k": 10,
            "return_documents": True
        }
    }
}

# Sentence Transformer reranker
config = {
    "reranker": {
        "provider": "sentence_transformer",
        "config": {
            "model": "cross-encoder/ms-marco-MiniLM-L-6-v2",
            "device": "cuda",
            "max_length": 512
        }
    }
}

# Hugging Face reranker
config = {
    "reranker": {
        "provider": "huggingface",
        "config": {
            "model": "BAAI/bge-reranker-base",
            "device": "cuda",
            "batch_size": 32
        }
    }
}

# LLM-based reranker
config = {
    "reranker": {
        "provider": "llm_reranker",
        "config": {
            "llm": {
                "provider": "openai",
                "config": {
                    "model": "gpt-4",
                    "api_key": "your-openai-api-key"
                }
            },
            "top_k": 5
        }
    }
}
```

<Note>
  Keep authentication keys in environment variables when you plug these configs into production projects.
</Note>

### Full stack example

```python  theme={null}
config = {
    "vector_store": {
        "provider": "qdrant",
        "config": {
            "host": "localhost",
            "port": 6333
        }
    },
    "llm": {
        "provider": "openai",
        "config": {
            "model": "gpt-4",
            "api_key": "your-openai-api-key"
        }
    },
    "embedder": {
        "provider": "openai",
        "config": {
            "model": "text-embedding-3-small",
            "api_key": "your-openai-api-key"
        }
    },
    "reranker": {
        "provider": "cohere",
        "config": {
            "model": "rerank-english-v3.0",
            "api_key": "your-cohere-api-key",
            "top_k": 15,
            "return_documents": True
        }
    }
}

m = Memory.from_config(config)
```

<Info icon="check">
  A quick search should now return results with both vector and reranker scores, letting you compare improvements immediately.
</Info>

### Async support

```python  theme={null}
from mem0 import AsyncMemory

async_memory = AsyncMemory.from_config(config)

async def search_with_rerank():
    return await async_memory.search(
        "What are my preferences?",
        user_id="alice",
        rerank=True
    )

import asyncio
results = asyncio.run(search_with_rerank())
```

<Info icon="check">
  Inspect the async response to confirm reranking still applies; the scores should match the synchronous implementation.
</Info>

### Tune performance and cost

```python  theme={null}
# GPU-friendly local reranker configuration
config = {
    "reranker": {
        "provider": "sentence_transformer",
        "config": {
            "model": "cross-encoder/ms-marco-MiniLM-L-6-v2",
            "device": "cuda",
            "batch_size": 32,
            "top_k": 10,
            "max_length": 256
        }
    }
}

# Smart toggle for hosted rerankers
def smart_search(query, user_id, use_rerank=None):
    if use_rerank is None:
        use_rerank = len(query.split()) > 3
    return m.search(query, user_id=user_id, rerank=use_rerank)
```

<Tip>
  Use heuristics (query length, user tier) to decide when to rerank so high-signal queries benefit without taxing every request.
</Tip>

### Handle failures gracefully

```python  theme={null}
try:
    results = m.search("test query", user_id="alice", rerank=True)
except Exception as exc:
    print(f"Reranking failed: {exc}")
    results = m.search("test query", user_id="alice", rerank=False)
```

<Warning>
  Always fall back to vector-only search—dropped queries introduce bigger accuracy issues than slightly less relevant ordering.
</Warning>

### Migrate from v0.x

```python  theme={null}
# Before: basic vector search
results = m.search("query", user_id="alice")

# After: same API with reranking enabled via config
config = {
    "reranker": {
        "provider": "sentence_transformer",
        "config": {
            "model": "cross-encoder/ms-marco-MiniLM-L-6-v2"
        }
    }
}

m = Memory.from_config(config)
results = m.search("query", user_id="alice")
```

***

## See it in action

### Basic reranked search

```python  theme={null}
results = m.search(
    "What are my food preferences?",
    user_id="alice"
)

for result in results["results"]:
    print(f"Memory: {result['memory']}")
    print(f"Score: {result['score']}")
```

<Info icon="check">
  Expect each result to list the reranker-adjusted score so you can compare ordering against baseline vector results.
</Info>

### Toggle reranking per request

```python  theme={null}
results_with_rerank = m.search(
    "What movies do I like?",
    user_id="alice",
    rerank=True
)

results_without_rerank = m.search(
    "What movies do I like?",
    user_id="alice",
    rerank=False
)
```

<Tip>
  Log the reranked vs. non-reranked lists during rollout so stakeholders can see the improvement before enforcing it everywhere.
</Tip>

<Info icon="check">
  You should see the same memories in both lists, but the reranked response will reorder them based on semantic relevance.
</Info>

### Combine with metadata filters

```python  theme={null}
results = m.search(
    "important work tasks",
    user_id="alice",
    filters={
        "AND": [
            {"category": "work"},
            {"priority": {"gte": 7}}
        ]
    },
    rerank=True,
    limit=20
)
```

<Info icon="check">
  Verify filtered reranked searches still respect every metadata clause—reranking only reorders candidates, it never bypasses filters.
</Info>

### Real-world playbooks

#### Customer support

```python  theme={null}
config = {
    "reranker": {
        "provider": "cohere",
        "config": {
            "model": "rerank-english-v3.0",
            "api_key": "your-cohere-api-key"
        }
    }
}

m = Memory.from_config(config)

results = m.search(
    "customer having login issues with mobile app",
    agent_id="support_bot",
    filters={"category": "technical_support"},
    rerank=True
)
```

<Info icon="check">
  Top results should highlight tickets matching the login issue context so agents can respond faster.
</Info>

#### Content recommendation

```python  theme={null}
results = m.search(
    "science fiction books with space exploration themes",
    user_id="reader123",
    filters={"content_type": "book_recommendation"},
    rerank=True,
    limit=10
)

for result in results["results"]:
    print(f"Recommendation: {result['memory']}")
    print(f"Relevance: {result['score']:.3f}")
```

<Info icon="check">
  Expect high-scoring recommendations that match both the requested theme and any metadata limits you applied.
</Info>

#### Personal assistant

```python  theme={null}
results = m.search(
    "What restaurants did I enjoy last month that had good vegetarian options?",
    user_id="foodie_user",
    filters={
        "AND": [
            {"category": "dining"},
            {"rating": {"gte": 4}},
            {"date": {"gte": "2024-01-01"}}
        ]
    },
    rerank=True
)
```

<Tip>
  Reuse this pattern for other lifestyle queries—swap the filters and prompt text without changing the rerank configuration.
</Tip>

<Note>
  Each workflow keeps the same `m.search(...)` signature, so you can template these queries across agents with only the prompt and filters changing.
</Note>

***

## Verify the feature is working

* Inspect result payloads for both `score` (vector) and reranker scores; mismatched fields indicate the reranker didn’t execute.
* Track latency before and after enabling reranking to ensure SLAs hold.
* Review provider logs or dashboards for throttling or quota warnings.
* Run A/B comparisons (rerank on/off) to validate improved relevance before defaulting to reranked responses.

***

## Best practices

1. **Start local:** Try Sentence Transformer models to prove value before paying for hosted APIs.
2. **Monitor latency:** Add metrics around reranker duration so you notice regressions quickly.
3. **Control spend:** Use `top_k` and selective toggles to cap hosted reranker costs.
4. **Keep a fallback:** Always catch reranker failures and continue with vector-only ordering.
5. **Experiment often:** Swap providers or models to find the best fit for your domain and language mix.

***

<CardGroup cols={2}>
  <Card title="Configure Rerankers" icon="sliders" href="/components/rerankers/config">
    Review provider fields, defaults, and environment variables before going live.
  </Card>

  <Card title="Build a Custom LLM Reranker" icon="sparkles" href="/components/rerankers/models/llm_reranker">
    Extend scoring with prompt-tuned LLM rerankers for niche workflows.
  </Card>
</CardGroup>


# REST API Server
Source: https://docs.mem0.ai/open-source/features/rest-api

Reach every Mem0 OSS capability through a FastAPI-powered REST layer.

The Mem0 REST API server exposes every OSS memory operation over HTTP. Run it alongside your stack to add, search, update, and delete memories from any language that speaks REST.

<Info>
  **You’ll use this when…**

  * Your services already talk to REST APIs and you want Mem0 to match that style.
  * Teams on languages without the Mem0 SDK still need access to memories.
  * You plan to explore or debug endpoints through the built-in OpenAPI page at `/docs`.
</Info>

<Warning>
  Add your own authentication and HTTPS before exposing the server to anything beyond your internal network. The default image does not include auth.
</Warning>

***

## Feature

* **CRUD endpoints:** Create, retrieve, search, update, delete, and reset memories by `user_id`, `agent_id`, or `run_id`.
* **Status health check:** Access base routes to confirm the server is online.
* **OpenAPI explorer:** Visit `/docs` for interactive testing and schema reference.

***

## Configure it

### Run with Docker Compose (development)

<Tabs>
  <Tab title="Steps">
    1. Create `server/.env` with your keys:

    ```bash  theme={null}
    OPENAI_API_KEY=your-openai-api-key
    ```

    2. Start the stack:

    ```bash  theme={null}
    cd server
    docker compose up
    ```

    3. Reach the API at `http://localhost:8888`. Edits to the server or library auto-reload.
  </Tab>
</Tabs>

### Run with Docker

<Tabs>
  <Tab title="Pull image">
    ```bash  theme={null}
    docker pull mem0/mem0-api-server
    ```
  </Tab>

  <Tab title="Build locally">
    ```bash  theme={null}
    docker build -t mem0-api-server .
    ```
  </Tab>
</Tabs>

1. Create a `.env` file with `OPENAI_API_KEY`.
2. Run the container:

```bash  theme={null}
docker run -p 8000:8000 --env-file .env mem0-api-server
```

3. Visit `http://localhost:8000`.

### Run directly (no Docker)

```bash  theme={null}
pip install -r requirements.txt
uvicorn main:app --reload
```

<Tip>
  Use a process manager such as `systemd`, Supervisor, or PM2 when deploying the FastAPI server for production resilience.
</Tip>

<Note>
  The REST server reads the same configuration you use locally, so you can point it at your preferred LLM, vector store, graph backend, and reranker without changing code.
</Note>

***

## See it in action

### Create and search memories via HTTP

```bash  theme={null}
curl -X POST http://localhost:8000/memories \
  -H "Content-Type: application/json" \
  -d '{
    "messages": [
      {"role": "user", "content": "I love fresh vegetable pizza."}
    ],
    "user_id": "alice"
  }'
```

<Info icon="check">
  Expect a JSON response containing the new memory IDs and events (`ADD`, etc.).
</Info>

```bash  theme={null}
curl "http://localhost:8000/memories/search?user_id=alice&query=vegetable"
```

### Explore with OpenAPI docs

1. Navigate to `http://localhost:8000/docs`.
2. Pick an endpoint (e.g., `POST /memories/search`).
3. Fill in parameters and click **Execute** to try requests in-browser.

<Tip>
  Export the generated `curl` snippets from the OpenAPI UI to bootstrap integration tests.
</Tip>

***

## Verify the feature is working

* Hit the root route and `/docs` to confirm the server is reachable.
* Run a full cycle: `POST /memories` → `GET /memories/{id}` → `DELETE /memories/{id}`.
* Watch server logs for import errors or provider misconfigurations during startup.
* Confirm environment variables (API keys, vector store credentials) load correctly when containers restart.

***

## Best practices

1. **Add authentication:** Protect endpoints with API gateways, proxies, or custom FastAPI middleware.
2. **Use HTTPS:** Terminate TLS at your load balancer or reverse proxy.
3. **Monitor uptime:** Track request rates, latency, and error codes per endpoint.
4. **Version configs:** Keep environment files and Docker Compose definitions in source control.
5. **Limit exposure:** Bind to private networks unless you explicitly need public access.

***

<CardGroup cols={2}>
  <Card title="Configure OSS Components" icon="sliders" href="/open-source/configuration">
    Fine-tune LLMs, vector stores, and graph backends that power the REST server.
  </Card>

  <Card title="Automate Agent Integrations" icon="plug" href="/cookbooks/integrations/agents-sdk-tool">
    See how services call the REST endpoints as part of an automation pipeline.
  </Card>
</CardGroup>


# Node SDK Quickstart
Source: https://docs.mem0.ai/open-source/node-quickstart

Store and search Mem0 memories from a TypeScript or JavaScript app in minutes.

Spin up Mem0 with the Node SDK in just a few steps. You’ll install the package, initialize the client, add a memory, and confirm retrieval with a single search.

## Prerequisites

* Node.js 18 or higher
* (Optional) OpenAI API key stored in your environment when you want to customize providers

## Install and run your first memory

<Steps>
  <Step title="Install the SDK">
    ```bash  theme={null}
    npm install mem0ai
    ```
  </Step>

  <Step title="Initialize the client">
    ```ts  theme={null}
    import { Memory } from "mem0ai/oss";

    const memory = new Memory();
    ```
  </Step>

  <Step title="Add a memory">
    ```ts  theme={null}
    const 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." }
    ];

    await memory.add(messages, { userId: "alice", metadata: { category: "movie_recommendations" } });
    ```
  </Step>

  <Step title="Search memories">
    ```ts  theme={null}
    const results = await memory.search("What do you know about me?", { userId: "alice" });
    console.log(results);
    ```

    **Output**

    ```json  theme={null}
    {
      "results": [
        {
          "id": "892db2ae-06d9-49e5-8b3e-585ef9b85b8e",
          "memory": "User is planning to watch a movie tonight.",
          "score": 0.38920719231944799,
          "metadata": {
            "category": "movie_recommendations"
          },
          "userId": "alice"
        }
      ]
    }
    ```
  </Step>
</Steps>

<Note>
  By default the Node SDK uses local-friendly settings (OpenAI `gpt-4.1-nano-2025-04-14`, `text-embedding-3-small`, in-memory vector store, and SQLite history). Swap components by passing a config as shown below.
</Note>

## Configure for production

```ts  theme={null}
import { Memory } from "mem0ai/oss";

const memory = new Memory({
  version: "v1.1",
  embedder: {
    provider: "openai",
    config: {
      apiKey: process.env.OPENAI_API_KEY || "",
      model: "text-embedding-3-small"
    }
  },
  vectorStore: {
    provider: "memory",
    config: {
      collectionName: "memories",
      dimension: 1536
    }
  },
  llm: {
    provider: "openai",
    config: {
      apiKey: process.env.OPENAI_API_KEY || "",
      model: "gpt-4-turbo-preview"
    }
  },
  historyDbPath: "memory.db"
});
```

## Manage memories (optional)

<CodeGroup>
  ```ts Get all memories theme={null}
  const allMemories = await memory.getAll({ userId: "alice" });
  console.log(allMemories);
  ```

  ```ts Get one memory theme={null}
  const singleMemory = await memory.get("892db2ae-06d9-49e5-8b3e-585ef9b85b8e");
  console.log(singleMemory);
  ```

  ```ts Search memories theme={null}
  const result = await memory.search("What do you know about me?", { userId: "alice" });
  console.log(result);
  ```

  ```ts Update a memory theme={null}
  const updateResult = await memory.update(
    "892db2ae-06d9-49e5-8b3e-585ef9b85b8e",
    "I love India, it is my favorite country."
  );
  console.log(updateResult);
  ```
</CodeGroup>

```ts  theme={null}
// Audit history
const history = await memory.history("892db2ae-06d9-49e5-8b3e-585ef9b85b8e");
console.log(history);

// Delete specific or scoped memories
await memory.delete("892db2ae-06d9-49e5-8b3e-585ef9b85b8e");
await memory.deleteAll({ userId: "alice" });

// Reset everything
await memory.reset();
```

## Use a custom history store

The Node SDK supports Supabase (or other providers) when you need serverless-friendly history storage.

<CodeGroup>
  ```ts Supabase provider theme={null}
  import { Memory } from "mem0ai/oss";

  const memory = new Memory({
    historyStore: {
      provider: "supabase",
      config: {
        supabaseUrl: process.env.SUPABASE_URL || "",
        supabaseKey: process.env.SUPABASE_KEY || "",
        tableName: "memory_history"
      }
    }
  });
  ```

  ```ts Disable history theme={null}
  import { Memory } from "mem0ai/oss";

  const memory = new Memory({
    disableHistory: true
  });
  ```
</CodeGroup>

Create the Supabase table with:

```sql  theme={null}
create table memory_history (
  id text primary key,
  memory_id text not null,
  previous_value text,
  new_value text,
  action text not null,
  created_at timestamp with time zone default timezone('utc', now()),
  updated_at timestamp with time zone,
  is_deleted integer default 0
);
```

## Configuration parameters

Mem0 offers granular configuration across vector stores, LLMs, embedders, and history stores.

<AccordionGroup>
  <Accordion title="Vector store">
    | Parameter  | Description                              | Default       |
    | ---------- | ---------------------------------------- | ------------- |
    | `provider` | Vector store provider (e.g., `"memory"`) | `"memory"`    |
    | `host`     | Host address                             | `"localhost"` |
    | `port`     | Port number                              | `undefined`   |
  </Accordion>

  <Accordion title="LLM">
    | Parameter       | Description                                    | Provider |
    | --------------- | ---------------------------------------------- | -------- |
    | `provider`      | LLM provider (e.g., `"openai"`, `"anthropic"`) | All      |
    | `model`         | Model to use                                   | All      |
    | `temperature`   | Temperature value                              | All      |
    | `apiKey`        | API key                                        | All      |
    | `maxTokens`     | Max tokens to generate                         | All      |
    | `topP`          | Probability threshold                          | All      |
    | `topK`          | Token count to keep                            | All      |
    | `openaiBaseUrl` | Base URL override                              | OpenAI   |
  </Accordion>

  <Accordion title="Graph store">
    | Parameter  | Description                            | Default                      |
    | ---------- | -------------------------------------- | ---------------------------- |
    | `provider` | Graph store provider (e.g., `"neo4j"`) | `"neo4j"`                    |
    | `url`      | Connection URL                         | `process.env.NEO4J_URL`      |
    | `username` | Username                               | `process.env.NEO4J_USERNAME` |
    | `password` | Password                               | `process.env.NEO4J_PASSWORD` |
  </Accordion>

  <Accordion title="Embedder">
    | Parameter  | Description        | Default                    |
    | ---------- | ------------------ | -------------------------- |
    | `provider` | Embedding provider | `"openai"`                 |
    | `model`    | Embedding model    | `"text-embedding-3-small"` |
    | `apiKey`   | API key            | `undefined`                |
  </Accordion>

  <Accordion title="General">
    | Parameter       | Description              | Default                   |
    | --------------- | ------------------------ | ------------------------- |
    | `historyDbPath` | Path to history database | `"{mem0_dir}/history.db"` |
    | `version`       | API version              | `"v1.0"`                  |
    | `customPrompt`  | Custom processing prompt | `undefined`               |
  </Accordion>

  <Accordion title="History store">
    | Parameter        | Description            | Default     |
    | ---------------- | ---------------------- | ----------- |
    | `provider`       | History provider       | `"sqlite"`  |
    | `config`         | Provider configuration | `undefined` |
    | `disableHistory` | Disable history store  | `false`     |
  </Accordion>

  <Accordion title="Complete config example">
    ```ts  theme={null}
    const config = {
      version: "v1.1",
      embedder: {
        provider: "openai",
        config: {
          apiKey: process.env.OPENAI_API_KEY || "",
          model: "text-embedding-3-small"
        }
      },
      vectorStore: {
        provider: "memory",
        config: {
          collectionName: "memories",
          dimension: 1536
        }
      },
      llm: {
        provider: "openai",
        config: {
          apiKey: process.env.OPENAI_API_KEY || "",
          model: "gpt-4-turbo-preview"
        }
      },
      historyStore: {
        provider: "supabase",
        config: {
          supabaseUrl: process.env.SUPABASE_URL || "",
          supabaseKey: process.env.SUPABASE_KEY || "",
          tableName: "memories"
        }
      },
      disableHistory: false,
      customPrompt: "I'm a virtual assistant. I'm here to help you with your queries."
    };
    ```
  </Accordion>
</AccordionGroup>

## What's next?

<CardGroup cols={3}>
  <Card title="Explore Memory Operations" icon="database" href="/open-source/overview">
    Review CRUD patterns, filters, and advanced retrieval across the OSS stack.
  </Card>

  <Card title="Customize Configuration" icon="sliders" href="/open-source/configuration">
    Swap in your preferred LLM, vector store, and history provider for production use.
  </Card>

  <Card title="Automate Node Workflows" icon="plug" href="/cookbooks/integrations/openai-tool-calls">
    See a full Node-based workflow that layers Mem0 memories onto tool-calling agents.
  </Card>
</CardGroup>

If you have any questions, please feel free to reach out:

<Snippet file="get-help.mdx" />


# Overview
Source: https://docs.mem0.ai/open-source/overview

Self-host Mem0 with full control over your infrastructure and data

# Mem0 Open Source Overview

Mem0 Open Source delivers the same adaptive memory engine as the platform, but packaged for teams that need to run everything on their own infrastructure. You own the stack, the data, and the customizations.

<Tip>
  Mem0 v1.0.0 brought rerankers, async-by-default clients, and Azure OpenAI support. See the <Link href="/changelog">release notes</Link> for the full rundown before upgrading.
</Tip>

## What Mem0 OSS provides

* **Full control**: Tune every component, from LLMs to vector stores, inside your environment.
* **Offline ready**: Keep memory on your own network when compliance or privacy demands it.
* **Extendable codebase**: Fork the repo, add providers, and ship custom automations.

<Info>
  Begin with the <Link href="/open-source/python-quickstart">Python quickstart</Link> (or the Node.js variant) to clone the repo, configure dependencies, and validate memory reads/writes locally.
</Info>

## Choose your path

<CardGroup cols={2}>
  <Card title="Python Quickstart" icon="python" href="/open-source/python-quickstart">
    Bootstrap CLI and verify add/search loop.
  </Card>

  <Card title="Node.js Quickstart" icon="node" href="/open-source/node-quickstart">
    Install TypeScript SDK and run starter script.
  </Card>
</CardGroup>

<CardGroup cols={3}>
  <Card title="Configure Components" icon="sliders" href="/open-source/configuration">
    LLM, embedder, vector store, reranker setup.
  </Card>

  <Card title="Graph Memory Capability" icon="network-wired" href="/open-source/features/graph-memory">
    Relationship-aware recall with Neo4j, Memgraph.
  </Card>

  <Card title="Tune Retrieval & Rerankers" icon="sparkles" href="/open-source/features/reranker-search">
    Hybrid retrieval and reranker controls.
  </Card>
</CardGroup>

<CardGroup cols={2}>
  <Card title="Deploy with Docker Compose" icon="server" href="/cookbooks/companions/local-companion-ollama">
    Reference deployment with REST endpoints.
  </Card>

  <Card title="Use the REST API" icon="code" href="/open-source/features/rest-api">
    Async add/search flows and automation.
  </Card>
</CardGroup>

<Tip>
  Need a managed alternative? Compare hosting models in the <Link href="/platform/platform-vs-oss">Platform vs OSS guide</Link> or switch tabs to the Platform documentation.
</Tip>

<AccordionGroup>
  <Accordion title="What you get with Mem0 OSS" icon="code-branch">
    | Benefit                     | What you get                                                                   |
    | --------------------------- | ------------------------------------------------------------------------------ |
    | Full infrastructure control | Host on your own servers with complete access to configuration and deployment. |
    | Complete customization      | Modify the implementation, extend functionality, and tailor it to your stack.  |
    | Local development           | Perfect for development, testing, and offline environments.                    |
    | No vendor lock-in           | Keep ownership of your data, providers, and pipelines.                         |
    | Community driven            | Contribute improvements and tap into a growing ecosystem.                      |
  </Accordion>
</AccordionGroup>

## Default components

<Note>
  Mem0 OSS works out of the box with sensible defaults:

  * LLM: OpenAI `gpt-4.1-nano-2025-04-14` (via `OPENAI_API_KEY`)
  * Embeddings: OpenAI `text-embedding-3-small`
  * Vector store: Local Qdrant instance storing data at `/tmp/qdrant`
  * History store: SQLite database at `~/.mem0/history.db`
  * Reranker: Disabled until you configure a provider

  Override any component with <Link href="/open-source/configuration">`Memory.from_config`</Link>.
</Note>

## Keep going

<CardGroup cols={2}>
  <Card title="Review Platform vs OSS" description="Confirm whether managed infrastructure or self-hosting better suits your workload." icon="arrows-left-right" href="/platform/platform-vs-oss" />

  <Card title="Run the Python Quickstart" description="Clone the repo, install dependencies, and persist your first local memory." icon="terminal" href="/open-source/python-quickstart" />
</CardGroup>

<Tip>
  Need a managed alternative? Compare hosting models in the <Link href="/platform/platform-vs-oss">Platform vs OSS guide</Link> or switch tabs to the Platform documentation.
</Tip>


# Python SDK Quickstart
Source: https://docs.mem0.ai/open-source/python-quickstart

Get started with Mem0 quickly!

Get started with Mem0's Python SDK in under 5 minutes. This guide shows you how to install Mem0 and store your first memory.

## Prerequisites

* Python 3.10 or higher
* OpenAI API key ([Get one here](https://platform.openai.com/api-keys))

Set your OpenAI API key:

```bash  theme={null}
export OPENAI_API_KEY="your-openai-api-key"
```

<Note>
  Uses OpenAI by default. Want to use Ollama, Anthropic, or local models? See [Configuration](/open-source/configuration).
</Note>

## Installation

<Steps>
  <Step title="Install via pip">
    ```bash  theme={null}
    pip install mem0ai
    ```
  </Step>

  <Step title="Initialize Memory">
    ```python  theme={null}
    from mem0 import Memory

    m = Memory()

    ```
  </Step>

  <Step title="Add a memory">
    ```python  theme={null}
    messages = [
        {"role": "user", "content": "Hi, I'm Alex. I love basketball and gaming."},
        {"role": "assistant", "content": "Hey Alex! I'll remember your interests."}
    ]
    m.add(messages, user_id="alex")
    ```
  </Step>

  <Step title="Search memories">
    ```python  theme={null}
    results = m.search("What do you know about me?", filters={"user_id": "alex"})
    print(results)
    ```

    **Output:**

    ```json  theme={null}
    {
      "results": [
        {
          "id": "mem_123abc",
          "memory": "Name is Alex. Enjoys basketball and gaming.",
          "user_id": "alex",
          "categories": ["personal_info"],
          "created_at": "2025-10-22T04:40:22.864647-07:00",
          "score": 0.89
        }
      ]
    }
    ```
  </Step>
</Steps>

<Note>
  By default `Memory()` wires up:

  * OpenAI `gpt-4.1-nano-2025-04-14` for fact extraction and updates
  * OpenAI `text-embedding-3-small` embeddings (1536 dimensions)
  * Qdrant vector store with on-disk data at `/tmp/qdrant`
  * SQLite history at `~/.mem0/history.db`
  * No reranker (add one in the config when you need it)
</Note>

## What's Next?

<CardGroup cols={3}>
  <Card title="Memory Operations" icon="database" href="/open-source/overview">
    Learn how to search, update, and manage memories with full CRUD operations
  </Card>

  <Card title="Configuration" icon="sliders" href="/open-source/configuration">
    Customize Mem0 with different LLMs, vector stores, and embedders for production use
  </Card>

  <Card title="Advanced Features" icon="sparkles" href="/open-source/features/async-memory">
    Explore async support, graph memory, and multi-agent memory organization
  </Card>
</CardGroup>

## Additional Resources

* **[OpenAI Compatibility](/open-source/features/openai_compatibility)** - Use Mem0 with OpenAI-compatible chat completions
* **[Contributing Guide](/contributing/development)** - Learn how to contribute to Mem0
* **[Examples](/cookbooks/companions/local-companion-ollama)** - See Mem0 in action with Ollama and other integrations


# Advanced Memory Operations
Source: https://docs.mem0.ai/platform/advanced-memory-operations

Run richer add/search/update/delete flows on the managed platform with metadata, rerankers, and per-request controls.

# Make Platform Memory Operations Smarter

<Info>
  **Prerequisites**

  * Platform workspace with API key
  * Python 3.10+ and Node.js 18+
  * Async memories enabled in your dashboard (Settings → Memory Options)
</Info>

<Tip>
  Need a refresher on the core concepts first? Review the <Link href="/core-concepts/memory-operations/add">Add Memory</Link> overview, then come back for the advanced flow.
</Tip>

## Install and authenticate

<Tabs>
  <Tab title="Python">
    <Steps>
      <Step title="Install the SDK with async extras">
        ```bash  theme={null}
        pip install "mem0ai[async]"
        ```
      </Step>

      <Step title="Export your API key">
        ```bash  theme={null}
        export MEM0_API_KEY="sk-platform-..."
        ```
      </Step>

      <Step title="Create an async client">
        ```python  theme={null}
        import os
        from mem0 import AsyncMemoryClient

        memory = AsyncMemoryClient(api_key=os.environ["MEM0_API_KEY"])
        ```
      </Step>
    </Steps>
  </Tab>

  <Tab title="TypeScript">
    <Steps>
      <Step title="Install the OSS SDK">
        ```bash  theme={null}
        npm install mem0ai
        ```
      </Step>

      <Step title="Load your API key">
        ```bash  theme={null}
        export MEM0_API_KEY="sk-platform-..."
        ```
      </Step>

      <Step title="Instantiate the client">
        ```typescript  theme={null}
        import { Memory } from "mem0ai";

        const memory = new Memory({ apiKey: process.env.MEM0_API_KEY!, async: true });
        ```
      </Step>
    </Steps>
  </Tab>
</Tabs>

## Add memories with metadata and graph context

<Tabs>
  <Tab title="Python">
    <Steps>
      <Step title="Record conversations with metadata">
        ```python  theme={null}
        conversation = [
            {"role": "user", "content": "I'm Morgan, planning a 3-week trip to Japan in May."},
            {"role": "assistant", "content": "Great! I'll track dietary notes and cities you mention."},
            {"role": "user", "content": "Please remember I avoid shellfish and prefer boutique hotels in Tokyo."},
        ]

        result = await memory.add(
            conversation,
            user_id="traveler-42",
            metadata={"trip": "japan-2025", "preferences": ["boutique", "no-shellfish"]},
            enable_graph=True,
            run_id="planning-call-1",
        )
        ```
      </Step>
    </Steps>
  </Tab>

  <Tab title="TypeScript">
    <Steps>
      <Step title="Capture context-rich memories">
        ```typescript  theme={null}
        const conversation = [
          { role: "user", content: "I'm Morgan, planning a 3-week trip to Japan in May." },
          { role: "assistant", content: "Great! I'll track dietary notes and cities you mention." },
          { role: "user", content: "Please remember I avoid shellfish and love boutique hotels in Tokyo." },
        ];

        const result = await memory.add(conversation, {
          userId: "traveler-42",
          metadata: { trip: "japan-2025", preferences: ["boutique", "no-shellfish"] },
          enableGraph: true,
          runId: "planning-call-1",
        });
        ```
      </Step>
    </Steps>
  </Tab>
</Tabs>

<Info icon="check">
  Successful calls return memories tagged with the metadata you passed. In the dashboard, confirm a graph edge between “Morgan” and “Tokyo” and verify the `trip=japan-2025` tag exists.
</Info>

## Retrieve and refine

<Tabs>
  <Tab title="Python">
    <Steps>
      <Step title="Filter by metadata + reranker">
        ```python  theme={null}
        matches = await memory.search(
            "Any food alerts?",
            user_id="traveler-42",
            filters={"metadata.trip": "japan-2025"},
            rerank=True,
            include_vectors=False,
        )
        ```
      </Step>

      <Step title="Update a memory inline">
        ```python  theme={null}
        await memory.update(
            memory_id=matches["results"][0]["id"],
            content="Morgan avoids shellfish and prefers boutique hotels in central Tokyo.",
        )
        ```
      </Step>
    </Steps>
  </Tab>

  <Tab title="TypeScript">
    <Steps>
      <Step title="Search with metadata filters">
        ```typescript  theme={null}
        const matches = await memory.search("Any food alerts?", {
          userId: "traveler-42",
          filters: { "metadata.trip": "japan-2025" },
          rerank: true,
          includeVectors: false,
        });
        ```
      </Step>

      <Step title="Apply an update">
        ```typescript  theme={null}
        await memory.update(matches.results[0].id, {
          content: "Morgan avoids shellfish and prefers boutique hotels in central Tokyo.",
        });
        ```
      </Step>
    </Steps>
  </Tab>
</Tabs>

<Tip>
  Need to pause graph writes on a per-request basis? Pass `enableGraph: false` (TypeScript) or `enable_graph=False` (Python) when latency matters more than relationship building.
</Tip>

## Clean up

<Tabs>
  <Tab title="Python">
    <Steps>
      <Step title="Delete scoped memories">
        ```python  theme={null}
        await memory.delete_all(user_id="traveler-42", run_id="planning-call-1")
        ```
      </Step>
    </Steps>
  </Tab>

  <Tab title="TypeScript">
    <Steps>
      <Step title="Remove the run">
        ```typescript  theme={null}
        await memory.deleteAll({ userId: "traveler-42", runId: "planning-call-1" });
        ```
      </Step>
    </Steps>
  </Tab>
</Tabs>

## Quick recovery

* `Missing required key enableGraph`: update the SDK to `mem0ai>=0.4.0`.
* `Graph backend unavailable`: retry with `enableGraph=False` and inspect your graph provider status.
* Empty results with filters: log `filters` values and confirm metadata keys match (case-sensitive).

<Warning>
  Metadata keys become part of your filtering schema. Stick to lowercase snake\_case (`trip_id`, `preferences`) to avoid collisions down the road.
</Warning>

<CardGroup cols={2}>
  <Card title="Tune Metadata Filtering" description="Layer field-level filters on top of advanced operations." icon="funnel" href="/open-source/features/metadata-filtering" />

  <Card title="Explore Reranker Search" description="See how rerankers boost accuracy after vector + graph retrieval." icon="sparkles" href="/open-source/features/reranker-search" />
</CardGroup>


# Contribution Hub
Source: https://docs.mem0.ai/platform/contribute

Follow the shared playbook for writing and updating Mem0 documentation.

# Build Mem0 Docs the Right Way

<Info>
  **Who this is for**

  * Contributors and LLM assistants updating the docs
  * Reviewers vetting new pages before publication
  * Maintainers syncing live docs with the template library
</Info>

<Steps>
  <Step title="Review the standards">
    Check your team’s latest checklist or guidance so the update keeps the right navigation flow, CTA pattern, and language coverage.
  </Step>

  <Step title="Pick the right template">
    Select the doc type you are writing (quickstart, feature guide, migration, etc.) and copy the skeleton from the template library below.
  </Step>

  <Step title="Draft, verify, and note follow-ups">
    Fill the skeleton completely, include inline verification callouts, and jot down any open questions for maintainers before opening a PR.
  </Step>
</Steps>

<Info icon="check">
  When previewing locally, confirm the page ends with exactly two CTA cards, includes both Python and TypeScript examples when they exist, and keeps all Mintlify icons (no emojis).
</Info>

## Template Library

Choose the document type you need. Each card links directly to the canonical template inside this repo.

<CardGroup cols={3}>
  <Card title="Quickstart" description="Install → Configure → Add → Search → Delete with Tabs + Steps." icon="rocket" href="/templates/quickstart_template" />

  <Card title="Operation Guide" description="Single task walkthrough with verification checkpoints." icon="circle-check" href="/templates/operation_guide_template" />

  <Card title="Feature Guide" description="Explain when and why to use a capability, not just the API." icon="sparkles" href="/templates/feature_guide_template" />

  <Card title="Concept Guide" description="Define mental models, key terms, and diagrams." icon="brain" href="/templates/concept_guide_template" />

  <Card title="Integration Guide" description="Configure Mem0 with third-party tools using shared Tabs + Steps." icon="plug" href="/templates/integration_guide_template" />

  <Card title="Cookbook" description="Narrative end-to-end workflow with reusable snippets." icon="book-open" href="/templates/cookbook_template" />

  <Card title="API Reference" description="Document endpoints with quick facts and dual-language examples." icon="code" href="/templates/api_reference_template" />

  <Card title="Parameters Reference" description="Call out accepted fields, defaults, and misuse troubleshooting." icon="list" href="/templates/parameters_reference_template" />

  <Card title="Migration Guide" description="Plan → Migrate → Validate with rollback steps." icon="arrow-right" href="/templates/migration_guide_template" />

  <Card title="Release Notes" description="Ship highlights, stats, and mandatory CTA pair." icon="megaphone" href="/templates/release_notes_template" />

  <Card title="Troubleshooting Playbook" description="Symptom → Diagnose → Fix with escalation tips." icon="life-buoy" href="/templates/troubleshooting_playbook_template" />

  <Card title="Section Overview" description="Headline, card grid, and CTA pair for section landing pages." icon="grid" href="/templates/section_overview_template" />
</CardGroup>

## Contribution Checklist

<AccordionGroup>
  <Accordion title="Prep your draft">
    Confirm you copied the exact skeleton (`✅ COPY THIS` block) and removed every placeholder. Keep the DO-NOT-COPY guidance out of the published doc.
  </Accordion>

  <Accordion title="Mind the standards">
    Use Mintlify icons, include `<Info icon="check">` after runnable steps, and ensure Tabs show both Python and TypeScript (or justify the absence with `<Note>`).
  </Accordion>

  <Accordion title="Surface open questions early">
    Flag blockers or follow-up work in your PR description so reviewers know what to look for and can update project trackers as needed.
  </Accordion>
</AccordionGroup>

<CardGroup cols={2}>
  <Card title="Browse Templates" description="Jump straight into the quickstart skeleton and switch tabs for other types." icon="clipboard-check" href="/templates/quickstart_template" />

  <Card title="Return to Platform Overview" description="Jump back into the managed journey once you’re done editing." icon="compass" href="/platform/overview" />
</CardGroup>


# FAQs
Source: https://docs.mem0.ai/platform/faqs



<AccordionGroup>
  <Accordion title="How does Mem0 work?">
    Mem0 utilizes a sophisticated hybrid database system to efficiently manage and retrieve memories for AI agents and assistants. Each memory is linked to a unique identifier, such as a user ID or agent ID, enabling Mem0 to organize and access memories tailored to specific individuals or contexts.

    When a message is added to Mem0 via the `add` method, the system extracts pertinent facts and preferences, distributing them across various data stores: a vector database and a graph database. This hybrid strategy ensures that diverse types of information are stored optimally, facilitating swift and effective searches.

    When an AI agent or LLM needs to access memories, it employs the `search` method. Mem0 conducts a comprehensive search across these data stores, retrieving relevant information from each.

    The retrieved memories can be seamlessly integrated into the system prompt as required, enhancing the personalization and relevance of responses.
  </Accordion>

  <Accordion title="What are the key features of Mem0?">
    * **User, Session, and AI Agent Memory**: Retains information across sessions and interactions for users and AI agents, ensuring continuity and context.
    * **Adaptive Personalization**: Continuously updates memories based on user interactions and feedback.
    * **Developer-Friendly API**: Offers a straightforward API for seamless integration into various applications.
    * **Platform Consistency**: Ensures consistent behavior and data across different platforms and devices.
    * **Managed Service**: Provides a hosted solution for easy deployment and maintenance.
    * **Cost Savings**: Saves costs by adding relevant memories instead of complete transcripts to context window
  </Accordion>

  <Accordion title="How is Mem0 different from traditional RAG?">
    Mem0's memory implementation for Large Language Models (LLMs) offers several advantages over Retrieval-Augmented Generation (RAG):

    * **Entity Relationships**: Mem0 can understand and relate entities across different interactions, unlike RAG which retrieves information from static documents. This leads to a deeper understanding of context and relationships.

    * **Contextual Continuity**: Mem0 retains information across sessions, maintaining continuity in conversations and interactions, which is essential for long-term engagement applications like virtual companions or personalized learning assistants.

    * **Adaptive Learning**: Mem0 improves its personalization based on user interactions and feedback, making the memory more accurate and tailored to individual users over time.

    * **Dynamic Updates**: Mem0 can dynamically update its memory with new information and interactions, unlike RAG which relies on static data. This allows for real-time adjustments and improvements, enhancing the user experience.

    These advanced memory capabilities make Mem0 a powerful tool for developers aiming to create personalized and context-aware AI applications.
  </Accordion>

  <Accordion title="What are the common use-cases of Mem0?">
    * **Personalized Learning Assistants**: Long-term memory allows learning assistants to remember user preferences, strengths and weaknesses, and progress, providing a more tailored and effective learning experience.

    * **Customer Support AI Agents**: By retaining information from previous interactions, customer support bots can offer more accurate and context-aware assistance, improving customer satisfaction and reducing resolution times.

    * **Healthcare Assistants**: Long-term memory enables healthcare assistants to keep track of patient history, medication schedules, and treatment plans, ensuring personalized and consistent care.

    * **Virtual Companions**: Virtual companions can use long-term memory to build deeper relationships with users by remembering personal details, preferences, and past conversations, making interactions more delightful.

    * **Productivity Tools**: Long-term memory helps productivity tools remember user habits, frequently used documents, and task history, streamlining workflows and enhancing efficiency.

    * **Gaming AI**: In gaming, AI with long-term memory can create more immersive experiences by remembering player choices, strategies, and progress, adapting the game environment accordingly.
  </Accordion>

  <Accordion title="Why aren't my memories being created?">
    Mem0 uses a sophisticated classification system to determine which parts of text should be extracted as memories. Not all text content will generate memories, as the system is designed to identify specific types of memorable information.
    There are several scenarios where mem0 may return an empty list of memories:

    * When users input definitional questions (e.g., "What is backpropagation?")
    * For general concept explanations that don't contain personal or experiential information
    * Technical definitions and theoretical explanations
    * General knowledge statements without personal context
    * Abstract or theoretical content

    Example Scenarios

    ```
    Input: "What is machine learning?"
    No memories extracted - Content is definitional and does not meet memory classification criteria.

    Input: "Yesterday I learned about machine learning in class"
    Memory extracted - Contains personal experience and temporal context.
    ```

    Best Practices

    To ensure successful memory extraction:

    * Include temporal markers (when events occurred)
    * Add personal context or experiences
    * Frame information in terms of real-world applications or experiences
    * Include specific examples or cases rather than general definitions
  </Accordion>

  <Accordion title="How do I configure Mem0 for AWS Lambda?">
    When deploying Mem0 on AWS Lambda, you'll need to modify the storage directory configuration due to Lambda's file system restrictions. By default, Lambda only allows writing to the `/tmp` directory.

    To configure Mem0 for AWS Lambda, set the `MEM0_DIR` environment variable to point to a writable directory in `/tmp`:

    ```bash  theme={null}
    MEM0_DIR=/tmp/.mem0
    ```

    If you're not using environment variables, you'll need to modify the storage path in your code:

    ```python  theme={null}
    # Change from
    home_dir = os.path.expanduser("~")
    mem0_dir = os.environ.get("MEM0_DIR") or os.path.join(home_dir, ".mem0")

    # To
    mem0_dir = os.environ.get("MEM0_DIR", "/tmp/.mem0")
    ```

    Note that the `/tmp` directory in Lambda has a size limit of 512MB and its contents are not persistent between function invocations.
  </Accordion>

  <Accordion title="How can I use metadata with Mem0?">
    Metadata is the recommended approach for incorporating additional information with Mem0. You can store any type of structured data as metadata during the `add` method, such as location, timestamp, weather conditions, user state, or application context. This enriches your memories with valuable contextual information that can be used for more precise retrieval and filtering.

    During retrieval, you have two main approaches for using metadata:

    1. **Pre-filtering**: Include metadata parameters in your initial search query to narrow down the memory pool
    2. **Post-processing**: Retrieve a broader set of memories based on query, then apply metadata filters to refine the results

    Examples of useful metadata you might store:

    * **Contextual information**: Location, time, device type, application state
    * **User attributes**: Preferences, skill levels, demographic information
    * **Interaction details**: Conversation topics, sentiment, urgency levels
    * **Custom tags**: Any domain-specific categorization relevant to your application

    This flexibility allows you to create highly contextually aware AI applications that can adapt to specific user needs and situations. Metadata provides an additional dimension for memory retrieval, enabling more precise and relevant responses.
  </Accordion>

  <Accordion title="How do I disable telemetry in Mem0?">
    To disable telemetry in Mem0, you can set the `MEM0_TELEMETRY` environment variable to `False`:

    ```bash  theme={null}
    MEM0_TELEMETRY=False
    ```

    You can also disable telemetry programmatically in your code:

    ```python  theme={null}
    import os
    os.environ["MEM0_TELEMETRY"] = "False"
    ```

    Setting this environment variable will prevent Mem0 from collecting and sending any usage data, ensuring complete privacy for your application.
  </Accordion>
</AccordionGroup>


# Advanced Retrieval
Source: https://docs.mem0.ai/platform/features/advanced-retrieval

Advanced memory search with keyword expansion, intelligent reranking, and precision filtering

## What is Advanced Retrieval?

Advanced Retrieval gives you precise control over how memories are found and ranked. While basic search uses semantic similarity, these advanced options help you find exactly what you need, when you need it.

## Search Enhancement Options

### Keyword Search

Expands results to include memories with specific terms, names, and technical keywords.

<Tabs>
  <Tab title="When to Use">
    * Searching for specific entities, names, or technical terms
    * Need comprehensive coverage of a topic
    * Want broader recall even if some results are less relevant
    * Working with domain-specific terminology
  </Tab>

  <Tab title="How it Works">
    ```python Python theme={null}
    # Find memories containing specific food-related terms
    results = client.search(
        query="What foods should I avoid?",
        keyword_search=True,
        user_id="user123"
    )

    # Results might include:
    # ✓ "Allergic to peanuts and shellfish"  
    # ✓ "Lactose intolerant - avoid dairy"
    # ✓ "Mentioned avoiding gluten last week"
    ```
  </Tab>

  <Tab title="Performance">
    * **Latency**: \~10ms additional
    * **Recall**: Significantly increased
    * **Precision**: Slightly decreased
    * **Best for**: Entity search, comprehensive coverage
  </Tab>
</Tabs>

### Reranking

Reorders results using deep semantic understanding to put the most relevant memories first.

<Tabs>
  <Tab title="When to Use">
    * Need the most relevant result at the top
    * Result order is critical for your application
    * Want consistent quality across different queries
    * Building user-facing features where accuracy matters
  </Tab>

  <Tab title="How it Works">
    ```python Python theme={null}
    # Get the most relevant travel plans first
    results = client.search(
        query="What are my upcoming travel plans?",
        rerank=True,
        user_id="user123"
    )

    # Before reranking:        After reranking:
    # 1. "Went to Paris"   →   1. "Tokyo trip next month"
    # 2. "Tokyo trip next" →   2. "Need to book hotel in Tokyo"  
    # 3. "Need hotel"      →   3. "Went to Paris last year"
    ```
  </Tab>

  <Tab title="Performance">
    * **Latency**: 150-200ms additional
    * **Accuracy**: Significantly improved
    * **Ordering**: Much more relevant
    * **Best for**: Top-N precision, user-facing results
  </Tab>
</Tabs>

### Memory Filtering

Filters results to keep only the most precisely relevant memories.

<Tabs>
  <Tab title="When to Use">
    * Need highly specific, focused results
    * Working with large datasets where noise is problematic
    * Quality over quantity is essential
    * Building production or safety-critical applications
  </Tab>

  <Tab title="How it Works">
    ```python Python theme={null}
    # Get only the most relevant dietary restrictions
    results = client.search(
        query="What are my dietary restrictions?",
        filter_memories=True,
        user_id="user123"
    )

    # Before filtering:           After filtering:
    # • "Allergic to nuts"    →   • "Allergic to nuts"
    # • "Likes Italian food"  →   • "Vegetarian diet"
    # • "Vegetarian diet"     →   
    # • "Eats dinner at 7pm"  →   
    ```
  </Tab>

  <Tab title="Performance">
    * **Latency**: 200-300ms additional
    * **Precision**: Maximized
    * **Recall**: May be reduced
    * **Best for**: Focused queries, production systems
  </Tab>
</Tabs>

## Real-World Use Cases

<Tabs>
  <Tab title="Personal AI Assistant">
    ```python Python theme={null}
    # Smart home assistant finding device preferences
    results = client.search(
        query="How do I like my bedroom temperature?",
        keyword_search=True,    # Find specific temperature mentions
        rerank=True,           # Get most recent preferences first
        user_id="user123"
    )

    # Finds: "Keep bedroom at 68°F", "Too cold last night at 65°F", etc.
    ```
  </Tab>

  <Tab title="Customer Support">
    ```python Python theme={null}
    # Find specific product issues with high precision
    results = client.search(
        query="Problems with premium subscription billing",
        keyword_search=True,     # Find "premium", "billing", "subscription"
        filter_memories=True,    # Only billing-related issues
        user_id="customer456"
    )

    # Returns only relevant billing problems, not general questions
    ```
  </Tab>

  <Tab title="Healthcare AI">
    ```python Python theme={null}
    # Critical medical information needs perfect accuracy
    results = client.search(
        query="Patient allergies and contraindications",
        rerank=True,            # Most important info first
        filter_memories=True,   # Only medical restrictions
        user_id="patient789"
    )

    # Ensures critical allergy info appears first and filters out non-medical data
    ```
  </Tab>

  <Tab title="Learning Platform">
    ```python Python theme={null}
    # Find learning progress for specific topics
    results = client.search(
        query="Python programming progress and difficulties",
        keyword_search=True,    # Find "Python", "programming", specific concepts
        rerank=True,           # Recent progress first
        user_id="student123"
    )

    # Gets comprehensive view of Python learning journey
    ```
  </Tab>
</Tabs>

## Choosing the Right Combination

### Recommended Configurations

<CodeGroup>
  ```python Python theme={null}
  # Fast and broad - good for exploration
  def quick_search(query, user_id):
      return client.search(
          query=query,
          keyword_search=True,
          user_id=user_id
      )

  # Balanced - good for most applications  
  def standard_search(query, user_id):
      return client.search(
          query=query,
          keyword_search=True,
          rerank=True,
          user_id=user_id
      )

  # High precision - good for critical applications
  def precise_search(query, user_id):
      return client.search(
          query=query,
          rerank=True,
          filter_memories=True,
          user_id=user_id
      )
  ```

  ```javascript JavaScript theme={null}
  // Fast and broad - good for exploration
  function quickSearch(query, userId) {
      return client.search(query, {
          user_id: userId,
          keyword_search: true
      });
  }

  // Balanced - good for most applications
  function standardSearch(query, userId) {
      return client.search(query, {
          user_id: userId,
          keyword_search: true,
          rerank: true
      });
  }

  // High precision - good for critical applications
  function preciseSearch(query, userId) {
      return client.search(query, {
          user_id: userId,
          rerank: true,
          filter_memories: true
      });
  }
  ```
</CodeGroup>

## Best Practices

### Do

* Start simple with just one enhancement and measure impact
* Use keyword search for entity-heavy queries (names, places, technical terms)
* Use reranking when the top result quality matters most
* Use filtering for production systems where precision is critical
* Handle empty results gracefully when filtering is too aggressive
* Monitor latency and adjust based on your application's needs

### Don't

* Enable all options by default without measuring necessity
* Use filtering for broad exploratory queries
* Ignore latency impact in real-time applications
* Forget to handle cases where filtering returns no results
* Use advanced retrieval for simple, fast lookup scenarios

## Performance Guidelines

### Latency Expectations

```python Python theme={null}
# Performance monitoring example
import time

start_time = time.time()
results = client.search(
    query="user preferences",
    keyword_search=True,  # +10ms
    rerank=True,         # +150ms
    filter_memories=True, # +250ms
    user_id="user123"
)
latency = time.time() - start_time
print(f"Search completed in {latency:.2f}s")  # ~0.41s expected
```

### Optimization Tips

1. **Cache frequent queries** to avoid repeated advanced processing
2. **Use session-specific search** with `run_id` to reduce search space
3. **Implement fallback logic** when filtering returns empty results
4. **Monitor and alert** on search latency patterns

<Snippet file="get-help.mdx" />


# Async Client
Source: https://docs.mem0.ai/platform/features/async-client

Asynchronous client for Mem0

The `AsyncMemoryClient` is an asynchronous client for interacting with the Mem0 API. It provides similar functionality to the synchronous `MemoryClient` but allows for non-blocking operations, which can be beneficial in applications that require high concurrency.

## Initialization

To use the async client, you first need to initialize it:

<CodeGroup>
  ```python Python theme={null}
  import os
  from mem0 import AsyncMemoryClient

  os.environ["MEM0_API_KEY"] = "your-api-key"

  client = AsyncMemoryClient()
  ```

  ```javascript JavaScript theme={null}
  const { MemoryClient } = require('mem0ai');
  const client = new MemoryClient({ apiKey: 'your-api-key'});
  ```
</CodeGroup>

## Methods

The `AsyncMemoryClient` provides the following methods:

### Add

Add a new memory asynchronously.

<CodeGroup>
  ```python Python theme={null}
  messages = [
      {"role": "user", "content": "Alice loves playing badminton"},
      {"role": "assistant", "content": "That's great! Alice is a fitness freak"},
  ]
  await client.add(messages, user_id="alice")
  ```

  ```javascript JavaScript theme={null}
  const messages = [
      {"role": "user", "content": "Alice loves playing badminton"},
      {"role": "assistant", "content": "That's great! Alice is a fitness freak"},
  ];
  await client.add(messages, { user_id: "alice" });
  ```
</CodeGroup>

### Search

Search for memories based on a query asynchronously.

<CodeGroup>
  ```python Python theme={null}
  await client.search("What is Alice's favorite sport?", user_id="alice")
  ```

  ```javascript JavaScript theme={null}
  await client.search("What is Alice's favorite sport?", { user_id: "alice" });
  ```
</CodeGroup>

### Get All

Retrieve all memories for a user asynchronously.

<Callout type="warning" title="Filters Required">
  `get_all()` now requires filters to be specified.
</Callout>

<CodeGroup>
  ```python Python theme={null}
  await client.get_all(filters={"AND": [{"user_id": "alice"}]})
  ```

  ```javascript JavaScript theme={null}
  await client.getAll({ filters: {"AND": [{"user_id": "alice"}]} });
  ```
</CodeGroup>

### Delete

Delete a specific memory asynchronously.

<CodeGroup>
  ```python Python theme={null}
  await client.delete(memory_id="memory-id-here")
  ```

  ```javascript JavaScript theme={null}
  await client.delete("memory-id-here");
  ```
</CodeGroup>

### Delete All

Delete all memories for a user asynchronously.

<CodeGroup>
  ```python Python theme={null}
  await client.delete_all(user_id="alice")
  ```

  ```javascript JavaScript theme={null}
  await client.deleteAll({ user_id: "alice" });
  ```
</CodeGroup>

### History

Get the history of a specific memory asynchronously.

<CodeGroup>
  ```python Python theme={null}
  await client.history(memory_id="memory-id-here")
  ```

  ```javascript JavaScript theme={null}
  await client.history("memory-id-here");
  ```
</CodeGroup>

### Users

Get all users, agents, and runs which have memories associated with them asynchronously.

<CodeGroup>
  ```python Python theme={null}
  await client.users()
  ```

  ```javascript JavaScript theme={null}
  await client.users();
  ```
</CodeGroup>

### Reset

Reset the client, deleting all users and memories asynchronously.

<CodeGroup>
  ```python Python theme={null}
  await client.reset()
  ```

  ```javascript JavaScript theme={null}
  await client.reset();
  ```
</CodeGroup>

## Conclusion

The `AsyncMemoryClient` provides a powerful way to interact with the Mem0 API asynchronously, allowing for more efficient and responsive applications. By using this client, you can perform memory operations without blocking your application's execution.

If you have any questions or need further assistance, please don't hesitate to reach out:

<Snippet file="get-help.mdx" />


# Async Mode Default Change
Source: https://docs.mem0.ai/platform/features/async-mode-default-change

Important update to Memory Addition API behavior

<Note type="warning">
  **Important Change**

  The `async_mode` parameter defaults to `true` for all memory additions, changing the default API behavior to asynchronous processing.
</Note>

## Overview

The Memory Addition API processes all memory additions asynchronously by default. This change improves performance and scalability by queuing memory operations in the background, allowing your application to continue without waiting for memory processing to complete.

## What's Changing

The parameter `async_mode` will default to `true` instead of `false`.

This means memory additions will be **processed asynchronously** by default - queued for background execution instead of waiting for processing to complete.

## Behavior Comparison

### Old Default Behavior (async\_mode = false)

When `async_mode` was set to `false`, the API returned fully processed memory objects immediately:

```json  theme={null}
{
  "results": [
    {
      "id": "de0ee948-af6a-436c-835c-efb6705207de",
      "event": "ADD",
      "memory": "User Order #1234 was for a 'Nova 2000'",
      "structured_attributes": {
        "day": 13,
        "hour": 16,
        "year": 2025,
        "month": 10,
        "minute": 59,
        "quarter": 4,
        "is_weekend": false,
        "day_of_week": "monday",
        "day_of_year": 286,
        "week_of_year": 42
      }
    }
  ]
}
```

### New Default Behavior (async\_mode = true)

With `async_mode` defaulting to `true`, memory processing is queued in the background and the API returns immediately:

```json  theme={null}
{
  "results": [
    {
      "message": "Memory processing has been queued for background execution",
      "status": "PENDING",
      "event_id": "d7b5282a-0031-4cc2-98ba-5a02d8531e17"
    }
  ]
}
```

## Migration Guide

### If You Need Synchronous Processing

If your integration relies on receiving the processed memory object immediately, you can explicitly set `async_mode` to `false` in your requests:

<CodeGroup>
  ```python Python theme={null}
  from mem0 import MemoryClient

  client = MemoryClient(api_key="your-api-key")

  # Explicitly set async_mode=False to preserve synchronous behavior
  messages = [
      {"role": "user", "content": "I ordered a Nova 2000"}
  ]

  result = client.add(
      messages,
      user_id="user-123",
      async_mode=False  # This ensures synchronous processing
  )
  ```

  ```javascript JavaScript theme={null}
  const { MemoryClient } = require('mem0ai');

  const client = new MemoryClient({ apiKey: 'your-api-key' });

  // Explicitly set async_mode: false to preserve synchronous behavior
  const messages = [
      { role: "user", content: "I ordered a Nova 2000" }
  ];

  const result = await client.add(messages, {
      user_id: "user-123",
      async_mode: false  // This ensures synchronous processing
  });
  ```

  ```bash cURL theme={null}
  curl -X POST https://api.mem0.ai/v1/memories/ \
    -H "Authorization: Token your-api-key" \
    -H "Content-Type: application/json" \
    -d '{
      "messages": [
        {"role": "user", "content": "I ordered a Nova 2000"}
      ],
      "user_id": "user-123",
      "async_mode": false
    }'
  ```
</CodeGroup>

### If You Want to Adopt Asynchronous Processing

If you want to benefit from the improved performance of asynchronous processing:

1. **Remove** any explicit `async_mode=False` parameters from your code
2. **Use webhooks** to receive notifications when memory processing completes

<Note>
  Learn more about [Webhooks](/platform/features/webhooks) for real-time notifications about memory events.
</Note>

## Benefits of Asynchronous Processing

Switching to asynchronous processing provides several advantages:

* **Faster API Response Times**: Your application doesn't wait for memory processing
* **Better Scalability**: Handle more memory additions concurrently
* **Improved User Experience**: Reduced latency in your application
* **Resource Efficiency**: Background processing optimizes server resources

## Important Notes

* The default behavior is now `async_mode=true` for asynchronous processing
* Explicitly set `async_mode=false` if you need synchronous behavior
* Use webhooks to receive notifications when memories are processed

## Monitoring Memory Processing

When using asynchronous mode, use webhooks to receive notifications about memory events:

<Card title="Configure Webhooks" icon="webhook" href="/platform/features/webhooks">
  Learn how to set up webhooks for memory processing events
</Card>

You can also retrieve all processed memories at any time:

<CodeGroup>
  ```python Python theme={null}
  # Retrieve all memories for a user
  # Note: get_all now requires filters
  memories = client.get_all(filters={"AND": [{"user_id": "user-123"}]})
  ```

  ```javascript JavaScript theme={null}
  // Retrieve all memories for a user
  // Note: getAll now requires filters
  const memories = await client.getAll({ filters: {"AND": [{"user_id": "user-123"}]} });
  ```
</CodeGroup>

## Need Help?

If you have questions about this change or need assistance updating your integration:

<Snippet file="get-help.mdx" />

## Related Documentation

<CardGroup cols={2}>
  <Card title="Async Client" icon="bolt" href="/platform/features/async-client">
    Learn about the asynchronous client for Mem0
  </Card>

  <Card title="Add Memories API" icon="plus" href="/api-reference/memory/add-memories">
    View the complete API reference for adding memories
  </Card>

  <Card title="Webhooks" icon="webhook" href="/platform/features/webhooks">
    Configure webhooks for memory processing events
  </Card>

  <Card title="Memory Operations" icon="gear" href="/core-concepts/memory-operations/add">
    Understand memory addition operations
  </Card>
</CardGroup>


# Contextual Memory Creation
Source: https://docs.mem0.ai/platform/features/contextual-add

Add messages with automatic context management - no manual history tracking required

## What is Contextual Memory Creation?

Contextual memory creation automatically manages message history, allowing you to focus on building AI experiences without manually tracking interactions. Simply send new messages, and Mem0 handles the context automatically.

<CodeGroup>
  ```python Python theme={null}
  # Just send new messages - Mem0 handles the context
  messages = [
      {"role": "user", "content": "I love Italian food, especially pasta"},
      {"role": "assistant", "content": "Great! I'll remember your preference for Italian cuisine."}
  ]

  client.add(messages, user_id="user123")
  ```

  ```javascript JavaScript theme={null}
  // Just send new messages - Mem0 handles the context
  const messages = [
      {"role": "user", "content": "I love Italian food, especially pasta"},
      {"role": "assistant", "content": "Great! I'll remember your preference for Italian cuisine."}
  ];

  await client.add(messages, { user_id: "user123", version: "v2" });
  ```
</CodeGroup>

## Why Use Contextual Memory Creation?

* **Simple**: Send only new messages, no manual history tracking
* **Efficient**: Smaller payloads and faster processing
* **Automatic**: Context management handled by Mem0
* **Reliable**: No risk of missing interaction history
* **Scalable**: Works seamlessly as your application grows

## How It Works

### Basic Usage

<CodeGroup>
  ```python Python theme={null}
  # First interaction
  messages1 = [
      {"role": "user", "content": "Hi, I'm Sarah from New York"},
      {"role": "assistant", "content": "Hello Sarah! Nice to meet you."}
  ]
  client.add(messages1, user_id="sarah")

  # Later interaction - just send new messages
  messages2 = [
      {"role": "user", "content": "I'm planning a trip to Italy next month"},
      {"role": "assistant", "content": "How exciting! Italy is beautiful this time of year."}
  ]
  client.add(messages2, user_id="sarah")
  # Mem0 automatically knows Sarah is from New York and can use this context
  ```

  ```javascript JavaScript theme={null}
  // First interaction
  const messages1 = [
      {"role": "user", "content": "Hi, I'm Sarah from New York"},
      {"role": "assistant", "content": "Hello Sarah! Nice to meet you."}
  ];
  await client.add(messages1, { user_id: "sarah", version: "v2" });

  // Later interaction - just send new messages
  const messages2 = [
      {"role": "user", "content": "I'm planning a trip to Italy next month"},
      {"role": "assistant", "content": "How exciting! Italy is beautiful this time of year."}
  ];
  await client.add(messages2, { user_id: "sarah", version: "v2" });
  // Mem0 automatically knows Sarah is from New York and can use this context
  ```
</CodeGroup>

## Organization Strategies

Choose the right approach based on your application's needs:

### User-Level Memories (`user_id` only)

**Best for:** Personal preferences, profile information, long-term user data

<CodeGroup>
  ```python Python theme={null}
  # Persistent user memories across all interactions
  messages = [
      {"role": "user", "content": "I'm allergic to nuts and dairy"},
      {"role": "assistant", "content": "I've noted your allergies for future reference."}
  ]

  client.add(messages, user_id="user123")
  # This allergy info will be available in ALL future interactions
  ```

  ```javascript JavaScript theme={null}
  // Persistent user memories across all interactions
  const messages = [
      {"role": "user", "content": "I'm allergic to nuts and dairy"},
      {"role": "assistant", "content": "I've noted your allergies for future reference."}
  ];

  await client.add(messages, { user_id: "user123", version: "v2" });
  // This allergy info will be available in ALL future interactions
  ```
</CodeGroup>

### Session-Specific Memories (`user_id` + `run_id`)

**Best for:** Task-specific context, separate interaction threads, project-based sessions

<CodeGroup>
  ```python Python theme={null}
  # Trip planning session
  messages1 = [
      {"role": "user", "content": "I want to plan a 5-day trip to Tokyo"},
      {"role": "assistant", "content": "Perfect! Let's plan your Tokyo adventure."}
  ]
  client.add(messages1, user_id="user123", run_id="tokyo-trip-2024")

  # Later in the same trip planning session
  messages2 = [
      {"role": "user", "content": "I prefer staying near Shibuya"},
      {"role": "assistant", "content": "Great choice! Shibuya is very convenient."}
  ]
  client.add(messages2, user_id="user123", run_id="tokyo-trip-2024")

  # Different session for work project (separate context)
  work_messages = [
      {"role": "user", "content": "Let's discuss the Q4 marketing strategy"},
      {"role": "assistant", "content": "Sure! What are your main goals for Q4?"}
  ]
  client.add(work_messages, user_id="user123", run_id="q4-marketing")
  ```

  ```javascript JavaScript theme={null}
  // Trip planning session
  const messages1 = [
      {"role": "user", "content": "I want to plan a 5-day trip to Tokyo"},
      {"role": "assistant", "content": "Perfect! Let's plan your Tokyo adventure."}
  ];
  await client.add(messages1, { user_id: "user123", run_id: "tokyo-trip-2024", version: "v2" });

  // Later in the same trip planning session
  const messages2 = [
      {"role": "user", "content": "I prefer staying near Shibuya"},
      {"role": "assistant", "content": "Great choice! Shibuya is very convenient."}
  ];
  await client.add(messages2, { user_id: "user123", run_id: "tokyo-trip-2024", version: "v2" });

  // Different session for work project (separate context)
  const workMessages = [
      {"role": "user", "content": "Let's discuss the Q4 marketing strategy"},
      {"role": "assistant", "content": "Sure! What are your main goals for Q4?"}
  ];
  await client.add(workMessages, { user_id: "user123", run_id: "q4-marketing", version: "v2" });
  ```
</CodeGroup>

## Real-World Use Cases

<Tabs>
  <Tab title="Customer Support">
    ```python Python theme={null}
    # Support ticket context - keeps interaction focused
    messages = [
        {"role": "user", "content": "My subscription isn't working"},
        {"role": "assistant", "content": "I can help with that. What specific issue are you experiencing?"},
        {"role": "user", "content": "I can't access premium features even though I paid"}
    ]

    # Each support ticket gets its own run_id
    client.add(messages, 
        user_id="customer123", 
        run_id="ticket-2024-001"
    )
    ```
  </Tab>

  <Tab title="Personal AI Assistant">
    ```python Python theme={null}
    # Personal preferences (persistent across all interactions)
    preference_messages = [
        {"role": "user", "content": "I prefer morning workouts and vegetarian meals"},
        {"role": "assistant", "content": "Got it! I'll keep your fitness and dietary preferences in mind."}
    ]

    client.add(preference_messages, user_id="user456")

    # Daily planning session (session-specific)
    planning_messages = [
        {"role": "user", "content": "Help me plan tomorrow's schedule"},
        {"role": "assistant", "content": "Of course! I'll consider your morning workout preference."}
    ]

    client.add(planning_messages, 
        user_id="user456", 
        run_id="daily-plan-2024-01-15"
    )
    ```
  </Tab>

  <Tab title="Educational Platform">
    ```python Python theme={null}
    # Student profile (persistent)
    profile_messages = [
        {"role": "user", "content": "I'm studying computer science and struggle with math"},
        {"role": "assistant", "content": "I'll tailor explanations to help with math concepts."}
    ]

    client.add(profile_messages, user_id="student789")

    # Specific lesson session
    lesson_messages = [
        {"role": "user", "content": "Can you explain algorithms?"},
        {"role": "assistant", "content": "Sure! I'll explain algorithms with math-friendly examples."}
    ]

    client.add(lesson_messages,
        user_id="student789",
        run_id="algorithms-lesson-1"
    )
    ```
  </Tab>
</Tabs>

## Best Practices

### ✅ Do

* **Organize by context scope**: Use `user_id` only for persistent data, add `run_id` for session-specific context
* **Keep messages focused** on the current interaction
* **Test with real interaction flows** to ensure context works as expected

### ❌ Don't

* Send duplicate messages or interaction history
* Skip identifiers like `user_id` or `run_id` that scope the memory
* Mix contextual and non-contextual approaches in the same application

## Troubleshooting

| Issue                           | Solution                                                                          |
| ------------------------------- | --------------------------------------------------------------------------------- |
| **Context not working**         | Ensure each call uses the same `user_id` / `run_id` combo; version is automatic   |
| **Wrong context retrieved**     | Check if you need separate `run_id` values for different interaction topics       |
| **Missing interaction history** | Verify all messages in the interaction thread use the same `user_id` and `run_id` |
| **Too much irrelevant context** | Use more specific `run_id` values to separate different interaction types         |

<Snippet file="get-help.mdx" />


# Criteria Retrieval
Source: https://docs.mem0.ai/platform/features/criteria-retrieval



Mem0's Criteria Retrieval feature allows you to retrieve memories based on your defined criteria. It goes beyond generic semantic relevance and ranks memories based on what matters to your application: emotional tone, intent, behavioral signals, or other custom traits.

Instead of just searching for "how similar a memory is to this query," you can define what relevance truly means for your project. For example:

* Prioritize joyful memories when building a wellness assistant
* Downrank negative memories in a productivity-focused agent
* Highlight curiosity in a tutoring agent

You define criteria: custom attributes like "joy", "negativity", "confidence", or "urgency", and assign weights to control how they influence scoring. When you search, Mem0 uses these to re-rank semantically relevant memories, favoring those that better match your intent.

This gives you nuanced, intent-aware memory search that adapts to your use case.

## When to Use Criteria Retrieval

Use Criteria Retrieval if:

* You’re building an agent that should react to **emotions** or **behavioral signals**
* You want to guide memory selection based on **context**, not just content
* You have domain-specific signals like "risk", "positivity", "confidence", etc. that shape recall

## Setting Up Criteria Retrieval

Let’s walk through how to configure and use Criteria Retrieval step by step.

### Initialize the Client

Before defining any criteria, make sure to initialize the `MemoryClient` with your credentials and project ID:

```python  theme={null}
from mem0 import MemoryClient

client = MemoryClient(
    api_key="your_mem0_api_key",
    org_id="your_organization_id",
    project_id="your_project_id"
)
```

### Define Your Criteria

Each criterion includes:

* A `name` (used in scoring)
* A `description` (interpreted by the LLM)
* A `weight` (how much it influences the final score)

```python  theme={null}
retrieval_criteria = [
    {
        "name": "joy",
        "description": "Measure the intensity of positive emotions such as happiness, excitement, or amusement expressed in the sentence. A higher score reflects greater joy.",
        "weight": 3
    },
    {
        "name": "curiosity",
        "description": "Assess the extent to which the sentence reflects inquisitiveness, interest in exploring new information, or asking questions. A higher score reflects stronger curiosity.",
        "weight": 2
    },
    {
        "name": "emotion",
        "description": "Evaluate the presence and depth of sadness or negative emotional tone, including expressions of disappointment, frustration, or sorrow. A higher score reflects greater sadness.",
        "weight": 1
    }
]
```

### Apply Criteria to Your Project

Once defined, register the criteria to your project:

```python  theme={null}
client.project.update(retrieval_criteria=retrieval_criteria)
```

Criteria apply project-wide. Once set, they affect all searches automatically.

## Example Walkthrough

After setting up your criteria, you can use them to filter and retrieve memories. Here's an example:

### Add Memories

```python  theme={null}
messages = [
    {"role": "user", "content": "What a beautiful sunny day! I feel so refreshed and ready to take on anything!"},
    {"role": "user", "content": "I've always wondered how storms form—what triggers them in the atmosphere?"},
    {"role": "user", "content": "It's been raining for days, and it just makes everything feel heavier."},
    {"role": "user", "content": "Finally I get time to draw something today, after a long time!! I am super happy today."}
]

client.add(messages, user_id="alice")
```

### Run Standard vs. Criteria-Based Search

```python  theme={null}
# Search with criteria enabled
filters = {"user_id": "alice"}
results_with_criteria = client.search(
    query="Why I am feeling happy today?",
    filters=filters
)

# To disable criteria for a specific search
results_without_criteria = client.search(
    query="Why I am feeling happy today?",
    filters=filters,
    use_criteria=False  # Disable criteria-based scoring
)
```

### Compare Results

### Search Results (with Criteria)

```python  theme={null}
[
    {"memory": "User feels refreshed and ready to take on anything on a beautiful sunny day", "score": 0.666, ...},
    {"memory": "User finally has time to draw something after a long time", "score": 0.616, ...},
    {"memory": "User is happy today", "score": 0.500, ...},
    {"memory": "User is curious about how storms form and what triggers them in the atmosphere.", "score": 0.400, ...},
    {"memory": "It has been raining for days, making everything feel heavier.", "score": 0.116, ...}
]
```

### Search Results (without Criteria)

```python  theme={null}
[
    {"memory": "User is happy today", "score": 0.607, ...},
    {"memory": "User feels refreshed and ready to take on anything on a beautiful sunny day", "score": 0.512, ...},
    {"memory": "It has been raining for days, making everything feel heavier.", "score": 0.4617, ...},
    {"memory": "User is curious about how storms form and what triggers them in the atmosphere.", "score": 0.340, ...},
    {"memory": "User finally has time to draw something after a long time", "score": 0.336, ...},
]
```

## Search Results Comparison

1. **Memory Ordering**: With criteria, memories with high joy scores (like feeling refreshed and drawing) are ranked higher. Without criteria, the most relevant memory ("User is happy today") comes first.
2. **Score Distribution**: With criteria, scores are more spread out (0.116 to 0.666) and reflect the criteria weights. Without criteria, scores are more clustered (0.336 to 0.607) and based purely on relevance.
3. **Trait Sensitivity**: "Rainy day" content is penalized due to negative tone, while "Storm curiosity" is recognized and scored accordingly.

## Key Differences vs. Standard Search

| Aspect                 | Standard Search               | Criteria Retrieval                              |
| ---------------------- | ----------------------------- | ----------------------------------------------- |
| Ranking Logic          | Semantic similarity only      | Semantic + LLM-based criteria scoring           |
| Control Over Relevance | None                          | Fully customizable with weighted criteria       |
| Memory Reordering      | Static based on similarity    | Dynamically re-ranked by intent alignment       |
| Emotional Sensitivity  | No tone or trait awareness    | Incorporates emotion, tone, or custom behaviors |
| Activation             | Default (no criteria defined) | Enabled when criteria are defined in project    |

<Note>
  If no criteria are defined for a project, search behaves normally based on semantic similarity only.
</Note>

## Best Practices

* Choose 3-5 criteria that reflect your application's intent
* Make descriptions clear and distinct; these are interpreted by an LLM
* Use stronger weights to amplify the impact of important traits
* Avoid redundant or ambiguous criteria (e.g., "positivity" and "joy")
* Always handle empty result sets in your application logic

## How It Works

1. **Criteria Definition**: Define custom criteria with a name, description, and weight. These describe what matters in a memory (e.g., joy, urgency, empathy).
2. **Project Configuration**: Register these criteria using `project.update()`. They apply at the project level and automatically influence all searches.
3. **Memory Retrieval**: When you perform a search, Mem0 first retrieves relevant memories based on the query.
4. **Weighted Scoring**: Each retrieved memory is evaluated and scored against your defined criteria and weights.

This lets you prioritize memories that align with your agent's goals and not just those that look similar to the query.

<Note>
  Criteria retrieval is automatically enabled when criteria are defined in your project. Use `use_criteria=False` in search to temporarily disable it for a specific query.
</Note>

## Summary

* Define what "relevant" means using criteria
* Apply them per project via `project.update()`
* Criteria-aware search activates automatically when criteria are configured
* Build agents that reason not just with relevance, but **contextual importance**

***

Need help designing or tuning your criteria?

<Snippet file="get-help.mdx" />


# Custom Categories
Source: https://docs.mem0.ai/platform/features/custom-categories

Teach Mem0 the labels that matter to your team.

# Custom Categories

Mem0 automatically tags every memory, but the default labels (travel, sports, music, etc.) may not match the names your app uses. Custom categories let you replace that list so the tags line up with your own wording.

<Info>
  **Use custom categories when…**

  * You need Mem0 to tag memories with names your product team already uses.
  * You want clean reports or automations that rely on those tags.
  * You’re moving from the open-source version and want the same labels here.
</Info>

<Warning>
  Per-request overrides (`custom_categories=...` on `client.add`) are not supported on the managed API yet. Set categories at the project level, then ingest memories as usual.
</Warning>

## Configure access

* Ensure `MEM0_API_KEY` is set in your environment or pass it to the SDK constructor.
* If you scope work to a specific organization/project, initialize the client with those identifiers.

## How it works

* **Default list** — Each project starts with 15 broad categories like `travel`, `sports`, and `music`.
* **Project override** — When you call `project.update(custom_categories=[...])`, that list replaces the defaults for future memories.
* **Automatic tags** — As new memories come in, Mem0 picks the closest matches from your list and saves them in the `categories` field.

<Note>
  Default catalog: `personal_details`, `family`, `professional_details`, `sports`, `travel`, `food`, `music`, `health`, `technology`, `hobbies`, `fashion`, `entertainment`, `milestones`, `user_preferences`, `misc`.
</Note>

## Configure it

### 1. Set custom categories at the project level

<CodeGroup>
  ```python Code theme={null}
  import os
  from mem0 import MemoryClient

  os.environ["MEM0_API_KEY"] = "your-api-key"

  client = MemoryClient()

  # Update custom categories
  new_categories = [
      {"lifestyle_management_concerns": "Tracks daily routines, habits, hobbies and interests including cooking, time management and work-life balance"},
      {"seeking_structure": "Documents goals around creating routines, schedules, and organized systems in various life areas"},
      {"personal_information": "Basic information about the user including name, preferences, and personality traits"}
  ]

  response = client.project.update(custom_categories=new_categories)
  print(response)
  ```

  ```json Output theme={null}
  {
      "message": "Updated custom categories"
  }
  ```
</CodeGroup>

### 2. Confirm the active catalog

<CodeGroup>
  ```python Code theme={null}
  # Get current custom categories
  categories = client.project.get(fields=["custom_categories"])
  print(categories)
  ```

  ```json Output theme={null}
  {
    "custom_categories": [
      {"lifestyle_management_concerns": "Tracks daily routines, habits, hobbies and interests including cooking, time management and work-life balance"},
      {"seeking_structure": "Documents goals around creating routines, schedules, and organized systems in various life areas"},
      {"personal_information": "Basic information about the user including name, preferences, and personality traits"}
    ]
  }
  ```
</CodeGroup>

## See it in action

### Add a memory (uses the project catalog automatically)

<CodeGroup>
  ```python Code theme={null}
  messages = [
      {"role": "user", "content": "My name is Alice. I need help organizing my daily schedule better. I feel overwhelmed trying to balance work, exercise, and social life."},
      {"role": "assistant", "content": "I understand how overwhelming that can feel. Let's break this down together. What specific areas of your schedule feel most challenging to manage?"},
      {"role": "user", "content": "I want to be more productive at work, maintain a consistent workout routine, and still have energy for friends and hobbies."},
      {"role": "assistant", "content": "Those are great goals for better time management. What's one small change you could make to start improving your daily routine?"},
  ]

  # Add memories with project-level custom categories
  client.add(messages, user_id="alice", async_mode=False)
  ```
</CodeGroup>

### Retrieve memories and inspect categories

<CodeGroup>
  ```python Code theme={null}
  memories = client.get_all(filters={"user_id": "alice"})
  ```

  ```json Output theme={null}
  ["lifestyle_management_concerns", "seeking_structure"]
  ```
</CodeGroup>

<Info>
  **Sample memory payload**

  ```json  theme={null}
  {
    "id": "33d2***",
    "memory": "Trying to balance work and workouts",
    "user_id": "alice",
    "metadata": null,
    "categories": ["wellness"],  // ← matches the custom category we set
    "created_at": "2025-11-01T02:13:32.828364-07:00",
    "updated_at": "2025-11-01T02:13:32.830896-07:00",
    "expiration_date": null,
    "structured_attributes": {
      "day": 1,
      "hour": 9,
      "year": 2025,
      "month": 11,
      "minute": 13,
      "quarter": 4,
      "is_weekend": true,
      "day_of_week": "saturday",
      "day_of_year": 305,
      "week_of_year": 44
    }
  }
  ```
</Info>

<Note>
  Need ad-hoc labels for a single call? Store them in `metadata` until per-request overrides become available.
</Note>

## Default categories (fallback)

If you do nothing, memories are tagged with the built-in set below.

```
- personal_details
- family
- professional_details
- sports
- travel
- food
- music
- health
- technology
- hobbies
- fashion
- entertainment
- milestones
- user_preferences
- misc
```

<CodeGroup>
  ```python Code theme={null}
  import os
  from mem0 import MemoryClient

  os.environ["MEM0_API_KEY"] = "your-api-key"

  client = MemoryClient()

  messages = [
      {"role": "user", "content": "Hi, my name is Alice."},
      {"role": "assistant", "content": "Hi Alice, what sports do you like to play?"},
      {"role": "user", "content": "I love playing badminton, football, and basketball. I'm quite athletic!"},
      {"role": "assistant", "content": "That's great! Alice seems to enjoy both individual sports like badminton and team sports like football and basketball."},
      {"role": "user", "content": "Sometimes, I also draw and sketch in my free time."},
      {"role": "assistant", "content": "That's cool! I'm sure you're good at it."}
  ]

  # Add memories with default categories
  client.add(messages, user_id='alice', async_mode=False)
  ```

  ```python Memories with categories theme={null}
  # Following categories will be created for the memories added
  Sometimes draws and sketches in free time (hobbies)
  Is quite athletic (sports)
  Loves playing badminton, football, and basketball (sports)
  Name is Alice (personal_details)
  ```
</CodeGroup>

You can verify the defaults are active by checking:

<CodeGroup>
  ```python Code theme={null}
  client.project.get(["custom_categories"])
  ```

  ```json Output theme={null}
  {
      "custom_categories": None
  }
  ```
</CodeGroup>

## Verify the feature is working

* `client.project.get(["custom_categories"])` returns the category list you set.
* `client.get_all(filters={"user_id": ...})` shows populated `categories` lists on new memories.
* The Mem0 dashboard (Project → Memories) displays the custom labels in the Category column.

## Best practices

* Keep category descriptions concise but specific; the classifier uses them to disambiguate.
* Review memories with empty `categories` to see where you might extend or rename your list.
* Stick with project-level overrides until per-request support is released; mixing approaches causes confusion.

<CardGroup cols={2}>
  <Card title="Advanced Memory Operations" icon="wand-magic-sparkles" href="/platform/advanced-memory-operations">
    Explore other ingestion tunables like custom prompts and selective writes.
  </Card>

  <Card title="Travel Assistant Cookbook" icon="plane-up" href="/cookbooks/companions/travel-assistant">
    See custom tagging drive personalization in a full agent workflow.
  </Card>
</CardGroup>


# Custom Instructions
Source: https://docs.mem0.ai/platform/features/custom-instructions

Control how Mem0 extracts and stores memories using natural language guidelines

## What are Custom Instructions?

Custom instructions are natural language guidelines that let you define exactly what Mem0 should include or exclude when creating memories from conversations. This gives you precise control over what information is extracted, acting as smart filters so your AI application only remembers what matters for your use case.

<CodeGroup>
  ```python Python theme={null}
  # Simple example: Health app focusing on wellness
  prompt = """
  Extract only health and wellness information:
  - Symptoms, medications, and treatments
  - Exercise routines and dietary habits
  - Doctor appointments and health goals

  Exclude: Personal identifiers, financial data
  """

  client.project.update(custom_instructions=prompt)
  ```

  ```javascript JavaScript theme={null}
  // Simple example: Health app focusing on wellness
  const prompt = `
  Extract only health and wellness information:
  - Symptoms, medications, and treatments
  - Exercise routines and dietary habits
  - Doctor appointments and health goals

  Exclude: Personal identifiers, financial data
  `;

  await client.project.update({ custom_instructions: prompt });
  ```
</CodeGroup>

## Why Use Custom Instructions?

* **Focus on What Matters**: Only capture information relevant to your application
* **Maintain Privacy**: Explicitly exclude sensitive data like passwords or personal identifiers
* **Ensure Consistency**: All memories follow the same extraction rules across your project
* **Improve Quality**: Filter out noise and irrelevant conversations

## How to Set Custom Instructions

### Basic Setup

<CodeGroup>
  ```python Python theme={null}
  # Set instructions for your project
  client.project.update(custom_instructions="Your guidelines here...")

  # Retrieve current instructions
  response = client.project.get(fields=["custom_instructions"])
  print(response["custom_instructions"])
  ```

  ```javascript JavaScript theme={null}
  // Set instructions for your project
  await client.project.update({ custom_instructions: "Your guidelines here..." });

  // Retrieve current instructions
  const response = await client.project.get({ fields: ["custom_instructions"] });
  console.log(response.custom_instructions);
  ```
</CodeGroup>

### Best Practice Template

Structure your instructions using this proven template:

```
Your Task: [Brief description of what to extract]

Information to Extract:
1. [Category 1]:
   - [Specific details]
   - [What to look for]

2. [Category 2]:
   - [Specific details]
   - [What to look for]

Guidelines:
- [Processing rules]
- [Quality requirements]

Exclude:
- [Sensitive data to avoid]
- [Irrelevant information]
```

## Real-World Examples

<Tabs>
  <Tab title="E-commerce Customer Support">
    <CodeGroup>
      ```python Python theme={null}
      instructions = """
      Extract customer service information for better support:

      1. Product Issues:
         - Product names, SKUs, defects
         - Return/exchange requests
         - Quality complaints

      2. Customer Preferences:
         - Preferred brands, sizes, colors
         - Shopping frequency and habits
         - Price sensitivity

      3. Service Experience:
         - Satisfaction with support
         - Resolution time expectations
         - Communication preferences

      Exclude: Payment card numbers, passwords, personal identifiers.
      """

      client.project.update(custom_instructions=instructions)
      ```

      ```javascript JavaScript theme={null}
      const instructions = `
      Extract customer service information for better support:

      1. Product Issues:
         - Product names, SKUs, defects
         - Return/exchange requests
         - Quality complaints

      2. Customer Preferences:
         - Preferred brands, sizes, colors
         - Shopping frequency and habits
         - Price sensitivity

      3. Service Experience:
         - Satisfaction with support
         - Resolution time expectations
         - Communication preferences

      Exclude: Payment card numbers, passwords, personal identifiers.
      `;

      await client.project.update({ custom_instructions: instructions });
      ```
    </CodeGroup>
  </Tab>

  <Tab title="Personalized Learning Platform">
    <CodeGroup>
      ```python Python theme={null}
      education_prompt = """
      Extract learning-related information for personalized education:

      1. Learning Progress:
         - Course completions and current modules
         - Skills acquired and improvement areas
         - Learning goals and objectives

      2. Student Preferences:
         - Learning styles (visual, audio, hands-on)
         - Time availability and scheduling
         - Subject interests and career goals

      3. Performance Data:
         - Assignment feedback and patterns
         - Areas of struggle or strength
         - Study habits and engagement

      Exclude: Specific grades, personal identifiers, financial information.
      """

      client.project.update(custom_instructions=education_prompt)
      ```

      ```javascript JavaScript theme={null}
      const educationPrompt = `
      Extract learning-related information for personalized education:

      1. Learning Progress:
         - Course completions and current modules
         - Skills acquired and improvement areas
         - Learning goals and objectives

      2. Student Preferences:
         - Learning styles (visual, audio, hands-on)
         - Time availability and scheduling
         - Subject interests and career goals

      3. Performance Data:
         - Assignment feedback and patterns
         - Areas of struggle or strength
         - Study habits and engagement

      Exclude: Specific grades, personal identifiers, financial information.
      `;

      await client.project.update({ custom_instructions: educationPrompt });
      ```
    </CodeGroup>
  </Tab>

  <Tab title="AI Financial Advisor">
    <CodeGroup>
      ```python Python theme={null}
      finance_prompt = """
      Extract financial planning information for advisory services:

      1. Financial Goals:
         - Retirement and investment objectives
         - Risk tolerance and preferences
         - Short-term and long-term goals

      2. Life Events:
         - Career and income changes
         - Family changes (marriage, children)
         - Major planned purchases

      3. Investment Interests:
         - Asset allocation preferences
         - ESG or ethical investment interests
         - Previous investment experience

      Exclude: Account numbers, SSNs, passwords, specific financial amounts.
      """

      client.project.update(custom_instructions=finance_prompt)
      ```

      ```javascript JavaScript theme={null}
      const financePrompt = `
      Extract financial planning information for advisory services:

      1. Financial Goals:
         - Retirement and investment objectives
         - Risk tolerance and preferences
         - Short-term and long-term goals

      2. Life Events:
         - Career and income changes
         - Family changes (marriage, children)
         - Major planned purchases

      3. Investment Interests:
         - Asset allocation preferences
         - ESG or ethical investment interests
         - Previous investment experience

      Exclude: Account numbers, SSNs, passwords, specific financial amounts.
      `;

      await client.project.update({ custom_instructions: financePrompt });
      ```
    </CodeGroup>
  </Tab>
</Tabs>

## Advanced Techniques

### Conditional Processing

Handle different conversation types with conditional logic:

<CodeGroup>
  ```python Python theme={null}
  advanced_prompt = """
  Extract information based on conversation context:

  IF customer support conversation:
  - Issue type, severity, resolution status
  - Customer satisfaction indicators

  IF sales conversation:
  - Product interests, budget range
  - Decision timeline and influencers

  IF onboarding conversation:
  - User experience level
  - Feature interests and priorities

  Always exclude personal identifiers and maintain professional context.
  """

  client.project.update(custom_instructions=advanced_prompt)
  ```
</CodeGroup>

### Testing Your Instructions

Always test your custom instructions with real message examples:

<CodeGroup>
  ```python Python theme={null}
  # Test with sample messages
  messages = [
      {"role": "user", "content": "I'm having billing issues with my subscription"},
      {"role": "assistant", "content": "I can help with that. What's the specific problem?"},
      {"role": "user", "content": "I'm being charged twice each month"}
  ]

  # Add the messages and check extracted memories
  result = client.add(messages, user_id="test_user")
  memories = client.get_all(filters={"AND": [{"user_id": "test_user"}]})

  # Review if the right information was extracted
  for memory in memories:
      print(f"Extracted: {memory['memory']}")
  ```
</CodeGroup>

## Best Practices

### ✅ Do

* **Be specific** about what information to extract
* **Use clear categories** to organize your instructions
* **Test with real conversations** before deploying
* **Explicitly state exclusions** for privacy and compliance
* **Start simple** and iterate based on results

### ❌ Don't

* Make instructions too long or complex
* Create conflicting rules within your guidelines
* Be overly restrictive (balance specificity with flexibility)
* Forget to exclude sensitive information
* Skip testing with diverse conversation examples

## Common Issues and Solutions

| Issue                         | Solution                                        |
| ----------------------------- | ----------------------------------------------- |
| **Instructions too long**     | Break into focused categories, keep concise     |
| **Missing important data**    | Add specific examples of what to capture        |
| **Capturing irrelevant info** | Strengthen exclusion rules and be more specific |
| **Inconsistent results**      | Clarify guidelines and test with more examples  |


# Direct Import
Source: https://docs.mem0.ai/platform/features/direct-import

Bypass the memory deduction phase and directly store pre-defined memories for efficient retrieval

## How to Use Direct Import

The Direct Import feature allows users to skip the memory deduction phase and directly input pre-defined memories into the system for storage and retrieval. To enable this feature, set the `infer` parameter to `False` in the `add` method.

<CodeGroup>
  ```python Python theme={null}
  messages = [
      {"role": "user", "content": "Alice loves playing badminton"},
      {"role": "assistant", "content": "That's great! Alice is a fitness freak"},
      {"role": "user", "content": "Alice mostly cooks at home because of her gym plan"},
  ]


  client.add(messages, user_id="alice", infer=False)
  ```

  ```markdown Output theme={null}
  []
  ```
</CodeGroup>

You can see that the output of the add call is an empty list.

<Note>Only messages with the role "user" will be used for storage. Messages with roles such as "assistant" or "system" will be ignored during the storage process.</Note>

<Warning>
  Direct import skips the inference pipeline, so it also skips duplicate detection. If you later send the same fact with `infer=True`, Mem0 will store a second copy. Pick one mode per memory source unless you truly want both versions.
</Warning>

## How to Retrieve Memories

You can retrieve memories using the `search` method.

<CodeGroup>
  ```python Python theme={null}
  client.search("What is Alice's favorite sport?", user_id="alice")
  ```

  ```json Output theme={null}
  {
    "results": [
      {
        "id": "19d6d7aa-2454-4e58-96fc-e74d9e9f8dd1",
        "memory": "Alice loves playing badminton",
        "user_id": "pc123",
        "metadata": null,
        "categories": null,
        "created_at": "2024-10-15T21:52:11.474901-07:00",
        "updated_at": "2024-10-15T21:52:11.474912-07:00"
      }
    ]
  }
  ```
</CodeGroup>

## How to Retrieve All Memories

You can retrieve all memories using the `get_all` method.

<Callout type="warning" title="Filters Required">
  `get_all()` now requires filters to be specified.
</Callout>

<CodeGroup>
  ```python Python theme={null}
  client.get_all(filters={"AND": [{"user_id": "alice"}]})
  ```

  ```json Output theme={null}
  {
    "results": [
      {
        "id": "19d6d7aa-2454-4e58-96fc-e74d9e9f8dd1",
        "memory": "Alice loves playing badminton",
        "user_id": "pc123",
        "metadata": null,
        "categories": null,
        "created_at": "2024-10-15T21:52:11.474901-07:00",
        "updated_at": "2024-10-15T21:52:11.474912-07:00"
      },
      {
        "id": "8557f05d-7b3c-47e5-b409-9886f9e314fc",
        "memory": "Alice mostly cooks at home because of her gym plan",
        "user_id": "pc123",
        "metadata": null,
        "categories": null,
        "created_at": "2024-10-15T21:52:11.474929-07:00",
        "updated_at": "2024-10-15T21:52:11.474932-07:00"
      }
    ]
  }
  ```
</CodeGroup>

If you have any questions, please feel free to reach out to us using one of the following methods:

<Snippet file="get-help.mdx" />


# Entity-Scoped Memory
Source: https://docs.mem0.ai/platform/features/entity-scoped-memory

Scope conversations by user, agent, app, and session so memories land exactly where they belong.

Mem0's Platform API lets you separate memories for different users, agents, and apps. By tagging each write and query with the right identifiers, you can prevent data from mixing between them, maintain clear audit trails, and control data retention.

<Tip icon="layers">
  Want the long-form tutorial? The <Link href="/cookbooks/essentials/entity-partitioning-playbook">Partition Memories by Entity</Link> cookbook walks through multi-agent storage, debugging, and cleanup step by step.
</Tip>

<Info>
  **You'll use this when…**

  * You run assistants for multiple customers who each need private memory spaces
  * Different agents (like a planner and a critic) need separate context for the same user
  * Sessions should expire on their own schedule, making debugging and data removal more precise
</Info>

## Configure access

```python  theme={null}
from mem0 import MemoryClient

client = MemoryClient(api_key="m0-...")
```

Call `client.project.get()` to verify your connection. It should return your project details including `org_id` and `project_id`. If you get a 401 error, generate a new API key in the Mem0 dashboard.

## Feature anatomy

| Dimension   | Field      | When to use it                                   | Example value       |
| ----------- | ---------- | ------------------------------------------------ | ------------------- |
| User        | `user_id`  | Persistent persona or account                    | `"customer_6412"`   |
| Agent       | `agent_id` | Distinct agent persona or tool                   | `"meal_planner"`    |
| Application | `app_id`   | White-label app or product surface               | `"ios_retail_demo"` |
| Session     | `run_id`   | Short-lived flow, ticket, or conversation thread | `"ticket-9241"`     |

* **Writes** (`client.add`) accept any combination of these fields. Absent fields default to `null`.
* **Reads** (`client.search`, `client.get_all`, exports, deletes) accept the same identifiers inside the `filters` JSON object.
* **Implicit null scoping**: Passing only `{"user_id": "alice"}` automatically restricts results to records where `agent_id`, `app_id`, and `run_id` are `null`. Add wildcards (`"*"`), explicit lists, or additional filters when you need broader joins.

<Warning>
  **Common Pitfall**: If you create a memory with `user_id="alice"` but the other fields default to `null`, then search with `{"AND": [{"user_id": "alice"}, {"agent_id": "bot"}]}` will return nothing because you're looking for a memory where `agent_id="bot"`, not `null`.
</Warning>

## Choose the right identifier

| Identifier | Purpose                                                                                    | Example Use Cases                                      |
| ---------- | ------------------------------------------------------------------------------------------ | ------------------------------------------------------ |
| `user_id`  | Store preferences, profile details, and historical actions that follow a person everywhere | Dietary restrictions, seat preferences, meeting habits |
| `agent_id` | Keep an agent's personality, operating modes, or brand voice in one place                  | Travel agent vs concierge vs customer support personas |
| `app_id`   | Tag every write from a partner app or deployment for tenant separation                     | White-label deployments, partner integrations          |
| `run_id`   | Isolate temporary flows that should reset or expire independently                          | Support tickets, chat sessions, experiments            |

For more detailed examples, see the Partition Memories by Entity cookbook.

## Configure it

The example below adds memories with entity tags:

```python  theme={null}
messages = [
    {"role": "user", "content": "I teach ninth-grade algebra."},
    {"role": "assistant", "content": "I'll tailor study plans to algebra topics."}
]

client.add(
    messages,
    user_id="teacher_872",
    agent_id="study_planner",
    app_id="district_dashboard",
    run_id="prep-period-2025-09-02"
)
```

The response will include one or more memory IDs. Check the dashboard → Memories to confirm the entry appears under the correct user, agent, app, and run.

The HTTP equivalent uses `POST /v1/memories/` with the same identifiers in the JSON body. See the Add Memories API reference for REST details.

## See it in action

**1. Store scoped memories**

```python  theme={null}
traveler_messages = [
    {"role": "user", "content": "I prefer boutique hotels and avoid shellfish."},
    {"role": "assistant", "content": "Logged your travel preferences for future itineraries."}
]

client.add(
    traveler_messages,
    user_id="customer_6412",
    agent_id="travel_planner",
    app_id="concierge_portal",
    run_id="itinerary-2025-apr",
    metadata={"category": "preferences"}
)
```

**2. Retrieve by user scope**

```python  theme={null}
user_scope = {
    "AND": [
        {"user_id": "customer_6412"},
        {"app_id": "concierge_portal"},
        {"run_id": "itinerary-2025-apr"}
    ]
}

user_results = client.search("Any dietary flags?", filters=user_scope)
print(user_results)
```

**3. Retrieve by agent scope**

```python  theme={null}
agent_scope = {
    "AND": [
        {"agent_id": "travel_planner"},
        {"app_id": "concierge_portal"}
    ]
}

agent_results = client.search("Any dietary flags?", filters=agent_scope)
print(agent_results)
```

<Tip icon="compass">
  Writes can include multiple identifiers, but searches resolve one entity space at a time. Query user scope *or* agent scope in a given call—combining both returns an empty list today.
</Tip>

<Tip icon="sparkles">
  Want to experiment with AND/OR logic, nested operators, or wildcards? The <Link href="/platform/features/v2-memory-filters">Memory Filters v2 guide</Link> walks through every filter pattern with working examples.
</Tip>

**4. Audit everything for an app**

```python  theme={null}
app_scope = {
    "AND": [
        {"app_id": "concierge_portal"},
        {"user_id": "*"},
        {"agent_id": "*"}
    ]
}

page = client.get_all(filters=app_scope, page=1, page_size=20)
```

<Info>
  Wildcards (`"*"`) include only non-null values. Use them when you want "any agent" or "any user" without limiting results to null-only records.
</Info>

**5. Clean up a session**

```python  theme={null}
client.delete_all(
    user_id="customer_6412",
    run_id="itinerary-2025-apr"
)
```

<Info icon="check">
  A successful delete returns `{"message": "Memories deleted successfully!"}`. Run the previous `get_all` call again to confirm the session memories were removed.
</Info>

## Verify the feature is working

* Run `client.search` with your filters and confirm only expected memories appear. Mismatched identifiers usually mean a typo in your scoping.
* Check the Mem0 dashboard filter pills. User, agent, app, and run should all show populated values for your memory entry.
* Call `client.delete_all` with a unique `run_id` and confirm other sessions remain intact (the count in `get_all` should only drop for that run).

## Best practices

* Use consistent identifier formats (like `team-alpha` or `app-ios-retail`) so you can query or delete entire groups later
* When debugging, print your filters before each call to verify wildcards (`"*"`), lists, and run IDs are spelled correctly
* Combine entity filters with metadata filters (categories, created\_at) for precise exports or audits
* Use `run_id` for temporary sessions like support tickets or experiments, then schedule cleanup jobs to delete them

For a complete walkthrough, see the Partition Memories by Entity cookbook.

<CardGroup cols={2}>
  <Card title="Master Memory Filters" description="Deep dive into JSON logic, operators, and wildcard behavior." icon="sliders" href="/platform/features/v2-memory-filters" />

  <Card title="Partition Memories in Practice" description="Follow the essentials cookbook to implement scoped workflows." icon="book-open" href="/cookbooks/essentials/entity-partitioning-playbook" />
</CardGroup>


# Expiration Date
Source: https://docs.mem0.ai/platform/features/expiration-date

Set time-bound memories in Mem0 with automatic expiration dates to manage temporal information effectively.

## Benefits of Memory Expiration

Setting expiration dates for memories offers several advantages:

* **Time-Sensitive Information Management**: Handle information that is only relevant for a specific time period.
* **Event-Based Memory**: Manage information related to upcoming events that becomes irrelevant after the event passes.

These benefits enable more sophisticated memory management for applications where temporal context matters.

## Setting Memory Expiration Date

You can set an expiration date for memories, after which they will no longer be retrieved in searches. This is useful for creating temporary memories or memories that are relevant only for a specific time period.

<CodeGroup>
  ```python Python theme={null}
  import datetime
  from mem0 import MemoryClient

  client = MemoryClient(api_key="your-api-key")

  messages = [
      {
          "role": "user", 
          "content": "I'll be in San Francisco until the end of this month."
      }
  ]

  # Set an expiration date for this memory
  client.add(messages=messages, user_id="alex", expiration_date=str(datetime.datetime.now().date() + datetime.timedelta(days=30)))

  # You can also use an explicit date string
  client.add(messages=messages, user_id="alex", expiration_date="2023-08-31")
  ```

  ```javascript JavaScript theme={null}
  import MemoryClient from 'mem0ai';
  const client = new MemoryClient({ apiKey: 'your-api-key' });

  const messages = [
      {
          "role": "user", 
          "content": "I'll be in San Francisco until the end of this month."
      }
  ];

  // Set an expiration date 30 days from now
  const expirationDate = new Date();
  expirationDate.setDate(expirationDate.getDate() + 30);
  client.add(messages, { 
      user_id: "alex", 
      expiration_date: expirationDate.toISOString().split('T')[0] 
  })
      .then(response => console.log(response))
      .catch(error => console.error(error));

  // You can also use an explicit date string
  client.add(messages, { 
      user_id: "alex", 
      expiration_date: "2023-08-31" 
  })
      .then(response => console.log(response))
      .catch(error => console.error(error));
  ```

  ```bash cURL theme={null}
  curl -X POST "https://api.mem0.ai/v1/memories/" \
       -H "Authorization: Token your-api-key" \
       -H "Content-Type: application/json" \
       -d '{
           "messages": [
               {
                  "role": "user", 
                  "content": "I'll be in San Francisco until the end of this month."
              }
           ],
           "user_id": "alex",
           "expiration_date": "2023-08-31"
       }'
  ```

  ```json Output theme={null}
  {
      "results": [
          {
              "id": "a1b2c3d4-e5f6-4g7h-8i9j-k0l1m2n3o4p5",
              "data": {
                  "memory": "In San Francisco until the end of this month"
              },
              "event": "ADD"
          }
      ]
  }
  ```
</CodeGroup>

<Note>
  Once a memory reaches its expiration date, it will not be included in search or get results, though the data remains stored in the system.
</Note>

If you have any questions, please feel free to reach out to us using one of the following methods:

<Snippet file="get-help.mdx" />


# Feedback Mechanism
Source: https://docs.mem0.ai/platform/features/feedback-mechanism



Mem0's Feedback Mechanism allows you to provide feedback on the memories generated by your application. This feedback is used to improve the accuracy of the memories and search results.

## How it works

The feedback mechanism is a simple API that allows you to provide feedback on the memories generated by your application. The feedback is stored in the database and used to improve the accuracy of the memories and search results. Over time, Mem0 continuously learns from this feedback, refining its memory generation and search capabilities for better performance.

## Give Feedback

You can give feedback on a memory by calling the `feedback` method on the Mem0 client.

<CodeGroup>
  ```python Python theme={null}
  from mem0 import MemoryClient

  client = MemoryClient(api_key="your_api_key")

  client.feedback(memory_id="your-memory-id", feedback="NEGATIVE", feedback_reason="I don't like this memory because it is not relevant.")
  ```

  ```javascript JavaScript theme={null}
  import MemoryClient from 'mem0ai';

  const client = new MemoryClient({ apiKey: 'your-api-key'});

  client.feedback({
      memory_id: "your-memory-id", 
      feedback: "NEGATIVE", 
      feedback_reason: "I don't like this memory because it is not relevant."
  })
  ```
</CodeGroup>

## Feedback Types

The `feedback` parameter can be one of the following values:

* `POSITIVE`: The memory is useful.
* `NEGATIVE`: The memory is not useful.
* `VERY_NEGATIVE`: The memory is not useful at all.

## Parameters

The `feedback` method accepts these parameters:

| Parameter         | Type   | Required | Description                                                  |
| ----------------- | ------ | -------- | ------------------------------------------------------------ |
| `memory_id`       | string | Yes      | The ID of the memory to give feedback on                     |
| `feedback`        | string | No       | Type of feedback: `POSITIVE`, `NEGATIVE`, or `VERY_NEGATIVE` |
| `feedback_reason` | string | No       | Optional explanation for the feedback                        |

<Note>
  Pass `None` or `null` to the `feedback` and `feedback_reason` parameters to remove existing feedback for a memory.
</Note>

## Bulk Feedback Operations

For applications with high volumes of feedback, you can provide feedback on multiple memories at once:

<CodeGroup>
  ```python Python theme={null}
  from mem0 import MemoryClient

  client = MemoryClient(api_key="your_api_key")

  # Bulk feedback example
  feedback_data = [
      {
          "memory_id": "memory-1", 
          "feedback": "POSITIVE", 
          "feedback_reason": "Accurately captured the user's preference"
      },
      {
          "memory_id": "memory-2", 
          "feedback": "NEGATIVE", 
          "feedback_reason": "Contains outdated information"
      }
  ]

  for item in feedback_data:
      client.feedback(**item)
  ```

  ```javascript JavaScript theme={null}
  import MemoryClient from 'mem0ai';

  const client = new MemoryClient({ apiKey: 'your-api-key'});

  // Bulk feedback example
  const feedbackData = [
      {
          memory_id: "memory-1", 
          feedback: "POSITIVE", 
          feedback_reason: "Accurately captured the user's preference"
      },
      {
          memory_id: "memory-2", 
          feedback: "NEGATIVE", 
          feedback_reason: "Contains outdated information"
      }
  ];

  for (const item of feedbackData) {
      await client.feedback(item);
  }
  ```
</CodeGroup>

## Best Practices

### When to Provide Feedback

* Immediately after memory retrieval when you can assess relevance
* During user interactions when users explicitly indicate satisfaction or dissatisfaction
* Through automated evaluation using your application's success metrics

### Effective Feedback Reasons

Provide specific, actionable feedback reasons:

**Good examples:**

* "Contains outdated contact information"
* "Accurately captured the user's dietary restrictions"
* "Irrelevant to the current conversation context"

**Avoid vague reasons:**

* "Bad memory"
* "Wrong"
* "Not good"

### Feedback Strategy

1. Be consistent: Apply the same criteria across similar memories
2. Be specific: Detailed reasons help improve the system faster
3. Monitor patterns: Regular feedback analysis helps identify improvement areas

## Error Handling

Handle potential errors when submitting feedback:

<CodeGroup>
  ```python Python theme={null}
  from mem0 import MemoryClient
  from mem0.exceptions import MemoryNotFoundError, APIError

  client = MemoryClient(api_key="your_api_key")

  try:
      client.feedback(
          memory_id="memory-123", 
          feedback="POSITIVE", 
          feedback_reason="Helpful context for user query"
      )
      print("Feedback submitted successfully")
  except MemoryNotFoundError:
      print("Memory not found")
  except APIError as e:
      print(f"API error: {e}")
  except Exception as e:
      print(f"Unexpected error: {e}")
  ```

  ```javascript JavaScript theme={null}
  import MemoryClient from 'mem0ai';

  const client = new MemoryClient({ apiKey: 'your-api-key'});

  try {
      await client.feedback({
          memory_id: "memory-123", 
          feedback: "POSITIVE", 
          feedback_reason: "Helpful context for user query"
      });
      console.log("Feedback submitted successfully");
  } catch (error) {
      if (error.status === 404) {
          console.log("Memory not found");
      } else {
          console.log(`Error: ${error.message}`);
      }
  }
  ```
</CodeGroup>

## Feedback Analytics

Track the impact of your feedback by monitoring memory performance over time. Consider implementing:

* Feedback completion rates: What percentage of memories receive feedback
* Feedback distribution: Balance of positive vs. negative feedback
* Memory quality trends: How accuracy improves with feedback volume
* User satisfaction metrics: Correlation between feedback and user experience


# Graph Memory
Source: https://docs.mem0.ai/platform/features/graph-memory

Enable graph-based memory retrieval for more contextually relevant results

## Overview

Graph Memory enhances the memory pipeline by creating relationships between entities in your data. It builds a network of interconnected information for more contextually relevant search results.

This feature allows your AI applications to understand connections between entities, providing richer context for responses. It's ideal for applications needing relationship tracking and nuanced information retrieval across related memories.

## How Graph Memory Works

The Graph Memory feature analyzes how each entity connects and relates to each other. When enabled:

1. Mem0 automatically builds a graph representation of entities
2. Vector search returns the top semantic matches (with any reranker you configure)
3. Graph relations are returned alongside those results to provide additional context—they do not reorder the vector hits

## Using Graph Memory

To use Graph Memory, you need to enable it in your API calls by setting the `enable_graph=True` parameter.

### Adding Memories with Graph Memory

When adding new memories, enable Graph Memory to automatically build relationships with existing memories:

<CodeGroup>
  ```python Python theme={null}
  from mem0 import MemoryClient

  client = MemoryClient(
      api_key="your-api-key",
      org_id="your-org-id",
      project_id="your-project-id"
  )

  messages = [
      {"role": "user", "content": "My name is Joseph"},
      {"role": "assistant", "content": "Hello Joseph, it's nice to meet you!"},
      {"role": "user", "content": "I'm from Seattle and I work as a software engineer"}
  ]

  # Enable graph memory when adding
  client.add(
      messages,
      user_id="joseph",
      enable_graph=True
  )
  ```

  ```javascript JavaScript theme={null}
  import { MemoryClient } from "mem0";

  const client = new MemoryClient({
    apiKey: "your-api-key",
    org_id: "your-org-id",
    project_id: "your-project-id"
  });

  const messages = [
    { role: "user", content: "My name is Joseph" },
    { role: "assistant", content: "Hello Joseph, it's nice to meet you!" },
    { role: "user", content: "I'm from Seattle and I work as a software engineer" }
  ];

  // Enable graph memory when adding
  await client.add({
    messages,
    user_id: "joseph",
    enable_graph: true
  });
  ```

  ```json Output theme={null}
  {
    "results": [
      {
        "memory": "Name is Joseph",
        "event": "ADD",
        "id": "4a5a417a-fa10-43b5-8c53-a77c45e80438"
      },
      {
        "memory": "Is from Seattle",
        "event": "ADD",
        "id": "8d268d0f-5452-4714-b27d-ae46f676a49d"
      },
      {
        "memory": "Is a software engineer",
        "event": "ADD",
        "id": "5f0a184e-ddea-4fe6-9b92-692d6a901df8"
      }
    ]
  }
  ```
</CodeGroup>

The graph memory would look like this:

<Frame>
  <img src="https://mintcdn.com/mem0/k4LG2Flv5533NbwL/images/graph-platform.png?fit=max&auto=format&n=k4LG2Flv5533NbwL&q=85&s=2d2b29b42b225295e44e53faac520111" alt="Graph Memory Visualization showing relationships between entities" data-og-width="1154" width="1154" data-og-height="850" height="850" data-path="images/graph-platform.png" data-optimize="true" data-opv="3" srcset="https://mintcdn.com/mem0/k4LG2Flv5533NbwL/images/graph-platform.png?w=280&fit=max&auto=format&n=k4LG2Flv5533NbwL&q=85&s=db033be5c7c0fef8b5ee8704928f6d0e 280w, https://mintcdn.com/mem0/k4LG2Flv5533NbwL/images/graph-platform.png?w=560&fit=max&auto=format&n=k4LG2Flv5533NbwL&q=85&s=db35424a3d6cfb6a276bd7b52782f520 560w, https://mintcdn.com/mem0/k4LG2Flv5533NbwL/images/graph-platform.png?w=840&fit=max&auto=format&n=k4LG2Flv5533NbwL&q=85&s=136522d1f6d855a2adb22086a4c63f91 840w, https://mintcdn.com/mem0/k4LG2Flv5533NbwL/images/graph-platform.png?w=1100&fit=max&auto=format&n=k4LG2Flv5533NbwL&q=85&s=5d027f89e813b473b120f413cdbdb559 1100w, https://mintcdn.com/mem0/k4LG2Flv5533NbwL/images/graph-platform.png?w=1650&fit=max&auto=format&n=k4LG2Flv5533NbwL&q=85&s=7638d0008f9d1f25bce09566ec618d21 1650w, https://mintcdn.com/mem0/k4LG2Flv5533NbwL/images/graph-platform.png?w=2500&fit=max&auto=format&n=k4LG2Flv5533NbwL&q=85&s=b3ce639270d1682c9d4b48b81db80f28 2500w" />
</Frame>

<Caption>Graph Memory creates a network of relationships between entities, enabling more contextual retrieval</Caption>

<Note>
  Response for the graph memory's `add` operation will not be available directly in the response. As adding graph memories is an asynchronous operation due to heavy processing, you can use the `get_all()` endpoint to retrieve the memory with the graph metadata.
</Note>

### Searching with Graph Memory

When searching memories, Graph Memory helps retrieve entities that are contextually important even if they're not direct semantic matches.

<CodeGroup>
  ```python Python theme={null}
  # Search with graph memory enabled
  results = client.search(
      "what is my name?",
      user_id="joseph",
      enable_graph=True
  )

  print(results)
  ```

  ```javascript JavaScript theme={null}
  // Search with graph memory enabled
  const results = await client.search({
    query: "what is my name?",
    user_id: "joseph",
    enable_graph: true
  });

  console.log(results);
  ```

  ```json Output theme={null}
  {
    "results": [
      {
        "id": "4a5a417a-fa10-43b5-8c53-a77c45e80438",
        "memory": "Name is Joseph",
        "user_id": "joseph",
        "metadata": null,
        "categories": ["personal_details"],
        "immutable": false,
        "created_at": "2025-03-19T09:09:00.146390-07:00",
        "updated_at": "2025-03-19T09:09:00.146404-07:00",
        "score": 0.3621795393335552
      },
      {
        "id": "8d268d0f-5452-4714-b27d-ae46f676a49d",
        "memory": "Is from Seattle",
        "user_id": "joseph",
        "metadata": null,
        "categories": ["personal_details"],
        "immutable": false,
        "created_at": "2025-03-19T09:09:00.170680-07:00",
        "updated_at": "2025-03-19T09:09:00.170692-07:00",
        "score": 0.31212713194651254
      }
    ],
    "relations": [
      {
        "source": "joseph",
        "source_type": "person",
        "relationship": "name",
        "target": "joseph",
        "target_type": "person",
        "score": 0.39
      }
    ]
  }
  ```
</CodeGroup>

<Note>
  `results` always reflects the vector search order (optionally reranked). Graph Memory augments that response by adding related entities in the `relations` array; it does not re-rank the vector results automatically.
</Note>

### Retrieving All Memories with Graph Memory

When retrieving all memories, Graph Memory provides additional relationship context:

<Callout type="warning" title="Filters Required">
  `get_all()` now requires filters to be specified.
</Callout>

<CodeGroup>
  ```python Python theme={null}
  # Get all memories with graph context
  memories = client.get_all(
      filters={"AND": [{"user_id": "joseph"}]},
      enable_graph=True
  )

  print(memories)
  ```

  ```javascript JavaScript theme={null}
  // Get all memories with graph context
  const memories = await client.getAll({
    filters: {"AND": [{"user_id": "joseph"}]},
    enable_graph: true
  });

  console.log(memories);
  ```

  ```json Output theme={null}
  {
    "results": [
      {
        "id": "5f0a184e-ddea-4fe6-9b92-692d6a901df8",
        "memory": "Is a software engineer",
        "user_id": "joseph",
        "metadata": null,
        "categories": ["professional_details"],
        "immutable": false,
        "created_at": "2025-03-19T09:09:00.194116-07:00",
        "updated_at": "2025-03-19T09:09:00.194128-07:00",
      },
      {
        "id": "8d268d0f-5452-4714-b27d-ae46f676a49d",
        "memory": "Is from Seattle",
        "user_id": "joseph",
        "metadata": null,
        "categories": ["personal_details"],
        "immutable": false,
        "created_at": "2025-03-19T09:09:00.170680-07:00",
        "updated_at": "2025-03-19T09:09:00.170692-07:00",
      },
      {
        "id": "4a5a417a-fa10-43b5-8c53-a77c45e80438",
        "memory": "Name is Joseph",
        "user_id": "joseph",
        "metadata": null,
        "categories": ["personal_details"],
        "immutable": false,
        "created_at": "2025-03-19T09:09:00.146390-07:00",
        "updated_at": "2025-03-19T09:09:00.146404-07:00",
      }
    ],
    "relations": [
      {
        "source": "joseph",
        "source_type": "person",
        "relationship": "name",
        "target": "joseph",
        "target_type": "person"
      },
      {
        "source": "joseph",
        "source_type": "person",
        "relationship": "city",
        "target": "seattle",
        "target_type": "city"
      },
      {
        "source": "joseph",
        "source_type": "person",
        "relationship": "job",
        "target": "software engineer",
        "target_type": "job"
      }
    ]
  }
  ```
</CodeGroup>

### Setting Graph Memory at Project Level

Instead of passing `enable_graph=True` to every add call, you can enable it once at the project level:

<CodeGroup>
  ```python Python theme={null}
  from mem0 import MemoryClient

  client = MemoryClient(
      api_key="your-api-key",
      org_id="your-org-id",
      project_id="your-project-id"
  )

  # Enable graph memory for all operations in this project
  client.project.update(enable_graph=True)

  # Now all add operations will use graph memory by default
  messages = [
      {"role": "user", "content": "My name is Joseph"},
      {"role": "assistant", "content": "Hello Joseph, it's nice to meet you!"},
      {"role": "user", "content": "I'm from Seattle and I work as a software engineer"}
  ]

  client.add(
      messages,
      user_id="joseph"
  )
  ```

  ```javascript JavaScript theme={null}
  import { MemoryClient } from "mem0";

  const client = new MemoryClient({
    apiKey: "your-api-key",
    org_id: "your-org-id",
    project_id: "your-project-id"
  });

  // Enable graph memory for all operations in this project
  await client.project.update({ enable_graph: true });

  // Now all add operations will use graph memory by default
  const messages = [
    { role: "user", content: "My name is Joseph" },
    { role: "assistant", content: "Hello Joseph, it's nice to meet you!" },
    { role: "user", content: "I'm from Seattle and I work as a software engineer" }
  ];

  await client.add({
    messages,
    user_id: "joseph"
  });
  ```
</CodeGroup>

## Best Practices

* Enable Graph Memory for applications where understanding context and relationships between memories is important.
* Graph Memory works best with a rich history of related conversations.
* Consider Graph Memory for long-running assistants that need to track evolving information.

## Performance Considerations

Graph Memory requires additional processing and may increase response times slightly for very large memory stores. However, for most use cases, the improved retrieval quality outweighs the minimal performance impact.

If you have any questions, please feel free to reach out to us using one of the following methods:

<Snippet file="get-help.mdx" />


# Configurable Graph Threshold
Source: https://docs.mem0.ai/platform/features/graph-threshold



## Overview

The graph store threshold parameter controls how strictly nodes are matched during graph data ingestion based on embedding similarity. This feature allows you to customize the matching behavior to prevent false matches or enable entity merging based on your specific use case.

## Configuration

Add the `threshold` parameter to your graph store configuration:

```python  theme={null}
from mem0 import Memory

config = {
    "graph_store": {
        "provider": "neo4j",  # or memgraph, neptune, kuzu
        "config": {
            "url": "bolt://localhost:7687",
            "username": "neo4j",
            "password": "password"
        },
        "threshold": 0.7  # Default value, range: 0.0 to 1.0
    }
}

memory = Memory.from_config(config)
```

## Parameters

| Parameter   | Type  | Default | Range     | Description                                                                                |
| ----------- | ----- | ------- | --------- | ------------------------------------------------------------------------------------------ |
| `threshold` | float | 0.7     | 0.0 - 1.0 | Minimum embedding similarity score required to match existing nodes during graph ingestion |

## Use Cases

### Strict Matching (UUIDs, IDs)

Use higher thresholds (0.95-0.99) when working with identifiers that should remain distinct:

```python  theme={null}
config = {
    "graph_store": {
        "provider": "neo4j",
        "config": {...},
        "threshold": 0.95  # Strict matching
    }
}
```

**Example:** Prevents UUID collisions like `MXxBUE18QVBQTElDQVRJT058MjM3MTM4NjI5` being matched with `MXxBUE18QVBQTElDQVRJT058MjA2OTYxMzM`

### Permissive Matching (Natural Language)

Use lower thresholds (0.6-0.7) when entity variations should be merged:

```python  theme={null}
config = {
    "graph_store": {
        "threshold": 0.6  # Permissive matching
    }
}
```

**Example:** Merges similar entities like "Bob" and "Robert" as the same person.

## Threshold Guidelines

| Use Case         | Recommended Threshold | Behavior                                          |
| ---------------- | --------------------- | ------------------------------------------------- |
| UUIDs, IDs, Keys | 0.95 - 0.99           | Prevent false matches between similar identifiers |
| Structured Data  | 0.85 - 0.9            | Balanced precision and recall                     |
| General Purpose  | 0.7 - 0.8             | Default recommendation                            |
| Natural Language | 0.6 - 0.7             | Allow entity variations to merge                  |

## Examples

### Example 1: Preventing Data Loss with UUIDs

```python  theme={null}
from mem0 import Memory

config = {
    "graph_store": {
        "provider": "neo4j",
        "config": {
            "url": "bolt://localhost:7687",
            "username": "neo4j",
            "password": "password"
        },
        "threshold": 0.98  # Very strict for UUIDs
    }
}

memory = Memory.from_config(config)

# These UUIDs create separate nodes instead of being incorrectly merged
memory.add(
    [{"role": "user", "content": "MXxBUE18QVBQTElDQVRJT058MjM3MTM4NjI5 relates to Project A"}],
    user_id="user1"
)

memory.add(
    [{"role": "user", "content": "MXxBUE18QVBQTElDQVRJT058MjA2OTYxMzM relates to Project B"}],
    user_id="user1"
)
```

### Example 2: Merging Entity Variations

```python  theme={null}
config = {
    "graph_store": {
        "provider": "neo4j",
        "config": {...},
        "threshold": 0.6  # More permissive
    }
}

memory = Memory.from_config(config)

# These will be merged as the same entity
memory.add([{"role": "user", "content": "Bob works at Google"}], user_id="user1")
memory.add([{"role": "user", "content": "Robert works at Google"}], user_id="user1")
```

### Example 3: Different Thresholds for Different Clients

```python  theme={null}
# Client 1: Strict matching for transactional data
memory_strict = Memory.from_config({
    "graph_store": {"threshold": 0.95}
})

# Client 2: Permissive matching for conversational data
memory_permissive = Memory.from_config({
    "graph_store": {"threshold": 0.6}
})
```

## Supported Graph Providers

The threshold parameter works with all graph store providers:

* ✅ Neo4j
* ✅ Memgraph
* ✅ Kuzu
* ✅ Neptune (both Analytics and DB)

## How It Works

When adding a relation to the graph:

1. **Embedding Generation**: The system generates embeddings for source and destination entities
2. **Node Search**: Searches for existing nodes with similar embeddings
3. **Threshold Comparison**: Compares similarity scores against the configured threshold
4. **Decision**:
   * If similarity ≥ threshold: Uses the existing node
   * If similarity \< threshold: Creates a new node

```python  theme={null}
# Pseudocode
if node_similarity >= threshold:
    use_existing_node()
else:
    create_new_node()
```

## Troubleshooting

### Issue: Duplicate nodes being created

**Symptom**: Expected nodes to merge but they're created separately

**Solution**: Lower the threshold

```python  theme={null}
config = {"graph_store": {"threshold": 0.6}}
```

### Issue: Unrelated entities being merged

**Symptom**: Different entities incorrectly matched as the same node

**Solution**: Raise the threshold

```python  theme={null}
config = {"graph_store": {"threshold": 0.95}}
```

### Issue: Validation error

**Symptom**: `ValidationError: threshold must be between 0.0 and 1.0`

**Solution**: Ensure threshold is in valid range

```python  theme={null}
config = {"graph_store": {"threshold": 0.7}}  # Valid: 0.0 ≤ x ≤ 1.0
```

## Backward Compatibility

* **Default Value**: 0.7 (maintains existing behavior)
* **Optional Parameter**: Existing code works without any changes
* **No Breaking Changes**: Graceful fallback if not specified

## Related

* [Graph Memory](/platform/features/graph-memory)
* [Issue #3590](https://github.com/mem0ai/mem0/issues/3590)


# Group Chat
Source: https://docs.mem0.ai/platform/features/group-chat

Enable multi-participant conversations with automatic memory attribution to individual speakers

<Snippet file="paper-release.mdx" />

## Overview

The Group Chat feature enables Mem0 to process conversations involving multiple participants and automatically attribute memories to individual speakers. This allows for precise tracking of each participant's preferences, characteristics, and contributions in collaborative discussions, team meetings, or multi-agent conversations.

When you provide messages with participant names, Mem0 automatically:

* Extracts memories from each participant's messages separately
* Attributes each memory to the correct speaker using their name as the `user_id` or `agent_id`
* Maintains individual memory profiles for each participant

## How Group Chat Works

Mem0 automatically detects group chat scenarios when messages contain a `name` field:

```json  theme={null}
{
  "role": "user",
  "name": "Alice",
  "content": "Hey team, I think we should use React for the frontend"
}
```

When names are present, Mem0:

* Formats messages as `"Alice (user): content"` for processing
* Extracts memories with proper attribution to each speaker
* Stores memories with the speaker's name as the `user_id` (for users) or `agent_id` (for assistants/agents)

### Memory Attribution Rules

* **User Messages**: The `name` field becomes the `user_id` in stored memories
* **Assistant/Agent Messages**: The `name` field becomes the `agent_id` in stored memories
* **Messages without names**: Fall back to standard processing using role as identifier

## Using Group Chat

### Basic Group Chat

Add memories from a multi-participant conversation:

<CodeGroup>
  ```python Python theme={null}
  from mem0 import MemoryClient

  client = MemoryClient(api_key="your-api-key")

  # Group chat with multiple users
  messages = [
      {"role": "user", "name": "Alice", "content": "Hey team, I think we should use React for the frontend"},
      {"role": "user", "name": "Bob", "content": "I disagree, Vue.js would be better for our use case"},
      {"role": "user", "name": "Charlie", "content": "What about considering Angular? It has great enterprise support"},
      {"role": "assistant", "content": "All three frameworks have their merits. Let me summarize the pros and cons of each."}
  ]

  response = client.add(
      messages,
      run_id="group_chat_1",
      infer=True
  )
  print(response)
  ```

  ```json Output theme={null}
  {
    "results": [
      {
        "id": "4d82478a-8d50-47e6-9324-1f65efff5829",
        "event": "ADD",
        "memory": "prefers using React for the frontend"
      },
      {
        "id": "1d8b8f39-7b17-4d18-8632-ab1c64fa35b9",
        "event": "ADD",
        "memory": "prefers Vue.js for our use case"
      },
      {
        "id": "147559a8-c5f7-44d0-9418-91f53f7a89a4",
        "event": "ADD",
        "memory": "suggests considering Angular because it has great enterprise support"
      }
    ]
  }
  ```
</CodeGroup>

## Retrieving Group Chat Memories

### Get All Memories for a Session

Retrieve all memories from a specific group chat session:

<CodeGroup>
  ```python Python theme={null}
  # Get all memories for a specific run_id
  # Use wildcard "*" for user_id to match all participants
  filters = {
      "AND": [
          {"user_id": "*"},
          {"run_id": "group_chat_1"}
      ]
  }

  all_memories = client.get_all(filters=filters, page=1)
  print(all_memories)
  ```

  ```json Output theme={null}
  [
      {
          "id": "147559a8-c5f7-44d0-9418-91f53f7a89a4",
          "memory": "suggests considering Angular because it has great enterprise support",
          "user_id": "charlie",
          "run_id": "group_chat_1",
          "created_at": "2025-06-21T05:51:11.007223-07:00",
          "updated_at": "2025-06-21T05:51:11.626562-07:00"
      },
      {
          "id": "1d8b8f39-7b17-4d18-8632-ab1c64fa35b9",
          "memory": "prefers Vue.js for our use case",
          "user_id": "bob",
          "run_id": "group_chat_1",
          "created_at": "2025-06-21T05:51:08.675301-07:00",
          "updated_at": "2025-06-21T05:51:09.319269-07:00",
      },
      {
          "id": "4d82478a-8d50-47e6-9324-1f65efff5829",
          "memory": "prefers using React for the frontend",
          "user_id": "alice",
          "run_id": "group_chat_1",
          "created_at": "2025-06-21T05:51:05.943223-07:00",
          "updated_at": "2025-06-21T05:51:06.982539-07:00",
      }
  ]
  ```
</CodeGroup>

### Get Memories for a Specific Participant

Retrieve memories from a specific participant in a group chat:

<CodeGroup>
  ```python Python theme={null}
  # Get memories for a specific participant
  filters = {
      "AND": [
          {"user_id": "charlie"},
          {"run_id": "group_chat_1"}
      ]
  }

  charlie_memories = client.get_all(filters=filters, page=1)
  print(charlie_memories)
  ```

  ```json Output theme={null}
  [
      {
          "id": "147559a8-c5f7-44d0-9418-91f53f7a89a4",
          "memory": "suggests considering Angular because it has great enterprise support",
          "user_id": "charlie",
          "run_id": "group_chat_1",
          "created_at": "2025-06-21T05:51:11.007223-07:00",
          "updated_at": "2025-06-21T05:51:11.626562-07:00",

      }
  ]
  ```
</CodeGroup>

### Search Within Group Chat Context

Search for specific information within a group chat session:

<CodeGroup>
  ```python Python theme={null}
  # Search within group chat context
  filters = {
      "AND": [
          {"user_id": "charlie"},
          {"run_id": "group_chat_1"}
      ]
  }

  search_response = client.search(
      query="What are the tasks?",
      filters=filters
  )
  print(search_response)
  ```

  ```json Output theme={null}
  [
      {
          "id": "147559a8-c5f7-44d0-9418-91f53f7a89a4",
          "memory": "suggests considering Angular because it has great enterprise support",
          "user_id": "charlie",
          "run_id": "group_chat_1",
          "created_at": "2025-06-21T05:51:11.007223-07:00",
          "updated_at": "2025-06-21T05:51:11.626562-07:00",
      }
  ]
  ```
</CodeGroup>

## Async Mode Support

Group chat also supports async processing for improved performance:

<CodeGroup>
  ```python Python theme={null}
  # Group chat with async mode
  response = client.add(
      messages,
      run_id="groupchat_async",
      infer=True,
      async_mode=True
  )
  print(response)
  ```
</CodeGroup>

## Message Format Requirements

### Required Fields

Each message in a group chat must include:

* `role`: The participant's role (`"user"`, `"assistant"`, `"agent"`)
* `content`: The message content
* `name`: The participant's name (required for group chat detection)

### Example Message Structure

```json  theme={null}
{
  "role": "user",
  "name": "Alice",
  "content": "I think we should use React for the frontend"
}
```

### Supported Roles

* **`user`**: Human participants (memories stored with `user_id`)
* **`assistant`**: AI assistants (memories stored with `agent_id`)

## Best Practices

1. **Consistent Naming**: Use consistent names for participants across sessions to maintain proper memory attribution.

2. **Clear Role Assignment**: Ensure each participant has the correct role (`user`, `assistant`, or `agent`) for proper memory categorization.

3. **Session Management**: Use meaningful `run_id` values to organize group chat sessions and enable easy retrieval.

4. **Memory Filtering**: Use filters to retrieve memories from specific participants or sessions when needed.

5. **Async Processing**: Use `async_mode=True` for large group conversations to improve performance.

6. **Search Context**: Leverage the search functionality to find specific information within group chat contexts.

## Use Cases

* **Team Meetings**: Track individual team member preferences and contributions
* **Customer Support**: Maintain separate memory profiles for different customers
* **Multi-Agent Systems**: Manage conversations with multiple AI assistants
* **Collaborative Projects**: Track individual preferences and expertise areas
* **Group Discussions**: Maintain context for each participant's viewpoints

If you have any questions, please feel free to reach out to us using one of the following methods:

<Snippet file="get-help.mdx" />


# Memory Export
Source: https://docs.mem0.ai/platform/features/memory-export

Export memories in a structured format using customizable Pydantic schemas

## Overview

The Memory Export feature allows you to create structured exports of memories using customizable Pydantic schemas. This process enables you to transform your stored memories into specific data formats that match your needs. You can apply various filters to narrow down which memories to export and define exactly how the data should be structured.

## Creating a Memory Export

To create a memory export, you'll need to:

1. Define your schema structure
2. Submit an export job
3. Retrieve the exported data

### Define Schema

Here's an example schema for extracting professional profile information:

```json  theme={null}
{
    "$defs": {
        "EducationLevel": {
            "enum": ["high_school", "bachelors", "masters"],
            "title": "EducationLevel",
            "type": "string"
        },
        "EmploymentStatus": {
            "enum": ["full_time", "part_time", "student"],
            "title": "EmploymentStatus", 
            "type": "string"
        }
    },
    "properties": {
        "full_name": {
            "anyOf": [
                {
                    "maxLength": 100,
                    "minLength": 2,
                    "type": "string"
                },
                {
                    "type": "null"
                }
            ],
            "default": null,
            "description": "The professional's full name",
            "title": "Full Name"
        },
        "current_role": {
            "anyOf": [
                {
                    "type": "string"
                },
                {
                    "type": "null"
                }
            ],
            "default": null,
            "description": "Current job title or role",
            "title": "Current Role"
        }
    },
    "title": "ProfessionalProfile",
    "type": "object"
}
```

### Submit Export Job

You can optionally provide additional instructions to guide how memories are processed and structured during export using the `export_instructions` parameter.

<CodeGroup>
  ```python Python theme={null}
  # Basic export request
  filters = {"user_id": "alice"}
  response = client.create_memory_export(
      schema=json_schema,
      filters=filters
  )

  # Export with custom instructions and additional filters
  export_instructions = """
  1. Create a comprehensive profile with detailed information in each category
  2. Only mark fields as "None" when absolutely no relevant information exists
  3. Base all information directly on the user's memories
  4. When contradictions exist, prioritize the most recent information
  5. Clearly distinguish between factual statements and inferences
  """

  filters = {
      "AND": [
          {"user_id": "alex"},
          {"created_at": {"gte": "2024-01-01"}}
      ]
  }

  response = client.create_memory_export(
      schema=json_schema,
      filters=filters,
      export_instructions=export_instructions  # Optional
  )

  print(response)
  ```

  ```javascript JavaScript theme={null}
  // Basic Export request
  const filters = {"user_id": "alice"};
  const response = await client.createMemoryExport({
      schema: json_schema,
      filters: filters
  });

  // Export with custom instructions and additional filters
  const export_instructions = `
  1. Create a comprehensive profile with detailed information in each category
  2. Only mark fields as "None" when absolutely no relevant information exists
  3. Base all information directly on the user's memories
  4. When contradictions exist, prioritize the most recent information
  5. Clearly distinguish between factual statements and inferences
  `;

  // For create operation, using only user_id filter as requested
  const filters = {
      "AND": [
          {"user_id": "alex"},
          {"created_at": {"gte": "2024-01-01"}}
      ]
  }

  const responseWithInstructions = await client.createMemoryExport({
      schema: json_schema,
      filters: filters,
      export_instructions: export_instructions
  });

  console.log(responseWithInstructions);
  ```

  ```bash cURL theme={null}
  curl -X POST "https://api.mem0.ai/v1/memories/export/" \
       -H "Authorization: Token your-api-key" \
       -H "Content-Type: application/json" \
       -d '{
           "schema": {json_schema},
           "filters": {"user_id": "alice"},
           "export_instructions": "1. Create a comprehensive profile with detailed information\n2. Only mark fields as \"None\" when absolutely no relevant information exists"
       }'
  ```

  ```json Output theme={null}
  {
      "message": "Memory export request received. The export will be ready in a few seconds.",
      "id": "550e8400-e29b-41d4-a716-446655440000"
  }
  ```
</CodeGroup>

### Retrieve Export

Once the export job is complete, you can retrieve the structured data in two ways:

#### Using Export ID

<CodeGroup>
  ```python Python theme={null}
  # Retrieve using export ID
  response = client.get_memory_export(memory_export_id="550e8400-e29b-41d4-a716-446655440000")
  print(response)
  ```

  ```javascript JavaScript theme={null}
  // Retrieve using export ID
  const memory_export_id = "550e8400-e29b-41d4-a716-446655440000";

  const response = await client.getMemoryExport({
      memory_export_id: memory_export_id
  });

  console.log(response);
  ```

  ```json Output theme={null}
  {
      "full_name": "John Doe",
      "current_role": "Senior Software Engineer",
      "years_experience": 8,
      "employment_status": "full_time",
      "education_level": "masters",
      "skills": ["Python", "AWS", "Machine Learning"]
  }
  ```
</CodeGroup>

#### Using Filters

<CodeGroup>
  ```python Python theme={null}
  # Retrieve using filters
  filters = {
      "AND": [
          {"created_at": {"gte": "2024-07-10", "lte": "2024-07-20"}},
          {"user_id": "alex"}
      ]
  }

  response = client.get_memory_export(filters=filters)
  print(response)
  ```

  ```javascript JavaScript theme={null}
  // Retrieve using filters
  const filters = {
      "AND": [
          {"created_at": {"gte": "2024-07-10", "lte": "2024-07-20"}},
          {"user_id": "alex"}
      ]
  }

  const response = await client.getMemoryExport({
      filters: filters
  });

  console.log(response);
  ```

  ```json Output theme={null}
  {
      "full_name": "John Doe",
      "current_role": "Senior Software Engineer",
      "years_experience": 8,
      "employment_status": "full_time",
      "education_level": "masters",
      "skills": ["Python", "AWS", "Machine Learning"]
  }
  ```
</CodeGroup>

## Available Filters

You can apply various filters to customize which memories are included in the export:

* `user_id`: Filter memories by specific user
* `agent_id`: Filter memories by specific agent
* `run_id`: Filter memories by specific run
* `session_id`: Filter memories by specific session
* `created_at`: Filter memories by date

<Note>
  The export process may take some time to complete, especially when dealing with a large number of memories or complex schemas.
</Note>

If you have any questions, please feel free to reach out to us using one of the following methods:

<Snippet file="get-help.mdx" />


# Multimodal Support
Source: https://docs.mem0.ai/platform/features/multimodal-support

Integrate images and documents into your interactions with Mem0

Mem0 extends its capabilities beyond text by supporting multimodal data, including images and documents. With this feature, users can seamlessly integrate visual and document content into their interactions, allowing Mem0 to extract relevant information from various media types and enrich the memory system.

## How It Works

When a user submits an image or document, Mem0 processes it to extract textual information and other pertinent details. These details are then added to the user's memory, enhancing the system's ability to understand and recall multimodal inputs.

<CodeGroup>
  ```python Python theme={null}
  import os
  from mem0 import MemoryClient

  os.environ["MEM0_API_KEY"] = "your-api-key"

  client = MemoryClient()

  messages = [
      {
          "role": "user",
          "content": "Hi, my name is Alice."
      },
      {
          "role": "assistant",
          "content": "Nice to meet you, Alice! What do you like to eat?"
      },
      {
          "role": "user",
          "content": {
              "type": "image_url",
              "image_url": {
                  "url": "https://www.superhealthykids.com/wp-content/uploads/2021/10/best-veggie-pizza-featured-image-square-2.jpg"
              }
          }
      },
  ]

  # Calling the add method to ingest messages into the memory system
  client.add(messages, user_id="alice")
  ```

  ```typescript TypeScript theme={null}
  import MemoryClient from "mem0ai";

  const client = new MemoryClient();

  const messages = [
      {
          role: "user",
          content: "Hi, my name is Alice."
      },
      {
          role: "assistant",
          content: "Nice to meet you, Alice! What do you like to eat?"
      },
      {
          role: "user",
          content: {
              type: "image_url",
              image_url: {
                  url: "https://www.superhealthykids.com/wp-content/uploads/2021/10/best-veggie-pizza-featured-image-square-2.jpg"
              }
          }
      },
  ]

  await client.add(messages, { user_id: "alice" })
  ```

  ```json Output theme={null}
  {
    "results": [
      {
        "memory": "Name is Alice",
        "event": "ADD",
        "id": "7ae113a3-3cb5-46e9-b6f7-486c36391847"
      },
      {
        "memory": "Likes large pizza with toppings including cherry tomatoes, black olives, green spinach, yellow bell peppers, diced ham, and sliced mushrooms",
        "event": "ADD",
        "id": "56545065-7dee-4acf-8bf2-a5b2535aabb3"
      }
    ]
  }
  ```
</CodeGroup>

## Supported Media Types

Mem0 currently supports the following media types:

1. **Images** - JPG, PNG, and other common image formats
2. **Documents** - MDX, TXT, and PDF files

## Integration Methods

### 1. Images

#### Using an Image URL

You can include an image by providing its direct URL. This method is simple and efficient for online images.

```python {2, 5-13} theme={null}
# Define the image URL
image_url = "https://www.superhealthykids.com/wp-content/uploads/2021/10/best-veggie-pizza-featured-image-square-2.jpg"

# Create the message dictionary with the image URL
image_message = {
    "role": "user",
    "content": {
        "type": "image_url",
        "image_url": {
            "url": image_url
        }
    }
}
client.add([image_message], user_id="alice")
```

#### Using Base64 Image Encoding for Local Files

For local images or when embedding the image directly is preferable, you can use a Base64-encoded string.

<CodeGroup>
  ```python Python theme={null}
  import base64

  # Path to the image file
  image_path = "path/to/your/image.jpg"

  # Encode the image in Base64
  with open(image_path, "rb") as image_file:
      base64_image = base64.b64encode(image_file.read()).decode("utf-8")

  # Create the message dictionary with the Base64-encoded image
  image_message = {
      "role": "user",
      "content": {
          "type": "image_url",
          "image_url": {
              "url": f"data:image/jpeg;base64,{base64_image}"
          }
      }
  }
  client.add([image_message], user_id="alice")
  ```

  ```typescript TypeScript theme={null}
  import MemoryClient from "mem0ai";
  import fs from 'fs';

  const imagePath = 'path/to/your/image.jpg';

  const base64Image = fs.readFileSync(imagePath, { encoding: 'base64' });

  const imageMessage = {
      role: "user",
      content: {
          type: "image_url",
          image_url: {
              url: `data:image/jpeg;base64,${base64Image}`
          }
      }
  };

  await client.add([imageMessage], { user_id: "alice" })
  ```
</CodeGroup>

### 2. Text Documents (MDX/TXT)

Mem0 supports both online and local text documents in MDX or TXT format.

#### Using a Document URL

```python  theme={null}
# Define the document URL
document_url = "https://www.w3.org/TR/2003/REC-PNG-20031110/iso_8859-1.txt"

# Create the message dictionary with the document URL
document_message = {
    "role": "user",
    "content": {
        "type": "mdx_url",
        "mdx_url": {
            "url": document_url
        }
    }
}
client.add([document_message], user_id="alice")
```

#### Using Base64 Encoding for Local Documents

```python  theme={null}
import base64

# Path to the document file
document_path = "path/to/your/document.txt"

# Function to convert file to Base64
def file_to_base64(file_path):
    with open(file_path, "rb") as file:
        return base64.b64encode(file.read()).decode('utf-8')

# Encode the document in Base64
base64_document = file_to_base64(document_path)

# Create the message dictionary with the Base64-encoded document
document_message = {
    "role": "user",
    "content": {
        "type": "mdx_url",
        "mdx_url": {
            "url": base64_document
        }
    }
}
client.add([document_message], user_id="alice")
```

### 3. PDF Documents

Mem0 supports PDF documents via URL.

```python  theme={null}
# Define the PDF URL
pdf_url = "https://www.w3.org/WAI/ER/tests/xhtml/testfiles/resources/pdf/dummy.pdf"

# Create the message dictionary with the PDF URL
pdf_message = {
    "role": "user",
    "content": {
        "type": "pdf_url",
        "pdf_url": {
            "url": pdf_url
        }
    }
}
client.add([pdf_message], user_id="alice")
```

## Complete Example with Multiple File Types

Here's a comprehensive example showing how to work with different file types:

```python  theme={null}
import base64
from mem0 import MemoryClient

client = MemoryClient()

def file_to_base64(file_path):
    with open(file_path, "rb") as file:
        return base64.b64encode(file.read()).decode('utf-8')

# Example 1: Using an image URL
image_message = {
    "role": "user",
    "content": {
        "type": "image_url",
        "image_url": {
            "url": "https://example.com/sample-image.jpg"
        }
    }
}

# Example 2: Using a text document URL
text_message = {
    "role": "user",
    "content": {
        "type": "mdx_url",
        "mdx_url": {
            "url": "https://www.w3.org/TR/2003/REC-PNG-20031110/iso_8859-1.txt"
        }
    }
}

# Example 3: Using a PDF URL
pdf_message = {
    "role": "user",
    "content": {
        "type": "pdf_url",
        "pdf_url": {
            "url": "https://www.w3.org/WAI/ER/tests/xhtml/testfiles/resources/pdf/dummy.pdf"
        }
    }
}

# Add each message to the memory system
client.add([image_message], user_id="alice")
client.add([text_message], user_id="alice")
client.add([pdf_message], user_id="alice")
```

Using these methods, you can seamlessly incorporate various media types into your interactions, further enhancing Mem0's multimodal capabilities.

If you have any questions, please feel free to reach out to us using one of the following methods:

<Snippet file="get-help.mdx" />


# Overview
Source: https://docs.mem0.ai/platform/features/platform-overview

See how Mem0 Platform features evolve from baseline filters to graph-powered retrieval.

Mem0 Platform features help managed deployments scale from basic filtering to graph-powered retrieval and data governance. Use this page to pick the right feature lane for your team.

<Info>
  New to the platform? Start with the <Link href="/platform/quickstart">Platform quickstart</Link>,
  then dive into the journeys below.
</Info>

## Choose your path

<CardGroup cols={3}>
  <Card title="Apply Essential Filters" icon="rocket" href="/platform/features/v2-memory-filters">
    Field-level filtering with async defaults.
  </Card>

  <Card title="Go Real-Time with Async" icon="bolt" href="/platform/features/async-client">
    Non-blocking add/search requests for agents.
  </Card>

  <Card title="Unlock Graph Memory" icon="circle-nodes" href="/platform/features/graph-memory">
    Relationship-aware recall across entities.
  </Card>

  <Card title="Boost Retrieval Quality" icon="sparkles" href="/platform/features/advanced-retrieval">
    Metadata filters, rerankers, and toggles.
  </Card>

  <Card title="Manage Data Lifecycle" icon="database" href="/platform/features/direct-import">
    Imports, exports, timestamps, and expirations.
  </Card>

  <Card title="Extend With Integrations" icon="plug" href="/platform/features/webhooks">
    Webhooks, feedback loops, and multi-agent chat.
  </Card>
</CardGroup>

<Tip>
  Self-hosting instead? Jump to the{" "}
  <Link href="/open-source/features/overview">OSS feature overview</Link> for equivalent
  capabilities.
</Tip>

## Keep going

<CardGroup cols={2}>
  <Card title="Compare with Open Source" description="See how managed features map to the OSS stack." icon="server" href="/platform/platform-vs-oss" />

  <Card title="Run the Quickstart" description="Provision the workspace and ship your first advanced search." icon="rocket" href="/platform/quickstart" />
</CardGroup>


# Memory Timestamps
Source: https://docs.mem0.ai/platform/features/timestamp

Add timestamps to your memories to maintain chronological accuracy and historical context

## Overview

The Memory Timestamps feature allows you to specify when a memory was created, regardless of when it's actually added to the system. This powerful capability enables you to:

* Maintain accurate chronological ordering of memories
* Import historical data with proper timestamps
* Create memories that reflect when events actually occurred
* Build timelines with precise temporal information

By leveraging custom timestamps, you can ensure that your memory system maintains an accurate representation of when information was generated or events occurred.

## Benefits of Custom Timestamps

Custom timestamps offer several important benefits:

* **Historical Accuracy**: Preserve the exact timing of past events and information.
* **Data Migration**: Seamlessly migrate existing data while maintaining original timestamps.
* **Time-Sensitive Analysis**: Enable time-based analysis and pattern recognition across memories.
* **Consistent Chronology**: Maintain proper ordering of memories for coherent storytelling.

## Using Custom Timestamps

When adding new memories, you can specify a custom timestamp to indicate when the memory was created. This timestamp will be used instead of the current time.

### Adding Memories with Custom Timestamps

<CodeGroup>
  ```python Python theme={null}
  import os
  import time
  from datetime import datetime, timedelta

  from mem0 import MemoryClient

  os.environ["MEM0_API_KEY"] = "your-api-key"

  client = MemoryClient()

  # Get the current time
  current_time = datetime.now()

  # Calculate 5 days ago
  five_days_ago = current_time - timedelta(days=5)

  # Convert to Unix timestamp (seconds since epoch)
  unix_timestamp = int(five_days_ago.timestamp())

  # Add memory with custom timestamp
  messages = [
      {"role": "user", "content": "I'm travelling to SF"}
  ]
  client.add(messages, user_id="user1", timestamp=unix_timestamp)
  ```

  ```javascript JavaScript theme={null}
  import MemoryClient from 'mem0ai';
  const client = new MemoryClient({ apiKey: 'your-api-key' });

  // Get the current time
  const currentTime = new Date();

  // Calculate 5 days ago
  const fiveDaysAgo = new Date();
  fiveDaysAgo.setDate(currentTime.getDate() - 5);

  // Convert to Unix timestamp (seconds since epoch)
  const unixTimestamp = Math.floor(fiveDaysAgo.getTime() / 1000);

  // Add memory with custom timestamp
  const messages = [
      {"role": "user", "content": "I'm travelling to SF"}
  ]
  client.add(messages, { user_id: "user1", timestamp: unixTimestamp })
      .then(response => console.log(response))
      .catch(error => console.error(error));
  ```

  ```bash cURL theme={null}
  curl -X POST "https://api.mem0.ai/v1/memories/" \
       -H "Authorization: Token your-api-key" \
       -H "Content-Type: application/json" \
       -d '{
           "messages": [{"role": "user", "content": "I'm travelling to SF"}],
           "user_id": "user1",
           "timestamp": 1721577600
       }'
  ```

  ```json Output theme={null}
  {
      "results": [
          {
              "id": "a1b2c3d4-e5f6-4g7h-8i9j-k0l1m2n3o4p5",
              "data": {"memory": "Travelling to SF"},
              "event": "ADD"
          }
      ]
  }
  ```
</CodeGroup>

### Timestamp Format

When specifying a custom timestamp, you should provide a Unix timestamp (seconds since epoch). This is an integer representing the number of seconds that have elapsed since January 1, 1970 (UTC).

For example, to create a memory with a timestamp of January 1, 2023:

<CodeGroup>
  ```python Python theme={null}
  # January 1, 2023 timestamp
  january_2023_timestamp = 1672531200  # Unix timestamp for 2023-01-01 00:00:00 UTC

  messages = [
      {"role": "user", "content": "I'm travelling to SF"}
  ]
  client.add(messages, user_id="user1", timestamp=january_2023_timestamp)
  ```

  ```javascript JavaScript theme={null}
  // January 1, 2023 timestamp
  const january2023Timestamp = 1672531200;  // Unix timestamp for 2023-01-01 00:00:00 UTC

  const messages = [
      {"role": "user", "content": "I'm travelling to SF"}
  ]
  client.add(messages, { user_id: "user1", timestamp: january2023Timestamp })
      .then(response => console.log(response))
      .catch(error => console.error(error));
  ```
</CodeGroup>

If you have any questions, please feel free to reach out to us using one of the following methods:

<Snippet file="get-help.mdx" />


# Memory Filters
Source: https://docs.mem0.ai/platform/features/v2-memory-filters

Query and retrieve memories with powerful filtering capabilities. Filter by users, agents, content, time ranges, and more.

> Memory filters provide a flexible way to query and retrieve specific memories from your memory store. You can filter by users, agents, content categories, time ranges, and combine multiple conditions using logical operators.

## When to use filters

When working with large-scale memory stores, you need precise control over which memories to retrieve. Filters help you:

* **Isolate user data**: Retrieve memories for specific users while maintaining privacy
* **Debug and audit**: Export specific memory subsets for analysis
* **Target content**: Find memories with specific categories or metadata
* **Time-based queries**: Retrieve memories within specific date ranges
* **Performance optimization**: Reduce query complexity by pre-filtering

<Callout type="info" icon="info-circle" color="#7A5DFF">
  Filters were introduced in v1.0.0 to provide precise control over memory retrieval.
</Callout>

## Filter structure

Filters use a nested JSON structure with logical operators at the root:

```python  theme={null}
# Basic structure
{
    "AND": [  # or "OR", "NOT"
        { "field": "value" },
        { "field": { "operator": "value" } }
    ]
}
```

## Available fields and operators

### Entity fields

| Field      | Operators            | Example                                |
| ---------- | -------------------- | -------------------------------------- |
| `user_id`  | `=`, `!=`, `in`, `*` | `{"user_id": "user_123"}`              |
| `agent_id` | `=`, `!=`, `in`, `*` | `{"agent_id": "*"}`                    |
| `app_id`   | `=`, `!=`, `in`, `*` | `{"app_id": {"in": ["app1", "app2"]}}` |
| `run_id`   | `=`, `!=`, `in`, `*` | `{"run_id": "*"}`                      |

### Time fields

| Field        | Operators                       | Example                                 |
| ------------ | ------------------------------- | --------------------------------------- |
| `created_at` | `>`, `>=`, `<`, `<=`, `=`, `!=` | `{"created_at": {"gte": "2024-01-01"}}` |
| `updated_at` | `>`, `>=`, `<`, `<=`, `=`, `!=` | `{"updated_at": {"lt": "2024-12-31"}}`  |
| `timestamp`  | `>`, `>=`, `<`, `<=`, `=`, `!=` | `{"timestamp": {"gt": "2024-01-01"}}`   |

### Content fields

| Field        | Operators                   | Example                                  |
| ------------ | --------------------------- | ---------------------------------------- |
| `categories` | `=`, `!=`, `in`, `contains` | `{"categories": {"in": ["finance"]}}`    |
| `metadata`   | `=`, `!=`                   | `{"metadata": {"key": "value"}}`         |
| `keywords`   | `contains`, `icontains`     | `{"keywords": {"icontains": "invoice"}}` |

### Special fields

| Field        | Operators | Example                          |
| ------------ | --------- | -------------------------------- |
| `memory_ids` | `in`      | `{"memory_ids": ["id1", "id2"]}` |

<Callout type="warning" icon="exclamation-triangle" color="#F7B731">
  The `*` wildcard matches any non-null value. Records with null values for that field are excluded.
</Callout>

## Common filter patterns

Use these ready-made filters to target typical retrieval scenarios without rebuilding logic from scratch.

<AccordionGroup>
  <Accordion title="Single user">
    ```python  theme={null}
    # Narrow to one user's memories
    filters = {"AND": [{"user_id": "user_123"}]}
    memories = client.get_all(filters=filters)
    ```
  </Accordion>

  <Accordion title="All users">
    ```python  theme={null}
    # Wildcard skips null user_id entries
    filters = {"AND": [{"user_id": "*"}]}
    memories = client.get_all(filters=filters)
    ```
  </Accordion>

  <Accordion title="User across all runs">
    ```python  theme={null}
    # Pair a user filter with a run wildcard
    filters = {
        "AND": [
            {"user_id": "user_123"},
            {"run_id": "*"}
        ]
    }
    memories = client.get_all(filters=filters)
    ```
  </Accordion>
</AccordionGroup>

### Content search

Find memories containing specific text, categories, or metadata values.

<AccordionGroup>
  <Accordion title="Text search">
    ```python  theme={null}
    # Case-insensitive match
    filters = {
        "AND": [
            {"user_id": "user_123"},
            {"keywords": {"icontains": "pizza"}}
        ]
    }

    # Case-sensitive match
    filters = {
        "AND": [
            {"user_id": "user_123"},
            {"keywords": {"contains": "Invoice_2024"}}
        ]
    }
    ```
  </Accordion>

  <Accordion title="Categories">
    ```python  theme={null}
    # Match against category list
    filters = {
        "AND": [
            {"user_id": "user_123"},
            {"categories": {"in": ["finance", "health"]}}
        ]
    }

    # Partial category match
    filters = {
        "AND": [
            {"user_id": "user_123"},
            {"categories": {"contains": "finance"}}
        ]
    }
    ```
  </Accordion>

  <Accordion title="Metadata">
    ```python  theme={null}
    # Pin to a metadata attribute
    filters = {
        "AND": [
            {"user_id": "user_123"},
            {"metadata": {"source": "email"}}
        ]
    }
    ```
  </Accordion>
</AccordionGroup>

### Time-based filtering

Retrieve memories within specific date ranges using time operators.

<AccordionGroup>
  <Accordion title="Date range">
    ```python  theme={null}
    # Created in January 2024
    filters = {
        "AND": [
            {"user_id": "user_123"},
            {"created_at": {"gte": "2024-01-01T00:00:00Z"}},
            {"created_at": {"lt": "2024-02-01T00:00:00Z"}}
        ]
    }

    # Updated recently
    filters = {
        "AND": [
            {"user_id": "user_123"},
            {"updated_at": {"gte": "2024-12-01T00:00:00Z"}}
        ]
    }
    ```
  </Accordion>
</AccordionGroup>

### Multiple criteria

Combine various filters for complex queries across different dimensions.

<AccordionGroup>
  <Accordion title="Multiple users">
    ```python  theme={null}
    # Expand scope to a short user list
    filters = {
        "AND": [
            {"user_id": {"in": ["user_1", "user_2", "user_3"]}}
        ]
    }
    ```
  </Accordion>

  <Accordion title="OR logic">
    ```python  theme={null}
    # Return matches on either condition
    filters = {
        "OR": [
            {"user_id": "user_123"},
            {"run_id": "run_456"}
        ]
    }
    ```
  </Accordion>

  <Accordion title="Exclude categories">
    ```python  theme={null}
    # Wrap negative logic with NOT
    filters = {
        "AND": [
            {"user_id": "user_123"},
            {"NOT": {
                "categories": {"in": ["spam", "test"]}
            }}
        ]
    }
    ```
  </Accordion>

  <Accordion title="Specific memory IDs">
    ```python  theme={null}
    # Fetch a fixed set of memory IDs
    filters = {
        "AND": [
            {"user_id": "user_123"},
            {"memory_ids": ["mem_1", "mem_2", "mem_3"]}
        ]
    }
    ```
  </Accordion>

  <Accordion title="All entities populated">
    ```python  theme={null}
    # Require every entity field to be non-null
    filters = {
        "AND": [
            {"user_id": "*"},
            {"agent_id": "*"},
            {"run_id": "*"},
            {"app_id": "*"}
        ]
    }
    ```
  </Accordion>
</AccordionGroup>

## Advanced examples

Level up foundational patterns with compound filters that coordinate entity scope, tighten time windows, and weave in exclusion rules for high-precision retrievals.

<AccordionGroup>
  <Accordion title="Multi-dimensional filtering">
    ```python  theme={null}
    # Invoice memories in Q1 2024
    filters = {
        "AND": [
            {"user_id": "user_123"},
            {"keywords": {"icontains": "invoice"}},
            {"categories": {"in": ["finance"]}},
            {"created_at": {"gte": "2024-01-01T00:00:00Z"}},
            {"created_at": {"lt": "2024-04-01T00:00:00Z"}}
        ]
    }
    ```
  </Accordion>

  <Accordion title="Cross-entity relationships">
    ```python  theme={null}
    # From specific agent, all users
    filters = {
        "AND": [
            {"agent_id": "finance_bot"},
            {"user_id": "*"}
        ]
    }

    # Any entity populated
    filters = {
        "OR": [
            {"user_id": "*"},
            {"agent_id": "*"},
            {"run_id": "*"},
            {"app_id": "*"}
        ]
    }
    ```
  </Accordion>

  <Accordion title="Nested NOT/OR logic">
    ```python  theme={null}
    # User memories from 2024, excluding spam and test
    filters = {
        "AND": [
            {"user_id": "user_123"},
            {"created_at": {"gte": "2024-01-01T00:00:00Z"}},
            {"NOT": {
                "OR": [
                    {"categories": {"in": ["spam"]}},
                    {"categories": {"in": ["test"]}}
                ]
            }}
        ]
    }
    ```
  </Accordion>
</AccordionGroup>

## Best practices

<Callout type="tip" icon="lightbulb" color="#26A17B">
  The root must be `AND`, `OR`, or `NOT` with an array of conditions.
</Callout>

<Callout type="tip" icon="lightbulb" color="#26A17B">
  Use `"*"` to match any non-null value for a field.
</Callout>

<Callout type="warning" icon="exclamation-triangle" color="#E74C3C">
  When you specify `user_id` only, other entity fields default to null. Use wildcards to include them.
</Callout>

## Troubleshooting

<AccordionGroup>
  <Accordion title="Missing results with agent_id">
    **Problem**: Filtered by `user_id` but don't see agent memories.

    **Solution**: Add a wildcard for `agent_id` so non-null entries return:

    ```python  theme={null}
    {"AND": [{"user_id": "user_123"}, {"agent_id": "*"}]}
    ```
  </Accordion>

  <Accordion title="ne operator returns too much">
    **Problem**: `ne` comparison pulls in records with null values.

    **Solution**: Pair `ne` with a wildcard guard:

    ```python  theme={null}
    {"AND": [{"agent_id": "*"}, {"agent_id": {"ne": "old_agent"}}]}
    ```
  </Accordion>

  <Accordion title="Case-insensitive search">
    **Solution**: Swap to `icontains` to normalize casing.
  </Accordion>

  <Accordion title="Date range between two dates">
    **Solution**: Use `gte` for the start and `lt` for the end boundary:

    ```python  theme={null}
    {"AND": [
        {"created_at": {"gte": "2024-01-01"}},
        {"created_at": {"lt": "2024-02-01"}}
    ]}
    ```
  </Accordion>

  <Accordion title="Metadata filter not working">
    **Solution**: Match top-level metadata keys exactly:

    ```python  theme={null}
    {"metadata": {"source": "email"}}
    ```
  </Accordion>
</AccordionGroup>

## FAQ

<AccordionGroup>
  <Accordion title="Do I need AND/OR/NOT?">
    Yes. The root must be a logical operator with an array.
  </Accordion>

  <Accordion title="What does * match?">
    Any non-null value. Nulls are excluded.
  </Accordion>

  <Accordion title="Why use wildcards?">
    Unspecified fields default to NULL. Use `"*"` to include non-null values.
  </Accordion>

  <Accordion title="Is = required?">
    No. Equality is the default: `{"user_id": "u1"}` works.
  </Accordion>

  <Accordion title="Can I filter nested metadata?">
    Only top-level keys are supported.
  </Accordion>

  <Accordion title="How to search text?">
    Use `keywords` with `contains` (case-sensitive) or `icontains` (case-insensitive).
  </Accordion>

  <Accordion title="Can I nest AND/OR?">
    ```python  theme={null}
    {
        "AND": [
            {"user_id": "user_123"},
            {"OR": [
                {"categories": "finance"},
                {"categories": "health"}
            ]}
        ]
    }
    ```
  </Accordion>
</AccordionGroup>


# Webhooks
Source: https://docs.mem0.ai/platform/features/webhooks

Configure and manage webhooks to receive real-time notifications about memory events

## Overview

Webhooks enable real-time notifications for memory events in your Mem0 project. Webhooks are configured at the project level, meaning each webhook is tied to a specific project and receives events solely from that project. You can configure webhooks to send HTTP POST requests to your specified URLs whenever memories are created, updated, or deleted.

## Managing Webhooks

### Create Webhook

Create a webhook for your project. It will receive events only from that project:

<CodeGroup>
  ```python Python theme={null}
  import os
  from mem0 import MemoryClient

  os.environ["MEM0_API_KEY"] = "your-api-key"

  client = MemoryClient()

  # Create webhook in a specific project
  webhook = client.create_webhook(
      url="https://your-app.com/webhook",
      name="Memory Logger",
      project_id="proj_123",
      event_types=["memory_add"]
  )
  print(webhook)
  ```

  ```javascript JavaScript theme={null}
  const { MemoryClient } = require('mem0ai');
  const client = new MemoryClient({ apiKey: 'your-api-key'});

  // Create webhook in a specific project
  const webhook = await client.createWebhook({
      url: "https://your-app.com/webhook",
      name: "Memory Logger",
      projectId: "proj_123",
      eventTypes: ["memory_add"]
  });
  console.log(webhook);
  ```

  ```json Output theme={null}
  {
    "webhook_id": "wh_123",
    "name": "Memory Logger",
    "url": "https://your-app.com/webhook",
    "event_types": ["memory_add"],
    "project": "default-project",
    "is_active": true,
    "created_at": "2025-02-18T22:59:56.804993-08:00",
    "updated_at": "2025-02-18T23:06:41.479361-08:00"
  }
  ```
</CodeGroup>

### Get Webhooks

Retrieve all webhooks for your project:

<CodeGroup>
  ```python Python theme={null}
  # Get webhooks for a specific project
  webhooks = client.get_webhooks(project_id="proj_123")
  print(webhooks)
  ```

  ```javascript JavaScript theme={null}
  // Get webhooks for a specific project
  const webhooks = await client.getWebhooks({projectId: "proj_123"});
  console.log(webhooks);
  ```

  ```json Output theme={null}
  [
      {
          "webhook_id": "wh_123",
          "url": "https://mem0.ai",
          "name": "mem0",
          "owner": "john",
          "event_types": ["memory_add"],
          "project": "default-project",
          "is_active": true,
          "created_at": "2025-02-18T22:59:56.804993-08:00",
          "updated_at": "2025-02-18T23:06:41.479361-08:00"
      }
  ]

  ```
</CodeGroup>

### Update Webhook

Update an existing webhook’s configuration by specifying its `webhook_id`:

<CodeGroup>
  ```python Python theme={null}
  # Update webhook for a specific project
  updated_webhook = client.update_webhook(
      name="Updated Logger",
      url="https://your-app.com/new-webhook",
      event_types=["memory_update", "memory_add"],
      webhook_id="wh_123"
  )
  print(updated_webhook)
  ```

  ```javascript JavaScript theme={null}
  // Update webhook for a specific project
  const updatedWebhook = await client.updateWebhook({
      name: "Updated Logger",
      url: "https://your-app.com/new-webhook",
      eventTypes: ["memory_update", "memory_add"],
      webhookId: "wh_123"
  });
  console.log(updatedWebhook);
  ```

  ```json Output theme={null}
  {
    "message": "Webhook updated successfully"
  }
  ```
</CodeGroup>

### Delete Webhook

Delete a webhook by providing its `webhook_id`:

<CodeGroup>
  ```python Python theme={null}
  # Delete webhook from a specific project
  response = client.delete_webhook(webhook_id="wh_123")
  print(response)
  ```

  ```javascript JavaScript theme={null}
  // Delete webhook from a specific project
  const response = await client.deleteWebhook({webhookId: "wh_123"});
  console.log(response);
  ```

  ```json Output theme={null}
  {
    "message": "Webhook deleted successfully"
  }
  ```
</CodeGroup>

## Event Types

Mem0 supports the following event types for webhooks:

* `memory_add`: Triggered when a memory is added.
* `memory_update`: Triggered when an existing memory is updated.
* `memory_delete`: Triggered when a memory is deleted.

## Webhook Payload

When a memory event occurs, Mem0 sends an HTTP POST request to your webhook URL with the following payload:

```json  theme={null}
{
    "event_details": {
        "id": "a1b2c3d4-e5f6-4g7h-8i9j-k0l1m2n3o4p5",
            "data": {
            "memory": "Name is Alex"
            },
        "event": "ADD"
    }
}
```

## Best Practices

1. **Implement Retry Logic**: Ensure your webhook endpoint can handle temporary failures.
2. **Verify Webhook Source**: Implement security measures to verify that webhook requests originate from Mem0.
3. **Process Events Asynchronously**: Process webhook events asynchronously to avoid timeouts and ensure reliable handling.
4. **Monitor Webhook Health**: Regularly review your webhook logs to ensure functionality and promptly address delivery failures.

If you have any questions, please feel free to reach out to us using one of the following methods:

<Snippet file="get-help.mdx" />


# Overview
Source: https://docs.mem0.ai/platform/overview

Managed memory layer for AI agents - production-ready in minutes

# Mem0 Platform Overview

Mem0 is the memory engine that keeps conversations contextual so users never repeat themselves and your agents respond with continuity. Mem0 Platform delivers that experience as a fully managed service—scaling, securing, and enriching memories without any infrastructure work on your side.

<Tip>
  Mem0 v1.0.0 shipped rerankers, async-by-default behavior, and Azure OpenAI support. Catch the full list of changes in the <Link href="/changelog">release notes</Link>.
</Tip>

## Why it matters

* **Personalized replies**: Memories persist across users and agents, cutting prompt bloat and repeat questions.
* **Hosted stack**: Mem0 runs the vector store, graph services, and rerankers—no provisioning, tuning, or maintenance.
* **Enterprise controls**: SOC 2, audit logs, and workspace governance ship by default for production readiness.

<AccordionGroup>
  <Accordion title="What you get with Mem0 Platform" icon="sparkles">
    | Feature           | Why it helps                                                                                          |
    | ----------------- | ----------------------------------------------------------------------------------------------------- |
    | Fast setup        | Add a few lines of code and you’re production-ready—no vector database or LLM configuration required. |
    | Production scale  | Automatic scaling, high availability, and managed infrastructure so you focus on product work.        |
    | Advanced features | Graph memory, webhooks, multimodal support, and custom categories are ready to enable.                |
    | Enterprise ready  | SOC 2 Type II, GDPR compliance, and dedicated support keep security and governance covered.           |
  </Accordion>
</AccordionGroup>

<Info>
  Start with the <Link href="/platform/quickstart">Platform quickstart</Link> to provision your workspace, then pick the journey below that matches your next milestone.
</Info>

## Choose your path

<CardGroup cols={2}>
  <Card title="Launch Your Workspace" icon="rocket" href="/platform/quickstart">
    Create project and ship first memory.
  </Card>

  <Card title="Understand Memory Types" icon="brain" href="/core-concepts/memory-types">
    User, agent, and session memory behavior.
  </Card>
</CardGroup>

<CardGroup cols={3}>
  <Card title="Master Core Operations" icon="circle-check" href="/core-concepts/memory-operations/add">
    Add, search, update, and delete workflows.
  </Card>

  <Card title="Explore Platform Features" icon="sparkles" href="/platform/features/platform-overview">
    Graph memory, async clients, and rerankers.
  </Card>

  <Card title="Configure Advanced Operations" icon="bolt" href="/platform/advanced-memory-operations">
    Metadata filters and per-request toggles.
  </Card>
</CardGroup>

<CardGroup cols={2}>
  <Card title="Connect Integrations" icon="plug" href="/integrations">
    LangChain, CrewAI, Vercel AI SDK.
  </Card>

  <Card title="Monitor in the Dashboard" icon="presentation" href="https://app.mem0.ai">
    Track activity and manage workspaces.
  </Card>
</CardGroup>

<Tip>
  Evaluating self-hosting instead? Jump to the <Link href="/platform/platform-vs-oss">Platform vs OSS comparison</Link> to see trade-offs before you commit.
</Tip>

## Keep going

<CardGroup cols={2}>
  <Card title="Compare with Open Source" description="Review feature parity, migration paths, and when to stay managed." icon="arrows-left-right" href="/platform/platform-vs-oss" />

  <Card title="Run the Quickstart" description="Provision your workspace, install the SDK, and persist your first memory." icon="rocket" href="/platform/quickstart" />
</CardGroup>


# Platform vs Open Source
Source: https://docs.mem0.ai/platform/platform-vs-oss

Choose the right Mem0 solution for your needs

## Which Mem0 is right for you?

Mem0 offers two powerful ways to add memory to your AI applications. Choose based on your priorities:

<CardGroup cols={2}>
  <Card title="Mem0 Platform" icon="cloud" href="/platform/quickstart">
    **Managed, hassle-free**

    Get started in 5 minutes with our hosted solution. Perfect for fast iteration and production apps.
  </Card>

  <Card title="Open Source" icon="code-branch" href="/open-source/python-quickstart">
    **Self-hosted, full control**

    Deploy on your infrastructure. Choose your vector DB, LLM, and configure everything.
  </Card>
</CardGroup>

***

## Feature Comparison

<AccordionGroup>
  <Accordion title="Setup & Getting Started" icon="rocket">
    | Feature                   | Platform                 | Open Source                          |
    | ------------------------- | ------------------------ | ------------------------------------ |
    | **Time to first memory**  | 5 minutes                | 15-30 minutes                        |
    | **Infrastructure needed** | None                     | Vector DB + Python/Node env          |
    | **API key setup**         | One environment variable | Configure LLM + embedder + vector DB |
    | **Maintenance**           | Fully managed by Mem0    | Self-managed                         |
  </Accordion>

  <Accordion title="Core Memory Features" icon="brain">
    | Feature                   | Platform           | Open Source        |
    | ------------------------- | ------------------ | ------------------ |
    | **User & agent memories** | ✅                  | ✅                  |
    | **Smart deduplication**   | ✅                  | ✅                  |
    | **Semantic search**       | ✅                  | ✅                  |
    | **Memory updates**        | ✅                  | ✅                  |
    | **Multi-language SDKs**   | Python, JavaScript | Python, JavaScript |
  </Accordion>

  <Accordion title="Advanced Capabilities" icon="sparkles">
    | Feature                | Platform    | Open Source         |
    | ---------------------- | ----------- | ------------------- |
    | **Graph Memory**       | ✅ (Managed) | ✅ (Self-configured) |
    | **Multimodal support** | ✅           | ✅                   |
    | **Custom categories**  | ✅           | Limited             |
    | **Advanced retrieval** | ✅           | ✅                   |
    | **Memory filters v2**  | ✅           | ⚠️ (via metadata)   |
    | **Webhooks**           | ✅           | ❌                   |
    | **Memory export**      | ✅           | ❌                   |
  </Accordion>

  <Accordion title="Infrastructure & Scaling" icon="server">
    | Feature               | Platform            | Open Source                                   |
    | --------------------- | ------------------- | --------------------------------------------- |
    | **Hosting**           | Managed by Mem0     | Self-hosted                                   |
    | **Auto-scaling**      | ✅                   | Manual                                        |
    | **High availability** | ✅ Built-in          | DIY setup                                     |
    | **Vector DB choice**  | Managed             | Qdrant, Chroma, Pinecone, Milvus, +20 more    |
    | **LLM choice**        | Managed (optimized) | OpenAI, Anthropic, Ollama, Together, +10 more |
    | **Data residency**    | US (expandable)     | Your choice                                   |
  </Accordion>

  <Accordion title="Pricing & Cost" icon="dollar-sign">
    | Aspect                   | Platform                        | Open Source                          |
    | ------------------------ | ------------------------------- | ------------------------------------ |
    | **License**              | Usage-based pricing             | Apache 2.0 (free)                    |
    | **Infrastructure costs** | Included in pricing             | You pay for VectorDB + LLM + hosting |
    | **Support**              | Included                        | Community + GitHub                   |
    | **Best for**             | Fast iteration, production apps | Cost-sensitive, custom requirements  |
  </Accordion>

  <Accordion title="Development & Integration" icon="code">
    | Feature                    | Platform                           | Open Source          |
    | -------------------------- | ---------------------------------- | -------------------- |
    | **REST API**               | ✅                                  | ✅ (via feature flag) |
    | **Python SDK**             | ✅                                  | ✅                    |
    | **JavaScript SDK**         | ✅                                  | ✅                    |
    | **Framework integrations** | LangChain, CrewAI, LlamaIndex, +15 | Same                 |
    | **Dashboard**              | ✅ Web-based                        | ❌                    |
    | **Analytics**              | ✅ Built-in                         | DIY                  |
  </Accordion>
</AccordionGroup>

***

## Decision Guide

### Choose **Platform** if you want:

<CardGroup cols={2}>
  <Card icon="bolt" title="Fast Time to Market">
    Get your AI app with memory live in hours, not weeks. No infrastructure setup needed.
  </Card>

  <Card icon="shield" title="Production-Ready">
    Auto-scaling, high availability, and managed infrastructure out of the box.
  </Card>

  <Card icon="chart-line" title="Built-in Analytics">
    Track memory usage, query patterns, and user engagement through our dashboard.
  </Card>

  <Card icon="webhook" title="Advanced Features">
    Access to webhooks, memory export, custom categories, and priority support.
  </Card>
</CardGroup>

### Choose **Open Source** if you need:

<CardGroup cols={2}>
  <Card icon="lock" title="Full Data Control">
    Host everything on your infrastructure. Complete data residency and privacy control.
  </Card>

  <Card icon="wrench" title="Custom Configuration">
    Choose your own vector DB, LLM provider, embedder, and deployment strategy.
  </Card>

  <Card icon="code" title="Extensibility">
    Modify the codebase, add custom features, and contribute back to the community.
  </Card>

  <Card icon="dollar-sign" title="Cost Optimization">
    Use local LLMs (Ollama), self-hosted vector DBs, and optimize for your specific use case.
  </Card>
</CardGroup>

***

## Still not sure?

<CardGroup cols={2}>
  <Card title="Try Platform Free" icon="rocket" href="https://app.mem0.ai">
    Sign up and test the Platform with our free tier. No credit card required.
  </Card>

  <Card title="Explore Open Source" icon="github" href="https://github.com/mem0ai/mem0">
    Clone the repo and run locally to see how it works. Star us while you're there!
  </Card>
</CardGroup>


# Quickstart
Source: https://docs.mem0.ai/platform/quickstart

Get started with Mem0 Platform in minutes

Get started with Mem0 Platform's hosted API in under 5 minutes. This guide shows you how to authenticate and store your first memory.

## Prerequisites

* Mem0 Platform account ([Sign up here](https://app.mem0.ai))
* API key ([Get one from dashboard](https://app.mem0.ai/settings/api-keys))
* Python 3.10+, Node.js 14+, or cURL

## Installation

<Steps>
  <Step title="Install SDK">
    <CodeGroup>
      ```bash pip theme={null}
      pip install mem0ai
      ```

      ```bash npm theme={null}
      npm install mem0ai
      ```
    </CodeGroup>
  </Step>

  <Step title="Set your API key">
    <CodeGroup>
      ```python Python theme={null}
      from mem0 import MemoryClient

      client = MemoryClient(api_key="your-api-key")
      ```

      ```javascript JavaScript theme={null}
      import MemoryClient from 'mem0ai';
      const client = new MemoryClient({ apiKey: 'your-api-key' });
      ```

      ```bash cURL theme={null}
      export MEM0_API_KEY="your-api-key"
      ```
    </CodeGroup>
  </Step>

  <Step title="Add a memory">
    <CodeGroup>
      ```python Python theme={null}
      messages = [
          {"role": "user", "content": "I'm a vegetarian and allergic to nuts."},
          {"role": "assistant", "content": "Got it! I'll remember your dietary preferences."}
      ]
      client.add(messages, user_id="user123")
      ```

      ```javascript JavaScript theme={null}
      const messages = [
          {"role": "user", "content": "I'm a vegetarian and allergic to nuts."},
          {"role": "assistant", "content": "Got it! I'll remember your dietary preferences."}
      ];
      await client.add(messages, { user_id: "user123" });
      ```

      ```bash cURL theme={null}
      curl -X POST https://api.mem0.ai/v1/memories/add \
        -H "Authorization: Bearer $MEM0_API_KEY" \
        -H "Content-Type: application/json" \
        -d '{
          "messages": [
            {"role": "user", "content": "Im a vegetarian and allergic to nuts."},
            {"role": "assistant", "content": "Got it! Ill remember your dietary preferences."}
          ],
          "user_id": "user123"
        }'
      ```
    </CodeGroup>
  </Step>

  <Step title="Search memories">
    <CodeGroup>
      ```python Python theme={null}
      results = client.search("What are my dietary restrictions?", filters={"user_id": "user123"})
      print(results)
      ```

      ```javascript JavaScript theme={null}
      const results = await client.search("What are my dietary restrictions?", { filters: { user_id: "user123" } });
      console.log(results);
      ```

      ```bash cURL theme={null}
      curl -X POST https://api.mem0.ai/v1/memories/search \
        -H "Authorization: Bearer $MEM0_API_KEY" \
        -H "Content-Type: application/json" \
        -d '{
          "query": "What are my dietary restrictions?",
          "filters": {"user_id": "user123"}
        }'
      ```
    </CodeGroup>

    **Output:**

    ```json  theme={null}
    {
      "results": [
        {
          "id": "14e1b28a-2014-40ad-ac42-69c9ef42193d",
          "memory": "Allergic to nuts",
          "user_id": "user123",
          "categories": ["health"],
          "created_at": "2025-10-22T04:40:22.864647-07:00",
          "score": 0.30
        }
      ]
    }
    ```
  </Step>
</Steps>

## What's Next?

<CardGroup cols={3}>
  <Card title="Memory Operations" icon="database" href="/core-concepts/memory-operations/add">
    Learn how to search, update, and delete memories with complete CRUD operations
  </Card>

  <Card title="Platform Features" icon="star" href="/platform/features/platform-overview">
    Explore advanced features like metadata filtering, graph memory, and webhooks
  </Card>

  <Card title="API Reference" icon="code" href="/api-reference/memory/add-memories">
    See complete API documentation and integration examples
  </Card>
</CardGroup>

## Additional Resources

* **[Platform vs OSS](/platform/platform-vs-oss)** - Understand the differences between Platform and Open Source
* **[Troubleshooting](/platform/faqs)** - Common issues and solutions
* **[Integration Examples](/cookbooks/companions/quickstart-demo)** - See Mem0 in action


# Overview
Source: https://docs.mem0.ai/api-reference

REST APIs for memory management, search, and entity operations

## Mem0 REST API

Mem0 provides a comprehensive REST API for integrating advanced memory capabilities into your applications. Create, search, update, and manage memories across users, agents, and custom entities with simple HTTP requests.

<Info>
  **Quick start:** Get your API key from the [Mem0 Dashboard](https://app.mem0.ai/dashboard/api-keys) and make your first memory operation in minutes.
</Info>

***

## Quick Start Guide

Get started with Mem0 API in three simple steps:

1. **[Add Memories](/api-reference/memory/add-memories)** - Store information and context from user conversations
2. **[Search Memories](/api-reference/memory/v2-search-memories)** - Retrieve relevant memories using semantic search
3. **[Get Memories](/api-reference/memory/v2-get-memories)** - Fetch all memories for a specific entity

***

## Core Operations

<CardGroup cols={2}>
  <Card title="Add Memories" icon="plus" href="/api-reference/memory/add-memories">
    Store new memories from conversations and interactions
  </Card>

  <Card title="Search Memories" icon="magnifying-glass" href="/api-reference/memory/v2-search-memories">
    Find relevant memories using semantic search with filters
  </Card>

  <Card title="Update Memory" icon="pen" href="/api-reference/memory/update-memory">
    Modify existing memory content and metadata
  </Card>

  <Card title="Delete Memory" icon="trash" href="/api-reference/memory/delete-memory">
    Remove specific memories or batch delete operations
  </Card>
</CardGroup>

***

## API Categories

Explore the full API organized by functionality:

<CardGroup cols={2}>
  <Card title="Memory APIs" icon="microchip" href="/api-reference/memory/add-memories">
    Core and advanced operations: CRUD, search, batch updates, history, and exports
  </Card>

  <Card title="Events APIs" icon="clock" href="/api-reference/events/get-events">
    Track and monitor the status of asynchronous memory operations
  </Card>

  <Card title="Entities APIs" icon="users" href="/api-reference/entities/get-users">
    Manage users, agents, and their associated memory data
  </Card>

  <Card title="Organizations & Projects" icon="building" href="/api-reference/organizations-projects">
    Multi-tenant support, access control, and team collaboration
  </Card>

  <Card title="Webhooks" icon="webhook" href="/api-reference/webhook/create-webhook">
    Real-time notifications for memory events and updates
  </Card>
</CardGroup>

<Note>
  **Building multi-tenant apps?** Learn about [Organizations & Projects](/api-reference/organizations-projects) for team isolation and access control.
</Note>

***

## Authentication

All API requests require authentication using Token-based authentication. Include your API key in the Authorization header:

```bash  theme={null}
Authorization: Token <your-api-key>
```

Get your API key from the [Mem0 Dashboard](https://app.mem0.ai/dashboard/api-keys).

<Warning>
  **Keep your API key secure.** Never expose it in client-side code or public repositories. Use environment variables and server-side requests only.
</Warning>

***

## Next Steps

<CardGroup cols={2}>
  <Card title="Add Your First Memory" icon="rocket" href="/api-reference/memory/add-memories">
    Start storing memories via the REST API
  </Card>

  <Card title="Search with Filters" icon="filter" href="/api-reference/memory/v2-search-memories">
    Learn advanced search and filtering techniques
  </Card>
</CardGroup>


# Delete User
Source: https://docs.mem0.ai/api-reference/entities/delete-user

delete /v1/entities/{entity_type}/{entity_id}/



# Get Users
Source: https://docs.mem0.ai/api-reference/entities/get-users

get /v1/entities/



# Get Event
Source: https://docs.mem0.ai/api-reference/events/get-event

get /v1/event/{event_id}/

Retrieve details about a specific event by passing its `event_id`. This endpoint is particularly helpful for tracking the status, payload, and completion details of asynchronous memory operations.


# Get Events
Source: https://docs.mem0.ai/api-reference/events/get-events

get /v1/events/

List recent events for your organization and project.

## Use Cases

* **Dashboards**: Summarize adds/searches over time by paging through events.
* **Alerting**: Poll for `FAILED` events and trigger follow-up workflows.
* **Audit**: Store the returned payload/metadata for compliance logs.


# Add Memories
Source: https://docs.mem0.ai/api-reference/memory/add-memories

post /v1/memories/
Add memories.

Add new facts, messages, or metadata to a user’s memory store. The Add Memories endpoint accepts either raw text or conversational turns and commits them asynchronously so the memory is ready for later search, retrieval, and graph queries.

## Endpoint

* **Method**: `POST`
* **URL**: `/v1/memories/`
* **Content-Type**: `application/json`

Memories are processed asynchronously by default. The response contains queued events you can track while the platform finalizes enrichment.

## Required headers

| Header                                 | Required | Description                       |
| -------------------------------------- | -------- | --------------------------------- |
| `Authorization: Bearer <MEM0_API_KEY>` | Yes      | API key scoped to your workspace. |
| `Accept: application/json`             | Yes      | Ensures a JSON response.          |

## Request body

Provide at least one message or direct memory string. Most callers supply `messages` so Mem0 can infer structured memories as part of ingestion.

<CodeGroup>
  ```json Basic request theme={null}
  {
    "user_id": "alice",
    "messages": [
      { "role": "user", "content": "I moved to Austin last month." }
    ],
    "metadata": {
      "source": "onboarding_form"
    }
  }
  ```
</CodeGroup>

### Common fields

| Field           | Type                     | Required | Description                                                                                          |
| --------------- | ------------------------ | -------- | ---------------------------------------------------------------------------------------------------- |
| `user_id`       | string                   | No\*     | Associates the memory with a user. Provide when you want the memory scoped to a specific identity.   |
| `messages`      | array                    | No\*     | Conversation turns for Mem0 to infer memories from. Each object should include `role` and `content`. |
| `metadata`      | object                   | Optional | Custom key/value metadata (e.g., `{"topic": "preferences"}`).                                        |
| `infer`         | boolean (default `true`) | Optional | Set to `false` to skip inference and store the provided text as-is.                                  |
| `async_mode`    | boolean (default `true`) | Optional | Controls asynchronous processing. Most clients leave this enabled.                                   |
| `output_format` | string (default `v1.1`)  | Optional | Response format. `v1.1` wraps results in a `results` array.                                          |

> \* Provide at least one `messages` entry to describe what you are storing. For scoped memories, include `user_id`. You can also attach `agent_id`, `app_id`, `run_id`, `project_id`, or `org_id` to refine ownership.

## Response

Successful requests return an array of events queued for processing. Each event includes the generated memory text and an identifier you can persist for auditing.

<CodeGroup>
  ```json 200 response theme={null}
  [
    {
      "id": "mem_01JF8ZS4Y0R0SPM13R5R6H32CJ",
      "event": "ADD",
      "data": {
        "memory": "The user moved to Austin in 2025."
      }
    }
  ]
  ```

  ```json 400 response theme={null}
  {
    "error": "400 Bad Request",
    "details": {
      "message": "Invalid input data. Please refer to the memory creation documentation at https://docs.mem0.ai/platform/quickstart#4-1-create-memories for correct formatting and required fields."
    }
  }
  ```
</CodeGroup>

## Graph relationships

Add Memories can enrich the knowledge graph on write. Set `enable_graph: true` to create entity nodes and relationships for the stored memory. Use this when you want downstream `get_all` or search calls to traverse connected entities.

<CodeGroup>
  ```json Graph-aware request theme={null}
  {
    "user_id": "alice",
    "messages": [
      { "role": "user", "content": "I met with Dr. Lee at General Hospital." }
    ],
    "enable_graph": true
  }
  ```
</CodeGroup>

The response follows the same format, and related entities become available in [Graph Memory](/platform/features/graph-memory) queries.


# Batch Delete Memories
Source: https://docs.mem0.ai/api-reference/memory/batch-delete

delete /v1/batch/
Batch delete multiple memories (up to 1000) in a single API call.



# Batch Update Memories
Source: https://docs.mem0.ai/api-reference/memory/batch-update

put /v1/batch/
Batch update multiple memories (up to 1000) in a single API call.



# Create Memory Export
Source: https://docs.mem0.ai/api-reference/memory/create-memory-export

post /v1/exports/
Create a structured export of memories based on a provided schema.

Submit a job to create a structured export of memories using a customizable Pydantic schema. This process may take some time to complete, especially if you're exporting a large number of memories. You can tailor the export by applying various filters (e.g., `user_id`, `agent_id`, `run_id`, or `session_id`) and by modifying the Pydantic schema to ensure the final data matches your exact needs.


# Delete Memories
Source: https://docs.mem0.ai/api-reference/memory/delete-memories

delete /v1/memories/
Delete memories.



# Delete Memory
Source: https://docs.mem0.ai/api-reference/memory/delete-memory

delete /v1/memories/{memory_id}/
Get or Update or delete a memory.



# Feedback
Source: https://docs.mem0.ai/api-reference/memory/feedback

post /v1/feedback/
Submit feedback for a memory.



# Get Memories
Source: https://docs.mem0.ai/api-reference/memory/get-memories

post /v2/memories/
Get all memories.

The v2 get memories API is powerful and flexible, allowing for more precise memory listing without the need for a search query. It supports complex logical operations (AND, OR, NOT) and comparison operators for advanced filtering capabilities. The comparison operators include:

* `in`: Matches any of the values specified
* `gte`: Greater than or equal to
* `lte`: Less than or equal to
* `gt`: Greater than
* `lt`: Less than
* `ne`: Not equal to
* `icontains`: Case-insensitive containment check
* `*`: Wildcard character that matches everything

<CodeGroup>
  ```python Code theme={null}
  memories = client.get_all(
      filters={
          "AND": [
              {
                  "user_id": "alex"
              },
              {
                  "created_at": {"gte": "2024-07-01", "lte": "2024-07-31"}
              }
          ]
      }
  )
  ```

  ```python Output theme={null}
  {
      "results": [
          {
              "id": "f4cbdb08-7062-4f3e-8eb2-9f5c80dfe64c",
              "memory": "Alex is planning a trip to San Francisco from July 1st to July 10th",
              "created_at": "2024-07-01T12:00:00Z",
              "updated_at": "2024-07-01T12:00:00Z"
          },
          {
              "id": "a2b8c3d4-5e6f-7g8h-9i0j-1k2l3m4n5o6p",
              "memory": "Alex prefers vegetarian restaurants",
              "created_at": "2024-07-05T15:30:00Z",
              "updated_at": "2024-07-05T15:30:00Z"
          }
      ],
      "total": 2
  }
  ```
</CodeGroup>

## Graph Memory

To retrieve graph memory relationships between entities, pass `output_format="v1.1"` in your request. This will return memories with entity and relationship information from the knowledge graph.

<CodeGroup>
  ```python Code theme={null}
  memories = client.get_all(
      filters={
          "user_id": "alex"
      },
      output_format="v1.1"
  )
  ```

  ```python Output theme={null}
  {
      "results": [
          {
              "id": "f4cbdb08-7062-4f3e-8eb2-9f5c80dfe64c",
              "memory": "Alex is planning a trip to San Francisco",
              "entities": [
                  {
                      "id": "entity-1",
                      "name": "Alex",
                      "type": "person"
                  },
                  {
                      "id": "entity-2",
                      "name": "San Francisco",
                      "type": "location"
                  }
              ],
              "relations": [
                  {
                      "source": "entity-1",
                      "target": "entity-2",
                      "relationship": "traveling_to"
                  }
              ]
          }
      ]
  }
  ```
</CodeGroup>


# Get Memory
Source: https://docs.mem0.ai/api-reference/memory/get-memory

get /v1/memories/{memory_id}/
Get a memory.



# Get Memory Export
Source: https://docs.mem0.ai/api-reference/memory/get-memory-export

post /v1/exports/get
Get the latest memory export.

Retrieve the latest structured memory export after submitting an export job. You can filter the export by `user_id`, `run_id`, `session_id`, or `app_id` to get the most recent export matching your filters.


# Memory History
Source: https://docs.mem0.ai/api-reference/memory/history-memory

get /v1/memories/{memory_id}/history/
Retrieve the history of a memory.



# Search Memories
Source: https://docs.mem0.ai/api-reference/memory/search-memories

post /v2/memories/search/
Search memories based on a query and filters.

The v2 search API is powerful and flexible, allowing for more precise memory retrieval. It supports complex logical operations (AND, OR, NOT) and comparison operators for advanced filtering capabilities. The comparison operators include:

* `in`: Matches any of the values specified
* `gte`: Greater than or equal to
* `lte`: Less than or equal to
* `gt`: Greater than
* `lt`: Less than
* `ne`: Not equal to
* `icontains`: Case-insensitive containment check
* `*`: Wildcard character that matches everything

<CodeGroup>
  ```python Platform API Example theme={null}
  related_memories = client.search(
      query="What are Alice's hobbies?",
      filters={
          "OR": [
              {
                "user_id": "alice"
              },
              {
                "agent_id": {"in": ["travel-agent", "sports-agent"]}
              }
          ]
      },
  )
  ```

  ```json Output theme={null}
  {
    "memories": [
      {
        "id": "ea925981-272f-40dd-b576-be64e4871429",
        "memory": "Likes to play cricket and plays cricket on weekends.",
        "metadata": {
          "category": "hobbies"
        },
        "score": 0.32116443111457704,
        "created_at": "2024-07-26T10:29:36.630547-07:00",
        "updated_at": null,
        "user_id": "alice",
        "agent_id": "sports-agent"
      }
    ],
  }
  ```
</CodeGroup>

<CodeGroup>
  ```python Wildcard Example theme={null}
  # Using wildcard to match all run_ids for a specific user
  all_memories = client.search(
      query="What are Alice's hobbies?",
      filters={
          "AND": [
              {
                  "user_id": "alice"
              },
              {
                  "run_id": "*"
              }
          ]
      },
  )
  ```
</CodeGroup>

<CodeGroup>
  ```python Categories Filter Examples theme={null}
  # Example 1: Using 'contains' for partial matching
  finance_memories = client.search(
      query="What are my financial goals?",
      filters={
          "AND": [
              { "user_id": "alice" },
              {
                  "categories": {
                      "contains": "finance"
                  }
              }
          ]
      },
  )

  # Example 2: Using 'in' for exact matching
  personal_memories = client.search(
      query="What personal information do you have?",
      filters={
          "AND": [
              { "user_id": "alice" },
              {
                  "categories": {
                      "in": ["personal_information"]
                  }
              }
          ]
      },
  )
  ```
</CodeGroup>


# Update Memory
Source: https://docs.mem0.ai/api-reference/memory/update-memory

put /v1/memories/{memory_id}/
Get or Update or delete a memory.



# Add Member
Source: https://docs.mem0.ai/api-reference/organization/add-org-member

post /api/v1/orgs/organizations/{org_id}/members/
Add a new member to a specific organization.

The API provides two roles for organization members:

* `READER`: Allows viewing of organization resources.
* `OWNER`: Grants full administrative access to manage the organization and its resources.


# Create Organization
Source: https://docs.mem0.ai/api-reference/organization/create-org

post /api/v1/orgs/organizations/
Create a new organization.



# Delete Organization
Source: https://docs.mem0.ai/api-reference/organization/delete-org

delete /api/v1/orgs/organizations/{org_id}/
Delete an organization by its ID.



# Get Organization
Source: https://docs.mem0.ai/api-reference/organization/get-org

get /api/v1/orgs/organizations/{org_id}/
Get a organization.



# Get Members
Source: https://docs.mem0.ai/api-reference/organization/get-org-members

get /api/v1/orgs/organizations/{org_id}/members/
Retrieve a list of members for a specific organization.



# Get Organizations
Source: https://docs.mem0.ai/api-reference/organization/get-orgs

get /api/v1/orgs/organizations/



# Organizations & Projects
Source: https://docs.mem0.ai/api-reference/organizations-projects

Manage multi-tenant applications with organization and project APIs

## Overview

Organizations and projects provide multi-tenant support, access control, and team collaboration capabilities for Mem0 Platform. Use these APIs to build applications that support multiple teams, customers, or isolated environments.

<Info>
  Organizations and projects are **optional** features. You can use Mem0 without them for single-user or simple multi-user applications.
</Info>

## Key Capabilities

* **Multi-org/project Support**: Specify organization and project when initializing the Mem0 client to attribute API usage appropriately
* **Member Management**: Control access to data through organization and project membership
* **Access Control**: Only members can access memories and data within their organization/project scope
* **Team Isolation**: Maintain data separation between different teams and projects for secure collaboration

***

## Using Organizations & Projects

### Initialize with Org/Project Context

Example with the mem0 Python package:

<Tabs>
  <Tab title="Python">
    ```python  theme={null}
    from mem0 import MemoryClient
    client = MemoryClient(org_id='YOUR_ORG_ID', project_id='YOUR_PROJECT_ID')
    ```
  </Tab>

  <Tab title="Node.js">
    ```javascript  theme={null}
    import { MemoryClient } from "mem0ai";
    const client = new MemoryClient({
      organizationId: "YOUR_ORG_ID",
      projectId: "YOUR_PROJECT_ID"
    });
    ```
  </Tab>
</Tabs>

***

## Project Management

The Mem0 client provides comprehensive project management through the `client.project` interface:

### Get Project Details

Retrieve information about the current project:

```python  theme={null}
# Get all project details
project_info = client.project.get()

# Get specific fields only
project_info = client.project.get(fields=["name", "description", "custom_categories"])
```

### Create a New Project

Create a new project within your organization:

```python  theme={null}
# Create a project with name and description
new_project = client.project.create(
    name="My New Project",
    description="A project for managing customer support memories"
)
```

### Update Project Settings

Modify project configuration including custom instructions, categories, and graph settings:

```python  theme={null}
# Update project with custom categories
client.project.update(
    custom_categories=[
        {"customer_preferences": "Customer likes, dislikes, and preferences"},
        {"support_history": "Previous support interactions and resolutions"}
    ]
)

# Update project with custom instructions
client.project.update(
    custom_instructions="..."
)

# Enable graph memory for the project
client.project.update(enable_graph=True)

# Update multiple settings at once
client.project.update(
    custom_instructions="...",
    custom_categories=[
        {"personal_info": "User personal information and preferences"},
        {"work_context": "Professional context and work-related information"}
    ],
    enable_graph=True
)
```

### Delete Project

<Warning>
  This action will remove all memories, messages, and other related data in the project. **This operation is irreversible.**
</Warning>

Remove a project and all its associated data:

```python  theme={null}
# Delete the current project (irreversible)
result = client.project.delete()
```

***

## Member Management

Manage project members and their access levels:

```python  theme={null}
# Get all project members
members = client.project.get_members()

# Add a new member as a reader
client.project.add_member(
    email="colleague@company.com",
    role="READER"  # or "OWNER"
)

# Update a member's role
client.project.update_member(
    email="colleague@company.com",
    role="OWNER"
)

# Remove a member from the project
client.project.remove_member(email="colleague@company.com")
```

### Member Roles

| Role       | Permissions                                                                               |
| ---------- | ----------------------------------------------------------------------------------------- |
| **READER** | Can view and search memories, but cannot modify project settings or manage members        |
| **OWNER**  | Full access including project modification, member management, and all reader permissions |

***

## Async Support

All project methods are available in async mode:

```python  theme={null}
from mem0 import AsyncMemoryClient

async def manage_project():
    client = AsyncMemoryClient(org_id='YOUR_ORG_ID', project_id='YOUR_PROJECT_ID')

    # All methods support async/await
    project_info = await client.project.get()
    await client.project.update(enable_graph=True)
    members = await client.project.get_members()

# To call the async function properly
import asyncio
asyncio.run(manage_project())
```

***

## API Reference

For complete API specifications and additional endpoints, see:

<CardGroup cols={2}>
  <Card title="Organizations APIs" icon="building" href="/api-reference/organization/create-org">
    Create, get, and manage organizations
  </Card>

  <Card title="Project APIs" icon="folder" href="/api-reference/project/create-project">
    Full project CRUD and member management endpoints
  </Card>
</CardGroup>


# Create Project
Source: https://docs.mem0.ai/api-reference/project/create-project

post /api/v1/orgs/organizations/{org_id}/projects/
Create a new project within an organization.



# Get Project
Source: https://docs.mem0.ai/api-reference/project/get-project

get /api/v1/orgs/organizations/{org_id}/projects/{project_id}/
Retrieve details of a specific project within an organization.



# Get Projects
Source: https://docs.mem0.ai/api-reference/project/get-projects

get /api/v1/orgs/organizations/{org_id}/projects/
Retrieve a list of projects for a specific organization.



# AWS Bedrock
Source: https://docs.mem0.ai/components/embedders/models/aws_bedrock



To use AWS Bedrock embedding models, you need to have the appropriate AWS credentials and permissions. The embeddings implementation relies on the `boto3` library.

### Setup

* Ensure you have model access from the [AWS Bedrock Console](https://us-east-1.console.aws.amazon.com/bedrock/home?region=us-east-1#/modelaccess)
* Authenticate the boto3 client using a method described in the [AWS documentation](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html)
* Set up environment variables for authentication:
  ```bash  theme={null}
  export AWS_REGION=us-east-1
  export AWS_ACCESS_KEY_ID=your-access-key
  export AWS_SECRET_ACCESS_KEY=your-secret-key
  ```

### Usage

<CodeGroup>
  ```python Python theme={null}
  import os
  from mem0 import Memory

  # For LLM if needed
  os.environ["OPENAI_API_KEY"] = "your-openai-api-key"

  # AWS credentials
  os.environ["AWS_REGION"] = "us-west-2"
  os.environ["AWS_ACCESS_KEY_ID"] = "your-access-key"
  os.environ["AWS_SECRET_ACCESS_KEY"] = "your-secret-key"

  config = {
      "embedder": {
          "provider": "aws_bedrock",
          "config": {
              "model": "amazon.titan-embed-text-v2:0"
          }
      }
  }

  m = Memory.from_config(config)
  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."}
  ]
  m.add(messages, user_id="alice")
  ```
</CodeGroup>

### Config

Here are the parameters available for configuring AWS Bedrock embedder:

<Tabs>
  <Tab title="Python">
    | Parameter | Description                            | Default Value                |
    | --------- | -------------------------------------- | ---------------------------- |
    | `model`   | The name of the embedding model to use | `amazon.titan-embed-text-v1` |
  </Tab>
</Tabs>


# Google AI
Source: https://docs.mem0.ai/components/embedders/models/google_AI



To use Google AI embedding models, set the `GOOGLE_API_KEY` environment variables. You can obtain the Gemini API key from [here](https://aistudio.google.com/app/apikey).

### Usage

<CodeGroup>
  ```python Python theme={null}
  import os
  from mem0 import Memory

  os.environ["GOOGLE_API_KEY"] = "key"
  os.environ["OPENAI_API_KEY"] = "your_api_key" # For LLM

  config = {
      "embedder": {
          "provider": "gemini",
          "config": {
              "model": "models/text-embedding-004",
          }
      }
  }

  m = Memory.from_config(config)
  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."}
  ]
  m.add(messages, user_id="john")
  ```

  ```typescript TypeScript theme={null}
  import { Memory } from 'mem0ai/oss';

  const config = {
    embedder: {
        provider: "google",
        config: {
          apiKey: process.env["GOOGLE_API_KEY"],
          model: "gemini-embedding-001",
          embeddingDims: 1536,
        },
      },
  };

  const memory = new Memory(config);
  const 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."}
  ]
  await memory.add(messages, { userId: "john" });
  ```
</CodeGroup>

### Config

Here are the parameters available for configuring Gemini embedder:

<Tabs>
  <Tab title="Python">
    | Parameter        | Description                            | Default Value               |
    | ---------------- | -------------------------------------- | --------------------------- |
    | `model`          | The name of the embedding model to use | `models/text-embedding-004` |
    | `embedding_dims` | Dimensions of the embedding model      | `1536`                      |
    | `api_key`        | The Google API key                     | `None`                      |
  </Tab>

  <Tab title="TypeScript">
    | Parameter       | Description                            | Default Value          |
    | --------------- | -------------------------------------- | ---------------------- |
    | `model`         | The name of the embedding model to use | `gemini-embedding-001` |
    | `embeddingDims` | Dimensions of the embedding model      | `1536`                 |
    | `apiKey`        | Google API key                         | `None`                 |
  </Tab>
</Tabs>


# LangChain
Source: https://docs.mem0.ai/components/embedders/models/langchain



Mem0 supports LangChain as a provider to access a wide range of embedding models. LangChain is a framework for developing applications powered by language models, making it easy to integrate various embedding providers through a consistent interface.

For a complete list of available embedding models supported by LangChain, refer to the [LangChain Text Embedding documentation](https://python.langchain.com/docs/integrations/text_embedding/).

## Usage

<CodeGroup>
  ```python Python theme={null}
  import os
  from mem0 import Memory
  from langchain_openai import OpenAIEmbeddings

  # Set necessary environment variables for your chosen LangChain provider
  os.environ["OPENAI_API_KEY"] = "your-api-key"

  # Initialize a LangChain embeddings model directly
  openai_embeddings = OpenAIEmbeddings(
      model="text-embedding-3-small",
      dimensions=1536
  )

  # Pass the initialized model to the config
  config = {
      "embedder": {
          "provider": "langchain",
          "config": {
              "model": openai_embeddings
          }
      }
  }

  m = Memory.from_config(config)
  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."}
  ]
  m.add(messages, user_id="alice", metadata={"category": "movies"})
  ```

  ```typescript TypeScript theme={null}
  import { Memory } from 'mem0ai/oss';
  import { OpenAIEmbeddings } from "@langchain/openai";

  // Initialize a LangChain embeddings model directly
  const openaiEmbeddings = new OpenAIEmbeddings({
      modelName: "text-embedding-3-small",
      dimensions: 1536,
      apiKey: process.env.OPENAI_API_KEY,
  });

  const config = {
    embedder: {
      provider: 'langchain',
      config: {
        model: openaiEmbeddings,
      },
    },
  };

  const memory = new Memory(config);
  const 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."}
  ]
  await memory.add(messages, { userId: "alice", metadata: { category: "movies" } });
  ```
</CodeGroup>

## Supported LangChain Embedding Providers

LangChain supports a wide range of embedding providers, including:

* OpenAI (`OpenAIEmbeddings`)
* Cohere (`CohereEmbeddings`)
* Google (`VertexAIEmbeddings`)
* Hugging Face (`HuggingFaceEmbeddings`)
* Sentence Transformers (`HuggingFaceEmbeddings`)
* Azure OpenAI (`AzureOpenAIEmbeddings`)
* Ollama (`OllamaEmbeddings`)
* Together (`TogetherEmbeddings`)
* And many more

You can use any of these model instances directly in your configuration. For a complete and up-to-date list of available embedding providers, refer to the [LangChain Text Embedding documentation](https://python.langchain.com/docs/integrations/text_embedding/).

## Provider-Specific Configuration

When using LangChain as an embedder provider, you'll need to:

1. Set the appropriate environment variables for your chosen embedding provider
2. Import and initialize the specific model class you want to use
3. Pass the initialized model instance to the config

### Examples with Different Providers

<CodeGroup>
  #### HuggingFace Embeddings

  ```python Python theme={null}
  from langchain_huggingface import HuggingFaceEmbeddings

  # Initialize a HuggingFace embeddings model
  hf_embeddings = HuggingFaceEmbeddings(
      model_name="BAAI/bge-small-en-v1.5",
      encode_kwargs={"normalize_embeddings": True}
  )

  config = {
      "embedder": {
          "provider": "langchain",
          "config": {
              "model": hf_embeddings
          }
      }
  }
  ```

  ```typescript TypeScript theme={null}
  import { Memory } from 'mem0ai/oss';
  import { HuggingFaceEmbeddings } from "@langchain/community/embeddings/hf";

  // Initialize a HuggingFace embeddings model
  const hfEmbeddings = new HuggingFaceEmbeddings({
      modelName: "BAAI/bge-small-en-v1.5",
      encode: {
          normalize_embeddings: true,
      },
  });

  const config = {
    embedder: {
      provider: 'langchain',
      config: {
        model: hfEmbeddings,
      },
    },
  };
  ```
</CodeGroup>

<CodeGroup>
  #### Ollama Embeddings

  ```python Python theme={null}
  from langchain_ollama import OllamaEmbeddings

  # Initialize an Ollama embeddings model
  ollama_embeddings = OllamaEmbeddings(
      model="nomic-embed-text"
  )

  config = {
      "embedder": {
          "provider": "langchain",
          "config": {
              "model": ollama_embeddings
          }
      }
  }
  ```

  ```typescript TypeScript theme={null}
  import { Memory } from 'mem0ai/oss';
  import { OllamaEmbeddings } from "@langchain/community/embeddings/ollama";

  // Initialize an Ollama embeddings model
  const ollamaEmbeddings = new OllamaEmbeddings({
      model: "nomic-embed-text",
      baseUrl: "http://localhost:11434", // Ollama server URL
  });

  const config = {
    embedder: {
      provider: 'langchain',
      config: {
        model: ollamaEmbeddings,
      },
    },
  };
  ```
</CodeGroup>

<Note>
  Make sure to install the necessary LangChain packages and any provider-specific dependencies.
</Note>

## Config

All available parameters for the `langchain` embedder config are present in [Master List of All Params in Config](../config).


# null
Source: https://docs.mem0.ai/components/embedders/models/lmstudio



You can use embedding models from LM Studio to run Mem0 locally.

### Usage

```python  theme={null}
import os
from mem0 import Memory

os.environ["OPENAI_API_KEY"] = "your_api_key" # For LLM

config = {
    "embedder": {
        "provider": "lmstudio",
        "config": {
            "model": "nomic-embed-text-v1.5-GGUF/nomic-embed-text-v1.5.f16.gguf"
        }
    }
}

m = Memory.from_config(config)
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."}
]
m.add(messages, user_id="john")
```

### Config

Here are the parameters available for configuring LM Studio embedder:

| Parameter           | Description                            | Default Value                                               |
| ------------------- | -------------------------------------- | ----------------------------------------------------------- |
| `model`             | The name of the LM Studio model to use | `nomic-embed-text-v1.5-GGUF/nomic-embed-text-v1.5.f16.gguf` |
| `embedding_dims`    | Dimensions of the embedding model      | `1536`                                                      |
| `lmstudio_base_url` | Base URL for LM Studio connection      | `http://localhost:1234/v1`                                  |


# Together
Source: https://docs.mem0.ai/components/embedders/models/together



To use Together embedding models, set the `TOGETHER_API_KEY` environment variable. You can obtain the Together API key from the [Together Platform](https://api.together.xyz/settings/api-keys).

### Usage

<Note> The `embedding_model_dims` parameter for `vector_store` should be set to `768` for Together embedder. </Note>

```python  theme={null}
import os
from mem0 import Memory

os.environ["TOGETHER_API_KEY"] = "your_api_key"
os.environ["OPENAI_API_KEY"] = "your_api_key" # For LLM

config = {
    "embedder": {
        "provider": "together",
        "config": {
            "model": "togethercomputer/m2-bert-80M-8k-retrieval"
        }
    }
}

m = Memory.from_config(config)
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."}
]
m.add(messages, user_id="john")
```

### Config

Here are the parameters available for configuring Together embedder:

| Parameter        | Description                            | Default Value                               |
| ---------------- | -------------------------------------- | ------------------------------------------- |
| `model`          | The name of the embedding model to use | `togethercomputer/m2-bert-80M-8k-retrieval` |
| `embedding_dims` | Dimensions of the embedding model      | `768`                                       |
| `api_key`        | The Together API key                   | `None`                                      |


# Config
Source: https://docs.mem0.ai/components/rerankers/config

Configuration options for rerankers in Mem0

## Common Configuration Parameters

All rerankers share these common configuration parameters:

| Parameter  | Description                                         | Type  | Default  |
| ---------- | --------------------------------------------------- | ----- | -------- |
| `provider` | Reranker provider name                              | `str` | Required |
| `top_k`    | Maximum number of results to return after reranking | `int` | `None`   |
| `api_key`  | API key for the reranker service                    | `str` | `None`   |

## Provider-Specific Configuration

### Zero Entropy

| Parameter | Description                                  | Type  | Default      |
| --------- | -------------------------------------------- | ----- | ------------ |
| `model`   | Model to use: `zerank-1` or `zerank-1-small` | `str` | `"zerank-1"` |
| `api_key` | Zero Entropy API key                         | `str` | `None`       |

### Cohere

| Parameter            | Description                                  | Type   | Default                 |
| -------------------- | -------------------------------------------- | ------ | ----------------------- |
| `model`              | Cohere rerank model                          | `str`  | `"rerank-english-v3.0"` |
| `api_key`            | Cohere API key                               | `str`  | `None`                  |
| `return_documents`   | Whether to return document texts in response | `bool` | `False`                 |
| `max_chunks_per_doc` | Maximum chunks per document                  | `int`  | `None`                  |

### Sentence Transformer

| Parameter           | Description                                  | Type   | Default                                  |
| ------------------- | -------------------------------------------- | ------ | ---------------------------------------- |
| `model`             | HuggingFace cross-encoder model name         | `str`  | `"cross-encoder/ms-marco-MiniLM-L-6-v2"` |
| `device`            | Device to run model on (`cpu`, `cuda`, etc.) | `str`  | `None`                                   |
| `batch_size`        | Batch size for processing                    | `int`  | `32`                                     |
| `show_progress_bar` | Show progress during processing              | `bool` | `False`                                  |

### Hugging Face

| Parameter | Description                                  | Type  | Default                     |
| --------- | -------------------------------------------- | ----- | --------------------------- |
| `model`   | HuggingFace reranker model name              | `str` | `"BAAI/bge-reranker-large"` |
| `api_key` | HuggingFace API token                        | `str` | `None`                      |
| `device`  | Device to run model on (`cpu`, `cuda`, etc.) | `str` | `None`                      |

### LLM-based

| Parameter        | Description                                | Type    | Default                |
| ---------------- | ------------------------------------------ | ------- | ---------------------- |
| `model`          | LLM model to use for scoring               | `str`   | `"gpt-4o-mini"`        |
| `provider`       | LLM provider (`openai`, `anthropic`, etc.) | `str`   | `"openai"`             |
| `api_key`        | API key for LLM provider                   | `str`   | `None`                 |
| `temperature`    | Temperature for LLM generation             | `float` | `0.0`                  |
| `max_tokens`     | Maximum tokens for LLM response            | `int`   | `100`                  |
| `scoring_prompt` | Custom prompt template for scoring         | `str`   | Default scoring prompt |

### LLM Reranker

| Parameter      | Description                 | Type   | Default  |
| -------------- | --------------------------- | ------ | -------- |
| `llm.provider` | LLM provider for reranking  | `str`  | Required |
| `llm.config`   | LLM configuration object    | `dict` | Required |
| `top_n`        | Number of results to return | `int`  | `None`   |

## Environment Variables

You can set API keys using environment variables:

* `ZERO_ENTROPY_API_KEY` - Zero Entropy API key
* `COHERE_API_KEY` - Cohere API key
* `HUGGINGFACE_API_KEY` - HuggingFace API token
* `OPENAI_API_KEY` - OpenAI API key (for LLM-based reranker)
* `ANTHROPIC_API_KEY` - Anthropic API key (for LLM-based reranker)

## Basic Configuration Example

```python Python theme={null}
config = {
    "vector_store": {
        "provider": "chroma",
        "config": {
            "collection_name": "my_memories",
            "path": "./chroma_db"
        }
    },
    "llm": {
        "provider": "openai",
        "config": {
            "model": "gpt-4.1-nano-2025-04-14"
        }
    },
    "reranker": {
        "provider": "zero_entropy",
        "config": {
            "model": "zerank-1",
            "top_k": 5
        }
    }
}
```


# Custom Prompts
Source: https://docs.mem0.ai/components/rerankers/custom-prompts



When using LLM rerankers, you can customize the prompts used for ranking to better suit your specific use case and domain.

## Default Prompt

The default LLM reranker prompt is designed to be general-purpose:

```
Given a query and a list of memory entries, rank the memory entries based on their relevance to the query.
Rate each memory on a scale of 1-10 where 10 is most relevant.

Query: {query}

Memory entries:
{memories}

Provide your ranking as a JSON array with scores for each memory.
```

## Custom Prompt Configuration

You can provide a custom prompt template when configuring the LLM reranker:

```python  theme={null}
from mem0 import Memory

custom_prompt = """
You are an expert at ranking memories for a personal AI assistant.
Given a user query and a list of memory entries, rank each memory based on:
1. Direct relevance to the query
2. Temporal relevance (recent memories may be more important)
3. Emotional significance
4. Actionability

Query: {query}
User Context: {user_context}

Memory entries:
{memories}

Rate each memory from 1-10 and provide reasoning.
Return as JSON: {{"rankings": [{{"index": 0, "score": 8, "reason": "..."}}]}}
"""

config = {
    "reranker": {
        "provider": "llm_reranker",
        "config": {
            "llm": {
                "provider": "openai",
                "config": {
                    "model": "gpt-4.1-nano-2025-04-14",
                    "api_key": "your-openai-key"
                }
            },
            "custom_prompt": custom_prompt,
            "top_n": 5
        }
    }
}

memory = Memory.from_config(config)
```

## Prompt Variables

Your custom prompt can use the following variables:

| Variable         | Description                           |
| ---------------- | ------------------------------------- |
| `{query}`        | The search query                      |
| `{memories}`     | The list of memory entries to rank    |
| `{user_id}`      | The user ID (if available)            |
| `{user_context}` | Additional user context (if provided) |

## Domain-Specific Examples

### Customer Support

```python  theme={null}
customer_support_prompt = """
You are ranking customer support conversation memories.
Prioritize memories that:
- Relate to the current customer issue
- Show previous resolution patterns
- Indicate customer preferences or constraints

Query: {query}
Customer Context: Previous interactions with this customer

Memories:
{memories}

Rank each memory 1-10 based on support relevance.
"""
```

### Educational Content

```python  theme={null}
educational_prompt = """
Rank these learning memories for a student query.
Consider:
- Prerequisite knowledge requirements
- Learning progression and difficulty
- Relevance to current learning objectives

Student Query: {query}
Learning Context: {user_context}

Available memories:
{memories}

Score each memory for educational value (1-10).
"""
```

### Personal Assistant

```python  theme={null}
personal_assistant_prompt = """
Rank personal memories for relevance to the user's query.
Consider:
- Recent vs. historical importance
- Personal preferences and habits
- Contextual relationships between memories

Query: {query}
Personal context: {user_context}

Memories to rank:
{memories}

Provide relevance scores (1-10) with brief explanations.
"""
```

## Advanced Prompt Techniques

### Multi-Criteria Ranking

```python  theme={null}
multi_criteria_prompt = """
Evaluate memories using multiple criteria:

1. RELEVANCE (40%): How directly related to the query
2. RECENCY (20%): How recent the memory is
3. IMPORTANCE (25%): Personal or business significance
4. ACTIONABILITY (15%): How useful for next steps

Query: {query}
Context: {user_context}

Memories:
{memories}

For each memory, provide:
- Overall score (1-10)
- Breakdown by criteria
- Final ranking recommendation

Format: JSON with detailed scoring
"""
```

### Contextual Ranking

```python  theme={null}
contextual_prompt = """
Consider the following context when ranking memories:
- Current user situation: {user_context}
- Time of day: {current_time}
- Recent activities: {recent_activities}

Query: {query}

Rank these memories considering both direct relevance and contextual appropriateness:
{memories}

Provide contextually-aware relevance scores (1-10).
"""
```

## Best Practices

1. **Be Specific**: Clearly define what makes a memory relevant for your use case
2. **Use Examples**: Include examples in your prompt for better model understanding
3. **Structure Output**: Specify the exact JSON format you want returned
4. **Test Iteratively**: Refine your prompt based on actual ranking performance
5. **Consider Token Limits**: Keep prompts concise while being comprehensive

## Prompt Testing

You can test different prompts by comparing ranking results:

```python  theme={null}
# Test multiple prompt variations
prompts = [
    default_prompt,
    custom_prompt_v1,
    custom_prompt_v2
]

for i, prompt in enumerate(prompts):
    config["reranker"]["config"]["custom_prompt"] = prompt
    memory = Memory.from_config(config)

    results = memory.search("test query", user_id="test_user")
    print(f"Prompt {i+1} results: {results}")
```

## Common Issues

* **Too Long**: Keep prompts under token limits for your chosen LLM
* **Too Vague**: Be specific about ranking criteria
* **Inconsistent Format**: Ensure JSON output format is clearly specified
* **Missing Context**: Include relevant variables for your use case


# Cohere
Source: https://docs.mem0.ai/components/rerankers/models/cohere

Reranking with Cohere

Cohere provides enterprise-grade reranking models with excellent multilingual support and production-ready performance.

## Models

Cohere offers several reranking models:

* **`rerank-english-v3.0`**: Latest English reranker with best performance
* **`rerank-multilingual-v3.0`**: Multilingual support for global applications
* **`rerank-english-v2.0`**: Previous generation English reranker

## Installation

```bash  theme={null}
pip install cohere
```

## Configuration

```python Python theme={null}
from mem0 import Memory

config = {
    "vector_store": {
        "provider": "chroma",
        "config": {
            "collection_name": "my_memories",
            "path": "./chroma_db"
        }
    },
    "llm": {
        "provider": "openai",
        "config": {
            "model": "gpt-4.1-nano-2025-04-14"
        }
    },
    "reranker": {
        "provider": "cohere",
        "config": {
            "model": "rerank-english-v3.0",
            "api_key": "your-cohere-api-key",  # or set COHERE_API_KEY
            "top_k": 5,
            "return_documents": False,
            "max_chunks_per_doc": None
        }
    }
}

memory = Memory.from_config(config)
```

## Environment Variables

Set your API key as an environment variable:

```bash  theme={null}
export COHERE_API_KEY="your-api-key"
```

## Usage Example

```python Python theme={null}
import os
from mem0 import Memory

# Set API key
os.environ["COHERE_API_KEY"] = "your-api-key"

# Initialize memory with Cohere reranker
config = {
    "vector_store": {"provider": "chroma"},
    "llm": {"provider": "openai", "config": {"model": "gpt-4o-mini"}},
    "rerank": {
        "provider": "cohere",
        "config": {
            "model": "rerank-english-v3.0",
            "top_k": 3
        }
    }
}

memory = Memory.from_config(config)

# Add memories
messages = [
    {"role": "user", "content": "I work as a data scientist at Microsoft"},
    {"role": "user", "content": "I specialize in machine learning and NLP"},
    {"role": "user", "content": "I enjoy playing tennis on weekends"}
]

memory.add(messages, user_id="bob")

# Search with reranking
results = memory.search("What is the user's profession?", user_id="bob")

for result in results['results']:
    print(f"Memory: {result['memory']}")
    print(f"Vector Score: {result['score']:.3f}")
    print(f"Rerank Score: {result['rerank_score']:.3f}")
    print()
```

## Multilingual Support

For multilingual applications, use the multilingual model:

```python Python theme={null}
config = {
    "rerank": {
        "provider": "cohere",
        "config": {
            "model": "rerank-multilingual-v3.0",
            "top_k": 5
        }
    }
}
```

## Configuration Parameters

| Parameter            | Description                      | Type   | Default                 |
| -------------------- | -------------------------------- | ------ | ----------------------- |
| `model`              | Cohere rerank model to use       | `str`  | `"rerank-english-v3.0"` |
| `api_key`            | Cohere API key                   | `str`  | `None`                  |
| `top_k`              | Maximum documents to return      | `int`  | `None`                  |
| `return_documents`   | Whether to return document texts | `bool` | `False`                 |
| `max_chunks_per_doc` | Maximum chunks per document      | `int`  | `None`                  |

## Features

* **High Quality**: Enterprise-grade relevance scoring
* **Multilingual**: Support for 100+ languages
* **Scalable**: Production-ready with high throughput
* **Reliable**: SLA-backed service with 99.9% uptime

## Best Practices

1. **Model Selection**: Use `rerank-english-v3.0` for English, `rerank-multilingual-v3.0` for other languages
2. **Batch Processing**: Process multiple queries efficiently
3. **Error Handling**: Implement retry logic for production systems
4. **Monitoring**: Track reranking performance and costs


# Hugging Face Reranker
Source: https://docs.mem0.ai/components/rerankers/models/huggingface

Access thousands of reranking models from Hugging Face Hub

## Overview

The Hugging Face reranker provider gives you access to thousands of reranking models available on the Hugging Face Hub. This includes popular models like BAAI's BGE rerankers and other state-of-the-art cross-encoder models.

## Configuration

### Basic Setup

```python  theme={null}
from mem0 import Memory

config = {
    "reranker": {
        "provider": "huggingface",
        "config": {
            "model": "BAAI/bge-reranker-base",
            "device": "cpu"
        }
    }
}

m = Memory.from_config(config)
```

### Configuration Parameters

| Parameter           | Type | Default  | Description                                   |
| ------------------- | ---- | -------- | --------------------------------------------- |
| `model`             | str  | Required | Hugging Face model identifier                 |
| `device`            | str  | "cpu"    | Device to run model on ("cpu", "cuda", "mps") |
| `batch_size`        | int  | 32       | Batch size for processing                     |
| `max_length`        | int  | 512      | Maximum input sequence length                 |
| `trust_remote_code` | bool | False    | Allow remote code execution                   |

### Advanced Configuration

```python  theme={null}
config = {
    "reranker": {
        "provider": "huggingface",
        "config": {
            "model": "BAAI/bge-reranker-large",
            "device": "cuda",
            "batch_size": 16,
            "max_length": 512,
            "trust_remote_code": False,
            "model_kwargs": {
                "torch_dtype": "float16"
            }
        }
    }
}
```

## Popular Models

### BGE Rerankers (Recommended)

```python  theme={null}
# Base model - good balance of speed and quality
config = {
    "reranker": {
        "provider": "huggingface",
        "config": {
            "model": "BAAI/bge-reranker-base",
            "device": "cuda"
        }
    }
}

# Large model - better quality, slower
config = {
    "reranker": {
        "provider": "huggingface",
        "config": {
            "model": "BAAI/bge-reranker-large",
            "device": "cuda"
        }
    }
}

# v2 models - latest improvements
config = {
    "reranker": {
        "provider": "huggingface",
        "config": {
            "model": "BAAI/bge-reranker-v2-m3",
            "device": "cuda"
        }
    }
}
```

### Multilingual Models

```python  theme={null}
# Multilingual BGE reranker
config = {
    "reranker": {
        "provider": "huggingface",
        "config": {
            "model": "BAAI/bge-reranker-v2-multilingual",
            "device": "cuda"
        }
    }
}
```

### Domain-Specific Models

```python  theme={null}
# For code search
config = {
    "reranker": {
        "provider": "huggingface",
        "config": {
            "model": "microsoft/codebert-base",
            "device": "cuda"
        }
    }
}

# For biomedical content
config = {
    "reranker": {
        "provider": "huggingface",
        "config": {
            "model": "dmis-lab/biobert-base-cased-v1.1",
            "device": "cuda"
        }
    }
}
```

## Usage Examples

### Basic Usage

```python  theme={null}
from mem0 import Memory

m = Memory.from_config(config)

# Add some memories
m.add("I love hiking in the mountains", user_id="alice")
m.add("Pizza is my favorite food", user_id="alice")
m.add("I enjoy reading science fiction books", user_id="alice")

# Search with reranking
results = m.search(
    "What outdoor activities do I enjoy?",
    user_id="alice",
    rerank=True
)

for result in results["results"]:
    print(f"Memory: {result['memory']}")
    print(f"Score: {result['score']:.3f}")
```

### Batch Processing

```python  theme={null}
# Process multiple queries efficiently
queries = [
    "What are my hobbies?",
    "What food do I like?",
    "What books interest me?"
]

results = []
for query in queries:
    result = m.search(query, user_id="alice", rerank=True)
    results.append(result)
```

## Performance Optimization

### GPU Acceleration

```python  theme={null}
# Use GPU for better performance
config = {
    "reranker": {
        "provider": "huggingface",
        "config": {
            "model": "BAAI/bge-reranker-base",
            "device": "cuda",
            "batch_size": 64,  # Increase batch size for GPU
        }
    }
}
```

### Memory Optimization

```python  theme={null}
# For limited memory environments
config = {
    "reranker": {
        "provider": "huggingface",
        "config": {
            "model": "BAAI/bge-reranker-base",
            "device": "cpu",
            "batch_size": 8,   # Smaller batch size
            "max_length": 256, # Shorter sequences
            "model_kwargs": {
                "torch_dtype": "float16"  # Half precision
            }
        }
    }
}
```

## Model Comparison

| Model                        | Size | Quality | Speed  | Memory | Best For            |
| ---------------------------- | ---- | ------- | ------ | ------ | ------------------- |
| bge-reranker-base            | 278M | Good    | Fast   | Low    | General use         |
| bge-reranker-large           | 560M | Better  | Medium | Medium | High quality needs  |
| bge-reranker-v2-m3           | 568M | Best    | Medium | Medium | Latest improvements |
| bge-reranker-v2-multilingual | 568M | Good    | Medium | Medium | Multiple languages  |

## Error Handling

```python  theme={null}
try:
    results = m.search(
        "test query",
        user_id="alice",
        rerank=True
    )
except Exception as e:
    print(f"Reranking failed: {e}")
    # Fall back to vector search only
    results = m.search(
        "test query",
        user_id="alice",
        rerank=False
    )
```

## Custom Models

### Using Private Models

```python  theme={null}
# Use a private model from Hugging Face
config = {
    "reranker": {
        "provider": "huggingface",
        "config": {
            "model": "your-org/custom-reranker",
            "device": "cuda",
            "use_auth_token": "your-hf-token"
        }
    }
}
```

### Local Model Path

```python  theme={null}
# Use a locally downloaded model
config = {
    "reranker": {
        "provider": "huggingface",
        "config": {
            "model": "/path/to/local/model",
            "device": "cuda"
        }
    }
}
```

## Best Practices

1. **Choose the Right Model**: Balance quality vs speed based on your needs
2. **Use GPU**: Significantly faster than CPU for larger models
3. **Optimize Batch Size**: Tune based on your hardware capabilities
4. **Monitor Memory**: Watch GPU/CPU memory usage with large models
5. **Cache Models**: Download once and reuse to avoid repeated downloads

## Troubleshooting

### Common Issues

**Out of Memory Error**

```python  theme={null}
# Reduce batch size and sequence length
config = {
    "reranker": {
        "provider": "huggingface",
        "config": {
            "model": "BAAI/bge-reranker-base",
            "batch_size": 4,
            "max_length": 256
        }
    }
}
```

**Model Download Issues**

```python  theme={null}
# Set cache directory
import os
os.environ["TRANSFORMERS_CACHE"] = "/path/to/cache"

# Or use offline mode
config = {
    "reranker": {
        "provider": "huggingface",
        "config": {
            "model": "BAAI/bge-reranker-base",
            "local_files_only": True
        }
    }
}
```

**CUDA Not Available**

```python  theme={null}
import torch

config = {
    "reranker": {
        "provider": "huggingface",
        "config": {
            "model": "BAAI/bge-reranker-base",
            "device": "cuda" if torch.cuda.is_available() else "cpu"
        }
    }
}
```

## Next Steps

<CardGroup cols={2}>
  <Card title="Reranker Overview" icon="sort" href="/components/rerankers/overview">
    Learn about reranking concepts
  </Card>

  <Card title="Configuration Guide" icon="gear" href="/components/rerankers/config">
    Detailed configuration options
  </Card>
</CardGroup>


# LLM Reranker
Source: https://docs.mem0.ai/components/rerankers/models/llm_reranker

Use any language model as a reranker with custom prompts

## Overview

The LLM reranker allows you to use any supported language model as a reranker. This approach uses prompts to instruct the LLM to score and rank memories based on their relevance to the query. While slower than specialized rerankers, it offers maximum flexibility and can be fine-tuned with custom prompts.

## Configuration

### Basic Setup

```python  theme={null}
from mem0 import Memory

config = {
    "reranker": {
        "provider": "llm_reranker",
        "config": {
            "llm": {
                "provider": "openai",
                "config": {
                    "model": "gpt-4",
                    "api_key": "your-openai-api-key"
                }
            }
        }
    }
}

m = Memory.from_config(config)
```

### Configuration Parameters

| Parameter       | Type  | Default  | Description                     |
| --------------- | ----- | -------- | ------------------------------- |
| `llm`           | dict  | Required | LLM configuration object        |
| `top_k`         | int   | 10       | Number of results to rerank     |
| `temperature`   | float | 0.0      | LLM temperature for consistency |
| `custom_prompt` | str   | None     | Custom reranking prompt         |
| `score_range`   | tuple | (0, 10)  | Score range for relevance       |

### Advanced Configuration

```python  theme={null}
config = {
    "reranker": {
        "provider": "llm_reranker",
        "config": {
            "llm": {
                "provider": "anthropic",
                "config": {
                    "model": "claude-3-sonnet-20240229",
                    "api_key": "your-anthropic-api-key"
                }
            },
            "top_k": 15,
            "temperature": 0.0,
            "score_range": (1, 5),
            "custom_prompt": """
            Rate the relevance of each memory to the query on a scale of 1-5.
            Consider semantic similarity, context, and practical utility.
            Only provide the numeric score.
            """
        }
    }
}
```

## Supported LLM Providers

### OpenAI

```python  theme={null}
config = {
    "reranker": {
        "provider": "llm_reranker",
        "config": {
            "llm": {
                "provider": "openai",
                "config": {
                    "model": "gpt-4",
                    "api_key": "your-openai-api-key",
                    "temperature": 0.0
                }
            }
        }
    }
}
```

### Anthropic

```python  theme={null}
config = {
    "reranker": {
        "provider": "llm_reranker",
        "config": {
            "llm": {
                "provider": "anthropic",
                "config": {
                    "model": "claude-3-sonnet-20240229",
                    "api_key": "your-anthropic-api-key"
                }
            }
        }
    }
}
```

### Ollama (Local)

```python  theme={null}
config = {
    "reranker": {
        "provider": "llm_reranker",
        "config": {
            "llm": {
                "provider": "ollama",
                "config": {
                    "model": "llama2",
                    "ollama_base_url": "http://localhost:11434"
                }
            }
        }
    }
}
```

### Azure OpenAI

```python  theme={null}
config = {
    "reranker": {
        "provider": "llm_reranker",
        "config": {
            "llm": {
                "provider": "azure_openai",
                "config": {
                    "model": "gpt-4",
                    "api_key": "your-azure-api-key",
                    "azure_endpoint": "https://your-resource.openai.azure.com/",
                    "azure_deployment": "gpt-4-deployment"
                }
            }
        }
    }
}
```

## Custom Prompts

### Default Prompt Behavior

The default prompt asks the LLM to score relevance on a 0-10 scale:

```
Given a query and a memory, rate how relevant the memory is to answering the query.
Score from 0 (completely irrelevant) to 10 (perfectly relevant).
Only provide the numeric score.

Query: {query}
Memory: {memory}
Score:
```

### Custom Prompt Examples

#### Domain-Specific Scoring

```python  theme={null}
custom_prompt = """
You are a medical information specialist. Rate how relevant each memory is for answering the medical query.
Consider clinical accuracy, specificity, and practical applicability.
Rate from 1-10 where:
- 1-3: Irrelevant or potentially harmful
- 4-6: Somewhat relevant but incomplete
- 7-8: Relevant and helpful
- 9-10: Highly relevant and clinically useful

Query: {query}
Memory: {memory}
Score:
"""

config = {
    "reranker": {
        "provider": "llm_reranker",
        "config": {
            "llm": {
                "provider": "openai",
                "config": {
                    "model": "gpt-4",
                    "api_key": "your-api-key"
                }
            },
            "custom_prompt": custom_prompt
        }
    }
}
```

#### Contextual Relevance

```python  theme={null}
contextual_prompt = """
Rate how well this memory answers the specific question asked.
Consider:
- Direct relevance to the question
- Completeness of information
- Recency and accuracy
- Practical usefulness

Rate 1-5:
1 = Not relevant
2 = Slightly relevant
3 = Moderately relevant
4 = Very relevant
5 = Perfectly answers the question

Query: {query}
Memory: {memory}
Score:
"""
```

#### Conversational Context

```python  theme={null}
conversation_prompt = """
You are helping evaluate which memories are most useful for a conversational AI assistant.
Rate how helpful this memory would be for generating a relevant response.

Consider:
- Direct relevance to user's intent
- Emotional appropriateness
- Factual accuracy
- Conversation flow

Rate 0-10:
Query: {query}
Memory: {memory}
Score:
"""
```

## Usage Examples

### Basic Usage

```python  theme={null}
from mem0 import Memory

m = Memory.from_config(config)

# Add memories
m.add("I'm allergic to peanuts", user_id="alice")
m.add("I love Italian food", user_id="alice")
m.add("I'm vegetarian", user_id="alice")

# Search with LLM reranking
results = m.search(
    "What foods should I avoid?",
    user_id="alice",
    rerank=True
)

for result in results["results"]:
    print(f"Memory: {result['memory']}")
    print(f"LLM Score: {result['score']:.2f}")
```

### Batch Processing with Error Handling

```python  theme={null}
def safe_llm_rerank_search(query, user_id, max_retries=3):
    for attempt in range(max_retries):
        try:
            return m.search(query, user_id=user_id, rerank=True)
        except Exception as e:
            print(f"Attempt {attempt + 1} failed: {e}")
            if attempt == max_retries - 1:
                # Fall back to vector search
                return m.search(query, user_id=user_id, rerank=False)

# Use the safe function
results = safe_llm_rerank_search("What are my preferences?", "alice")
```

## Performance Considerations

### Speed vs Quality Trade-offs

| Model Type      | Speed    | Quality   | Cost   | Best For                       |
| --------------- | -------- | --------- | ------ | ------------------------------ |
| GPT-3.5 Turbo   | Fast     | Good      | Low    | High-volume applications       |
| GPT-4           | Medium   | Excellent | Medium | Quality-critical applications  |
| Claude 3 Sonnet | Medium   | Excellent | Medium | Balanced performance           |
| Ollama Local    | Variable | Good      | Free   | Privacy-sensitive applications |

### Optimization Strategies

```python  theme={null}
# Fast configuration for high-volume use
fast_config = {
    "reranker": {
        "provider": "llm_reranker",
        "config": {
            "llm": {
                "provider": "openai",
                "config": {
                    "model": "gpt-3.5-turbo",
                    "api_key": "your-api-key"
                }
            },
            "top_k": 5,  # Limit candidates
            "temperature": 0.0
        }
    }
}

# High-quality configuration
quality_config = {
    "reranker": {
        "provider": "llm_reranker",
        "config": {
            "llm": {
                "provider": "openai",
                "config": {
                    "model": "gpt-4",
                    "api_key": "your-api-key"
                }
            },
            "top_k": 15,
            "temperature": 0.0
        }
    }
}
```

## Advanced Use Cases

### Multi-Step Reasoning

```python  theme={null}
reasoning_prompt = """
Evaluate this memory's relevance using multi-step reasoning:

1. What is the main intent of the query?
2. What key information does the memory contain?
3. How directly does the memory address the query?
4. What additional context might be needed?

Based on this analysis, rate relevance 1-10:

Query: {query}
Memory: {memory}

Analysis:
Step 1 (Intent):
Step 2 (Information):
Step 3 (Directness):
Step 4 (Context):
Final Score:
"""
```

### Comparative Ranking

```python  theme={null}
comparative_prompt = """
You will see a query and multiple memories. Rank them in order of relevance.
Consider which memories best answer the question and would be most helpful.

Query: {query}

Memories to rank:
{memories}

Provide scores 1-10 for each memory, considering their relative usefulness.
"""
```

### Emotional Intelligence

```python  theme={null}
emotional_prompt = """
Consider both factual relevance and emotional appropriateness.
Rate how suitable this memory is for responding to the user's query.

Factors to consider:
- Factual accuracy and relevance
- Emotional tone and sensitivity
- User's likely emotional state
- Appropriateness of response

Query: {query}
Memory: {memory}
Emotional Context: {context}
Score (1-10):
"""
```

## Error Handling and Fallbacks

```python  theme={null}
class RobustLLMReranker:
    def __init__(self, primary_config, fallback_config=None):
        self.primary = Memory.from_config(primary_config)
        self.fallback = Memory.from_config(fallback_config) if fallback_config else None

    def search(self, query, user_id, max_retries=2):
        # Try primary LLM reranker
        for attempt in range(max_retries):
            try:
                return self.primary.search(query, user_id=user_id, rerank=True)
            except Exception as e:
                print(f"Primary reranker attempt {attempt + 1} failed: {e}")

        # Try fallback reranker
        if self.fallback:
            try:
                return self.fallback.search(query, user_id=user_id, rerank=True)
            except Exception as e:
                print(f"Fallback reranker failed: {e}")

        # Final fallback: vector search only
        return self.primary.search(query, user_id=user_id, rerank=False)

# Usage
primary_config = {
    "reranker": {
        "provider": "llm_reranker",
        "config": {"llm": {"provider": "openai", "config": {"model": "gpt-4"}}}
    }
}

fallback_config = {
    "reranker": {
        "provider": "llm_reranker",
        "config": {"llm": {"provider": "openai", "config": {"model": "gpt-3.5-turbo"}}}
    }
}

reranker = RobustLLMReranker(primary_config, fallback_config)
results = reranker.search("What are my preferences?", "alice")
```

## Best Practices

1. **Use Specific Prompts**: Tailor prompts to your domain and use case
2. **Set Temperature to 0**: Ensure consistent scoring across runs
3. **Limit Top-K**: Don't rerank too many candidates to control costs
4. **Implement Fallbacks**: Always have a backup plan for API failures
5. **Monitor Costs**: Track API usage, especially with expensive models
6. **Cache Results**: Consider caching reranking results for repeated queries
7. **Test Prompts**: Experiment with different prompts to find what works best

## Troubleshooting

### Common Issues

**Inconsistent Scores**

* Set temperature to 0.0
* Use more specific prompts
* Consider using multiple calls and averaging

**API Rate Limits**

* Implement exponential backoff
* Use cheaper models for high-volume scenarios
* Add retry logic with delays

**Poor Ranking Quality**

* Refine your custom prompt
* Try different LLM models
* Add examples to your prompt

## Next Steps

<CardGroup cols={2}>
  <Card title="Custom Prompts Guide" icon="pencil" href="/components/rerankers/custom-prompts">
    Learn to craft effective reranking prompts
  </Card>

  <Card title="Performance Optimization" icon="bolt" href="/components/rerankers/optimization">
    Optimize LLM reranker performance
  </Card>
</CardGroup>


# Sentence Transformer
Source: https://docs.mem0.ai/components/rerankers/models/sentence_transformer

Local reranking with HuggingFace cross-encoder models

Sentence Transformer reranker provides local reranking using HuggingFace cross-encoder models, perfect for privacy-focused deployments where you want to keep data on-premises.

## Models

Any HuggingFace cross-encoder model can be used. Popular choices include:

* **`cross-encoder/ms-marco-MiniLM-L-6-v2`**: Default, good balance of speed and accuracy
* **`cross-encoder/ms-marco-TinyBERT-L-2-v2`**: Fastest, smaller model size
* **`cross-encoder/ms-marco-electra-base`**: Higher accuracy, larger model
* **`cross-encoder/stsb-distilroberta-base`**: Good for semantic similarity tasks

## Installation

```bash  theme={null}
pip install sentence-transformers
```

## Configuration

```python Python theme={null}
from mem0 import Memory

config = {
    "vector_store": {
        "provider": "chroma",
        "config": {
            "collection_name": "my_memories",
            "path": "./chroma_db"
        }
    },
    "llm": {
        "provider": "openai",
        "config": {
            "model": "gpt-4o-mini"
        }
    },
    "rerank": {
        "provider": "sentence_transformer",
        "config": {
            "model": "cross-encoder/ms-marco-MiniLM-L-6-v2",
            "device": "cpu",  # or "cuda" for GPU
            "batch_size": 32,
            "show_progress_bar": False,
            "top_k": 5
        }
    }
}

memory = Memory.from_config(config)
```

## GPU Acceleration

For better performance, use GPU acceleration:

```python Python theme={null}
config = {
    "rerank": {
        "provider": "sentence_transformer",
        "config": {
            "model": "cross-encoder/ms-marco-MiniLM-L-6-v2",
            "device": "cuda",  # Use GPU
            "batch_size": 64   # high batch size for high memory GPUs
        }
    }
}
```

## Usage Example

```python Python theme={null}
from mem0 import Memory

# Initialize memory with local reranker
config = {
    "vector_store": {"provider": "chroma"},
    "llm": {"provider": "openai", "config": {"model": "gpt-4o-mini"}},
    "rerank": {
        "provider": "sentence_transformer",
        "config": {
            "model": "cross-encoder/ms-marco-MiniLM-L-6-v2",
            "device": "cpu"
        }
    }
}

memory = Memory.from_config(config)

# Add memories
messages = [
    {"role": "user", "content": "I love reading science fiction novels"},
    {"role": "user", "content": "My favorite author is Isaac Asimov"},
    {"role": "user", "content": "I also enjoy watching sci-fi movies"}
]

memory.add(messages, user_id="charlie")

# Search with local reranking
results = memory.search("What books does the user like?", user_id="charlie")

for result in results['results']:
    print(f"Memory: {result['memory']}")
    print(f"Vector Score: {result['score']:.3f}")
    print(f"Rerank Score: {result['rerank_score']:.3f}")
    print()
```

## Custom Models

You can use any HuggingFace cross-encoder model:

```python Python theme={null}
# Using a different model
config = {
    "rerank": {
        "provider": "sentence_transformer", 
        "config": {
            "model": "cross-encoder/stsb-distilroberta-base",
            "device": "cpu"
        }
    }
}
```

## Configuration Parameters

| Parameter           | Description                                  | Type   | Default                                  |
| ------------------- | -------------------------------------------- | ------ | ---------------------------------------- |
| `model`             | HuggingFace cross-encoder model name         | `str`  | `"cross-encoder/ms-marco-MiniLM-L-6-v2"` |
| `device`            | Device to run model on (`cpu`, `cuda`, etc.) | `str`  | `None`                                   |
| `batch_size`        | Batch size for processing documents          | `int`  | `32`                                     |
| `show_progress_bar` | Show progress bar during processing          | `bool` | `False`                                  |
| `top_k`             | Maximum documents to return                  | `int`  | `None`                                   |

## Advantages

* **Privacy**: Complete local processing, no external API calls
* **Cost**: No per-token charges after initial model download
* **Customization**: Use any HuggingFace cross-encoder model
* **Offline**: Works without internet connection after model download

## Performance Considerations

* **First Run**: Model download may take time initially
* **Memory Usage**: Models require GPU/CPU memory
* **Batch Size**: Optimize batch size based on available memory
* **Device**: GPU acceleration significantly improves speed

## Best Practices

1. **Model Selection**: Choose model based on accuracy vs speed requirements
2. **Device Management**: Use GPU when available for better performance
3. **Batch Processing**: Process multiple documents together for efficiency
4. **Memory Monitoring**: Monitor system memory usage with larger models


# Zero Entropy
Source: https://docs.mem0.ai/components/rerankers/models/zero_entropy

Neural reranking with Zero Entropy

[Zero Entropy](https://www.zeroentropy.dev) provides neural reranking models that significantly improve search relevance with fast performance.

## Models

Zero Entropy offers two reranking models:

* **`zerank-1`**: Flagship state-of-the-art reranker (non-commercial license)
* **`zerank-1-small`**: Open-source model (Apache 2.0 license)

## Installation

```bash  theme={null}
pip install zeroentropy
```

## Configuration

```python Python theme={null}
from mem0 import Memory

config = {
    "vector_store": {
        "provider": "chroma",
        "config": {
            "collection_name": "my_memories",
            "path": "./chroma_db"
        }
    },
    "llm": {
        "provider": "openai",
        "config": {
            "model": "gpt-4o-mini"
        }
    },
    "rerank": {
        "provider": "zero_entropy",
        "config": {
            "model": "zerank-1",  # or "zerank-1-small"
            "api_key": "your-zero-entropy-api-key",  # or set ZERO_ENTROPY_API_KEY
            "top_k": 5
        }
    }
}

memory = Memory.from_config(config)
```

## Environment Variables

Set your API key as an environment variable:

```bash  theme={null}
export ZERO_ENTROPY_API_KEY="your-api-key"
```

## Usage Example

```python Python theme={null}
import os
from mem0 import Memory

# Set API key
os.environ["ZERO_ENTROPY_API_KEY"] = "your-api-key"

# Initialize memory with Zero Entropy reranker
config = {
    "vector_store": {"provider": "chroma"},
    "llm": {"provider": "openai", "config": {"model": "gpt-4o-mini"}},
    "rerank": {"provider": "zero_entropy", "config": {"model": "zerank-1"}}
}

memory = Memory.from_config(config)

# Add memories
messages = [
    {"role": "user", "content": "I love Italian pasta, especially carbonara"},
    {"role": "user", "content": "Japanese sushi is also amazing"},
    {"role": "user", "content": "I enjoy cooking Mediterranean dishes"}
]

memory.add(messages, user_id="alice")

# Search with reranking
results = memory.search("What Italian food does the user like?", user_id="alice")

for result in results['results']:
    print(f"Memory: {result['memory']}")
    print(f"Vector Score: {result['score']:.3f}")
    print(f"Rerank Score: {result['rerank_score']:.3f}")
    print()
```

## Configuration Parameters

| Parameter | Description                                      | Type  | Default      |
| --------- | ------------------------------------------------ | ----- | ------------ |
| `model`   | Model to use: `"zerank-1"` or `"zerank-1-small"` | `str` | `"zerank-1"` |
| `api_key` | Zero Entropy API key                             | `str` | `None`       |
| `top_k`   | Maximum documents to return after reranking      | `int` | `None`       |

## Performance

* **Fast**: Optimized neural architecture for low latency
* **Accurate**: State-of-the-art relevance scoring
* **Cost-effective**: \~\$0.025/1M tokens processed

## Best Practices

1. **Model Selection**: Use `zerank-1` for best quality, `zerank-1-small` for faster processing
2. **Batch Size**: Process multiple queries together when possible
3. **Top-k Limiting**: Set reasonable `top_k` values (5-20) for best performance
4. **API Key Management**: Use environment variables for secure key storage


# Performance Optimization
Source: https://docs.mem0.ai/components/rerankers/optimization



Optimizing reranker performance is crucial for maintaining fast search response times while improving result quality. This guide covers best practices for different reranker types.

## General Optimization Principles

### Candidate Set Size

The number of candidates sent to the reranker significantly impacts performance:

```python  theme={null}
# Optimal candidate sizes for different rerankers
config_map = {
    "cohere": {"initial_candidates": 100, "top_n": 10},
    "sentence_transformer": {"initial_candidates": 50, "top_n": 10},
    "huggingface": {"initial_candidates": 30, "top_n": 5},
    "llm_reranker": {"initial_candidates": 20, "top_n": 5}
}
```

### Batching Strategy

Process multiple queries efficiently:

```python  theme={null}
# Configure for batch processing
config = {
    "reranker": {
        "provider": "sentence_transformer",
        "config": {
            "model": "cross-encoder/ms-marco-MiniLM-L-6-v2",
            "batch_size": 16,  # Process multiple candidates at once
            "top_n": 10
        }
    }
}
```

## Provider-Specific Optimizations

### Cohere Optimization

```python  theme={null}
# Optimized Cohere configuration
config = {
    "reranker": {
        "provider": "cohere",
        "config": {
            "model": "rerank-english-v3.0",
            "top_n": 10,
            "max_chunks_per_doc": 10,  # Limit chunk processing
            "return_documents": False   # Reduce response size
        }
    }
}
```

**Best Practices:**

* Use v3.0 models for better speed/accuracy balance
* Limit candidates to 100 or fewer
* Cache API responses when possible
* Monitor API rate limits

### Sentence Transformer Optimization

```python  theme={null}
# Performance-optimized configuration
config = {
    "reranker": {
        "provider": "sentence_transformer",
        "config": {
            "model": "cross-encoder/ms-marco-MiniLM-L-6-v2",
            "device": "cuda",  # Use GPU when available
            "batch_size": 32,
            "top_n": 10,
            "max_length": 512  # Limit input length
        }
    }
}
```

**Device Optimization:**

```python  theme={null}
import torch

# Auto-detect best device
device = "cuda" if torch.cuda.is_available() else "mps" if torch.backends.mps.is_available() else "cpu"

config = {
    "reranker": {
        "provider": "sentence_transformer",
        "config": {
            "device": device,
            "model": "cross-encoder/ms-marco-MiniLM-L-6-v2"
        }
    }
}
```

### Hugging Face Optimization

```python  theme={null}
# Optimized for Hugging Face models
config = {
    "reranker": {
        "provider": "huggingface",
        "config": {
            "model": "BAAI/bge-reranker-base",
            "use_fp16": True,  # Half precision for speed
            "max_length": 512,
            "batch_size": 8,
            "top_n": 10
        }
    }
}
```

### LLM Reranker Optimization

```python  theme={null}
# Optimized LLM reranker configuration
config = {
    "reranker": {
        "provider": "llm_reranker",
        "config": {
            "llm": {
                "provider": "openai",
                "config": {
                    "model": "gpt-3.5-turbo",  # Faster than gpt-4
                    "temperature": 0,  # Deterministic results
                    "max_tokens": 500  # Limit response length
                }
            },
            "batch_ranking": True,  # Rank multiple at once
            "top_n": 5,  # Fewer results for faster processing
            "timeout": 10  # Request timeout
        }
    }
}
```

## Performance Monitoring

### Latency Tracking

```python  theme={null}
import time
from mem0 import Memory

def measure_reranker_performance(config, queries, user_id):
    memory = Memory.from_config(config)

    latencies = []
    for query in queries:
        start_time = time.time()
        results = memory.search(query, user_id=user_id)
        latency = time.time() - start_time
        latencies.append(latency)

    return {
        "avg_latency": sum(latencies) / len(latencies),
        "max_latency": max(latencies),
        "min_latency": min(latencies)
    }
```

### Memory Usage Monitoring

```python  theme={null}
import psutil
import os

def monitor_memory_usage():
    process = psutil.Process(os.getpid())
    return {
        "memory_mb": process.memory_info().rss / 1024 / 1024,
        "memory_percent": process.memory_percent()
    }
```

## Caching Strategies

### Result Caching

```python  theme={null}
from functools import lru_cache
import hashlib

class CachedReranker:
    def __init__(self, config):
        self.memory = Memory.from_config(config)
        self.cache_size = 1000

    @lru_cache(maxsize=1000)
    def search_cached(self, query_hash, user_id):
        return self.memory.search(query, user_id=user_id)

    def search(self, query, user_id):
        query_hash = hashlib.md5(f"{query}_{user_id}".encode()).hexdigest()
        return self.search_cached(query_hash, user_id)
```

### Model Caching

```python  theme={null}
# Pre-load models to avoid initialization overhead
config = {
    "reranker": {
        "provider": "sentence_transformer",
        "config": {
            "model": "cross-encoder/ms-marco-MiniLM-L-6-v2",
            "cache_folder": "/path/to/model/cache",
            "device": "cuda"
        }
    }
}
```

## Parallel Processing

### Async Configuration

```python  theme={null}
import asyncio
from mem0 import Memory

async def parallel_search(config, queries, user_id):
    memory = Memory.from_config(config)

    # Process multiple queries concurrently
    tasks = [
        memory.search_async(query, user_id=user_id)
        for query in queries
    ]

    results = await asyncio.gather(*tasks)
    return results
```

## Hardware Optimization

### GPU Configuration

```python  theme={null}
# Optimize for GPU usage
import torch

if torch.cuda.is_available():
    torch.cuda.set_per_process_memory_fraction(0.8)  # Reserve GPU memory

config = {
    "reranker": {
        "provider": "sentence_transformer",
        "config": {
            "device": "cuda",
            "model": "cross-encoder/ms-marco-electra-base",
            "batch_size": 64,  # Larger batch for GPU
            "fp16": True  # Half precision
        }
    }
}
```

### CPU Optimization

```python  theme={null}
import torch

# Optimize CPU threading
torch.set_num_threads(4)  # Adjust based on your CPU

config = {
    "reranker": {
        "provider": "sentence_transformer",
        "config": {
            "device": "cpu",
            "model": "cross-encoder/ms-marco-MiniLM-L-6-v2",
            "num_workers": 4  # Parallel processing
        }
    }
}
```

## Benchmarking Different Configurations

```python  theme={null}
def benchmark_rerankers():
    configs = [
        {"provider": "cohere", "model": "rerank-english-v3.0"},
        {"provider": "sentence_transformer", "model": "cross-encoder/ms-marco-MiniLM-L-6-v2"},
        {"provider": "huggingface", "model": "BAAI/bge-reranker-base"}
    ]

    test_queries = ["sample query 1", "sample query 2", "sample query 3"]

    results = {}
    for config in configs:
        provider = config["provider"]
        performance = measure_reranker_performance(
            {"reranker": {"provider": provider, "config": config}},
            test_queries,
            "test_user"
        )
        results[provider] = performance

    return results
```

## Production Best Practices

1. **Model Selection**: Choose the right balance of speed vs. accuracy
2. **Resource Allocation**: Monitor CPU/GPU usage and memory consumption
3. **Error Handling**: Implement fallbacks for reranker failures
4. **Load Balancing**: Distribute reranking load across multiple instances
5. **Monitoring**: Track latency, throughput, and error rates
6. **Caching**: Cache frequent queries and model predictions
7. **Batch Processing**: Group similar queries for efficient processing


# Overview
Source: https://docs.mem0.ai/components/rerankers/overview

Pick the right reranker path to boost Mem0 search relevance.

Mem0 rerankers rescore vector search hits so your agents surface the most relevant memories. Use this hub to decide when reranking helps, configure a provider, and fine-tune performance.

<Info>
  Reranking trades extra latency for better precision. Start once you have baseline search working and measure before/after relevance.
</Info>

<CardGroup cols={3}>
  <Card title="Understand Reranking" description="See how reranker-enhanced search changes your retrieval flow." icon="search" href="/open-source/features/reranker-search" />

  <Card title="Configure Providers" description="Add reranker blocks to your memory configuration." icon="settings" href="/components/rerankers/config" />

  <Card title="Optimize Performance" description="Balance relevance, latency, and cost with tuning tactics." icon="speedometer" href="/components/rerankers/optimization" />

  <Card title="Custom Prompts" description="Shape LLM-based reranking with tailored instructions." icon="code" href="/components/rerankers/custom-prompts" />

  <Card title="Zero Entropy Guide" description="Adopt the managed neural reranker for production workloads." icon="sparkles" href="/components/rerankers/models/zero_entropy" />

  <Card title="Sentence Transformers" description="Keep reranking on-device with cross-encoder models." icon="cpu" href="/components/rerankers/models/sentence_transformer" />
</CardGroup>

## Picking the Right Reranker

* **API-first** when you need top quality and can absorb request costs (Cohere, Zero Entropy).
* **Self-hosted** for privacy-sensitive deployments that must stay on your hardware (Sentence Transformer, Hugging Face).
* **LLM-driven** when you need bespoke scoring logic or complex prompts.
* **Hybrid** by enabling reranking only on premium journeys to control spend.

## Implementation Checklist

1. Confirm baseline search KPIs so you can measure uplift.
2. Select a provider and add the `reranker` block to your config.
3. Test latency impact with production-like query batches.
4. Decide whether to enable reranking globally or per-search via the `rerank` flag.

<CardGroup cols={2}>
  <Card title="Set Up Reranking" description="Walk through the configuration fields and defaults." icon="settings" href="/components/rerankers/config" />

  <Card title="Example: Reranker Search" description="Follow the feature guide to see reranking in action." icon="rocket" href="/open-source/features/reranker-search" />
</CardGroup>


# Development
Source: https://docs.mem0.ai/contributing/development



# Development Contributions

We strive to make contributions **easy, collaborative, and enjoyable**. Follow the steps below to ensure a smooth contribution process.

## Submitting Your Contribution through PR

To contribute, follow these steps:

1. **Fork & Clone** the repository: [Mem0 on GitHub](https://github.com/mem0ai/mem0)
2. **Create a Feature Branch**: Use a dedicated branch for your changes, e.g., `feature/my-new-feature`
3. **Implement Changes**: If adding a feature or fixing a bug, ensure to:
   * Write necessary **tests**
   * Add **documentation, docstrings, and runnable examples**
4. **Code Quality Checks**:
   * Run **linting** to catch style issues
   * Ensure **all tests pass**
5. **Submit a Pull Request**

For detailed guidance on pull requests, refer to [GitHub's documentation](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-a-pull-request).

***

## Dependency Management

We use `hatch` as our package manager. Install it by following the [official instructions](https://hatch.pypa.io/latest/install/).

**Do NOT use `pip` or `conda` for dependency management.** Instead, follow these steps in order:

```bash  theme={null}
# 1. Install base dependencies
make install

# 2. Activate virtual environment (this will install dependencies)
hatch shell  # For default environment
hatch -e dev_py_3_11 shell  # For dev_py_3_11 (differences are mentioned in pyproject.toml)

# 3. Install all optional dependencies
make install_all
```

***

## Development Standards

### Pre-commit Hooks

Ensure `pre-commit` is installed before contributing:

```bash  theme={null}
pre-commit install
```

### Linting with `ruff`

Run the linter and fix any reported issues before submitting your PR:

```bash  theme={null}
make lint
```

### Code Formatting

To maintain a consistent code style, format your code:

```bash  theme={null}
make format
```

### Testing with `pytest`

Run tests to verify functionality before submitting your PR:

```bash  theme={null}
make test
```

**Note:** Some dependencies have been removed from the main dependencies to reduce package size. Run `make install_all` to install necessary dependencies before running tests.

***

## Release Process

Currently, releases are handled manually. We aim for frequent releases, typically when new features or bug fixes are introduced.

***

Thank you for contributing to Mem0!


# Documentation
Source: https://docs.mem0.ai/contributing/documentation



# Documentation Contributions

## Prerequisites

Before getting started, ensure you have **Node.js (version 23.6.0 or higher)** installed on your system.

***

## Setting Up Mintlify

### Step 1: Install Mintlify

Install Mintlify globally using your preferred package manager:

<CodeGroup>
  ```bash npm theme={null}
  npm i -g mintlify
  ```

  ```bash yarn theme={null}
  yarn global add mintlify
  ```
</CodeGroup>

### Step 2: Run the Documentation Server

Navigate to the `docs/` directory (where `docs.json` is located) and start the development server:

```bash  theme={null}
mintlify dev
```

The documentation website will be available at: [http://localhost:3000](http://localhost:3000).

***

## Custom Ports

By default, Mintlify runs on **port 3000**. To use a different port, add the `--port` flag:

```bash  theme={null}
mintlify dev --port 3333
```

***

By following these steps, you can efficiently contribute to Mem0's documentation.


# Personalized AI Tutor
Source: https://docs.mem0.ai/cookbooks/companions/ai-tutor

Keep student progress and preferences persistent across tutoring sessions.

You can create a personalized AI Tutor using Mem0. This guide will walk you through the necessary steps and provide the complete code to get you started.

## Overview

The Personalized AI Tutor leverages Mem0 to retain information across interactions, enabling a tailored learning experience. By integrating with OpenAI's GPT-4 model, the tutor can provide detailed and context-aware responses to user queries.

## Setup

Before you begin, ensure you have the required dependencies installed. You can install the necessary packages using pip:

```bash  theme={null}
pip install openai mem0ai
```

## Full Code Example

Below is the complete code to create and interact with a Personalized AI Tutor using Mem0:

```python  theme={null}
import os 
from openai import OpenAI
from mem0 import Memory

# Set the OpenAI API key
os.environ['OPENAI_API_KEY'] = 'sk-xxx'

# Initialize the OpenAI client
client = OpenAI()

class PersonalAITutor:
    def __init__(self):
        """
        Initialize the PersonalAITutor with memory configuration and OpenAI client.
        """
        config = {
            "vector_store": {
                "provider": "qdrant",
                "config": {
                    "host": "localhost",
                    "port": 6333,
                }
            },
        }
        self.memory = Memory.from_config(config)
        self.client = client
        self.app_id = "app-1"

    def ask(self, question, user_id=None):
        """
        Ask a question to the AI and store the relevant facts in memory

        :param question: The question to ask the AI.
        :param user_id: Optional user ID to associate with the memory.
        """
        # Start a streaming response request to the AI
        response = self.client.responses.create(
            model="gpt-4.1-nano-2025-04-14",
            instructions="You are a personal AI Tutor.",
            input=question,
            stream=True
        )

        # Store the question in memory
        self.memory.add(question, user_id=user_id, metadata={"app_id": self.app_id})

        # Print the response from the AI in real-time
        for event in response:
            if event.type == "response.output_text.delta":
                print(event.delta, end="")

    def get_memories(self, user_id=None):
        """
        Retrieve all memories associated with the given user ID.

        :param user_id: Optional user ID to filter memories.
        :return: List of memories.
        """
        return self.memory.get_all(user_id=user_id)

# Instantiate the PersonalAITutor
ai_tutor = PersonalAITutor()

# Define a user ID
user_id = "john_doe"

# Ask a question
ai_tutor.ask("I am learning introduction to CS. What is queue? Briefly explain.", user_id=user_id)
```

### Fetching Memories

You can fetch all the memories at any point in time using the following code:

```python  theme={null}
memories = ai_tutor.get_memories(user_id=user_id)
for m in memories['results']:
    print(m['memory'])
```

## Key Points

* **Initialization**: The PersonalAITutor class is initialized with the necessary memory configuration and OpenAI client setup
* **Asking Questions**: The ask method sends a question to the AI and stores the relevant information in memory
* **Retrieving Memories**: The get\_memories method fetches all stored memories associated with a user

## Conclusion

As the conversation progresses, Mem0's memory automatically updates based on the interactions, providing a continuously improving personalized learning experience. This setup ensures that the AI Tutor can offer contextually relevant and accurate responses, enhancing the overall educational process.

***

<CardGroup cols={2}>
  <Card title="Build a Mem0 Companion" icon="users" href="/cookbooks/essentials/building-ai-companion">
    Learn the foundations of memory-powered companions with production-ready patterns.
  </Card>

  <Card title="Travel Assistant with Mem0" icon="plane" href="/cookbooks/companions/travel-assistant">
    Build a travel companion that remembers preferences and past conversations.
  </Card>
</CardGroup>


# Self-Hosted AI Companion
Source: https://docs.mem0.ai/cookbooks/companions/local-companion-ollama

Run Mem0 end-to-end on your machine using Ollama-powered LLMs and embedders.

Mem0 can be utilized entirely locally by leveraging Ollama for both the embedding model and the language model (LLM). This guide will walk you through the necessary steps and provide the complete code to get you started.

## Overview

By using Ollama, you can run Mem0 locally, which allows for greater control over your data and models. This setup uses Ollama for both the embedding model and the language model, providing a fully local solution.

## Setup

Before you begin, ensure you have Mem0 and Ollama installed and properly configured on your local machine.

## Full Code Example

Below is the complete code to set up and use Mem0 locally with Ollama:

```python  theme={null}
from mem0 import Memory

config = {
    "vector_store": {
        "provider": "qdrant",
        "config": {
            "collection_name": "test",
            "host": "localhost",
            "port": 6333,
            "embedding_model_dims": 768,  # Change this according to your local model's dimensions
        },
    },
    "llm": {
        "provider": "ollama",
        "config": {
            "model": "llama3.1:latest",
            "temperature": 0,
            "max_tokens": 2000,
            "ollama_base_url": "http://localhost:11434",  # Ensure this URL is correct
        },
    },
    "embedder": {
        "provider": "ollama",
        "config": {
            "model": "nomic-embed-text:latest",
            # Alternatively, you can use "snowflake-arctic-embed:latest"
            "ollama_base_url": "http://localhost:11434",
        },
    },
}

# Initialize Memory with the configuration
m = Memory.from_config(config)

# Add a memory
m.add("I'm visiting Paris", user_id="john")

# Retrieve memories
memories = m.get_all(user_id="john")
```

## Key Points

* **Configuration**: The setup involves configuring the vector store, language model, and embedding model to use local resources
* **Vector Store**: Qdrant is used as the vector store, running on localhost
* **Language Model**: Ollama is used as the LLM provider, with the `llama3.1:latest` model
* **Embedding Model**: Ollama is also used for embeddings, with the `nomic-embed-text:latest` model

## Conclusion

This local setup of Mem0 using Ollama provides a fully self-contained solution for memory management and AI interactions. It allows for greater control over your data and models while still leveraging the powerful capabilities of Mem0.

***

<CardGroup cols={2}>
  <Card title="Configure Open Source" icon="gear" href="/open-source/configuration">
    Explore advanced configuration options for vector stores, LLMs, and embedders.
  </Card>

  <Card title="Build a Mem0 Companion" icon="users" href="/cookbooks/essentials/building-ai-companion">
    Learn core companion patterns that work with any LLM provider.
  </Card>
</CardGroup>


# Build a Node.js Companion
Source: https://docs.mem0.ai/cookbooks/companions/nodejs-companion

Build a JavaScript fitness coach that remembers user goals run after run.

You can create a personalized AI Companion using Mem0. This guide will walk you through the necessary steps and provide the complete code to get you started.

## Overview

The Personalized AI Companion leverages Mem0 to retain information across interactions, enabling a tailored learning experience. It creates memories for each user interaction and integrates with OpenAI's GPT models to provide detailed and context-aware responses to user queries.

## Setup

Before you begin, ensure you have Node.js installed and create a new project. Install the required dependencies using npm:

```bash  theme={null}
npm install openai mem0ai
```

## Full Code Example

Below is the complete code to create and interact with an AI Companion using Mem0:

```javascript  theme={null}
import { OpenAI } from 'openai';
import { Memory } from 'mem0ai/oss';
import * as readline from 'readline';

const openaiClient = new OpenAI();
const memory = new Memory();

async function chatWithMemories(message, userId = "default_user") {
  const relevantMemories = await memory.search(message, { userId: userId });
  
  const memoriesStr = relevantMemories.results
    .map(entry => `- ${entry.memory}`)
    .join('\n');
  
  const systemPrompt = `You are a helpful AI. Answer the question based on query and memories.
User Memories:
${memoriesStr}`;
  
  const messages = [
    { role: "system", content: systemPrompt },
    { role: "user", content: message }
  ];
  
  const response = await openaiClient.chat.completions.create({
    model: "gpt-4.1-nano-2025-04-14",
    messages: messages
  });
  
  const assistantResponse = response.choices[0].message.content || "";
  
  messages.push({ role: "assistant", content: assistantResponse });
  await memory.add(messages, { userId: userId });
  
  return assistantResponse;
}

async function main() {
  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
  });
  
  console.log("Chat with AI (type 'exit' to quit)");
  
  const askQuestion = () => {
    return new Promise((resolve) => {
      rl.question("You: ", (input) => {
        resolve(input.trim());
      });
    });
  };
  
  try {
    while (true) {
      const userInput = await askQuestion();
      
      if (userInput.toLowerCase() === 'exit') {
        console.log("Goodbye!");
        rl.close();
        break;
      }
      
      const response = await chatWithMemories(userInput, "sample_user");
      console.log(`AI: ${response}`);
    }
  } catch (error) {
    console.error("An error occurred:", error);
    rl.close();
  }
}

main().catch(console.error);
```

### Key Components

1. **Initialization**
   * The code initializes both OpenAI and Mem0 Memory clients
   * Uses Node.js's built-in readline module for command-line interaction

2. **Memory Management (chatWithMemories function)**
   * Retrieves relevant memories using Mem0's search functionality
   * Constructs a system prompt that includes past memories
   * Makes API calls to OpenAI for generating responses
   * Stores new interactions in memory

3. **Interactive Chat Interface (main function)**
   * Creates a command-line interface for user interaction
   * Handles user input and displays AI responses
   * Includes graceful exit functionality

### Environment Setup

Make sure to set up your environment variables:

```bash  theme={null}
export OPENAI_API_KEY=your_api_key
```

### Conclusion

This implementation demonstrates how to create an AI Companion that maintains context across conversations using Mem0's memory capabilities. The system automatically stores and retrieves relevant information, creating a more personalized and context-aware interaction experience.

As users interact with the system, Mem0's memory system continuously learns and adapts, making future responses more relevant and personalized. This setup is ideal for creating long-term learning AI assistants that can maintain context and provide increasingly personalized responses over time.

***

<CardGroup cols={2}>
  <Card title="Partition Memories by Entity" icon="layers" href="/cookbooks/essentials/entity-partitioning-playbook">
    Separate user, agent, and session context to keep your companion consistent.
  </Card>

  <Card title="Quickstart Demo with Mem0" icon="rocket" href="/cookbooks/companions/quickstart-demo">
    Run the full showcase app to see memory-powered companions in action.
  </Card>
</CardGroup>


# Interactive Memory Demo
Source: https://docs.mem0.ai/cookbooks/companions/quickstart-demo

Spin up the showcase companion app to see Mem0 memories in action.

You can create a personalized AI Companion using Mem0. This guide will walk you through the necessary steps and provide the complete setup instructions to get you started.

<video autoPlay muted loop playsInline className="w-full aspect-video rounded-lg" src="https://github.com/user-attachments/assets/cebc4f8e-bdb9-4837-868d-13c5ab7bb433" />

You can try the [Mem0 Demo](https://mem0-4vmi.vercel.app) live here.

## Overview

The Personalized AI Companion leverages Mem0 to retain information across interactions, enabling a tailored learning experience. It creates memories for each user interaction and integrates with OpenAI's GPT models to provide detailed and context-aware responses to user queries.

## Setup

Before you begin, follow these steps to set up the demo application:

1. Clone the Mem0 repository:
   ```bash  theme={null}
   git clone https://github.com/mem0ai/mem0.git
   ```

2. Navigate to the demo application folder:
   ```bash  theme={null}
   cd mem0/examples/mem0-demo
   ```

3. Install dependencies:
   ```bash  theme={null}
   pnpm install
   ```

4. Set up environment variables by creating a `.env` file in the project root with the following content:
   ```bash  theme={null}
   OPENAI_API_KEY=your_openai_api_key
   MEM0_API_KEY=your_mem0_api_key
   ```
   You can obtain your `MEM0_API_KEY` by signing up at [Mem0 API Dashboard](https://app.mem0.ai/dashboard/api-keys).

5. Start the development server:
   ```bash  theme={null}
   pnpm run dev
   ```

## Enhancing the Next.js Application

Once the demo is running, you can customize and enhance the Next.js application by modifying the components in the `mem0-demo` folder. Consider:

* Adding new memory features to improve contextual retention
* Customizing the UI to better suit your application needs
* Integrating additional APIs or third-party services to extend functionality

## Full Code

You can find the complete source code for this demo on GitHub:
[Mem0 Demo GitHub](https://github.com/mem0ai/mem0/tree/main/examples/mem0-demo)

## Conclusion

This setup demonstrates how to build an AI Companion that maintains memory across interactions using Mem0. The system continuously adapts to user interactions, making future responses more relevant and personalized. Experiment with the application and enhance it further to suit your use case!

***

<CardGroup cols={2}>
  <Card title="Build a Mem0 Companion" icon="users" href="/cookbooks/essentials/building-ai-companion">
    Deep dive into production patterns for fitness coaches, tutors, and assistants.
  </Card>

  <Card title="Node.js Companion with Mem0" icon="code" href="/cookbooks/companions/nodejs-companion">
    Implement a command-line companion using the Node.js SDK.
  </Card>
</CardGroup>


# Smart Travel Assistant
Source: https://docs.mem0.ai/cookbooks/companions/travel-assistant

Plan itineraries that remember traveler preferences across trips.

Create a personalized AI Travel Assistant using Mem0. This guide provides step-by-step instructions and the complete code to get you started.

## Overview

The Personalized AI Travel Assistant uses Mem0 to store and retrieve information across interactions, enabling a tailored travel planning experience. It integrates with OpenAI's GPT-4 model to provide detailed and context-aware responses to user queries.

## Setup

Install the required dependencies using pip:

```bash  theme={null}
pip install openai mem0ai
```

## Full Code Example

Here's the complete code to create and interact with a Personalized AI Travel Assistant using Mem0:

<CodeGroup>
  ```python After v1.1 theme={null}
  import os
  from openai import OpenAI
  from mem0 import Memory

  # Set the OpenAI API key
  os.environ['OPENAI_API_KEY'] = "sk-xxx"

  config = {
      "llm": {
          "provider": "openai",
          "config": {
              "model": "gpt-4.1-nano-2025-04-14",
              "temperature": 0.1,
              "max_tokens": 2000,
          }
      },
      "embedder": {
          "provider": "openai",
          "config": {
              "model": "text-embedding-3-large"
          }
      },
      "vector_store": {
          "provider": "qdrant",
          "config": {
              "collection_name": "test",
              "embedding_model_dims": 3072,
          }
      },
      "version": "v1.1",
  }

  class PersonalTravelAssistant:
      def __init__(self):
          self.client = OpenAI()
          self.memory = Memory.from_config(config)
          self.messages = [{"role": "system", "content": "You are a personal AI Assistant."}]

      def ask_question(self, question, user_id):
          # Fetch previous related memories
          previous_memories = self.search_memories(question, user_id=user_id)

          # Build the prompt
          system_message = "You are a personal AI Assistant."

          if previous_memories:
              prompt = f"{system_message}\n\nUser input: {question}\nPrevious memories: {', '.join(previous_memories)}"
          else:
              prompt = f"{system_message}\n\nUser input: {question}"

          # Generate response using Responses API
          response = self.client.responses.create(
              model="gpt-4.1-nano-2025-04-14",
              input=prompt
          )

          # Extract answer from the response
          answer = response.output[0].content[0].text

          # Store the question in memory
          self.memory.add(question, user_id=user_id)
          return answer

      def get_memories(self, user_id):
          memories = self.memory.get_all(user_id=user_id)
          return [m['memory'] for m in memories['results']]

      def search_memories(self, query, user_id):
          memories = self.memory.search(query, user_id=user_id)
          return [m['memory'] for m in memories['results']]

  # Usage example
  user_id = "traveler_123"
  ai_assistant = PersonalTravelAssistant()

  def main():
      while True:
          question = input("Question: ")
          if question.lower() in ['q', 'exit']:
              print("Exiting...")
              break

          answer = ai_assistant.ask_question(question, user_id=user_id)
          print(f"Answer: {answer}")
          memories = ai_assistant.get_memories(user_id=user_id)
          print("Memories:")
          for memory in memories:
              print(f"- {memory}")
          print("-----")

  if __name__ == "__main__":
      main()
  ```

  ```python Before v1.1 theme={null}
  import os
  from openai import OpenAI
  from mem0 import Memory

  # Set the OpenAI API key
  os.environ['OPENAI_API_KEY'] = 'sk-xxx'

  class PersonalTravelAssistant:
      def __init__(self):
          self.client = OpenAI()
          self.memory = Memory()
          self.messages = [{"role": "system", "content": "You are a personal AI Assistant."}]

      def ask_question(self, question, user_id):
          # Fetch previous related memories
          previous_memories = self.search_memories(question, user_id=user_id)
          prompt = question
          if previous_memories:
              prompt = f"User input: {question}\n Previous memories: {previous_memories}"
          self.messages.append({"role": "user", "content": prompt})

          # Generate response using gpt-4.1-nano
          response = self.client.chat.completions.create(
              model="gpt-4.1-nano-2025-04-14"2025-04-14",
              messages=self.messages
          )
          answer = response.choices[0].message.content
          self.messages.append({"role": "assistant", "content": answer})

          # Store the question in memory
          self.memory.add(question, user_id=user_id)
          return answer

      def get_memories(self, user_id):
          memories = self.memory.get_all(user_id=user_id)
          return [m['memory'] for m in memories.get('results', [])]

      def search_memories(self, query, user_id):
          memories = self.memory.search(query, user_id=user_id)
          return [m['memory'] for m in memories.get('results', [])]

  # Usage example
  user_id = "traveler_123"
  ai_assistant = PersonalTravelAssistant()

  def main():
      while True:
          question = input("Question: ")
          if question.lower() in ['q', 'exit']:
              print("Exiting...")
              break

          answer = ai_assistant.ask_question(question, user_id=user_id)
          print(f"Answer: {answer}")
          memories = ai_assistant.get_memories(user_id=user_id)
          print("Memories:")
          for memory in memories:
              print(f"- {memory}")
          print("-----")

  if __name__ == "__main__":
      main()
  ```
</CodeGroup>

## Key Components

* **Initialization**: The `PersonalTravelAssistant` class is initialized with the OpenAI client and Mem0 memory setup.
* **Asking Questions**: The `ask_question` method sends a question to the AI, incorporates previous memories, and stores new information.
* **Memory Management**: The `get_memories` and search\_memories methods handle retrieval and searching of stored memories.

## Usage

1. Set your OpenAI API key in the environment variable.
2. Instantiate the `PersonalTravelAssistant`.
3. Use the `main()` function to interact with the assistant in a loop.

## Conclusion

This Personalized AI Travel Assistant leverages Mem0's memory capabilities to provide context-aware responses. As you interact with it, the assistant learns and improves, offering increasingly personalized travel advice and information.

***

<CardGroup cols={2}>
  <Card title="Tag and Organize Memories" icon="tag" href="/cookbooks/essentials/tagging-and-organizing-memories">
    Use categories to organize travel preferences, destinations, and user context.
  </Card>

  <Card title="AI Tutor with Mem0" icon="graduation-cap" href="/cookbooks/companions/ai-tutor">
    Build an educational companion that remembers learning progress and preferences.
  </Card>
</CardGroup>


# Voice-First AI Companion
Source: https://docs.mem0.ai/cookbooks/companions/voice-companion-openai

Pair the OpenAI Agents SDK with Mem0 to build a voice assistant that remembers.

This guide demonstrates how to combine OpenAI's Agents SDK for voice applications with Mem0's memory capabilities to create a voice assistant that remembers user preferences and past interactions.

## Prerequisites

Before you begin, make sure you have:

1. Installed OpenAI Agents SDK with voice dependencies:

```bash  theme={null}
pip install 'openai-agents[voice]'
```

2. Installed Mem0 SDK:

```bash  theme={null}
pip install mem0ai
```

3. Installed other required dependencies:

```bash  theme={null}
pip install numpy sounddevice pydantic
```

4. Set up your API keys:
   * OpenAI API key for the Agents SDK
   * Mem0 API key from the Mem0 Platform

## Code Breakdown

Let's break down the key components of this implementation:

### 1. Setting Up Dependencies and Environment

```python  theme={null}
# OpenAI Agents SDK imports
from agents import (
    Agent,
    function_tool
)
from agents.voice import (
    AudioInput,
    SingleAgentVoiceWorkflow,
    VoicePipeline
)
from agents.extensions.handoff_prompt import prompt_with_handoff_instructions

# Mem0 imports
from mem0 import AsyncMemoryClient

# Set up API keys (replace with your actual keys)
os.environ["OPENAI_API_KEY"] = "your-openai-api-key"
os.environ["MEM0_API_KEY"] = "your-mem0-api-key"

# Define a global user ID for simplicity
USER_ID = "voice_user"

# Initialize Mem0 client
mem0_client = AsyncMemoryClient()
```

This section handles:

* Importing required modules from OpenAI Agents SDK and Mem0
* Setting up environment variables for API keys
* Defining a simple user identification system (using a global variable)
* Initializing the Mem0 client that will handle memory operations

### 2. Memory Tools with Function Decorators

The `@function_tool` decorator transforms Python functions into callable tools for the OpenAI agent. Here are the key memory tools:

#### Storing User Memories

```python  theme={null}
import logging

# Set up logging at the top of your file
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    force=True
)
logger = logging.getLogger("memory_voice_agent")

# Then use logger in your function tools
@function_tool
async def save_memories(
    memory: str
) -> str:
    """Store a user memory in memory."""
    # This will be visible in your console
    logger.debug(f"Saving memory: {memory} for user {USER_ID}")
    
    # Store the preference in Mem0
    memory_content = f"User memory - {memory}"
    await mem0_client.add(
        memory_content,
        user_id=USER_ID,
    )

    return f"I've saved your memory: {memory}"
```

This function:

* Takes a memory string
* Creates a formatted memory string
* Stores it in Mem0 using the `add()` method
* Includes metadata to categorize the memory for easier retrieval
* Returns a confirmation message that the agent will speak

#### Finding Relevant Memories

```python  theme={null}
@function_tool
async def search_memories(
    query: str
) -> str:
    """
    Find memories relevant to the current conversation.
    Args:
        query: The search query to find relevant memories
    """
    print(f"Finding memories related to: {query}")
    results = await mem0_client.search(
        query,
        user_id=USER_ID,
        limit=5,
        threshold=0.7,  # Higher threshold for more relevant results
        
    )
    
    # Format and return the results
    if not results.get('results', []):
        return "I don't have any relevant memories about this topic."
    
    memories = [f"• {result['memory']}" for result in results.get('results', [])]
    return "Here's what I remember that might be relevant:\n" + "\n".join(memories)
```

This tool:

* Takes a search query string
* Passes it to Mem0's semantic search to find related memories
* Sets a threshold for relevance to ensure quality results
* Returns a formatted list of relevant memories or a default message

### 3. Creating the Voice Agent

```python  theme={null}
def create_memory_voice_agent():
    # Create the agent with memory-enabled tools
    agent = Agent(
        name="Memory Assistant",
        instructions=prompt_with_handoff_instructions(
            """You're speaking to a human, so be polite and concise.
            Always respond in clear, natural English.
            You have the ability to remember information about the user.
            Use the save_memories tool when the user shares an important information worth remembering.
            Use the search_memories tool when you need context from past conversations or user asks you to recall something.
            """,
        ),
        model="gpt-4.1-nano-2025-04-14",
        tools=[save_memories, search_memories],
    )
    
    return agent
```

This function:

* Creates an OpenAI Agent with specific instructions
* Configures it to use gpt-4.1-nano (you can use other models)
* Registers the memory-related tools with the agent
* Uses `prompt_with_handoff_instructions` to include standard voice agent behaviors

### 4. Microphone Recording Functionality

```python  theme={null}
async def record_from_microphone(duration=5, samplerate=24000):
    """Record audio from the microphone for a specified duration."""
    print(f"Recording for {duration} seconds...")
    
    # Create a buffer to store the recorded audio
    frames = []
    
    # Callback function to store audio data
    def callback(indata, frames_count, time_info, status):
        frames.append(indata.copy())
    
    # Start recording
    with sd.InputStream(samplerate=samplerate, channels=1, callback=callback, dtype=np.int16):
        await asyncio.sleep(duration)
    
    # Combine all frames into a single numpy array
    audio_data = np.concatenate(frames)
    return audio_data
```

This function:

* Creates a simple asynchronous microphone recording function
* Uses the sounddevice library to capture audio input
* Stores frames in a buffer during recording
* Combines frames into a single numpy array when complete
* Returns the audio data for processing

### 5. Main Loop and Voice Processing

```python  theme={null}
async def main():
    # Create the agent
    agent = create_memory_voice_agent()
    
    # Set up the voice pipeline
    pipeline = VoicePipeline(
        workflow=SingleAgentVoiceWorkflow(agent)
    )
    
    # Configure TTS settings
    pipeline.config.tts_settings.voice = "alloy"
    pipeline.config.tts_settings.speed = 1.0
    
    try:
        while True:
            # Get user input
            print("\nPress Enter to start recording (or 'q' to quit)...")
            user_input = input()
            if user_input.lower() == 'q':
                break
            
            # Record and process audio
            audio_data = await record_from_microphone(duration=5)
            audio_input = AudioInput(buffer=audio_data)
            result = await pipeline.run(audio_input)
            
            # Play response and handle events
            player = sd.OutputStream(samplerate=24000, channels=1, dtype=np.int16)
            player.start()
            
            agent_response = ""
            print("\nAgent response:")
            
            async for event in result.stream():
                if event.type == "voice_stream_event_audio":
                    player.write(event.data)
                elif event.type == "voice_stream_event_content":
                    content = event.data
                    agent_response += content
                    print(content, end="", flush=True)
            
            # Save the agent's response to memory
            if agent_response:
                try:
                    await mem0_client.add(
                        f"Agent response: {agent_response}", 
                        user_id=USER_ID,
                        metadata={"type": "agent_response"}
                    )
                except Exception as e:
                    print(f"Failed to store memory: {e}")
    
    except KeyboardInterrupt:
        print("\nExiting...")
```

This main function orchestrates the entire process:

1. Creates the memory-enabled voice agent
2. Sets up the voice pipeline with TTS settings
3. Implements an interactive loop for recording and processing voice input
4. Handles streaming of response events (both audio and text)
5. Automatically saves the agent's responses to memory
6. Includes proper error handling and exit mechanisms

## Create a Memory-Enabled Voice Agent

Now that we've explained each component, here's the complete implementation that combines OpenAI Agents SDK for voice with Mem0's memory capabilities:

```python  theme={null}
import asyncio
import os
import logging
from typing import Optional, List, Dict, Any
import numpy as np
import sounddevice as sd
from pydantic import BaseModel

# OpenAI Agents SDK imports
from agents import (
    Agent,
    function_tool
)
from agents.voice import (
    AudioInput,
    SingleAgentVoiceWorkflow,
    VoicePipeline
)
from agents.extensions.handoff_prompt import prompt_with_handoff_instructions

# Mem0 imports
from mem0 import AsyncMemoryClient

# Set up API keys (replace with your actual keys)
os.environ["OPENAI_API_KEY"] = "your-openai-api-key"
os.environ["MEM0_API_KEY"] = "your-mem0-api-key"

# Define a global user ID for simplicity
USER_ID = "voice_user"

# Initialize Mem0 client
mem0_client = AsyncMemoryClient()

# Create tools that utilize Mem0's memory
@function_tool
async def save_memories(
    memory: str
) -> str:
    """
    Store a user memory in memory.
    Args:
        memory: The memory to save
    """
    print(f"Saving memory: {memory} for user {USER_ID}")

    # Store the preference in Mem0
    memory_content = f"User memory - {memory}"
    await mem0_client.add(
        memory_content,
        user_id=USER_ID,
    )

    return f"I've saved your memory: {memory}"

@function_tool
async def search_memories(
    query: str
) -> str:
    """
    Find memories relevant to the current conversation.
    Args:
        query: The search query to find relevant memories
    """
    print(f"Finding memories related to: {query}")
    results = await mem0_client.search(
        query,
        user_id=USER_ID,
        limit=5,
        threshold=0.7,  # Higher threshold for more relevant results
        
    )
    
    # Format and return the results
    if not results.get('results', []):
        return "I don't have any relevant memories about this topic."
    
    memories = [f"• {result['memory']}" for result in results.get('results', [])]
    return "Here's what I remember that might be relevant:\n" + "\n".join(memories)

# Create the agent with memory-enabled tools
def create_memory_voice_agent():
    # Create the agent with memory-enabled tools
    agent = Agent(
        name="Memory Assistant",
        instructions=prompt_with_handoff_instructions(
            """You're speaking to a human, so be polite and concise.
            Always respond in clear, natural English.
            You have the ability to remember information about the user.
            Use the save_memories tool when the user shares an important information worth remembering.
            Use the search_memories tool when you need context from past conversations or user asks you to recall something.
            """,
        ),
        model="gpt-4.1-nano-2025-04-14",
        tools=[save_memories, search_memories],
    )
    
    return agent

async def record_from_microphone(duration=5, samplerate=24000):
    """Record audio from the microphone for a specified duration."""
    print(f"Recording for {duration} seconds...")
    
    # Create a buffer to store the recorded audio
    frames = []
    
    # Callback function to store audio data
    def callback(indata, frames_count, time_info, status):
        frames.append(indata.copy())
    
    # Start recording
    with sd.InputStream(samplerate=samplerate, channels=1, callback=callback, dtype=np.int16):
        await asyncio.sleep(duration)
    
    # Combine all frames into a single numpy array
    audio_data = np.concatenate(frames)
    return audio_data

async def main():
    print("Starting Memory Voice Agent")
    
    # Create the agent and context
    agent = create_memory_voice_agent()
    
    # Set up the voice pipeline
    pipeline = VoicePipeline(
        workflow=SingleAgentVoiceWorkflow(agent)
    )
    
    # Configure TTS settings
    pipeline.config.tts_settings.voice = "alloy"
    pipeline.config.tts_settings.speed = 1.0
    
    try:
        while True:
            # Get user input
            print("\nPress Enter to start recording (or 'q' to quit)...")
            user_input = input()
            if user_input.lower() == 'q':
                break
            
            # Record and process audio
            audio_data = await record_from_microphone(duration=5)
            audio_input = AudioInput(buffer=audio_data)
            
            print("Processing your request...")
            
            # Process the audio input
            result = await pipeline.run(audio_input)
            
            # Create an audio player
            player = sd.OutputStream(samplerate=24000, channels=1, dtype=np.int16)
            player.start()
            
            # Store the agent's response for adding to memory
            agent_response = ""
            
            print("\nAgent response:")
            # Play the audio stream as it comes in
            async for event in result.stream():
                if event.type == "voice_stream_event_audio":
                    player.write(event.data)
                elif event.type == "voice_stream_event_content":
                    # Accumulate and print the text response
                    content = event.data
                    agent_response += content
                    print(content, end="", flush=True)
            
            print("\n")
            
            # Example of saving the conversation to Mem0 after completion
            if agent_response:
                try:
                    await mem0_client.add(
                        f"Agent response: {agent_response}", 
                        user_id=USER_ID,
                        metadata={"type": "agent_response"}
                    )
                except Exception as e:
                    print(f"Failed to store memory: {e}")
    
    except KeyboardInterrupt:
        print("\nExiting...")

if __name__ == "__main__":
    asyncio.run(main())
```

## Key Features of This Implementation

This implementation offers several key features:

1. **Simplified User Management**: Uses a global `USER_ID` variable for simplicity, but can be extended to manage multiple users.

2. **Real Microphone Input**: Includes a `record_from_microphone()` function that captures actual voice input from your microphone.

3. **Interactive Voice Loop**: Implements a continuous interaction loop, allowing for multiple back-and-forth exchanges.

4. **Memory Management Tools**:
   * `save_memories`: Stores user memories in Mem0
   * `search_memories`: Searches for relevant past information

5. **Voice Configuration**: Demonstrates how to configure TTS settings for the voice response.

## Running the Example

To run this example:

1. Replace the placeholder API keys with your actual keys
2. Make sure your microphone is properly connected
3. Run the script with Python 3.8 or newer
4. Press Enter to start recording, then speak your request
5. Press 'q' to quit the application

The agent will listen to your request, process it through the OpenAI model, utilize Mem0 for memory operations as needed, and respond both through text output and voice speech.

## Best Practices for Voice Agents with Memory

1. **Optimizing Memory for Voice**: Keep memories concise and relevant for voice responses.

2. **Forgetting Mechanism**: Implement a way to delete or expire memories that are no longer relevant.

3. **Context Preservation**: Store enough context with each memory to make retrieval effective.

4. **Error Handling**: Implement robust error handling for memory operations, as voice interactions should continue smoothly even if memory operations fail.

## Conclusion

By combining OpenAI's Agents SDK with Mem0's memory capabilities, you can create voice agents that maintain persistent memory of user preferences and past interactions. This significantly enhances the user experience by making conversations more natural and personalized.

As you build your voice application, experiment with different memory strategies and filtering approaches to find the optimal balance between comprehensive memory and efficient retrieval for your specific use case.

## Debugging Function Tools

When working with the OpenAI Agents SDK, you might notice that regular `print()` statements inside `@function_tool` decorated functions don't appear in your console output. This is because the Agents SDK captures and redirects standard output when executing these functions.

To effectively debug your function tools, use Python's `logging` module instead:

```python  theme={null}
import logging

# Set up logging at the top of your file
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    force=True
)
logger = logging.getLogger("memory_voice_agent")

# Then use logger in your function tools
@function_tool
async def save_memories(
    memory: str
) -> str:
    """Store a user memory in memory."""
    # This will be visible in your console
    logger.debug(f"Saving memory: {memory} for user {USER_ID}")

    # Rest of your function...
```

***

<CardGroup cols={2}>
  <Card title="Multimodal Support" icon="image" href="/platform/features/multimodal-support">
    Learn how to add vision and audio memory alongside voice interactions.
  </Card>

  <Card title="Build a Mem0 Companion" icon="users" href="/cookbooks/essentials/building-ai-companion">
    Master the core patterns for building memory-powered companions.
  </Card>
</CardGroup>


# Research Assistant for YouTube
Source: https://docs.mem0.ai/cookbooks/companions/youtube-research

Layer personalized context over any video using the Mem0 YouTube assistant.

Enhance your YouTube experience with Mem0's YouTube Assistant, a Chrome extension that brings AI-powered chat directly to your YouTube videos. Get instant, personalized answers about video content while leveraging your own knowledge and memories, all without leaving the page.

## Features

* **Contextual AI Chat**: Ask questions about videos you're watching
* **Seamless Integration**: Chat interface sits alongside YouTube's native UI
* **Memory Integration**: Personalized responses based on your knowledge through Mem0
* **Real-Time Memory**: Memories are updated in real-time based on your interactions

## Demo Video

<video autoPlay muted loop playsInline width="700" height="400" src="https://github.com/user-attachments/assets/c0334ccd-311b-4dd7-8034-ef88204fc751" />

## Installation

This extension is not available on the Chrome Web Store yet. You can install it manually using below method:

### Manual Installation (Developer Mode)

1. **Download the Extension**: Clone or download the extension files from the [Mem0 GitHub repository](https://github.com/mem0ai/mem0/tree/main/examples)
2. **Build**: Run `npm install` followed by `npm run build` to install the dependencies and build the extension
3. **Access Chrome Extensions**: Open Google Chrome and navigate to `chrome://extensions`
4. **Enable Developer Mode**: Toggle the "Developer mode" switch in the top right corner
5. **Load Unpacked Extension**: Click "Load unpacked" and select the directory containing the extension files
6. **Confirm Installation**: The Mem0 YouTube Assistant Extension should now appear in your Chrome toolbar

## Setup

1. **Configure API Settings**: Click the extension icon and enter your OpenAI API key (required to use the extension)
2. **Customize Settings**: Configure additional settings such as model, temperature, and memory settings
3. **Navigate to YouTube**: Start using the assistant on any YouTube video
4. **Memories**: Enter your Mem0 API key to enable personalized responses, and feed initial memories from settings

## Example Prompts

* "Can you summarize the main points of this video?"
* "Explain the concept they just mentioned"
* "How does this relate to what I already know?"
* "What are some practical applications of this topic related to my work?"

## Privacy and Data Security

Your API keys are stored locally in your browser. Your messages are sent to the Mem0 API for extracting and retrieving memories. Mem0 is committed to ensuring your data's privacy and security.

***

<CardGroup cols={2}>
  <Card title="Tag and Organize Memories" icon="tag" href="/cookbooks/essentials/tagging-and-organizing-memories">
    Categorize video insights to build a searchable research knowledge base.
  </Card>

  <Card title="Deep Research with Mem0" icon="magnifying-glass" href="/cookbooks/operations/deep-research">
    Combine memory with search tools to conduct comprehensive research projects.
  </Card>
</CardGroup>


# Build a Companion with Mem0
Source: https://docs.mem0.ai/cookbooks/essentials/building-ai-companion

Spin up a fitness coach that remembers goals, adapts tone, and keeps sessions personal.

Essentially, creating a companion out of LLMs is as simple as a loop. But these loops work great for one type of character without personalization and fall short as soon as you restart the chat.

Problem: LLMs are stateless. GPT doesn't remember conversations. You could stuff everything inside the context window, but that becomes slow, expensive, and breaks at scale.

The solution: Mem0. It extracts and stores what matters from conversations, then retrieves it when needed. Your companion remembers user preferences, past events, and history.

In this cookbook we'll build a **fitness companion** that:

* Remembers user goals across sessions
* Recalls past workouts and progress
* Adapts its personality based on user preferences
* Handles both short-term context (today's chat) and long-term memory (months of history)

By the end, you'll have a working fitness companion and know how to handle common production challenges.

***

## The Basic Loop with Memory

Max wants to train for a marathon. He starts chatting with Ray, an AI running coach.

```python  theme={null}
from openai import OpenAI
from mem0 import MemoryClient

openai_client = OpenAI(api_key="your-openai-key")
mem0_client = MemoryClient(api_key="your-mem0-key")

def chat(user_input, user_id):
    # Retrieve relevant memories
    memories = mem0_client.search(user_input, user_id=user_id, limit=5)
    context = "\\n".join(m["memory"] for m in memories["results"])

    # Call LLM with memory context
    response = openai_client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": f"You're Ray, a running coach. Memories:\\n{context}"},
            {"role": "user", "content": user_input}
        ]
    ).choices[0].message.content

    # Store the exchange
    mem0_client.add([
        {"role": "user", "content": user_input},
        {"role": "assistant", "content": response}
    ], user_id=user_id)

    return response

```

**Session 1:**

```python  theme={null}
chat("I want to run a marathon in under 4 hours", user_id="max")
# Output: "That's a solid goal. What's your current weekly mileage?"
# Stored in Mem0: "Max wants to run sub-4 marathon"

```

**Session 2 (next day, app restarted):**

```python  theme={null}
chat("What should I focus on today?", user_id="max")
# Output: "Based on your sub-4 marathon goal, let's work on building your aerobic base..."

```

<Info>
  Ray remembers Max's goal across sessions. The app restarted, but the memory persisted. This is the core pattern: retrieve memories, pass them as context, store new exchanges.
</Info>

Ray remembers. Restart the app, and the goal persists. From here on, we'll focus on just the Mem0 API calls.

***

## Organizing Memory by Type

### Separating Temporary from Permanent

Max mentions his knee hurts. That's different from his marathon goal - one is temporary, the other is long-term.

**Categories vs Metadata:**

* **Categories**: AI-assigned by Mem0 based on content (you can't force them)
* **Metadata**: Manually set by you for forced tagging

Define custom categories at the project level. Mem0 will automatically tag memories with relevant categories based on content:

```python  theme={null}
mem0_client.project.update(custom_categories=[
    {"goals": "Race targets and training objectives"},
    {"constraints": "Injuries, limitations, recovery needs"},
    {"preferences": "Training style, surfaces, schedules"}
])

```

<Note>
  **Categories vs Metadata:** Categories are AI-assigned by Mem0 based on content semantics. You define the palette, Mem0 picks which ones apply. If you need guaranteed tagging, use `metadata` instead.
</Note>

Now when you add memories, Mem0 automatically assigns the appropriate categories:

```python  theme={null}
# Add goal - Mem0 automatically tags it as "goals"
mem0_client.add(
    [{"role": "user", "content": "Sub-4 marathon is my A-race"}],
    user_id="max"
)

# Add constraint - Mem0 automatically tags it as "constraints"
mem0_client.add(
    [{"role": "user", "content": "My right knee flares up on downhills"}],
    user_id="max"
)

```

Mem0 reads the content and intelligently picks which categories apply. You define the palette, it handles the tagging.

**Important:** You cannot force specific categories. Mem0's platform decides which categories are relevant based on content. If you need to force-tag something, use `metadata` instead:

```python  theme={null}
# Force tag using metadata (not categories)
mem0_client.add(
    [{"role": "user", "content": "Some workout note"}],
    user_id="max",
    metadata={"workout_type": "speed", "forced_tag": "custom_label"}
)

```

### Filtering by Category

Retrieve just constraints for workout planning:

```python  theme={null}
constraints = mem0_client.search(
    "injury concerns",
    user_id="max",
    filters={"categories": {"in": ["constraints"]}}
)
print([m["memory"] for m in constraints["results"]])
# Output: ["Max's right knee flares up on downhills"]

```

Ray can plan workouts that avoid aggravating Max's knee, without pulling in race goals or other unrelated memories.

***

## Filtering What Gets Stored

### The Problem

Run the basic loop for a week and check what's stored:

```python  theme={null}
memories = mem0_client.get_all(filters={"AND": [{"user_id": "max"}]})
print([m["memory"] for m in memories["results"]])
# Output: ["Max wants to run marathon under 4 hours", "hey", "lol ok", "cool thanks", "gtg bye"]

```

<Warning>
  Without filters, Mem0 stores everything—greetings, filler, and casual chat. This pollutes retrieval: instead of pulling "marathon goal," you get "lol ok." Set custom instructions to keep memory clean.
</Warning>

Noise. Greetings and filler clutter the memory.

### Custom Instructions

Tell Mem0 what matters:

```python  theme={null}
mem0_client.project.update(custom_instructions="""
Extract from running coach conversations:
- Training goals and race targets
- Physical constraints or injuries
- Training preferences (time of day, surfaces, weather)
- Progress milestones

Exclude:
- Greetings and filler
- Casual chatter
- Hypotheticals unless planning related
""")

```

Now chat again:

```python  theme={null}
chat("hey how's it going", user_id="max")
chat("I prefer trail running over roads", user_id="max")

memories = mem0_client.get_all(filters={"AND": [{"user_id": "max"}]})
print([m["memory"] for m in memories["results"]])
# Output: ["Max wants to run marathon under 4 hours", "Max prefers trail running over roads"]

```

<Info>
  **Expected output:** Only 2 memories stored—the marathon goal and trail preference. The greeting "hey how's it going" was filtered out automatically. Custom instructions are working.
</Info>

Only meaningful facts. Filler gets dropped automatically.

***

***

## Agent Memory for Personality

### Why Agents Need Memory Too

Max prefers direct feedback, not motivational fluff. Ray needs to remember how to communicate - that's agent memory, separate from user memory.

Store agent personality:

```python  theme={null}
mem0_client.add(
    [{"role": "system", "content": "Max wants direct, data-driven feedback. Skip motivational language."}],
    agent_id="ray_coach"
)

```

Retrieve agent style alongside user memories:

```python  theme={null}
# Get coach personality
agent_memories = mem0_client.search("coaching style", agent_id="ray_coach")
# Output: ["Max wants direct, data-driven feedback. Skip motivational language."]

# Store conversations with agent_id
mem0_client.add([
    {"role": "user", "content": "How'd my run look today?"},
    {"role": "assistant", "content": "Pace was 8:15/mile. Heart rate 152, zone 2."}
], user_id="max", agent_id="ray_coach")

```

<Info>
  **Expected behavior:** Ray's responses are now data-driven and direct. The agent memory stored the coaching style preference, so future responses adapt automatically without Max having to repeat his preference.
</Info>

No "Great job!" or "Keep it up!" - just data. Ray adapts to Max's preference.

***

## Managing Short-Term Context

### When to Store in Mem0

Don't send every single message to Mem0. Keep recent context in memory, let Mem0 handle the important long-term facts.

```python  theme={null}
# Store only meaningful exchanges in Mem0
mem0_client.add([
    {"role": "user", "content": "I want to run a marathon"},
    {"role": "assistant", "content": "Let's build a training plan"}
], user_id="max")

# Skip storing filler
# "hey" → don't store
# "cool thanks" → don't store

# Or rely on custom_instructions to filter automatically

```

Last 10 messages in your app's buffer. Important facts in Mem0. Faster, cheaper, still works.

***

## Time-Bound Memories

### Auto-Expiring Facts

Max tweaks his ankle. It'll heal in two weeks - the memory should expire too.

```python  theme={null}
from datetime import datetime, timedelta

expiration = (datetime.now() + timedelta(days=14)).strftime("%Y-%m-%d")

mem0_client.add(
    [{"role": "user", "content": "Rolled my left ankle, needs rest"}],
    user_id="max",
    expiration_date=expiration
)

```

In 14 days, this memory disappears automatically. Ray stops asking about the ankle.

***

## Putting It All Together

Here's the Mem0 setup combining everything:

```python  theme={null}
from mem0 import MemoryClient
from datetime import datetime, timedelta

mem0_client = MemoryClient(api_key="your-mem0-key")

# Configure memory filtering and categories
mem0_client.project.update(
    custom_instructions="""
    Extract: goals, constraints, preferences, progress
    Exclude: greetings, filler, casual chat
    """,
    custom_categories=[
        {"name": "goals", "description": "Training targets"},
        {"name": "constraints", "description": "Injuries and limitations"},
        {"name": "preferences", "description": "Training style"}
    ]
)

```

**Week 1 - Store goals and preferences:**

```python  theme={null}
mem0_client.add([
    {"role": "user", "content": "I want to run a sub-4 marathon"},
    {"role": "assistant", "content": "Got it. Let's build a training plan."}
], user_id="max", agent_id="ray", categories=["goals"])

mem0_client.add([
    {"role": "user", "content": "I prefer trail running over roads"}
], user_id="max", categories=["preferences"])

```

**Week 3 - Temporary injury with expiration:**

```python  theme={null}
expiration = (datetime.now() + timedelta(days=14)).strftime("%Y-%m-%d")
mem0_client.add(
    [{"role": "user", "content": "Rolled ankle, need light workouts"}],
    user_id="max",
    categories=["constraints"],
    expiration_date=expiration
)

```

**Retrieve for context:**

```python  theme={null}
memories = mem0_client.search("training plan", user_id="max", limit=5)
# Gets: marathon goal, trail preference, ankle injury (if still valid)

```

Ray remembers goals, preferences, and personality. Handles temporary injuries. Works across sessions.

***

## Common Production Patterns

### Episodic Stories with run\_id

Training for Boston is different from training for New York. Separate the memory threads:

```python  theme={null}
mem0_client.add(messages, user_id="max", run_id="boston-2025")
mem0_client.add(messages, user_id="max", run_id="nyc-2025")

# Retrieve only Boston memories
boston_memories = mem0_client.search(
    "training plan",
    user_id="max",
    run_id="boston-2025"
)

```

Each race gets its own episodic boundary. No cross-contamination.

### Importing Historical Data

Max has 6 months of training logs to backfill:

```python  theme={null}
old_logs = [
    [{"role": "user", "content": "Completed 20-mile long run"}],
    [{"role": "user", "content": "Hit 8:00 pace on tempo run"}],
]

for log in old_logs:
    mem0_client.add(log, user_id="max")

```

### Handling Contradictions

Max changes his goal from sub-4 to sub-3:45:

```python  theme={null}
# Find the old memory
memories = mem0_client.get_all(filters={"AND": [{"user_id": "max"}]})
goal_memory = [m for m in memories["results"] if "sub-4" in m["memory"]][0]

# Update it
mem0_client.update(goal_memory["id"], "Max wants to run sub-3:45 marathon")

```

Update instead of creating duplicates.

### Multiple Agents

Max works with Ray for running and Jordan for strength training:

```python  theme={null}
chat("easy run today", user_id="max", agent_id="ray")
chat("leg day workout", user_id="max", agent_id="jordan")

```

Each coach maintains separate personality memory while sharing user context.

### Filtering by Date

Prioritize recent training over old data:

```python  theme={null}
recent = mem0_client.search(
    "training progress",
    user_id="max",
    filters={"created_at": {"gte": "2025-10-01"}}
)

```

### Metadata Tagging

Tag workouts by type:

```python  theme={null}
mem0_client.add(
    [{"role": "user", "content": "10x400m intervals"}],
    user_id="max",
    metadata={"workout_type": "speed", "intensity": "high"}
)

# Later, find all speed workouts
speed_sessions = mem0_client.search(
    "speed work",
    user_id="max",
    filters={"metadata": {"workout_type": "speed"}}
)

```

### Pruning Old Memories

Delete irrelevant memories:

```python  theme={null}
mem0_client.delete(memory_id="mem_xyz")

# Or clear an entire run_id
mem0_client.delete_all(user_id="max", run_id="old-training-cycle")

```

***

## What You Built

A companion that:

* **Persists across sessions** - Mem0 storage
* **Filters noise** - custom instructions
* **Organizes by type** - categories
* **Adapts personality** - **`agent_id`**
* **Stays fast** - short-term buffer
* **Handles temporal facts** - expiration
* **Scales to production** - batching, metadata, pruning

This pattern works for any companion: fitness coaches, tutors, roleplay characters, therapy bots, creative writing partners.

***

<Tip>
  Start with 2-3 categories max (e.g., goals, constraints, preferences). More categories dilute tagging accuracy. You can always add more later after seeing what Mem0 extracts.
</Tip>

***

## Production Checklist

Before launching:

* Set custom instructions for your domain
* Define 2-3 categories (goals, constraints, preferences)
* Add expiration strategy for time-bound facts
* Implement error handling for API calls
* Monitor memory quality in Mem0 dashboard
* Clear test data from production project

***

<CardGroup cols={2}>
  <Card title="Partition Memories by Entity" icon="layers" href="/cookbooks/essentials/entity-partitioning-playbook">
    Keep companions from leaking context by combining user, agent, and session scopes.
  </Card>

  <Card title="Tag Support Memories" icon="tag" href="/cookbooks/essentials/tagging-and-organizing-memories">
    Organize customer context to keep assistants responsive at scale.
  </Card>
</CardGroup>


# Choose Vector vs Graph Memory
Source: https://docs.mem0.ai/cookbooks/essentials/choosing-memory-architecture-vector-vs-graph

Blend vector search with graph relationships to answer multi-hop questions.

Most AI agents use vector stores for RAG operations - they work great for semantic search and retrieving relevant context. But there's a gap when queries require understanding connections between entities.

Mem0 brings graph memory into the picture to fill this gap. In this cookbook, we'll create a company knowledge base with Mem0, using both vector and graph stores. You'll learn when each one helps along the way.

***

## Vector and Graph Stores

When you add a memory to Mem0, it goes into a **vector store** by default. Vector stores are excellent at semantic search - finding memories that match the meaning of your query.

**Graph stores** work differently. They extract **entities** (people, projects, teams) and **relationships between them** (works\_with, reports\_to, member\_of). This lets you answer questions that need connecting information across multiple memories.

We will go through examples in this cookbook while building a company's knowledge base along the way.

***

## Starting Simple

Since we're building a company knowledge base, let's add some employee information:

```python  theme={null}
from mem0 import MemoryClient

client = MemoryClient(api_key="your-api-key")
# Add employee info
client.add("Emma is a software engineer in Seattle", user_id="company_kb")
client.add("David is a product manager in Austin", user_id="company_kb")

```

Now let's search for Emma's role:

```python  theme={null}
results = client.search("What does Emma do?", filters={"user_id": "company_kb"})
print(results['results'][0]['memory'])

```

**Output:**

```
Emma is a software engineer in Seattle

```

<Info>
  **Expected output:** Vector search returned Emma's role instantly. When queries ask for facts directly stored in one memory, vector semantic search is perfect—fast and accurate.
</Info>

This works perfectly. Vector search found the memory that semantically matches "What does Emma do?" and returned Emma's role.

***

## Adding Team Structure

Let's add some information about how the team works together:

```python  theme={null}
client.add("Emma works with David on the mobile app redesign", user_id="company_kb")
client.add("David reports to Rachel, who manages the design team", user_id="company_kb")

```

Now we have two pieces of information stored:

1. Emma works with David
2. David reports to Rachel

Let's try asking something that needs both pieces:

```python  theme={null}
results = client.search(
    "Who is Emma's teammate's manager?",
    filters={"user_id": "company_kb"}
)

for r in results['results']:
    print(r['memory'])

```

**Output:**

```
Emma works with David on the mobile app redesign
David reports to Rachel, who manages the design team

```

Vector search returned both memories, but it didn't connect them. You'd need to manually figure out:

* Emma's teammate is David (from memory 1)
* David's manager is Rachel (from memory 2)
* So the answer is Rachel

<Warning>
  Vector search can't traverse relationships. It returns relevant memories, but you must connect the dots manually. For "Who is Emma's teammate's manager?", vector search gives you the pieces—not the answer. This breaks down as queries get more complex (3+ hops).
</Warning>

***

## Enter Graph Memory

Let's add the same information with graph memory enabled:

```python  theme={null}
client.add(
    "Emma works with David on the mobile app redesign",
    user_id="company_kb",
    enable_graph=True
)

client.add(
    "David reports to Rachel, who manages the design team",
    user_id="company_kb",
    enable_graph=True
)

```

When you set `enable_graph=True`, Mem0 extracts entities and relationships:

* `emma --[works_with]--> david`
* `david --[reports_to]--> rachel`
* `rachel --[manages]--> design_team`

Now the same query works differently:

```python  theme={null}
results = client.search(
    "Who is Emma's teammate's manager?",
    filters={"user_id": "company_kb"},
    enable_graph=True
)

print(results['results'][0]['memory'])
print("\\nRelationships found:")
for rel in results.get('relations', []):
    print(f"  {rel['source']}, {rel['target']} ({rel['relationship']})")

```

**Output:**

```
David reports to Rachel, who manages the design team

Relationships found:
  emma, david (works_with)
  david, rachel (reports_to)

```

<Info>
  **Expected behavior:** Graph memory returns the direct answer—"David reports to Rachel"—plus the relationship chain that got there. No manual connecting needed. The graph traversed: Emma → works\_with → David → reports\_to → Rachel.
</Info>

Graph memory traversed the relationships automatically: Emma works with David, David reports to Rachel, so Rachel is the answer.

***

## How It Connects

Here's what the graph looks like behind the scenes:

```mermaid  theme={null}
graph LR
    Emma[Emma] -->|works_with| David[David]
    David -->|reports_to| Rachel[Rachel]
    Rachel -->|manages| DesignTeam[Design Team]
    David -->|works_on| MobileApp[Mobile App]
    Emma -->|works_on| MobileApp

```

Graph memory lets you discover relations and memories which are tricky to do with direct vector stores.

Vector search would need the exact words in your query to match. Graph memory follows the connections.

***

## When to Use Each

Use **vector store** (default) when:

* Searching documents by semantic similarity
* Looking up facts that don't need relationships
* Building FAQs or knowledge bases where each item stands alone

Use **graph memory** when:

* Tracking organizational hierarchies (who reports to whom)
* Understanding project teams (who collaborates with whom)
* Building CRMs (which contacts connect to which companies)
* Product recommendations (what items are bought together)

For our company knowledge base, we'll use both:

* Vector for individual facts: "Emma specializes in React"
* Graph for relationships: "Emma works with David"

***

## Putting It Together

Let's build a small company knowledge base with both approaches:

```python  theme={null}
# Facts about individuals - vector store is fine
client.add("Emma specializes in React and TypeScript", user_id="company_kb")
client.add("David has 5 years of product management experience", user_id="company_kb")

# Relationships - use graph memory
client.add(
    "Emma and David work together on the mobile app",
    user_id="company_kb",
    enable_graph=True
)

client.add(
    "David reports to Rachel",
    user_id="company_kb",
    enable_graph=True
)

client.add(
    "Rachel runs weekly team syncs every Tuesday",
    user_id="company_kb",
    enable_graph=True
)

```

Now we can ask different types of questions:

```python  theme={null}
# Direct fact - vector search
results = client.search("What are Emma's skills?", filters={"user_id": "company_kb"})
print(results['results'][0]['memory'])

```

**Output:**

```
Emma specializes in React and TypeScript

```

```python  theme={null}
# Multi-hop relationship - graph search
results = client.search(
    "What meetings does Emma's project manager's boss run?",
    filters={"user_id": "company_kb"},
    enable_graph=True
)
print(results['results'][0]['memory'])

```

**Output:**

```
Rachel runs weekly team syncs every Tuesday

```

Graph memory connected: Emma works with David, David reports to Rachel, Rachel runs team syncs.

<Tip>
  Enable graph memory when your queries need multi-hop traversal: org charts (who reports to whom), project teams (who collaborates), CRMs (which contacts connect to companies). For single-fact lookups, stick with vector search—it's faster and cheaper.
</Tip>

***

## The Tradeoff

Graph memory adds processing time and cost. When you call `client.add()` with `enable_graph=True`, Mem0 makes extra LLM calls to extract entities and relationships.

<Note>
  **Cost consideration:** Graph memory extraction adds \~2-3 extra LLM calls per `add()` operation to identify entities and relationships. Use it selectively—enable graph for organizational structure and long-term relationships, skip it for temporary notes and simple facts.
</Note>

Use graph memory when the relationship traversal adds real value. For most use cases, vector search is sufficient and faster.

```python  theme={null}
# Long-term organizational structure - worth using graph
client.add(
    "Emma mentors two junior engineers on the frontend team",
    user_id="company_kb",
    enable_graph=True
)

# Temporary notes - skip graph, not worth the cost
client.add(
    "Emma is out sick today",
    user_id="company_kb",
    run_id="daily_notes"
)

```

***

## Enabling Graph Memory

You can enable graph memory in two ways:

**Per-call** (recommended to start):

```python  theme={null}
client.add("Emma works with David", user_id="company_kb", enable_graph=True)
client.search("team structure", filters={"user_id": "company_kb"}, enable_graph=True)

```

**Project-wide** (if most of your data has relationships):

```python  theme={null}
client.project.update(enable_graph=True)

# Now every add uses graph automatically
client.add("Emma mentors Jordan", user_id="company_kb")

```

***

## What You Built

A hybrid company knowledge base that combines both architectures:

* **Vector search** - Fast semantic lookups for individual facts (Emma's skills, David's experience)
* **Graph memory** - Multi-hop relationship traversal (Emma's teammate's manager, project hierarchies)
* **Selective enablement** - Graph only for long-term organizational structure, vector for everything else
* **Cost optimization** - Skip graph extraction for temporary notes and simple facts

This pattern scales from 10-person startups to enterprise org charts with thousands of employees.

***

## Summary

Vector stores handle most memory operations efficiently—semantic search works great for finding relevant information. Add graph memory when your queries need to understand how entities connect across multiple hops.

The key is knowing which tool fits your query pattern: direct questions work with vectors, multi-hop relationship queries need graphs.

<CardGroup cols={2}>
  <Card title="Partition Memories by Entity" icon="layers" href="/cookbooks/essentials/entity-partitioning-playbook">
    Scope memories across users, agents, apps, and sessions to balance personalization and reuse.
  </Card>

  <Card title="Export Everything Safely" icon="download" href="/cookbooks/essentials/exporting-memories">
    Learn how to migrate or audit stored memories with structured exports.
  </Card>
</CardGroup>


# Control Memory Ingestion
Source: https://docs.mem0.ai/cookbooks/essentials/controlling-memory-ingestion

Filter speculation, enforce formats, and gate low-confidence data before it persists.

AI assistants plugged with memory systems face a problem - they often store everything. Not every conversation needs to be remembered, and not every detail should go to the memory store. Without proper controls, memory systems accumulate unreliable data.

Mem0 lets you control your memory ingestion pipeline. In this cookbook, we'll demonstrate these controls using a medical assistant example - showing how to filter unwanted data, enforce data formats, and implement confidence-based storage.

***

## Overview

Without controls, everything gets stored - speculation, low-confidence data, and information that shouldn't persist. This uncontrolled ingestion leads to cluttered memory and retrieval failures.

Mem0 provides **three tools to control** what gets stored:

1. **Custom instructions** define what to remember and what to ignore.
2. **Confidence thresholds** ensure only verified facts persist.
3. **Memory updates** let you change information without creating duplicates.

In this tutorial, we will:

* Filter speculative statements with custom instructions
* Configure confidence thresholds for fact verification
* Update stored information without duplication
* Build a complete ingestion pipeline

***

## Setup

```python  theme={null}
from mem0 import MemoryClient

client = MemoryClient(api_key="your-api-key")
```

<Note>
  Replace `your-api-key` with your actual Mem0 API key from the [dashboard](https://app.mem0.ai). Without proper API authentication, memory operations will fail.
</Note>

***

## The Problem

Uncontrolled ingestion stores everything, including speculation:

```python  theme={null}
# Patient mentions speculation
messages = [{"role": "user", "content": "I think I might be allergic to penicillin"}]
client.add(messages, user_id="patient_123")

# Check what got stored
results = client.search("patient allergies", filters={"user_id": "patient_123"})
print(results['results'][0]['memory'])

```

**Output:**

```
Patient is allergic to penicillin
```

<Warning>
  Without custom instructions, AI assistants treat speculation as confirmed facts. "I think I might be allergic" becomes "Patient is allergic"—a dangerous transformation in sensitive domains like healthcare, legal, or financial services.
</Warning>

The speculation became a confirmed fact. Let's add controls.

***

## Custom Instructions

Custom instructions tell Mem0 what to store and what to ignore.

```python  theme={null}
instructions = """
Only store CONFIRMED medical facts.

Store:
- Confirmed diagnoses from doctors
- Known allergies with documented reactions
- Current medications being taken

Ignore:
- Speculation (words like "might", "maybe", "I think")
- Unverified symptoms
- Casual mentions without confirmation
"""

client.project.update(custom_instructions=instructions)

# Same speculative statement
messages = [{"role": "user", "content": "I think I might be allergic to penicillin"}]
client.add(messages, user_id="patient_123")

# Check what got stored
results = client.get_all(filters={"user_id": "patient_123"})
print(f"Memories stored: {len(results['results'])}")

```

**Output:**

```
Memories stored: 0
```

<Info>
  **Expected output:** Zero memories stored. The speculative statement "I think I might be allergic" was filtered out before reaching storage. Custom instructions are actively blocking unreliable data.
</Info>

The speculation was filtered out.

***

## Designing Custom Instructions

When designing instructions, consider the trade-off between precision and recall:

**Too restrictive:** You'll miss important information (false negatives)

```python  theme={null}
# Too strict - filters out useful context
"""
Only store information if explicitly stated by a doctor with full name,
date, time, and medical license number.
"""

```

**Too permissive:** You'll store unreliable data (false positives)

```python  theme={null}
# Too loose - stores speculation as fact
"""
Store any health-related information mentioned.
"""

```

**Balanced approach:**

```python  theme={null}
# Clear categories with examples
"""
Store CONFIRMED facts:
- Diagnoses: "Dr. Smith diagnosed hypertension on March 15th"
- Allergies: "Patient had hives reaction to penicillin"
- Medications: "Taking Lisinopril 10mg daily"

Ignore SPECULATION:
- "I think I might have..."
- "Maybe it's..."
- "Could be related to..."
"""

```

<Tip>
  Start with strict instructions (only store confirmed facts), then relax them based on your use case. It's easier to allow more data than to clean up polluted memory. Test with sample conversations before deploying to production.
</Tip>

Start with clear categories and iterate based on retrieval quality.

***

## Confidence Thresholds

Mem0 assigns confidence scores to extracted memories. Use these to filter low-quality data.

### Setting Thresholds

Setting the right confidence threshold depends on your application:

* **High-stakes domains** (medical, legal): Require 0.8+ confidence
* **General assistants**: 0.6+ confidence is often sufficient
* **Exploratory systems**: Lower thresholds (0.4+) capture more data

Test your pipeline with multiple input examples and threshold combinations to find what works for your use case.

```python  theme={null}
# Configure stricter instructions
client.project.update(
    custom_instructions="""
Only extract memories with HIGH confidence.
Require specific details (dates, dosages, doctor names) for medical facts.
Skip vague or uncertain statements.
"""
)

# Test with uncertain statement
messages = [{"role": "user", "content": "The doctor mentioned something about my blood pressure"}]
result1 = client.add(messages, user_id="patient_123")

# Test with confirmed fact
messages = [{"role": "user", "content": "Dr. Smith diagnosed me with hypertension on March 15th"}]
result2 = client.add(messages, user_id="patient_123")

print("Vague statement stored:", len(result1['results']) > 0)
print("Confirmed fact stored:", len(result2['results']) > 0)

```

**Output:**

```
Vague statement stored: False
Confirmed fact stored: True
```

<Info icon="check">
  **Expected behavior:** Low-confidence extractions are now filtered out automatically. Only verified facts with specific details (names, dates, dosages) persist in memory. The confidence threshold is working.
</Info>

The vague statement was filtered for low confidence. The confirmed fact with specific details was stored.

***

## Filtering Sensitive Information

Custom instructions can prevent storing personal identifiers:

```python  theme={null}
client.project.update(
    custom_instructions="""
Medical memory rules:

STORE:
- Confirmed diagnoses
- Verified allergies
- Current medications

NEVER STORE:
- Social Security Numbers
- Insurance policy numbers
- Credit card information
- Full addresses
- Phone numbers

Replace identifiers with generic references if mentioned.
"""
)

# Test with PII
messages = [
    {"role": "user", "content": "My SSN is 123-45-6789 and I'm allergic to penicillin"}
]
client.add(messages, user_id="patient_123")

# Check what was stored
results = client.get_all(filters={"user_id": "patient_123"})
for result in results['results']:
    print(result['memory'])

```

**Output:**

```
Patient is allergic to penicillin
```

The SSN was filtered out, but the allergy was stored.

***

## Updating Memories

When information changes, update existing memories instead of creating duplicates.

```python  theme={null}
# Initial allergy stored
result = client.add(
    [{"role": "user", "content": "Patient confirmed allergy to penicillin with documented hives reaction"}],
    user_id="patient_123"
)

memory_id = result['results'][0]['id']
print(f"Stored memory: {memory_id}")

# Later, patient gets retested - allergy was false positive
client.update(
    memory_id=memory_id,
    text="Patient tested negative for penicillin allergy on April 2nd, 2025. Previous allergy was false positive.",
    metadata={"verified": True, "updated_date": "2025-04-02"}
)

# Retrieve the updated memory
updated = client.get(memory_id)
print(f"\\nUpdated memory: {updated['memory']}")
print(f"Metadata: {updated['metadata']}")

```

**Output:**

```
Stored memory: mem_abc123

Updated memory: Patient tested negative for penicillin allergy on April 2nd, 2025. Previous allergy was false positive.
Metadata: {'verified': True, 'updated_date': '2025-04-02'}

```

### Benefits of Updating

**Preserves history:**

* `created_at` shows when the memory was first stored
* `updated_at` shows when it was modified
* Audit trail for compliance

**Avoids conflicts:**

* No duplicate or contradicting memories
* Single source of truth for each fact

<Warning>
  That “no duplicates” promise comes from the inference pipeline. Keep `infer=True` when you rely on automatic updates. Raw imports (`infer=False`) skip conflict checks, so mixing the two modes for the same fact will create duplicates.
</Warning>

**Maintains relationships:**

* If using graph memory, connections to other entities persist

### Pick the right inference mode

| Mode                     | What it does                                                                                  | Best for                                                             | Watch out for                                                                              |
| ------------------------ | --------------------------------------------------------------------------------------------- | -------------------------------------------------------------------- | ------------------------------------------------------------------------------------------ |
| `infer=True` *(default)* | Runs the LLM pipeline so Mem0 extracts structured facts and resolves conflicts automatically. | Daily conversations, preference tracking, anything you want deduped. | Slightly slower because inference runs on every write.                                     |
| `infer=False`            | Stores your payload exactly as-is—no inference, no dedupe.                                    | Bulk imports, compliance snapshots, curated facts you already trust. | Later `infer=True` calls for the same fact will create duplicates you must clean manually. |

<Tip>
  Stay consistent per data source. If you need both behaviors, keep them in separate scopes (e.g., different `app_id` or `run_id`) so you always know which memories are inferred vs direct imports.
</Tip>

***

## Update vs Delete

When should you update vs delete?

### Update when:

* Information changes but remains relevant
* You need audit history
* The memory has relationships to other data

```python  theme={null}
# Medication dosage changed
client.update(
    memory_id=med_id,
    text="Taking Lisinopril 20mg daily (increased from 10mg on March 1st)"
)

```

### Delete when:

* Information was completely wrong
* Memory is no longer relevant
* Duplicate entry

```python  theme={null}
# Duplicate entry
client.delete(memory_id)

```

***

## Putting It Together

Here's a complete ingestion pipeline with all controls:

```python  theme={null}
from mem0 import MemoryClient
import os

# Initialize client
client = MemoryClient(api_key=os.getenv("MEM0_API_KEY"))

# Configure custom instructions
client.project.update(
    custom_instructions="""
Medical memory assistant rules:

STORE:
- Confirmed diagnoses (with doctor name and date)
- Verified allergies (with reaction details)
- Current medications (with dosage)

IGNORE:
- Speculation (might, maybe, possibly)
- Unverified symptoms
- Personal identifiers (SSN, insurance numbers)

CONFIDENCE:
Require high confidence. Reject vague or uncertain statements.
Require specific details: names, dates, dosages.
"""
)

# Helper function for safe ingestion
def add_medical_memory(content, user_id, metadata=None):
    """Add memory with automatic filtering."""
    result = client.add(
        [{"role": "user", "content": content}],
        user_id=user_id,
        metadata=metadata or {}
    )

    if result['results']:
        print(f"✓ Stored: {result['results'][0]['memory']}")
    else:
        print(f"✗ Filtered: {content}")

    return result

# Test cases
print("Testing ingestion pipeline:\\n")

test_cases = [
    "I think I might be allergic to penicillin",
    "Dr. Johnson confirmed penicillin allergy on Jan 15th with hives reaction",
    "Patient SSN is 123-45-6789",
    "Currently taking Lisinopril 10mg daily for hypertension",
    "Feeling tired lately",
    "Dr. Martinez diagnosed Type 2 diabetes on February 3rd, 2025"
]

for content in test_cases:
    add_medical_memory(content, user_id="patient_123")
    print()

```

**Output:**

```
Testing ingestion pipeline:

✗ Filtered: I think I might be allergic to penicillin

✓ Stored: Patient has confirmed penicillin allergy diagnosed by Dr. Johnson on January 15th with hives reaction

✗ Filtered: Patient SSN is 123-45-6789

✓ Stored: Patient is currently taking Lisinopril 10mg daily for hypertension

✗ Filtered: Feeling tired lately

✓ Stored: Patient diagnosed with Type 2 diabetes by Dr. Martinez on February 3rd, 2025

```

***

## Per-Call Instructions

You can override project-level instructions for specific conversations:

First define custom instructions

```python  theme={null}
custom_instructions="""Emergency intake mode:Store ALL symptoms and observations immediately.
Flag for later review and verification."""
 
```

```python  theme={null}
# Emergency intake - store everything temporarily
emergency_messages = [
    {"role": "user", "content": "Patient arrived with chest pain and shortness of breath"}
]

client.add(
    emergency_messages,
    user_id="patient_456",
    custom_instructions=custom_instructions,
    metadata={"type": "emergency", "review_required": True}
)

```

This is useful for:

* Different conversation types (emergency vs routine)
* Channel-specific rules (phone vs in-person)
* Temporary data collection that needs review

***

## What You Built

You now have a medical assistant with production-grade memory controls:

* **Custom instructions** - Filter speculation and enforce confirmed facts only
* **Confidence thresholds** - Gate extractions below 0.7 confidence score
* **Memory updates** - Modify stored information without creating duplicates
* **Per-call instructions** - Apply temporary rules for specific conversations
* **PII filtering** - Block sensitive data (SSNs, insurance numbers) automatically

These controls prevent retrieval failures and ensure your AI assistant works with reliable, verified information.

***

## Summary

Start with conservative filters (only store confirmed facts) and iterate based on your application's needs. Combine custom instructions with confidence thresholds for the most reliable memory ingestion pipeline.

<CardGroup cols={2}>
  <Card title="Expire Short-Term Data" icon="timer" href="/cookbooks/essentials/memory-expiration-short-and-long-term">
    Automatically clean up session context before it clutters retrieval.
  </Card>

  <Card title="Choose Your Memory Architecture" icon="sitemap" href="/cookbooks/essentials/choosing-memory-architecture-vector-vs-graph">
    Learn when to layer graph memory alongside vectors for multi-hop queries.
  </Card>
</CardGroup>


# Partition Memories by Entity
Source: https://docs.mem0.ai/cookbooks/essentials/entity-partitioning-playbook

Keep memories separate by tagging each write and query with user, agent, app, and session identifiers.

Nora runs a travel service. When she stored all memories in one bucket, a recruiter's nut allergy accidentally appeared in a traveler's dinner reservation. Let's fix this by properly separating memories for different users, agents, and applications.

<Info icon="clock">
  **Time to complete:** \~15 minutes · **Languages:** Python
</Info>

## Setup

```python  theme={null}
from mem0 import MemoryClient

client = MemoryClient(api_key="m0-...")
```

Grab an API key from the <Link href="https://app.mem0.ai/">Mem0 dashboard</Link> to get started.

## Store and Retrieve Scoped Memories

Let's start by storing Cam's travel preferences and retrieving them:

```python  theme={null}
cam_messages = [
    {"role": "user", "content": "I'm Cam. Keep in mind I avoid shellfish and prefer boutique hotels."},
    {"role": "assistant", "content": "Noted! I'll use those preferences in future itineraries."}
]

result = client.add(
    cam_messages,
    user_id="traveler_cam",
    agent_id="travel_planner",
    run_id="tokyo-2025-weekend",
    app_id="concierge_app"
)
```

The memory is now stored. Let's retrieve those memories with the same identifiers:

```python  theme={null}
user_scope = {
    "AND": [
        {"user_id": "traveler_cam"},
        {"app_id": "concierge_app"},
        {"run_id": "tokyo-2025-weekend"}
    ]
}
user_memories = client.search("Any dietary restrictions?", filters=user_scope)
print(user_memories)

agent_scope = {
    "AND": [
        {"agent_id": "travel_planner"},
        {"app_id": "concierge_app"}
    ]
}
agent_memories = client.search("Any dietary restrictions?", filters=agent_scope)
print(agent_memories)
```

**Output:**

```
{'results': [{'memory': 'avoids shellfish and prefers boutique hotels', ...}]}
{'results': [{'memory': 'avoids shellfish and prefers boutique hotels', ...}]}
```

<Tip icon="compass">
  Memories can be written with several identifiers, but each search resolves one entity boundary at a time. Run separate queries for user and agent scopes—just like above—rather than combining both in a single filter.
</Tip>

## When Memories Leak

When Nora adds a chef agent, Cam's travel preferences leak into food recommendations:

```python  theme={null}
chef_filters = {"AND": [{"user_id": "traveler_cam"}]}

collision = client.search("What should I cook?", filters=chef_filters)
print(collision)
```

**Output:**

```
['avoids shellfish and prefers boutique hotels', 'prefers Kyoto kaiseki dining experiences']
```

The travel preferences appear because we only filtered by `user_id`. The chef agent shouldn't see hotel preferences.

## Fix the Leak with Proper Filters

First, let's add a memory specifically for the chef agent:

```python  theme={null}
chef_memory = [
    {"role": "user", "content": "I'd like to try some authentic Kyoto cuisine."},
    {"role": "assistant", "content": "I'll remember that you prefer Kyoto kaiseki dining experiences."}
]

client.add(
    chef_memory,
    user_id="traveler_cam",
    agent_id="chef_recommender",
    run_id="menu-planning-2025-04",
    app_id="concierge_app"
)
```

Now search within the chef's scope:

```python  theme={null}
safe_filters = {
    "AND": [
        {"agent_id": "chef_recommender"},
        {"app_id": "concierge_app"},
        {"run_id": "menu-planning-2025-04"}
    ]
}

chef_memories = client.search("Any food alerts?", filters=safe_filters)
print(chef_memories)
```

**Output:**

```
{'results': [{'memory': 'prefers Kyoto kaiseki dining experiences', ...}]}
```

Now the chef agent only sees its own food preferences. The hotel preferences stay with the travel agent.

## Separate Apps with app\_id

Nora white-labels her travel service for a sports brand. Use `app_id` to keep enterprise data separate:

```python  theme={null}
enterprise_filters = {
    "AND": [
        {"app_id": "sports_brand_portal"},
        {"user_id": "*"},
        {"agent_id": "*"}
    ]
}

page = client.get_all(filters=enterprise_filters, page=1, page_size=10)
print([row["user_id"] for row in page["results"]])
```

**Output:**

```
['athlete_jane', 'coach_mike', 'team_admin']
```

<Info>
  Wildcards (`"*"` ) only match non-null values. Make sure you write memories with explicit `app_id` values.
</Info>

<Tip icon="sparkles">
  Need a deeper tour of AND vs OR, nested filters, or wildcard tricks? Check the <Link href="/platform/features/v2-memory-filters">Memory Filters v2 guide</Link> for full examples you can copy into this flow.
</Tip>

When the sports brand offboards, delete all their data:

```python  theme={null}
client.delete_all(app_id="sports_brand_portal")
```

**Output:**

```
{'message': 'Memories deleted successfully!'}
```

## Production Patterns

```python  theme={null}
# Nightly audits - check all data for an app
def audit_app(app_id: str):
    filters = {"AND": [{"app_id": app_id}, {"user_id": "*"}, {"agent_id": "*"}]}
    return client.get_all(filters=filters, page=1, page_size=50)

# Session cleanup - delete temporary conversations
def close_ticket(ticket_id: str, user_id: str):
    client.delete_all(user_id=user_id, run_id=ticket_id)

# Compliance exports - get all data for one tenant
export = client.get_memory_export(filters={"AND": [{"app_id": "sports_brand_portal"}]})
```

## Complete Example

Putting it all together - here's how to properly scope memories:

```python  theme={null}
# Store memories with all identifiers
client.add(
    [{"role": "user", "content": "I need a hotel near the conference center."}],
    user_id="exec_123",
    agent_id="booking_assistant",
    app_id="enterprise_portal",
    run_id="trip-2025-03"
)

# Retrieve with the same scope
filters = {
    "AND": [
        {"user_id": "exec_123"},
        {"app_id": "enterprise_portal"},
        {"run_id": "trip-2025-03"}
    ]
}

# Alternative: Use wildcards if you're not sure about some fields
# filters = {
#     "AND": [
#         {"user_id": "exec_123"},
#         {"agent_id": "*"},  # Match any agent
#         {"app_id": "enterprise_portal"},
#         {"run_id": "*"}      # Match any run
#     ]
# }

results = client.search("Hotels near conference", filters=filters)

# Debug: Print the filter you're using
print(f"Searching with filters: {filters}")

# If no results, try a broader search to see what's stored
if not results["results"]:
    print("No results found! Trying broader search...")
    broader = client.get_all(filters={"user_id": "exec_123"})
    print(broader)

print(results["results"][0]["memory"])
```

**Output:**

```
I need a hotel near the conference center.
```

## When to Use Each Identifier

| Identifier | When to Use                                                 | Example Values                                                |
| ---------- | ----------------------------------------------------------- | ------------------------------------------------------------- |
| `user_id`  | Individual preferences that persist across all interactions | `cam_traveler`, `sarah_exec`, `team_alpha`                    |
| `agent_id` | Different AI roles need separate context                    | `travel_agent`, `concierge`, `customer_support`               |
| `app_id`   | White-label deployments or separate products                | `travel_app_ios`, `enterprise_portal`, `partner_integration`  |
| `run_id`   | Temporary sessions that should be isolated                  | `support_ticket_9234`, `chat_session_456`, `booking_flow_789` |

## Troubleshooting Common Issues

### My search returns empty results!

**Problem**: Using `AND` with exact matches but some fields might be `null`.

**Solution**:

```python  theme={null}
# If this returns nothing:
filters = {"AND": [{"user_id": "u1"}, {"agent_id": "a1"}]}

# Try using wildcards:
filters = {"AND": [{"user_id": "u1"}, {"agent_id": "*"}]}

# Or don't include fields you don't need:
filters = {"AND": [{"user_id": "u1"}]}
```

### OR gives results but AND doesn't

This confirms you have a **field mismatch**. The memory exists but some identifier values don't match exactly.

**Always check what's actually stored:**

```python  theme={null}
# Get all memories for the user to see the actual field values
all_mems = client.get_all(filters={"user_id": "your_user_id"})
print(json.dumps(all_mems, indent=2))
```

## Best Practices

1. **Use consistent identifier formats**
   ```python  theme={null}
   # Good: consistent patterns
   user_id = "cam_traveler"
   agent_id = "travel_agent_v1"
   app_id = "nora_concierge_app"
   run_id = "tokyo_trip_2025_03"

   # Avoid: mixed patterns
   # user_id = "123", agent_id = "agent2", app_id = "app"
   ```

2. **Print filters when debugging**
   ```python  theme={null}
   filters = {"AND": [{"user_id": "cam", "agent_id": "chef"}]}
   print(f"Searching with filters: {filters}")  # Helps catch typos
   ```

3. **Clean up temporary sessions**
   ```python  theme={null}
   # After a support ticket closes
   client.delete_all(user_id="customer_123", run_id="ticket_456")
   ```

## Summary

You learned how to:

* Store memories with proper entity scoping using `user_id`, `agent_id`, `app_id`, and `run_id`
* Prevent memory leaks between different agents and applications
* Clean up data for specific tenants or sessions
* Use wildcards to query across scoped memories

## Next Steps

<CardGroup cols={2}>
  <Card title="Deep Dive: Memory Filters v2" description="Layer entity filters with JSON logic to answer complex queries." icon="sliders" href="/platform/features/v2-memory-filters" />

  <Card title="Control Memory Ingestion" description="Pair scoped storage with rules that block low-quality facts." icon="shield-check" href="/cookbooks/essentials/controlling-memory-ingestion" />
</CardGroup>


# Export Stored Memories
Source: https://docs.mem0.ai/cookbooks/essentials/exporting-memories

Retrieve, review, and migrate user memories with structured exports.

Mem0 is a dynamic memory store that gives you full control over your data. Along with storing memories, it gives you the ability to retrieve, export, and migrate your data whenever you need.

This cookbook shows you how to retrieve and export your data for inspection, migration, or compliance.

***

## Setup

```python  theme={null}
from mem0 import MemoryClient

client = MemoryClient(api_key="your-api-key")

```

<Note>
  Your API key needs export permissions to download memory data. Check your project settings on the [dashboard](https://app.mem0.ai) if export operations fail with authentication errors.
</Note>

Let's add some sample memories to work with:

```python  theme={null}
# Dev's work history
client.add(
    "Dev works at TechCorp as a senior engineer",
    user_id="dev",
    metadata={"type": "professional"}
)

# Arjun's preferences
client.add(
    "Arjun prefers morning meetings and async communication",
    user_id="arjun",
    metadata={"type": "preference"}
)

# Carl's project notes
client.add(
    "Carl is leading the API redesign project, targeting Q2 launch",
    user_id="carl",
    metadata={"type": "project"}
)

```

***

## Getting All Memories

Use `get_all()` with filters to retrieve everything for a specific user:

```python  theme={null}
dev_memories = client.get_all(
    filters={"user_id": "dev"},
    page_size=50
)

print(f"Total memories: {dev_memories['count']}")
print(f"First memory: {dev_memories['results'][0]['memory']}")

```

**Output:**

```
Total memories: 1
First memory: Dev works at TechCorp as a senior engineer

```

<Info>
  **Expected output:** `get_all()` retrieved Dev's complete memory record. This method returns everything matching your filters—no semantic search, no ranking, just raw retrieval. Perfect for exports and audits.
</Info>

You can filter by metadata to get specific types:

```python  theme={null}
carl_projects = client.get_all(
    filters={
        "AND": [
            {"user_id": "carl"},
            {"metadata": {"type": "project"}}
        ]
    }
)

for memory in carl_projects['results']:
    print(memory['memory'])

```

**Output:**

```
Carl is leading the API redesign project, targeting Q2 launch

```

***

## Searching Memories

When you need semantic search instead of retrieving everything, use `search()`:

```python  theme={null}
results = client.search(
    query="What does Dev do for work?",
    filters={"user_id": "dev"},
    top_k=5
)

for result in results['results']:
    print(f"{result['memory']} (score: {result['score']:.2f})")

```

**Output:**

```
Dev works at TechCorp as a senior engineer (score: 0.89)

```

Search works across all memory fields and ranks by relevance. Use it when you have a specific question, use `get_all()` when you need everything.

***

## Exporting to Structured Format

For migrations or compliance, you can export memories into a structured schema using Pydantic-style JSON schemas.

### Step 1: Define the schema

```python  theme={null}
professional_profile_schema = {
    "properties": {
        "full_name": {
            "type": "string",
            "description": "The person's full name"
        },
        "current_role": {
            "type": "string",
            "description": "Current job title or role"
        },
        "company": {
            "type": "string",
            "description": "Current employer"
        }
    },
    "title": "ProfessionalProfile",
    "type": "object"
}

```

### Step 2: Create export job

```python  theme={null}
export_job = client.create_memory_export(
    schema=professional_profile_schema,
    filters={"user_id": "dev"}
)

print(f"Export ID: {export_job['id']}")
print(f"Status: {export_job['status']}")

```

**Output:**

```
Export ID: exp_abc123
Status: processing

```

<Info>
  **Export initiated:** Status is "processing". Large exports may take a few seconds. Poll with `get_memory_export()` until status changes to "completed" before downloading data.
</Info>

### Step 3: Download the export

```python  theme={null}
# Get by ID
export_data = client.get_memory_export(
    memory_export_id=export_job['id']
)

print(export_data['data'])

```

**Output:**

```json  theme={null}
{
  "full_name": "Dev",
  "current_role": "senior engineer",
  "company": "TechCorp"
}

```

You can also retrieve exports by filters:

```python  theme={null}
# Get latest export matching filters
export_by_filters = client.get_memory_export(
    filters={"user_id": "dev"}
)

print(export_by_filters['data'])

```

***

## Adding Export Instructions

Guide how Mem0 resolves conflicts or formats the export:

```python  theme={null}
export_with_instructions = client.create_memory_export(
    schema=professional_profile_schema,
    filters={"user_id": "arjun"},
    export_instructions="""
1. Use the most recent information if there are conflicts
2. Only include confirmed facts, not speculation
3. Return null for missing fields rather than guessing
"""
)

```

<Tip>
  Always check export status before downloading. Call `get_memory_export()` in a loop with a short delay until `status == "completed"`. Attempting to download while still processing returns incomplete data.
</Tip>

***

## Platform Export

You can also export memories directly from the Mem0 platform UI:

1. Navigate to **Memory Exports** in your project dashboard
2. Click **Create Export**
3. Select your filters and schema
4. Download the completed export as JSON

This is useful for one-off exports or manual data reviews.

<Warning>
  Exported data expires after 7 days. Download and store exports locally if you need long-term archives. After expiration, you'll need to recreate the export job.
</Warning>

***

## What You Built

A complete memory export system with multiple retrieval methods:

* **Bulk retrieval (get\_all)** - Fetch all memories matching filters for comprehensive audits
* **Semantic search** - Query-based lookups with relevance scoring
* **Structured exports** - Pydantic-schema exports for migrations and compliance
* **Export instructions** - Guide conflict resolution and data formatting
* **Platform UI exports** - One-off manual downloads via dashboard

This covers data portability, GDPR compliance, system migrations, and manual reviews.

***

## Summary

Use **`get_all()`** for bulk retrieval, **`search()`** for specific questions, and **`create_memory_export()`** for structured data exports with custom schemas. Remember exports expire after 7 days—download them locally for long-term archives.

<CardGroup cols={2}>
  <Card title="Expire Short-Term Data" icon="timer" href="/cookbooks/essentials/memory-expiration-short-and-long-term">
    Keep exports lean by clearing session context before you archive it.
  </Card>

  <Card title="Control Memory Ingestion" icon="filter" href="/cookbooks/essentials/controlling-memory-ingestion">
    Ensure only verified insights make it into your export pipeline.
  </Card>
</CardGroup>


# Set Memory Expiration
Source: https://docs.mem0.ai/cookbooks/essentials/memory-expiration-short-and-long-term

Define short-term versus long-term retention so the store stays fresh.

While building memory systems, we realized their size grows fast. Session notes, temporary context, chat history - everything starts accumulating and bogging down the system. This pollutes search results and increase storage costs. Not every memory needs to persist forever.

In this cookbook, we'll go through how to use short-term vs long-term memories and see where it's best to use them.

***

## Overview

By default, Mem0 memories persist forever. This works for user preferences and core facts, but temporary data should expire automatically.

In this tutorial, we will:

* Understand default (permanent) memory behavior
* Add expiration dates for temporary memories
* Decide what should be temporary vs permanent

***

## Setup

```python  theme={null}
from mem0 import MemoryClient
from datetime import datetime, timedelta

client = MemoryClient(api_key="your-api-key")
```

<Note>
  Import `datetime` and `timedelta` to calculate expiration dates. Without these imports, you'll need to manually format ISO timestamps—error-prone and harder to read.
</Note>

***

## Default Behavior: Everything Persists

By default, all memories persist forever:

```python  theme={null}
# Store user preference
client.add("User prefers dark mode", user_id="sarah")

# Store session context
client.add("Currently browsing electronics category", user_id="sarah")

# 6 months later - both still exist
results = client.get_all(filters={"user_id": "sarah"})
print(f"Total memories: {len(results['results'])}")

```

**Output:**

```
Total memories: 2

```

Both the preference and session context persist. The preference is useful, but the 6-month-old session context is not.

***

## The Problem: Memory Bloat

Without expiration, memories accumulate forever. Session notes from weeks ago mix with current preferences. Storage grows, search results get polluted with irrelevant old context, and retrieval quality degrades.

<Warning>
  Memory bloat degrades search quality. When "User prefers dark mode" competes with "Currently browsing electronics" from 6 months ago, semantic search returns stale session data instead of actual preferences. Old memories pollute retrieval.
</Warning>

***

## Short-Term Memories: Adding Expiration

Set `expiration_date` to make memories temporary:

```python  theme={null}
from datetime import datetime, timedelta

# Session context - expires in 7 days
expires_at = (datetime.now() + timedelta(days=7)).isoformat()

client.add(
    "Currently browsing electronics category",
    user_id="sarah",
    expiration_date=expires_at
)

# User preference - no expiration, persists forever
client.add(
    "User prefers dark mode",
    user_id="sarah"
)

```

<Info icon="check">
  **Expected behavior:** After 7 days, the session context automatically disappears—no cron jobs, no manual cleanup. The preference persists forever. Mem0 handles expiration transparently.
</Info>

Memories with `expiration_date` are automatically removed after expiring. No cleanup job needed - Mem0 handles it.

<Tip>
  Start conservative with short expiration windows (7 days), then extend them based on usage patterns. It's easier to increase retention than to clean up over-retained stale data. Monitor search quality to find the right balance.
</Tip>

***

## When to Use Each

### Permanent Memories (no expiration\_date):

**Use for:**

* User preferences and settings
* Account information
* Important facts and milestones
* Historical data that matters long-term

```python  theme={null}
client.add("User prefers email notifications", user_id="sarah")
client.add("User's birthday is March 15th", user_id="sarah")
client.add("User completed onboarding on Jan 5th", user_id="sarah")

```

### Temporary Memories (with expiration\_date):

**Use for:**

* Session context (current page, browsing history)
* Temporary reminders
* Recent chat history
* Cached data

```python  theme={null}
expires_7d = (datetime.now() + timedelta(days=7)).isoformat()

client.add(
    "Currently viewing product ABC123",
    user_id="sarah",
    expiration_date=expires_7d
)

client.add(
    "Asked about return policy",
    user_id="sarah",
    expiration_date=expires_7d
)

```

***

## Setting Different Expiration Periods

Different data needs different lifetimes:

```python  theme={null}
# Session context - 7 days
expires_7d = (datetime.now() + timedelta(days=7)).isoformat()
client.add("Browsing electronics", user_id="sarah", expiration_date=expires_7d)

# Recent chat - 30 days
expires_30d = (datetime.now() + timedelta(days=30)).isoformat()
client.add("User asked about warranty", user_id="sarah", expiration_date=expires_30d)

# Important preference - no expiration
client.add("User prefers dark mode", user_id="sarah")

```

***

## Using Metadata to Track Memory Types

Tag memories to make filtering easier:

```python  theme={null}
expires_7d = (datetime.now() + timedelta(days=7)).isoformat()

# Tag session context
client.add(
    "Browsing electronics",
    user_id="sarah",
    expiration_date=expires_7d,
    metadata={"type": "session"}
)

# Tag preference
client.add(
    "User prefers dark mode",
    user_id="sarah",
    metadata={"type": "preference"}
)

# Query only preferences
preferences = client.get_all(
    filters={
        "AND": [
            {"user_id": "sarah"},
            {"metadata": {"type": "preference"}}
        ]
    }
)

```

***

## Checking Expiration Status

See which memories will expire and when:

```python  theme={null}
results = client.get_all(filters={"user_id": "sarah"})

for memory in results['results']:
    exp_date = memory.get('expiration_date')

    if exp_date:
        print(f"Temporary: {memory['memory']}")
        print(f"  Expires: {exp_date}\\n")
    else:
        print(f"Permanent: {memory['memory']}\\n")

```

**Output:**

```
Temporary: Browsing electronics
  Expires: 2025-11-01T10:30:00Z

Temporary: Viewed MacBook Pro and Dell XPS
  Expires: 2025-11-01T10:30:00Z

Permanent: User prefers dark mode

Permanent: User prefers email notifications

```

***

## What You Built

A self-cleaning memory system with automatic retention policies:

* **Automatic expiration** - Memories self-destruct after defined periods, no cron jobs needed
* **Tiered retention** - 7-day session context, 30-day chat history, permanent preferences
* **Metadata tagging** - Classify memories by type (session, preference, chat) for filtered retrieval
* **Expiration tracking** - Check which memories will expire and when using `get_all()`

This pattern keeps storage costs low and search quality high as your memory store scales.

***

## Summary

Memory expiration keeps storage clean and search results relevant. Use **`expiration_date`** for temporary data (session context, recent chats), skip it for permanent facts (preferences, account info). Mem0 handles cleanup automatically—no background jobs required.

Start by identifying what's temporary versus permanent, then set conservative expiration windows and adjust based on retrieval quality.

<CardGroup cols={2}>
  <Card title="Control Memory Ingestion" icon="filter" href="/cookbooks/essentials/controlling-memory-ingestion">
    Pair expirations with ingestion rules so only trusted context persists.
  </Card>

  <Card title="Export Memories Safely" icon="download" href="/cookbooks/essentials/exporting-memories">
    Build compliant archives once your retention windows are dialed in.
  </Card>
</CardGroup>


# Tag and Organize Memories
Source: https://docs.mem0.ai/cookbooks/essentials/tagging-and-organizing-memories

Let Mem0 auto-categorize support data so teams retrieve the right facts fast.

When you have large volumes of memory data, sorting it during post-processing becomes difficult. What if your memory store understood the importance of creating tags and buckets without a lot of effort?

Mem0 handles this for you by providing the flexibility to organize memories with custom categories. This cookbook shows you how to tag and organize memories for a customer support platform.

***

## Setup

```python  theme={null}
from mem0 import MemoryClient

client = MemoryClient(api_key="your-api-key")
```

<Note>
  Define custom categories at the **project level** with `client.project.update()` before adding memories. Categories apply to all future memories—Mem0 auto-assigns them based on content semantics.
</Note>

***

## The Problem

Without categories, all memories sit in one undifferentiated bucket. Support agents waste time searching through everything to find billing issues, account details, or past tickets.

Let's see what happens without organization:

```python  theme={null}
# Joseph (support agent) stores various customer interactions
client.add(
    "Maria called about her account password reset",
    user_id="maria",
)

client.add(
    "Maria was charged twice for last month's subscription",
    user_id="maria",
)

client.add(
    "Maria wants to upgrade to the premium plan",
    user_id="maria",
)

# Now try to find just billing issues
all_memories = client.get_all(filters={"user_id": "maria"})
print(f"Total memories: {len(all_memories['results'])}")

for memory in all_memories['results']:
    print(f"- {memory['memory']}")

```

**Output:**

```
Total memories: 3
- Maria called about her account password reset
- Maria was charged twice for last month's subscription
- Maria wants to upgrade to the premium plan

```

<Warning>
  Without categories, agents waste time reading through everything. For a customer with 100 memories, finding one billing issue means scanning all 100. Categories let you filter to exactly what you need—billing issues only, no password resets or feedback mixed in.
</Warning>

Everything is mixed together. Support agents have to read through all memories to find what they need.

***

## Custom Categories

Define categories that match how your support team thinks about customer issues:

```python  theme={null}
custom_categories = [
    {"support_tickets": "Customer issues and resolutions"},
    {"account_info": "Account details and preferences"},
    {"billing": "Payment history and billing questions"},
    {"product_feedback": "Feature requests and feedback"},
]

client.project.update(custom_categories=custom_categories)

```

<Tip>
  Start with 3-5 clear categories that match how your team thinks. Too many categories dilute auto-tagging accuracy. Add more later if needed—it's easier to expand than to fix over-complicated classification.
</Tip>

These categories are now available project-wide. Every memory can be tagged with one or more categories.

***

## Tagging Memories

Once categories are defined at the project level, Mem0 automatically assigns them based on content:

```python  theme={null}
# Billing issue - automatically tagged as "billing"
client.add(
    "Maria was charged twice for last month's subscription",
    user_id="maria",
    metadata={"priority": "high", "source": "phone_call"}
)

# Account update - automatically tagged as "account_info"
client.add(
    "Maria changed her email to maria.new@example.com",
    user_id="maria",
    metadata={"source": "web_portal"}
)

# Product feedback - automatically tagged as "product_feedback"
client.add(
    "Maria requested a dark mode feature for the dashboard",
    user_id="maria",
    metadata={"source": "chat"}
)

```

Mem0 reads the content and intelligently assigns the appropriate categories. You don't manually tag - the platform does it for you based on the category definitions.

***

## Retrieving by Category

Filter memories by category to find exactly what you need:

```python  theme={null}
# Joseph needs to pull all billing issues for audit
billing_issues = client.get_all(
    filters={
        "AND": [
            {"user_id": "maria"},
            {"categories": {"in": ["billing"]}}
        ]
    }
)

print("Billing issues:")
for memory in billing_issues['results']:
    print(f"- {memory['memory']}")

```

**Output:**

```
Billing issues:
- Maria was charged twice for last month's subscription

```

<Info icon="check">
  **Expected output:** Only the billing issue returned—no password reset, no upgrade request. Category filtering worked. Joseph can audit billing without reading through unrelated support tickets.
</Info>

Only billing-related memories are returned. No need to filter through account updates or feedback.

You can also retrieve multiple categories:

```python  theme={null}
# Get both account info and billing
account_and_billing = client.get_all(
    filters={
        "AND": [
            {"user_id": "maria"},
            {"categories": {"in": ["account_info", "billing"]}}
        ]
    }
)

for memory in account_and_billing['results']:
    print(f"[{memory['categories'][0]}] {memory['memory']}")

```

**Output:**

```
[account_info] Maria changed her email to maria.new@example.com
[billing] Maria was charged twice for last month's subscription

```

***

## Updating Categories

Categories are automatically assigned based on content. To trigger re-categorization, update the memory content:

```python  theme={null}
# Find memories that need re-categorization
needs_update = client.get_all(
    filters={
        "AND": [
            {"user_id": "maria"},
            {"categories": {"in": ["misc"]}}
        ]
    }
)

# Update memory content to trigger re-categorization
for memory in needs_update['results']:
    client.update(
        memory_id=memory['id'],
        data=memory['memory']  # Re-process with current category definitions
    )

```

When you update a memory, Mem0 re-analyzes it against your current category definitions. This is useful when you introduce new categories or refine category descriptions.

***

## What You Built

A customer support platform with intelligent memory organization:

* **Project-wide categories** - Support tickets, billing, account info, and product feedback auto-classified
* **Automatic tagging** - Mem0 assigns categories based on content semantics, no manual tagging
* **Filtered retrieval** - Pull only billing issues or only account updates using `categories: {in: [...]}`
* **Re-categorization** - Update memory content to trigger re-analysis against new category definitions
* **Multi-category support** - Memories can belong to multiple categories when appropriate

This pattern scales from 10 customers to 10,000 without degrading retrieval speed.

***

## Summary

Categories make retrieval faster and compliance easier. Define 3-5 clear categories with `client.project.update()`, let Mem0 auto-assign them based on content, then filter with `categories: {in: [...]}` to pull exactly what you need.

Instead of searching through everything, agents jump directly to the information type they need—billing issues, account details, or support tickets.

<CardGroup cols={2}>
  <Card title="Control Memory Ingestion" icon="filter" href="/cookbooks/essentials/controlling-memory-ingestion">
    Keep categories meaningful by filtering noise before it lands in storage.
  </Card>

  <Card title="Export Tagged Memories" icon="download" href="/cookbooks/essentials/exporting-memories">
    Use categories to drive audits, migrations, and compliance reports.
  </Card>
</CardGroup>


# Browser Extension Memory
Source: https://docs.mem0.ai/cookbooks/frameworks/chrome-extension

Add Mem0's universal memory layer to Chrome chat surfaces.

Enhance your AI interactions with Mem0, a Chrome extension that introduces a universal memory layer across platforms like ChatGPT, Claude, and Perplexity. Mem0 ensures seamless context sharing, making your AI experiences more personalized and efficient.

<Note>
  We now support Grok! The Mem0 Chrome Extension has been updated to work with Grok, bringing the same powerful memory capabilities to your Grok conversations.
</Note>

## Features

* **Universal Memory Layer**: Share context seamlessly across ChatGPT, Claude, Perplexity, and Grok.
* **Smart Context Detection**: Automatically captures relevant information from your conversations.
* **Intelligent Memory Retrieval**: Surfaces pertinent memories at the right time.
* **One-Click Sync**: Easily synchronize with existing ChatGPT memories.
* **Memory Dashboard**: Manage all your memories in one centralized location.

## Installation

You can install the Mem0 Chrome Extension using one of the following methods:

### Method 1: Chrome Web Store Installation

1. **Download the Extension**: Open Google Chrome and navigate to the [Mem0 Chrome Extension page](https://chromewebstore.google.com/detail/mem0/onihkkbipkfeijkadecaafbgagkhglop?hl=en).
2. **Add to Chrome**: Click on the "Add to Chrome" button.
3. **Confirm Installation**: In the pop-up dialog, click "Add extension" to confirm. The Mem0 icon should now appear in your Chrome toolbar.

### Method 2: Manual Installation

1. **Download the Extension**: Clone or download the extension files from the [Mem0 Chrome Extension GitHub repository](https://github.com/mem0ai/mem0-chrome-extension).
2. **Access Chrome Extensions**: Open Google Chrome and navigate to `chrome://extensions`.
3. **Enable Developer Mode**: Toggle the "Developer mode" switch in the top right corner.
4. **Load Unpacked Extension**: Click "Load unpacked" and select the directory containing the extension files.
5. **Confirm Installation**: The Mem0 Chrome Extension should now appear in your Chrome toolbar.

## Usage

1. **Locate the Mem0 Icon**: After installation, find the Mem0 icon in your Chrome toolbar.
2. **Sign In**: Click the icon and sign in with your Google account.
3. **Interact with AI Assistants**:
   * **ChatGPT and Perplexity**: Continue your conversations as usual; Mem0 operates seamlessly in the background.
   * **Claude**: Click the Mem0 button or use the shortcut `Ctrl + M` to activate memory functions.

## Configuration

* **API Key**: Obtain your API key from the Mem0 Dashboard to connect the extension to the Mem0 API.
* **User ID**: This is your unique identifier in the Mem0 system. If not provided, it defaults to `chrome-extension-user`.

## Demo Video

<iframe width="700" height="400" src="https://www.youtube.com/embed/dqenCMMlfwQ?si=zhGVrkq6IS_0Jwyj" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen />

## Privacy and Data Security

Your messages are sent to the Mem0 API for extracting and retrieving memories. Mem0 is committed to ensuring your data's privacy and security.

***

<CardGroup cols={2}>
  <Card title="Build a Mem0 Companion" icon="users" href="/cookbooks/essentials/building-ai-companion">
    Learn the foundations of memory-powered assistants that work across platforms.
  </Card>

  <Card title="Multimodal Support" icon="image" href="/platform/features/multimodal-support">
    Extend your browser interactions with vision and audio memory.
  </Card>
</CardGroup>


# Persistent Eliza Characters
Source: https://docs.mem0.ai/cookbooks/frameworks/eliza-os-character

Bring persistent personality to Eliza OS agents using Mem0.

You can create a personalized Eliza OS Character using Mem0. This guide will walk you through the necessary steps and provide the complete code to get you started.

## Overview

ElizaOS is a powerful AI agent framework for autonomy and personality. It is a collection of tools that help you create a personalized AI agent.

## Setup

You can start by cloning the eliza-os repository:

```bash  theme={null}
git clone https://github.com/elizaOS/eliza.git
```

Change the directory to the eliza-os repository:

```bash  theme={null}
cd eliza
```

Install the dependencies:

```bash  theme={null}
pnpm install
```

Build the project:

```bash  theme={null}
pnpm build
```

## Setup ENVs

Create a `.env` file in the root of the project and add the following (you can use the `.env.example` file as a reference):

```bash  theme={null}
# Mem0 Configuration
MEM0_API_KEY= # Mem0 API Key (get from https://app.mem0.ai/dashboard/api-keys)
MEM0_USER_ID= # Default: eliza-os-user
MEM0_PROVIDER= # Default: openai
MEM0_PROVIDER_API_KEY= # API Key for the provider (OpenAI, Anthropic, etc.)
SMALL_MEM0_MODEL= # Default: gpt-4.1-nano
MEDIUM_MEM0_MODEL= # Default: gpt-4o
LARGE_MEM0_MODEL= # Default: gpt-4o
```

## Make the default character use Mem0

By default, there is a character called `eliza` that uses the Ollama model. You can make this character use Mem0 by changing the config in the `agent/src/defaultCharacter.ts` file.

```ts  theme={null}
modelProvider: ModelProviderName.MEM0,
```

This will make the character use Mem0 to generate responses.

## Run the project

```bash  theme={null}
pnpm start
```

## Conclusion

You have now created a personalized Eliza OS Character using Mem0. You can now start interacting with the character by running the project and talking to the character.

This is a simple example of how to use Mem0 to create a personalized AI agent. You can use this as a starting point to create your own AI agent.

***

<CardGroup cols={2}>
  <Card title="Partition Memories by Entity" icon="layers" href="/cookbooks/essentials/entity-partitioning-playbook">
    Keep character personas isolated by tagging user, agent, and session identifiers.
  </Card>

  <Card title="AI Tutor with Mem0" icon="graduation-cap" href="/cookbooks/companions/ai-tutor">
    Build another type of personalized companion with memory capabilities.
  </Card>
</CardGroup>


# Multi-Agent Collaboration
Source: https://docs.mem0.ai/cookbooks/frameworks/llamaindex-multiagent

Share a persistent memory layer across collaborating LlamaIndex agents.

<Snippet file="blank-notif.mdx" />

Build an intelligent multi-agent learning system that uses Mem0 to maintain persistent memory across multiple specialized agents. This example demonstrates how to create a tutoring system where different agents collaborate while sharing a unified memory layer.

## Overview

This example showcases a **Multi-Agent Personal Learning System** that combines:

* **LlamaIndex AgentWorkflow** for multi-agent orchestration
* **Mem0** for persistent, shared memory across agents
* **Multiple agents** that collaborate on teaching tasks

The system consists of two agents:

* **TutorAgent**: Primary instructor for explanations and concept teaching
* **PracticeAgent**: Generates exercises and tracks learning progress

Both agents share the same memory context, enabling seamless collaboration and continuous learning from student interactions.

## Key Features

* **Persistent Memory**: Agents remember previous interactions across sessions
* **Multi-Agent Collaboration**: Agents can hand off tasks to each other
* **Personalized Learning**: Adapts to individual student needs and learning styles
* **Progress Tracking**: Monitors learning patterns and skill development
* **Memory-Driven Teaching**: References past struggles and successes

## Prerequisites

Install the required packages:

```bash  theme={null}
pip install llama-index-core llama-index-memory-mem0 openai python-dotenv
```

Set up your environment variables:

* `MEM0_API_KEY`: Your Mem0 Platform API key
* `OPENAI_API_KEY`: Your OpenAI API key

You can obtain your Mem0 Platform API key from the [Mem0 Platform](https://app.mem0.ai).

## Complete Implementation

```python  theme={null}
"""
Multi-Agent Personal Learning System: Mem0 + LlamaIndex AgentWorkflow Example

INSTALLATIONS:
!pip install llama-index-core llama-index-memory-mem0 openai

You need MEM0_API_KEY and OPENAI_API_KEY to run the example.
"""

import asyncio
from datetime import datetime
from dotenv import load_dotenv

# LlamaIndex imports
from llama_index.core.agent.workflow import AgentWorkflow, FunctionAgent
from llama_index.llms.openai import OpenAI
from llama_index.core.tools import FunctionTool

# Memory integration
from llama_index.memory.mem0 import Mem0Memory

import warnings
warnings.filterwarnings("ignore", category=DeprecationWarning)

load_dotenv()


class MultiAgentLearningSystem:
    """
    Multi-Agent Architecture:
    - TutorAgent: Main teaching and explanations
    - PracticeAgent: Exercises and skill reinforcement
    - Shared Memory: Both agents learn from student interactions
    """

    def __init__(self, student_id: str):
        self.student_id = student_id
        self.llm = OpenAI(model="gpt-4.1-nano-2025-04-14", temperature=0.2)

        # Memory context for this student
        self.memory_context = {"user_id": student_id, "app": "learning_assistant"}
        self.memory = Mem0Memory.from_client(
            context=self.memory_context
        )

        self._setup_agents()

    def _setup_agents(self):
        """Setup two agents that work together and share memory"""

        # TOOLS
        async def assess_understanding(topic: str, student_response: str) -> str:
            """Assess student's understanding of a topic and save insights"""
            # Simulate assessment logic
            if "confused" in student_response.lower() or "don't understand" in student_response.lower():
                assessment = f"STRUGGLING with {topic}: {student_response}"
                insight = f"Student needs more help with {topic}. Prefers step-by-step explanations."
            elif "makes sense" in student_response.lower() or "got it" in student_response.lower():
                assessment = f"UNDERSTANDS {topic}: {student_response}"
                insight = f"Student grasped {topic} quickly. Can move to advanced concepts."
            else:
                assessment = f"PARTIAL understanding of {topic}: {student_response}"
                insight = f"Student has basic understanding of {topic}. Needs reinforcement."

            return f"Assessment: {assessment}\nInsight saved: {insight}"

        async def track_progress(topic: str, success_rate: str) -> str:
            """Track learning progress and identify patterns"""
            progress_note = f"Progress on {topic}: {success_rate} - {datetime.now().strftime('%Y-%m-%d')}"
            return f"Progress tracked: {progress_note}"

        # Convert to FunctionTools
        tools = [
            FunctionTool.from_defaults(async_fn=assess_understanding),
            FunctionTool.from_defaults(async_fn=track_progress)
        ]

        # AGENTS
        # Tutor Agent - Main teaching and explanation
        self.tutor_agent = FunctionAgent(
            name="TutorAgent",
            description="Primary instructor that explains concepts and adapts to student needs",
            system_prompt="""
            You are a patient, adaptive programming tutor. Your key strength is REMEMBERING and BUILDING on previous interactions.

            Key Behaviors:
            1. Always check what the student has learned before (use memory context)
            2. Adapt explanations based on their preferred learning style
            3. Reference previous struggles or successes
            4. Build progressively on past lessons
            5. Use assess_understanding to evaluate responses and save insights

            MEMORY-DRIVEN TEACHING:
            - "Last time you struggled with X, so let's approach Y differently..."
            - "Since you prefer visual examples, here's a diagram..."
            - "Building on the functions we covered yesterday..."

            When student shows understanding, hand off to PracticeAgent for exercises.
            """,
            tools=tools,
            llm=self.llm,
            can_handoff_to=["PracticeAgent"]
        )

        # Practice Agent - Exercises and reinforcement
        self.practice_agent = FunctionAgent(
            name="PracticeAgent",
            description="Creates practice exercises and tracks progress based on student's learning history",
            system_prompt="""
            You create personalized practice exercises based on the student's learning history and current level.

            Key Behaviors:
            1. Generate problems that match their skill level (from memory)
            2. Focus on areas they've struggled with previously
            3. Gradually increase difficulty based on their progress
            4. Use track_progress to record their performance
            5. Provide encouraging feedback that references their growth

            MEMORY-DRIVEN PRACTICE:
            - "Let's practice loops again since you wanted more examples..."
            - "Here's a harder version of the problem you solved yesterday..."
            - "You've improved a lot in functions, ready for the next level?"

            After practice, can hand back to TutorAgent for concept review if needed.
            """,
            tools=tools,
            llm=self.llm,
            can_handoff_to=["TutorAgent"]
        )

        # Create the multi-agent workflow
        self.workflow = AgentWorkflow(
            agents=[self.tutor_agent, self.practice_agent],
            root_agent=self.tutor_agent.name,
            initial_state={
                "current_topic": "",
                "student_level": "beginner",
                "learning_style": "unknown",
                "session_goals": []
            }
        )

    async def start_learning_session(self, topic: str, student_message: str = "") -> str:
        """
        Start a learning session with multi-agent memory-aware teaching
        """

        if student_message:
            request = f"I want to learn about {topic}. {student_message}"
        else:
            request = f"I want to learn about {topic}."

        # The magic happens here - multi-agent memory is automatically shared!
        response = await self.workflow.run(
            user_msg=request,
            memory=self.memory
        )

        return str(response)

    async def get_learning_history(self) -> str:
        """Show what the system remembers about this student"""
        try:
            # Search memory for learning patterns
            memories = self.memory.search(
                user_id=self.student_id,
                query="learning machine learning"
            )

            if memories and memories.get('results'):
                history = "\n".join(f"- {m['memory']}" for m in memories['results'])
                return history
            else:
                return "No learning history found yet. Let's start building your profile!"

        except Exception as e:
            return f"Memory retrieval error: {str(e)}"


async def run_learning_agent():

    learning_system = MultiAgentLearningSystem(student_id="Alexander")

    # First session
    print("Session 1:")
    response = await learning_system.start_learning_session(
        "Vision Language Models",
        "I'm new to machine learning but I have good hold on Python and have 4 years of work experience.")
    print(response)

    # Second session - multi-agent memory will remember the first
    print("\nSession 2:")
    response2 = await learning_system.start_learning_session(
        "Machine Learning", "what all did I cover so far?")
    print(response2)

    # Show what the multi-agent system remembers
    print("\nLearning History:")
    history = await learning_system.get_learning_history()
    print(history)


if __name__ == "__main__":
    """Run the example"""
    print("Multi-agent Learning System powered by LlamaIndex and Mem0")

    async def main():
        await run_learning_agent()

    asyncio.run(main())
```

## How It Works

### 1. Memory Context Setup

```python  theme={null}
# Memory context for this student
self.memory_context = {"user_id": student_id, "app": "learning_assistant"}
self.memory = Mem0Memory.from_client(context=self.memory_context)
```

The memory context identifies the specific student and application, ensuring memory isolation and proper retrieval.

### 2. Agent Collaboration

```python  theme={null}
# Agents can hand off to each other
can_handoff_to=["PracticeAgent"]  # TutorAgent can hand off to PracticeAgent
can_handoff_to=["TutorAgent"]     # PracticeAgent can hand off back
```

Agents collaborate seamlessly, with the TutorAgent handling explanations and the PracticeAgent managing exercises.

### 3. Shared Memory

```python  theme={null}
# Both agents share the same memory instance
response = await self.workflow.run(
    user_msg=request,
    memory=self.memory  # Shared across all agents
)
```

All agents in the workflow share the same memory context, enabling true collaborative learning.

### 4. Memory-Driven Interactions

The system prompts guide agents to:

* Reference previous learning sessions
* Adapt to discovered learning styles
* Build progressively on past lessons
* Track and respond to learning patterns

## Running the Example

```python  theme={null}
# Initialize the learning system
learning_system = MultiAgentLearningSystem(student_id="Alexander")

# Start a learning session
response = await learning_system.start_learning_session(
    "Vision Language Models",
    "I'm new to machine learning but I have good hold on Python and have 4 years of work experience."
)

# Continue learning in a new session (memory persists)
response2 = await learning_system.start_learning_session(
    "Machine Learning",
    "what all did I cover so far?"
)

# Check learning history
history = await learning_system.get_learning_history()
```

## Expected Output

The system will demonstrate memory-aware interactions:

```
Session 1:
I understand you want to learn about Vision Language Models and you mentioned you're new to machine learning but have a strong Python background with 4 years of experience. That's a great foundation to build on!

Let me start with an explanation tailored to your programming background...
[Agent provides explanation and may hand off to PracticeAgent for exercises]

Session 2:
Based on our previous session, I remember we covered Vision Language Models and I noted that you have a strong Python background with 4 years of experience. You mentioned being new to machine learning, so we started with foundational concepts...
[Agent references previous session and builds upon it]
```

## Key Benefits

1. **Persistent Learning**: Agents remember across sessions, creating continuity
2. **Collaborative Teaching**: Multiple specialized agents work together seamlessly
3. **Personalized Adaptation**: System learns and adapts to individual learning styles
4. **Scalable Architecture**: Easy to add more specialized agents
5. **Memory Efficiency**: Shared memory prevents duplication and ensures consistency

## Best Practices

1. **Clear Agent Roles**: Define specific responsibilities for each agent
2. **Memory Context**: Use descriptive context for memory isolation
3. **Handoff Strategy**: Design clear handoff criteria between agents
4. **Memory Hygiene**: Regularly review and clean memory for optimal performance

## Help & Resources

* [LlamaIndex Agent Workflows](https://docs.llamaindex.ai/en/stable/use_cases/agents/)
* [Mem0 Platform](https://app.mem0.ai/)

***

<CardGroup cols={2}>
  <Card title="LlamaIndex ReAct with Mem0" icon="brain" href="/cookbooks/frameworks/llamaindex-react">
    Start with single-agent patterns before scaling to multi-agent systems.
  </Card>

  <Card title="Partition Memories by Entity" icon="layers" href="/cookbooks/essentials/entity-partitioning-playbook">
    Learn how to scope memories across multiple agents, users, and sessions.
  </Card>
</CardGroup>


# ReAct Agents with Memory
Source: https://docs.mem0.ai/cookbooks/frameworks/llamaindex-react

Teach a ReAct agent to store and recall context via Mem0.

Create a ReAct Agent with LlamaIndex which uses Mem0 as the memory store.

## Overview

A ReAct agent combines reasoning and action capabilities, making it versatile for tasks requiring both thought processes (reasoning) and interaction with tools or APIs (acting). Mem0 as memory enhances these capabilities by allowing the agent to store and retrieve contextual information from past interactions.

## Setup

```bash  theme={null}
pip install llama-index-core llama-index-memory-mem0
```

Initialize the LLM.

```python  theme={null}
import os
from llama_index.llms.openai import OpenAI

os.environ["OPENAI_API_KEY"] = "<your-openai-api-key>"
llm = OpenAI(model="gpt-4.1-nano-2025-04-14")
```

Initialize the Mem0 client. You can find your API key [here](https://app.mem0.ai/dashboard/api-keys). Read about Mem0 [Open Source](https://docs.mem0.ai/open-source/overview).

```python  theme={null}
os.environ["MEM0_API_KEY"] = "<your-mem0-api-key>"

from llama_index.memory.mem0 import Mem0Memory

context = {"user_id": "david"}
memory_from_client = Mem0Memory.from_client(
    context=context,
    api_key=os.environ["MEM0_API_KEY"],
    search_msg_limit=4,  # optional, default is 5
)
```

Create the tools. These tools will be used by the agent to perform actions.

```python  theme={null}
from llama_index.core.tools import FunctionTool

def call_fn(name: str):
    """Call the provided name.
    Args:
        name: str (Name of the person)
    """
    return f"Calling... {name}"

def email_fn(name: str):
    """Email the provided name.
    Args:
        name: str (Name of the person)
    """
    return f"Emailing... {name}"

def order_food(name: str, dish: str):
    """Order food for the provided name.
    Args:
        name: str (Name of the person)
        dish: str (Name of the dish)
    """
    return f"Ordering {dish} for {name}"

call_tool = FunctionTool.from_defaults(fn=call_fn)
email_tool = FunctionTool.from_defaults(fn=email_fn)
order_food_tool = FunctionTool.from_defaults(fn=order_food)
```

Initialize the agent with tools and memory.

```python  theme={null}
from llama_index.core.agent import FunctionCallingAgent

agent = FunctionCallingAgent.from_tools(
    [call_tool, email_tool, order_food_tool],
    llm=llm,
    memory=memory_from_client,  # or memory_from_config
    verbose=True,
)
```

Start the chat.

<Note>The agent will use Mem0 to store the relevant memories from the chat.</Note>

**Input**

```python  theme={null}
response = agent.chat("Hi, My name is David")
print(response)
```

**Output**

```text  theme={null}
> Running step bf44a75a-a920-4cf3-944e-b6e6b5695043. Step input: Hi, My name is David
Added user message to memory: Hi, My name is David
=== LLM Response ===
Hello, David! How can I assist you today?
```

**Input**

```python  theme={null}
response = agent.chat("I love to eat pizza on weekends")
print(response)
```

**Output**

```text  theme={null}
> Running step 845783b0-b85b-487c-baee-8460ebe8b38d. Step input: I love to eat pizza on weekends
Added user message to memory: I love to eat pizza on weekends
=== LLM Response ===
Pizza is a great choice for the weekend! If you'd like, I can help you order some. Just let me know what kind of pizza you prefer!
```

**Input**

```python  theme={null}
response = agent.chat("My preferred way of communication is email")
print(response)
```

**Output**

```text  theme={null}
> Running step 345842f0-f8a0-42ea-a1b7-612265d72a92. Step input: My preferred way of communication is email
Added user message to memory: My preferred way of communication is email
=== LLM Response ===
Got it! If you need any assistance or have any requests, feel free to let me know, and I can communicate with you via email.
```

## Using the Agent Without Memory

**Input**

```python  theme={null}
agent = FunctionCallingAgent.from_tools(
    [call_tool, email_tool, order_food_tool],
    # memory is not provided
    llm=llm,
    verbose=True,
)
response = agent.chat("I am feeling hungry, order me something and send me the bill")
print(response)
```

**Output**

```text  theme={null}
> Running step e89eb75d-75e1-4dea-a8c8-5c3d4b77882d. Step input: I am feeling hungry, order me something and send me the bill
Added user message to memory: I am feeling hungry, order me something and send me the bill
=== LLM Response ===
Please let me know your name and the dish you'd like to order, and I'll take care of it for you!
```

<Note>The agent is not able to remember the past preferences the user shared in previous chats.</Note>

## Using the Agent With Memory

**Input**

```python  theme={null}
agent = FunctionCallingAgent.from_tools(
    [call_tool, email_tool, order_food_tool],
    llm=llm,
    # memory is provided
    memory=memory_from_client,  # or memory_from_config
    verbose=True,
)
response = agent.chat("I am feeling hungry, order me something and send me the bill")
print(response)
```

Output

```text  theme={null}
> Running step 5e473db9-3973-4cb1-a5fd-860be0ab0006. Step input: I am feeling hungry, order me something and send me the bill
Added user message to memory: I am feeling hungry, order me something and send me the bill
=== Calling Function ===
Calling function: order_food with args: {"name": "David", "dish": "pizza"}
=== Function Output ===
Ordering pizza for David
=== Calling Function ===
Calling function: email_fn with args: {"name": "David"}
=== Function Output ===
Emailing... David
> Running step 38080544-6b37-4bb2-aab2-7670100d926e. Step input: None
=== LLM Response ===
I've ordered a pizza for you, and the bill has been sent to your email. Enjoy your meal! If there's anything else you need, feel free to let me know.
```

<Note>The agent is able to remember the past preferences the user shared and use them to perform actions.</Note>

***

<CardGroup cols={2}>
  <Card title="LlamaIndex Multiagent with Mem0" icon="users" href="/cookbooks/frameworks/llamaindex-multiagent">
    Scale to multi-agent workflows with shared memory coordination.
  </Card>

  <Card title="Build a Mem0 Companion" icon="users" href="/cookbooks/essentials/building-ai-companion">
    Master the core patterns for memory-powered agents across frameworks.
  </Card>
</CardGroup>


# Visual Memory Retrieval
Source: https://docs.mem0.ai/cookbooks/frameworks/multimodal-retrieval

Store and recall visual context alongside text conversations.

Enhance your AI interactions with Mem0's multimodal capabilities. Mem0 now supports image understanding, allowing for richer context and more natural interactions across supported AI platforms.

> Experience the power of multimodal AI! Test out Mem0's image understanding capabilities at [multimodal-demo.mem0.ai](https://multimodal-demo.mem0.ai)

## Features

* **Image Understanding**: Share and discuss images with AI assistants while maintaining context
* **Smart Visual Context**: Automatically capture and reference visual elements in conversations
* **Cross-Modal Memory**: Link visual and textual information seamlessly in your memory layer
* **Cross-Session Recall**: Reference previously discussed visual content across different conversations
* **Seamless Integration**: Works naturally with existing chat interfaces for a smooth experience

## How It Works

1. **Upload Visual Content**: Simply drag and drop or paste images into your conversations
2. **Natural Interaction**: Discuss the visual content naturally with AI assistants
3. **Memory Integration**: Visual context is automatically stored and linked with your conversation history
4. **Persistent Recall**: Retrieve and reference past visual content effortlessly

## Demo Video

<iframe width="700" height="400" src="https://www.youtube.com/embed/2Md5AEFVpmg?si=rXXupn6CiDUPJsi3" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen />

## Try It Out

Visit [multimodal-demo.mem0.ai](https://multimodal-demo.mem0.ai) to experience Mem0's multimodal capabilities firsthand. Upload images and see how Mem0 understands and remembers visual context across your conversations.

***

<CardGroup cols={2}>
  <Card title="Multimodal Support" icon="image" href="/platform/features/multimodal-support">
    Learn how to store and retrieve vision and audio memories in your apps.
  </Card>

  <Card title="Voice Companion with OpenAI" icon="microphone" href="/cookbooks/companions/voice-companion-openai">
    Build voice-first companions that remember conversations.
  </Card>
</CardGroup>


# Memory-Powered Agent SDK
Source: https://docs.mem0.ai/cookbooks/integrations/agents-sdk-tool

Expose Mem0 memories as callable tools inside OpenAI agent workflows.

Integrate Mem0's memory capabilities with OpenAI's Agents SDK to create AI agents with persistent memory. You can create agents that remember past conversations and use that context to provide better responses.

## Installation

First, install the required packages:

```bash  theme={null}
pip install mem0ai pydantic openai-agents
```

You'll also need a custom agents framework for this implementation.

## Setting Up Environment Variables

Store your Mem0 API key as an environment variable:

```bash  theme={null}
export MEM0_API_KEY="your_mem0_api_key"
```

Or in your Python script:

```python  theme={null}
import os
os.environ["MEM0_API_KEY"] = "your_mem0_api_key"
```

## Code Structure

The integration consists of three main components:

1. **Context Manager**: Defines user context for memory operations
2. **Memory Tools**: Functions to add, search, and retrieve memories
3. **Memory Agent**: An agent configured to use these memory tools

## Step-by-Step Implementation

### 1. Import Dependencies

```python  theme={null}
from __future__ import annotations
import os
import asyncio
from pydantic import BaseModel
try:
    from mem0 import AsyncMemoryClient
except ImportError:
    raise ImportError("mem0 is not installed. Please install it using 'pip install mem0ai'.")
from agents import (
    Agent,
    ItemHelpers,
    MessageOutputItem,
    RunContextWrapper,
    Runner,
    ToolCallItem,
    ToolCallOutputItem,
    TResponseInputItem,
    function_tool,
)
```

### 2. Define Memory Context

```python  theme={null}
class Mem0Context(BaseModel):
    user_id: str | None = None
```

### 3. Initialize the Mem0 Client

```python  theme={null}
client = AsyncMemoryClient(api_key=os.getenv("MEM0_API_KEY"))
```

### 4. Create Memory Tools

#### Add to Memory

```python  theme={null}
@function_tool
async def add_to_memory(
    context: RunContextWrapper[Mem0Context],
    content: str,
) -> str:
    """
    Add a message to Mem0
    Args:
        content: The content to store in memory.
    """
    messages = [{"role": "user", "content": content}]
    user_id = context.context.user_id or "default_user"
    await client.add(messages, user_id=user_id)
    return f"Stored message: {content}"
```

#### Search Memory

```python  theme={null}
@function_tool
async def search_memory(
    context: RunContextWrapper[Mem0Context],
    query: str,
) -> str:
    """
    Search for memories in Mem0
    Args:
        query: The search query.
    """
    user_id = context.context.user_id or "default_user"
    memories = await client.search(query, user_id=user_id)
    results = '\n'.join([result["memory"] for result in memories["results"]])
    return str(results)
```

#### Get All Memories

```python  theme={null}
@function_tool
async def get_all_memory(
    context: RunContextWrapper[Mem0Context],
) -> str:
    """Retrieve all memories from Mem0"""
    user_id = context.context.user_id or "default_user"
    memories = await client.get_all(filters={"AND": [{"user_id": user_id}]})
    results = '\n'.join([result["memory"] for result in memories["results"]])
    return str(results)
```

### 5. Configure the Memory Agent

```python  theme={null}
memory_agent = Agent[Mem0Context](
    name="Memory Assistant",
    instructions="""You are a helpful assistant with memory capabilities. You can:
    1. Store new information using add_to_memory
    2. Search existing information using search_memory
    3. Retrieve all stored information using get_all_memory
    When users ask questions:
    - If they want to store information, use add_to_memory
    - If they're searching for specific information, use search_memory
    - If they want to see everything stored, use get_all_memory""",
    tools=[add_to_memory, search_memory, get_all_memory],
)
```

### 6. Implement the Main Runtime Loop

```python  theme={null}
async def main():
    current_agent: Agent[Mem0Context] = memory_agent
    input_items: list[TResponseInputItem] = []
    context = Mem0Context()
    while True:
        user_input = input("Enter your message (or 'quit' to exit): ")
        if user_input.lower() == 'quit':
            break
        input_items.append({"content": user_input, "role": "user"})
        result = await Runner.run(current_agent, input_items, context=context)
        for new_item in result.new_items:
            agent_name = new_item.agent.name
            if isinstance(new_item, MessageOutputItem):
                print(f"{agent_name}: {ItemHelpers.text_message_output(new_item)}")
            elif isinstance(new_item, ToolCallItem):
                print(f"{agent_name}: Calling a tool")
            elif isinstance(new_item, ToolCallOutputItem):
                print(f"{agent_name}: Tool call output: {new_item.output}")
            else:
                print(f"{agent_name}: Skipping item: {new_item.__class__.__name__}")
        input_items = result.to_input_list()

if __name__ == "__main__":
    asyncio.run(main())
```

## Usage Examples

### Storing Information

```
User: Remember that my favorite color is blue
Agent: Calling a tool
Agent: Tool call output: Stored message: my favorite color is blue
Agent: I've stored that your favorite color is blue in my memory. I'll remember that for future conversations.
```

### Searching Memory

```
User: What's my favorite color?
Agent: Calling a tool
Agent: Tool call output: my favorite color is blue
Agent: Your favorite color is blue, based on what you've told me earlier.
```

### Retrieving All Memories

```
User: What do you know about me?
Agent: Calling a tool
Agent: Tool call output: favorite color is blue
my birthday is on March 15
Agent: Based on our previous conversations, I know that:
1. Your favorite color is blue
2. Your birthday is on March 15
```

## Advanced Configuration

### Custom User IDs

You can specify different user IDs to maintain separate memory stores for multiple users:

```python  theme={null}
context = Mem0Context(user_id="user123")
```

## Resources

* [Mem0 Documentation](https://docs.mem0.ai)
* [Mem0 Dashboard](https://app.mem0.ai/dashboard)
* [API Reference](https://docs.mem0.ai/api-reference)

***

<CardGroup cols={2}>
  <Card title="OpenAI Tool Calls with Mem0" icon="wrench" href="/cookbooks/integrations/openai-tool-calls">
    Extend OpenAI assistants with tool-based memory operations.
  </Card>

  <Card title="Build a Mem0 Companion" icon="users" href="/cookbooks/essentials/building-ai-companion">
    Learn the core patterns for memory-powered agents with any SDK.
  </Card>
</CardGroup>


# Bedrock with Persistent Memory
Source: https://docs.mem0.ai/cookbooks/integrations/aws-bedrock

Pair Mem0 with AWS Bedrock, OpenSearch, and Neptune for a managed stack.

This example demonstrates how to configure and use the `mem0ai` SDK with **AWS Bedrock**, **OpenSearch Service (AOSS)**, and **AWS Neptune Analytics** for persistent memory capabilities in Python.

## Installation

Install the required dependencies to include the Amazon data stack, including **boto3**, **opensearch-py**, and **langchain-aws**:

```bash  theme={null}
pip install "mem0ai[graph,extras]"
```

## Environment Setup

Set your AWS environment variables:

```python  theme={null}
import os

# Set these in your environment or notebook
os.environ['AWS_REGION'] = 'us-west-2'
os.environ['AWS_ACCESS_KEY_ID'] = 'AK00000000000000000'
os.environ['AWS_SECRET_ACCESS_KEY'] = 'AS00000000000000000'

# Confirm they are set
print(os.environ['AWS_REGION'])
print(os.environ['AWS_ACCESS_KEY_ID'])
print(os.environ['AWS_SECRET_ACCESS_KEY'])
```

## Configuration and Usage

This sets up Mem0 with:

* [AWS Bedrock for LLM](https://docs.mem0.ai/components/llms/models/aws_bedrock)
* [AWS Bedrock for embeddings](https://docs.mem0.ai/components/embedders/models/aws_bedrock#aws-bedrock)
* [OpenSearch as the vector store](https://docs.mem0.ai/components/vectordbs/dbs/opensearch)
* [Graph Memory guide](https://docs.mem0.ai/open-source/features/graph-memory)

```python  theme={null}
import boto3
from opensearchpy import RequestsHttpConnection, AWSV4SignerAuth
from mem0.memory.main import Memory

region = 'us-west-2'
service = 'aoss'
credentials = boto3.Session().get_credentials()
auth = AWSV4SignerAuth(credentials, region, service)

config = {
    "embedder": {
        "provider": "aws_bedrock",
        "config": {
            "model": "amazon.titan-embed-text-v2:0"
        }
    },
    "llm": {
        "provider": "aws_bedrock",
        "config": {
            "model": "us.anthropic.claude-3-7-sonnet-20250219-v1:0",
            "temperature": 0.1,
            "max_tokens": 2000
        }
    },
    "vector_store": {
        "provider": "opensearch",
        "config": {
            "collection_name": "mem0",
            "host": "your-opensearch-domain.us-west-2.es.amazonaws.com",
            "port": 443,
            "http_auth": auth,
            "connection_class": RequestsHttpConnection,
            "pool_maxsize": 20,
            "use_ssl": True,
            "verify_certs": True,
            "embedding_model_dims": 1024,
        }
    },
    "graph_store": {
        "provider": "neptune",
        "config": {
            "endpoint": f"neptune-graph://my-graph-identifier",
        },
    },
}

# Initialize the memory system
m = Memory.from_config(config)
```

## Usage

Reference [Notebook example](https://github.com/mem0ai/mem0/blob/main/examples/graph-db-demo/neptune-example.ipynb)

### Add a memory

```python  theme={null}
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"})
```

### Search a memory

```python  theme={null}
relevant_memories = m.search(query, user_id="alice")
```

### Get all memories

```python  theme={null}
all_memories = m.get_all(user_id="alice")
```

### Get a specific memory

```python  theme={null}
memory = m.get(memory_id)
```

## Conclusion

With Mem0 and AWS services like Bedrock, OpenSearch, and Neptune Analytics, you can build intelligent AI companions that remember, adapt, and personalize their responses over time. This makes them ideal for long-term assistants, tutors, or support bots with persistent memory and natural conversation abilities.

***

<CardGroup cols={2}>
  <Card title="Neptune Analytics with Mem0" icon="database" href="/cookbooks/integrations/neptune-analytics">
    Explore graph-based memory storage with AWS Neptune Analytics.
  </Card>

  <Card title="Graph Memory Features" icon="sitemap" href="/platform/features/graph-memory">
    Learn how to leverage knowledge graphs for entity relationships.
  </Card>
</CardGroup>


# Healthcare Coach with ADK
Source: https://docs.mem0.ai/cookbooks/integrations/healthcare-google-adk

Guide patients with an assistant that remembers history across ADK sessions.

This example demonstrates how to build a healthcare assistant that remembers patient information across conversations using Google ADK and Mem0.

## Overview

The Healthcare Assistant helps patients by:

* Remembering their medical history and symptoms
* Providing general health information
* Scheduling appointment reminders
* Maintaining a personalized experience across conversations

By integrating Mem0's memory layer with Google ADK, the assistant maintains context about the patient without requiring them to repeat information.

## Setup

Before you begin, make sure you have:

Installed Google ADK and Mem0 SDK:

```bash  theme={null}
pip install google-adk mem0ai python-dotenv
```

## Code Breakdown

Let's get started and understand the different components required in building a healthcare assistant powered by memory

```python  theme={null}
# Import dependencies
import os
import asyncio
from google.adk.agents import Agent
from google.adk.runners import Runner
from google.adk.sessions import InMemorySessionService
from google.genai import types
from mem0 import MemoryClient
from dotenv import load_dotenv

load_dotenv()

# Set up environment variables
# os.environ["GOOGLE_API_KEY"] = "your-google-api-key"
# os.environ["MEM0_API_KEY"] = "your-mem0-api-key"

# Define a global user ID for simplicity
USER_ID = "Alex"

# Initialize Mem0 client
mem0 = MemoryClient()
```

## Define Memory Tools

First, we'll create tools that allow our agent to store and retrieve information using Mem0:

```python  theme={null}
def save_patient_info(information: str) -> dict:
    """Saves important patient information to memory."""

    # Store in Mem0
    response = mem0_client.add(
        [{"role": "user", "content": information}],
        user_id=USER_ID,
        run_id="healthcare_session",
        metadata={"type": "patient_information"}
    )


def retrieve_patient_info(query: str) -> dict:
    """Retrieves relevant patient information from memory."""

    # Search Mem0
    results = mem0_client.search(
        query,
        user_id=USER_ID,
        limit=5,
        threshold=0.7  # Higher threshold for more relevant results
    )

    # Format and return the results
    if results and len(results) > 0:
        memories = [memory["memory"] for memory in results.get('results', [])]
        return {
            "status": "success",
            "memories": memories,
            "count": len(memories)
        }
    else:
        return {
            "status": "no_results",
            "memories": [],
            "count": 0
        }
```

## Define Healthcare Tools

Next, we'll add tools specific to healthcare assistance:

```python  theme={null}
def schedule_appointment(date: str, time: str, reason: str) -> dict:
    """Schedules a doctor's appointment."""
    # In a real app, this would connect to a scheduling system
    appointment_id = f"APT-{hash(date + time) % 10000}"

    return {
        "status": "success",
        "appointment_id": appointment_id,
        "confirmation": f"Appointment scheduled for {date} at {time} for {reason}",
        "message": "Please arrive 15 minutes early to complete paperwork."
    }
```

## Create the Healthcare Assistant Agent

Now we'll create our main agent with all the tools:

```python  theme={null}
# Create the agent
healthcare_agent = Agent(
    name="healthcare_assistant",
    model="gemini-1.5-flash",  # Using Gemini for healthcare assistant
    description="Healthcare assistant that helps patients with health information and appointment scheduling.",
    instruction="""You are a helpful Healthcare Assistant with memory capabilities.

Your primary responsibilities are to:
1. Remember patient information using the 'save_patient_info' tool when they share symptoms, conditions, or preferences.
2. Retrieve past patient information using the 'retrieve_patient_info' tool when relevant to the current conversation.
3. Help schedule appointments using the 'schedule_appointment' tool.

IMPORTANT GUIDELINES:
- Always be empathetic, professional, and helpful.
- Save important patient information like symptoms, conditions, allergies, and preferences.
- Check if you have relevant patient information before asking for details they may have shared previously.
- Make it clear you are not a doctor and cannot provide medical diagnosis or treatment.
- For serious symptoms, always recommend consulting a healthcare professional.
- Keep all patient information confidential.
""",
    tools=[save_patient_info, retrieve_patient_info, schedule_appointment]
)
```

## Set Up Session and Runner

```python  theme={null}
# Set up Session Service and Runner
session_service = InMemorySessionService()

# Define constants for the conversation
APP_NAME = "healthcare_assistant_app"
USER_ID = "Alex"
SESSION_ID = "session_001"

# Create a session
session = session_service.create_session(
    app_name=APP_NAME,
    user_id=USER_ID,
    session_id=SESSION_ID
)

# Create the runner
runner = Runner(
    agent=healthcare_agent,
    app_name=APP_NAME,
    session_service=session_service
)
```

## Interact with the Healthcare Assistant

```python  theme={null}
# Function to interact with the agent
async def call_agent_async(query, runner, user_id, session_id):
    """Sends a query to the agent and returns the final response."""
    print(f"\n>>> Patient: {query}")

    # Format the user's message
    content = types.Content(
        role='user',
        parts=[types.Part(text=query)]
    )

    # Set user_id for tools to access
    save_patient_info.user_id = user_id
    retrieve_patient_info.user_id = user_id

    # Run the agent
    async for event in runner.run_async(
        user_id=user_id,
        session_id=session_id,
        new_message=content
    ):
        if event.is_final_response():
            if event.content and event.content.parts:
                response = event.content.parts[0].text
                print(f"<<< Assistant: {response}")
                return response

    return "No response received."

# Example conversation flow
async def run_conversation():
    # First interaction - patient introduces themselves with key information
    await call_agent_async(
        "Hi, I'm Alex. I've been having headaches for the past week, and I have a penicillin allergy.",
        runner=runner,
        user_id=USER_ID,
        session_id=SESSION_ID
    )

    # Request for health information
    await call_agent_async(
        "Can you tell me more about what might be causing my headaches?",
        runner=runner,
        user_id=USER_ID,
        session_id=SESSION_ID
    )

    # Schedule an appointment
    await call_agent_async(
        "I think I should see a doctor. Can you help me schedule an appointment for next Monday at 2pm?",
        runner=runner,
        user_id=USER_ID,
        session_id=SESSION_ID
    )

    # Test memory - should remember patient name, symptoms, and allergy
    await call_agent_async(
        "What medications should I avoid for my headaches?",
        runner=runner,
        user_id=USER_ID,
        session_id=SESSION_ID
    )

# Run the conversation example
if __name__ == "__main__":
    asyncio.run(run_conversation())
```

## How It Works

This healthcare assistant demonstrates several key capabilities:

1. **Memory Storage**: When Alex mentions her headaches and penicillin allergy, the agent stores this information in Mem0 using the `save_patient_info` tool.

2. **Contextual Retrieval**: When Alex asks about headache causes, the agent uses the `retrieve_patient_info` tool to recall her specific situation.

3. **Memory Application**: When discussing medications, the agent remembers Alex's penicillin allergy without her needing to repeat it, providing safer and more personalized advice.

4. **Conversation Continuity**: The agent maintains context across the entire conversation session, creating a more natural and efficient interaction.

## Key Implementation Details

## User ID Management

Instead of passing the user ID as a parameter to the memory tools (which would require modifying the ADK's tool calling system), we attach it directly to the function object:

```python  theme={null}
# Set user_id for tools to access
save_patient_info.user_id = user_id
retrieve_patient_info.user_id = user_id
```

Inside the tool functions, we retrieve this attribute:

```python  theme={null}
# Get user_id from session state or use default
user_id = getattr(save_patient_info, 'user_id', 'default_user')
```

This approach allows our tools to maintain user context without complicating their parameter signatures.

## Mem0 Integration

The integration with Mem0 happens through two primary functions:

1. `mem0_client.add()` - Stores new information with appropriate metadata
2. `mem0_client.search()` - Retrieves relevant memories using semantic search

The `threshold` parameter in the search function ensures that only highly relevant memories are returned.

## Conclusion

This example demonstrates how to build a healthcare assistant with persistent memory using Google ADK and Mem0. The integration allows for a more personalized patient experience by maintaining context across conversation turns, which is particularly valuable in healthcare scenarios where continuity of information is crucial.

By storing and retrieving patient information intelligently, the assistant provides more relevant responses without requiring the patient to repeat their medical history, symptoms, or preferences.

***

<CardGroup cols={2}>
  <Card title="Tag and Organize Memories" icon="tag" href="/cookbooks/essentials/tagging-and-organizing-memories">
    Categorize patient data by symptoms, history, and visit context.
  </Card>

  <Card title="Support Inbox with Mem0" icon="headset" href="/cookbooks/operations/support-inbox">
    Apply similar memory patterns to customer support workflows.
  </Card>
</CardGroup>


# Persistent Mastra Agents
Source: https://docs.mem0.ai/cookbooks/integrations/mastra-agent

Extend Mastra agents with persistent memories powered by Mem0.

In this example you'll learn how to use Mem0 to add long-term memory capabilities to [Mastra's agent](https://mastra.ai/) via tool-use. This memory integration can work alongside Mastra's [agent memory features](https://mastra.ai/docs/agents/01-agent-memory).

You can find the complete example code in the [Mastra repository](https://github.com/mastra-ai/mastra/tree/main/examples/memory-with-mem0).

## Overview

This guide will show you how to integrate Mem0 with Mastra to add long-term memory capabilities to your agents. We'll create tools that allow agents to save and retrieve memories using Mem0's API.

## Installation

**Install the Integration Package**

To install the Mem0 integration, run:

```bash  theme={null}
npm install @mastra/mem0
```

**Add the Integration to Your Project**

Create a new file for your integrations and import the integration:

```typescript integrations/index.ts theme={null}
import { Mem0Integration } from "@mastra/mem0";

export const mem0 = new Mem0Integration({
  config: {
    apiKey: process.env.MEM0_API_KEY!,
    userId: "alice",
  },
});
```

**Use the Integration in Tools or Workflows**

You can now use the integration when defining tools for your agents or in workflows.

```typescript tools/index.ts theme={null}
import { createTool } from "@mastra/core";
import { z } from "zod";
import { mem0 } from "../integrations";

export const mem0RememberTool = createTool({
  id: "Mem0-remember",
  description:
    "Remember your agent memories that you've previously saved using the Mem0-memorize tool.",
  inputSchema: z.object({
    question: z
      .string()
      .describe("Question used to look up the answer in saved memories."),
  }),
  outputSchema: z.object({
    answer: z.string().describe("Remembered answer"),
  }),
  execute: async ({ context }) => {
    console.log(`Searching memory "${context.question}"`);
    const memory = await mem0.searchMemory(context.question);
    console.log(`\nFound memory "${memory}"\n`);

    return {
      answer: memory,
    };
  },
});

export const mem0MemorizeTool = createTool({
  id: "Mem0-memorize",
  description:
    "Save information to mem0 so you can remember it later using the Mem0-remember tool.",
  inputSchema: z.object({
    statement: z.string().describe("A statement to save into memory"),
  }),
  execute: async ({ context }) => {
    console.log(`\nCreating memory "${context.statement}"\n`);
    // to reduce latency memories can be saved async without blocking tool execution
    void mem0.createMemory(context.statement).then(() => {
      console.log(`\nMemory "${context.statement}" saved.\n`);
    });
    return { success: true };
  },
});
```

**Create a New Agent**

```typescript agents/index.ts theme={null}
import { openai } from '@ai-sdk/openai';
import { Agent } from '@mastra/core/agent';
import { mem0MemorizeTool, mem0RememberTool } from '../tools';

export const mem0Agent = new Agent({
  name: 'Mem0 Agent',
  instructions: `
    You are a helpful assistant that has the ability to memorize and remember facts using Mem0.
  `,
  model: openai('gpt-4.1-nano'),
  tools: { mem0RememberTool, mem0MemorizeTool },
});
```

**Run the Agent**

```typescript index.ts theme={null}
import { Mastra } from '@mastra/core/mastra';
import { createLogger } from '@mastra/core/logger';

import { mem0Agent } from './agents';

export const mastra = new Mastra({
  agents: { mem0Agent },
  logger: createLogger({
    name: 'Mastra',
    level: 'error',
  }),
});
```

In the example above:

* We import the `@mastra/mem0` integration
* We define two tools that use the Mem0 API client to create new memories and recall previously saved memories
* The tool accepts `question` as an input and returns the memory as a string

***

<CardGroup cols={2}>
  <Card title="Partition Memories by Entity" icon="layers" href="/cookbooks/essentials/entity-partitioning-playbook">
    Separate user, agent, and app memories to keep multi-agent flows clean.
  </Card>

  <Card title="Agents SDK Tool with Mem0" icon="robot" href="/cookbooks/integrations/agents-sdk-tool">
    Explore tool-calling patterns with the OpenAI Agents SDK.
  </Card>
</CardGroup>


# Graph Memory on Neptune
Source: https://docs.mem0.ai/cookbooks/integrations/neptune-analytics

Combine Mem0 graph memory with AWS Neptune Analytics and Bedrock.

This example demonstrates how to configure and use the `mem0ai` SDK with **AWS Bedrock** and **AWS Neptune Analytics** for persistent memory capabilities in Python.

## Installation

Install the required dependencies to include the Amazon data stack, including **boto3** and **langchain-aws**:

```bash  theme={null}
pip install "mem0ai[graph,extras]"
```

## Environment Setup

Set your AWS environment variables:

```python  theme={null}
import os

# Set these in your environment or notebook
os.environ['AWS_REGION'] = 'us-west-2'
os.environ['AWS_ACCESS_KEY_ID'] = 'AK00000000000000000'
os.environ['AWS_SECRET_ACCESS_KEY'] = 'AS00000000000000000'

# Confirm they are set
print(os.environ['AWS_REGION'])
print(os.environ['AWS_ACCESS_KEY_ID'])
print(os.environ['AWS_SECRET_ACCESS_KEY'])
```

## Configuration and Usage

This sets up Mem0 with:

* [AWS Bedrock for LLM](https://docs.mem0.ai/components/llms/models/aws_bedrock)
* [AWS Bedrock for embeddings](https://docs.mem0.ai/components/embedders/models/aws_bedrock#aws-bedrock)
* [Neptune Analytics as the vector store](https://docs.mem0.ai/components/vectordbs/dbs/neptune_analytics)
* [Graph Memory guide](https://docs.mem0.ai/open-source/features/graph-memory).

```python  theme={null}
import boto3
from mem0.memory.main import Memory

region = 'us-west-2'
neptune_analytics_endpoint = 'neptune-graph://my-graph-identifier'

config = {
    "embedder": {
        "provider": "aws_bedrock",
        "config": {
            "model": "amazon.titan-embed-text-v2:0"
        }
    },
    "llm": {
        "provider": "aws_bedrock",
        "config": {
            "model": "us.anthropic.claude-3-7-sonnet-20250219-v1:0",
            "temperature": 0.1,
            "max_tokens": 2000
        }
    },
    "vector_store": {
        "provider": "neptune",
        "config": {
            "collection_name": "mem0",
            "endpoint": neptune_analytics_endpoint,
        },
    },
    "graph_store": {
        "provider": "neptune",
        "config": {
            "endpoint": neptune_analytics_endpoint,
        },
    },
}

# Initialize the memory system
m = Memory.from_config(config)
```

## Usage

Reference [Notebook example](https://github.com/mem0ai/mem0/blob/main/examples/graph-db-demo/neptune-example.ipynb)

#### Add a memory:

```python  theme={null}
messages = [
    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
    {"role": "assistant", "content": "How about a 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"})
```

#### Search a memory:

```python  theme={null}
relevant_memories = m.search(query, user_id="alice")
```

#### Get all memories:

```python  theme={null}
all_memories = m.get_all(user_id="alice")
```

#### Get a specific memory:

```python  theme={null}
memory = m.get(memory_id)
```

***

## Conclusion

With Mem0 and AWS services like Bedrock and Neptune Analytics, you can build intelligent AI companions that remember, adapt, and personalize their responses over time. This makes them ideal for long-term assistants, tutors, or support bots with persistent memory and natural conversation abilities.

***

<CardGroup cols={2}>
  <Card title="AWS Bedrock with Mem0" icon="aws" href="/cookbooks/integrations/aws-bedrock">
    Combine Neptune Analytics with AWS Bedrock for complete AWS stack.
  </Card>

  <Card title="Graph Memory Architecture" icon="sitemap" href="/cookbooks/essentials/choosing-memory-architecture-vector-vs-graph">
    Understand when to use graph vs vector memory for your use case.
  </Card>
</CardGroup>


# Memory as OpenAI Tool
Source: https://docs.mem0.ai/cookbooks/integrations/openai-tool-calls

Wire Mem0 memories into OpenAI's inbuilt function-calling flow.

Integrate Mem0’s memory capabilities with OpenAI’s Inbuilt Tools to create AI agents with persistent memory.

## Getting Started

### Installation

```bash  theme={null}
npm install mem0ai openai zod
```

## Environment Setup

Save your Mem0 and OpenAI API keys in a `.env` file:

```
MEM0_API_KEY=your_mem0_api_key
OPENAI_API_KEY=your_openai_api_key
```

Get your Mem0 API key from the [Mem0 Dashboard](https://app.mem0.ai/dashboard/api-keys).

### Configuration

```javascript  theme={null}
const mem0Config = {
    apiKey: process.env.MEM0_API_KEY,
    user_id: "sample-user",
};

const openAIClient = new OpenAI();
const mem0Client = new MemoryClient(mem0Config);
```

## Adding Memories

Store user preferences, past interactions, or any relevant information:

<CodeGroup>
  ```javascript JavaScript theme={null}
  async function addUserPreferences() {
      const mem0Client = new MemoryClient(mem0Config);
      
      const userPreferences = "I Love BMW, Audi and Porsche. I Hate Mercedes. I love Red cars and Maroon cars. I have a budget of 120K to 150K USD. I like Audi the most.";
      
      await mem0Client.add([{
          role: "user",
          content: userPreferences,
      }], mem0Config);
  }

  await addUserPreferences();
  ```

  ```json Output (Memories) theme={null}
   [
    {
      "id": "ff9f3367-9e83-415d-b9c5-dc8befd9a4b4",
      "data": { "memory": "Loves BMW, Audi, and Porsche" },
      "event": "ADD"
    },
    {
      "id": "04172ce6-3d7b-45a3-b4a1-ee9798593cb4",
      "data": { "memory": "Hates Mercedes" },
      "event": "ADD"
    },
    {
      "id": "db363a5d-d258-4953-9e4c-777c120de34d",
      "data": { "memory": "Loves red cars and maroon cars" },
      "event": "ADD"
    },
    {
      "id": "5519aaad-a2ac-4c0d-81d7-0d55c6ecdba8",
      "data": { "memory": "Has a budget of 120K to 150K USD" },
      "event": "ADD"
    },
    {
      "id": "523b7693-7344-4563-922f-5db08edc8634",
      "data": { "memory": "Likes Audi the most" },
      "event": "ADD"
    }
  ]
  ```
</CodeGroup>

## Retrieving Memories

Search for relevant memories based on the current user input:

```javascript  theme={null}
const relevantMemories = await mem0Client.search(userInput, mem0Config);
```

## Structured Responses with Zod

Define structured response schemas to get consistent output formats:

```javascript  theme={null}
// Define the schema for a car recommendation
const CarSchema = z.object({
  car_name: z.string(),
  car_price: z.string(),
  car_url: z.string(),
  car_image: z.string(),
  car_description: z.string(),
});

// Schema for a list of car recommendations
const Cars = z.object({
  cars: z.array(CarSchema),
});

// Create a function tool based on the schema
const carRecommendationTool = zodResponsesFunction({ 
    name: "carRecommendations", 
    parameters: Cars 
});

// Use the tool in your OpenAI request
const response = await openAIClient.responses.create({
    model: "gpt-4.1-nano-2025-04-14",
    tools: [{ type: "web_search_preview" }, carRecommendationTool],
    input: `${getMemoryString(relevantMemories)}\n${userInput}`,
});
```

## Using Web Search

Combine memory with web search for up-to-date recommendations:

```javascript  theme={null}
const response = await openAIClient.responses.create({
    model: "gpt-4.1-nano-2025-04-14",
    tools: [{ type: "web_search_preview" }, carRecommendationTool],
    input: `${getMemoryString(relevantMemories)}\n${userInput}`,
});
```

## Examples

## Complete Car Recommendation System

```javascript  theme={null}
import MemoryClient from "mem0ai";
import { OpenAI } from "openai";
import { zodResponsesFunction } from "openai/helpers/zod";
import { z } from "zod";
import dotenv from 'dotenv';

dotenv.config();

const mem0Config = {
    apiKey: process.env.MEM0_API_KEY,
    user_id: "sample-user",
};

async function run() {
    // Responses without memories
    console.log("\n\nRESPONSES WITHOUT MEMORIES\n\n");
    await main();

    // Adding sample memories
    await addSampleMemories();

    // Responses with memories
    console.log("\n\nRESPONSES WITH MEMORIES\n\n");
    await main(true);
}

// OpenAI Response Schema
const CarSchema = z.object({
  car_name: z.string(),
  car_price: z.string(),
  car_url: z.string(),
  car_image: z.string(),
  car_description: z.string(),
});

const Cars = z.object({
  cars: z.array(CarSchema),
});

async function main(memory = false) {
  const openAIClient = new OpenAI();
  const mem0Client = new MemoryClient(mem0Config);

  const input = "Suggest me some cars that I can buy today.";

  const tool = zodResponsesFunction({ name: "carRecommendations", parameters: Cars });

  // Store the user input as a memory
  await mem0Client.add([{
    role: "user",
    content: input,
  }], mem0Config);

  // Search for relevant memories
  let relevantMemories = []
  if (memory) {
    relevantMemories = await mem0Client.search(input, mem0Config);
  }

  const response = await openAIClient.responses.create({
    model: "gpt-4.1-nano-2025-04-14",
    tools: [{ type: "web_search_preview" }, tool],
    input: `${getMemoryString(relevantMemories)}\n${input}`,
  });

  console.log(response.output);
}

async function addSampleMemories() {
  const mem0Client = new MemoryClient(mem0Config);

  const myInterests = "I Love BMW, Audi and Porsche. I Hate Mercedes. I love Red cars and Maroon cars. I have a budget of 120K to 150K USD. I like Audi the most.";
  
  await mem0Client.add([{
    role: "user",
    content: myInterests,
  }], mem0Config);
}

const getMemoryString = (memories) => {
    const MEMORY_STRING_PREFIX = "These are the memories I have stored. Give more weightage to the question by users and try to answer that first. You have to modify your answer based on the memories I have provided. If the memories are irrelevant you can ignore them. Also don't reply to this section of the prompt, or the memories, they are only for your reference. The MEMORIES of the USER are: \n\n";
    const memoryString = (memories?.results || memories).map((mem) => `${mem.memory}`).join("\n") ?? "";
    return memoryString.length > 0 ? `${MEMORY_STRING_PREFIX}${memoryString}` : "";
};

run().catch(console.error);
```

## Responses

<CodeGroup>
  ```json Without Memories theme={null}
  {
    "cars": [
      {
        "car_name": "Toyota Camry",
        "car_price": "$25,000",
        "car_url": "https://www.toyota.com/camry/",
        "car_image": "https://link-to-toyota-camry-image.com",
        "car_description": "Reliable mid-size sedan with great fuel efficiency."
      },
      {
        "car_name": "Honda Accord",
        "car_price": "$26,000",
        "car_url": "https://www.honda.com/accord/",
        "car_image": "https://link-to-honda-accord-image.com",
        "car_description": "Comfortable and spacious with advanced safety features."
      },
      {
        "car_name": "Ford Mustang",
        "car_price": "$28,000",
        "car_url": "https://www.ford.com/mustang/",
        "car_image": "https://link-to-ford-mustang-image.com",
        "car_description": "Iconic sports car with powerful engine options."
      },
      {
        "car_name": "Tesla Model 3",
        "car_price": "$38,000",
        "car_url": "https://www.tesla.com/model3",
        "car_image": "https://link-to-tesla-model3-image.com",
        "car_description": "Electric vehicle with advanced technology and long range."
      },
      {
        "car_name": "Chevrolet Equinox",
        "car_price": "$24,000",
        "car_url": "https://www.chevrolet.com/equinox/",
        "car_image": "https://link-to-chevron-equinox-image.com",
        "car_description": "Compact SUV with a spacious interior and user-friendly technology."
      }
    ]
  }
  ```

  ```json With Memories theme={null}
  {
    "cars": [
      {
        "car_name": "Audi RS7",
        "car_price": "$118,500",
        "car_url": "https://www.audiusa.com/us/web/en/models/rs7/2023/overview.html",
        "car_image": "https://www.audiusa.com/content/dam/nemo/us/models/rs7/my23/gallery/1920x1080_AOZ_A717_191004.jpg",
        "car_description": "The Audi RS7 is a high-performance hatchback with a sleek design, powerful 591-hp twin-turbo V8, and luxurious interior. It's available in various colors including red."
      },
      {
        "car_name": "Porsche Panamera GTS",
        "car_price": "$129,300",
        "car_url": "https://www.porsche.com/usa/models/panamera/panamera-models/panamera-gts/",
        "car_image": "https://files.porsche.com/filestore/image/multimedia/noneporsche-panamera-gts-sample-m02-high/normal/8a6327c3-6c7f-4c6f-a9a8-fb9f58b21795;sP;twebp/porsche-normal.webp",
        "car_description": "The Porsche Panamera GTS is a luxury sports sedan with a 473-hp V8 engine, exquisite handling, and available in stunning red. Balances sportiness and comfort."
      },
      {
        "car_name": "BMW M5",
        "car_price": "$105,500",
        "car_url": "https://www.bmwusa.com/vehicles/m-models/m5/sedan/overview.html",
        "car_image": "https://www.bmwusa.com/content/dam/bmwusa/M/m5/2023/bmw-my23-m5-sapphire-black-twilight-purple-exterior-02.jpg",
        "car_description": "The BMW M5 is a powerhouse sedan with a 600-hp V8 engine, known for its great handling and luxury. It comes in several distinctive colors including maroon."
      }
    ]
  }
  ```
</CodeGroup>

## Resources

* [Mem0 Documentation](https://docs.mem0.ai)
* [Mem0 Dashboard](https://app.mem0.ai/dashboard)
* [API Reference](https://docs.mem0.ai/api-reference)
* [OpenAI Documentation](https://platform.openai.com/docs)

***

<CardGroup cols={2}>
  <Card title="Agents SDK Tool with Mem0" icon="robot" href="/cookbooks/integrations/agents-sdk-tool">
    Extend the OpenAI Agents SDK with Mem0 integration capabilities.
  </Card>

  <Card title="Control Memory Ingestion" icon="filter" href="/cookbooks/essentials/controlling-memory-ingestion">
    Fine-tune what memories get stored during tool calls.
  </Card>
</CardGroup>


# Search with Personal Context
Source: https://docs.mem0.ai/cookbooks/integrations/tavily-search

Blend Tavily's realtime results with personal context stored in Mem0.

<Snippet file="security-compliance.mdx" />

Imagine asking a search assistant for "coffee shops nearby" and instead of generic results, it shows remote-work-friendly cafes with great WiFi in your city because it remembers you mentioned working remotely before. Or when you search for "lunchbox ideas for kids" it knows you have a 7-year-old daughter and recommends peanut-free options that align with her allergy.

That's what we are going to build today, a Personalized Search Assistant powered by Mem0 for memory and [Tavily](https://tavily.com) for real-time search.

## Why Personalized Search

Most assistants treat every query like they've never seen you before. That means repeating yourself about your location, diet, or preferences, and getting results that feel generic.

* With Mem0, your assistant builds a memory of the user's world.
* With Tavily, it fetches fresh and accurate results in real time.

Together, they make every interaction smarter, faster, and more personal.

## Prerequisites

Before you begin, make sure you have:

1. Installed the dependencies:

```bash  theme={null}
pip install langchain mem0ai langchain-tavily langchain-openai
```

2. Set up your API keys in a .env file:

```bash  theme={null}
OPENAI_API_KEY=your-openai-key
TAVILY_API_KEY=your-tavily-key
MEM0_API_KEY=your-mem0-key
```

## Code Walkthrough

Let’s break down the main components.

### 1: Initialize Mem0 with Custom Instructions

We configure Mem0 with custom instructions that guide it to infer user memories tailored specifically for our usecase.

```python  theme={null}
from mem0 import MemoryClient

mem0_client = MemoryClient()

mem0_client.project.update(
    custom_instructions='''
INFER THE MEMORIES FROM USER QUERIES EVEN IF IT'S A QUESTION.

We are building personalized search for which we need to understand about user's preferences and life
and extract facts and memories accordingly.
'''
)
```

Now, if a user casually mentions "I need to pick up my daughter" or "What's the weather at Los Angeles", Mem0 remembers they have a daughter or the user is interested in or connected with Los Angeles in terms of location. These details will be referenced for future searches.

### 2. Simulating User History

To test personalization, we preload some sample conversation history for a user:

```python  theme={null}
def setup_user_history(user_id):
    conversations = [
        [{"role": "user", "content": "What will be the weather today at Los Angeles? I need to pick up my daughter from office."},
         {"role": "assistant", "content": "I'll check the weather in LA for you."}],
        [{"role": "user", "content": "I'm looking for vegan restaurants in Santa Monica"},
         {"role": "assistant", "content": "I'll find great vegan options in Santa Monica."}],
        [{"role": "user", "content": "My 7-year-old daughter is allergic to peanuts"},
         {"role": "assistant", "content": "I'll remember to check for peanut-free options."}],
        [{"role": "user", "content": "I work remotely and need coffee shops with good wifi"},
         {"role": "assistant", "content": "I'll find remote-work-friendly coffee shops."}],
        [{"role": "user", "content": "We love hiking and outdoor activities on weekends"},
         {"role": "assistant", "content": "Great! I'll keep your outdoor activity preferences in mind."}],
    ]

    for conversation in conversations:
        mem0_client.add(conversation, user_id=user_id)
```

This gives the agent a baseline understanding of the user’s lifestyle and needs.

### 3. Retrieving User Context from Memory

When a user makes a new search query, we retrieve relevant memories to enhance the search query:

```python  theme={null}
def get_user_context(user_id, query):
    # For Platform API, user_id goes in filters
    filters = {"user_id": user_id}
    user_memories = mem0_client.search(query=query, filters=filters)

    if user_memories:
        context = "\n".join([f"- {memory['memory']}" for memory in user_memories])
        return context
    else:
        return "No previous user context available."
```

This context is injected into the search agent so results are personalized.

### 4. Creating the Personalized Search Agent

The agent uses Tavily search, but always augments search queries with user context:

```python  theme={null}
def create_personalized_search_agent(user_context):
    tavily_search = TavilySearch(
        max_results=10,
        search_depth="advanced",
        include_answer=True,
        topic="general"
    )

    tools = [tavily_search]

    prompt = ChatPromptTemplate.from_messages([
        ("system", f"""You are a personalized search assistant.

USER CONTEXT AND PREFERENCES:
{user_context}

YOUR ROLE:
1. Analyze the user's query and context.
2. Enhance the query with relevant personal memories.
3. Always use tavily_search for results.
4. Explain which memories influenced personalization.
"""),
        MessagesPlaceholder(variable_name="messages"),
        MessagesPlaceholder(variable_name="agent_scratchpad"),
    ])

    agent = create_openai_tools_agent(llm=llm, tools=tools, prompt=prompt)
    return AgentExecutor(agent=agent, tools=tools, verbose=True, return_intermediate_steps=True)
```

### 5. Run a Personalized Search

The workflow ties everything together:

```python  theme={null}
def conduct_personalized_search(user_id, query):
    user_context = get_user_context(user_id, query)
    agent_executor = create_personalized_search_agent(user_context)

    response = agent_executor.invoke({"messages": [HumanMessage(content=query)]})
    return {"agent_response": response['output']}
```

### 6. Store New Interactions

Every new query/response pair is stored for future personalization:

```python  theme={null}
def store_search_interaction(user_id, original_query, agent_response):
    interaction = [
        {"role": "user", "content": f"Searched for: {original_query}"},
        {"role": "assistant", "content": f"Results based on preferences: {agent_response}"}
    ]
    mem0_client.add(messages=interaction, user_id=user_id)
```

### Full Example Run

```python  theme={null}
if __name__ == "__main__":
    user_id = "john"
    setup_user_history(user_id)

    queries = [
        "good coffee shops nearby for working",
        "what can I make for my kid in lunch?"
    ]

    for q in queries:
        results = conduct_personalized_search(user_id, q)
        print(f"\nQuery: {q}")
        print(f"Personalized Response: {results['agent_response']}")
```

## How It Works in Practice

Here's how personalization plays out:

* **Context Gathering**: User previously mentioned living in Los Angeles, being vegan, and having a 7-year-old daughter allergic to peanuts.
* **Enhanced Search Query**:
  * Query: "good coffee shops nearby for working"
  * Enhanced Query: "good coffee shops in Los Angeles with strong WiFi, remote-work-friendly"
* **Personalized Results**: The assistant only returns WiFi-friendly, work-friendly cafes near Los Angeles.
* **Memory Update**: Interaction is saved for better future recommendations.

## Conclusion

With Mem0 and Tavily, you can build a search assistant that doesn't just fetch results but understands the person behind the query.

Whether for shopping, travel, or daily life, this approach turns a generic search into a truly personalized experience.

Full Code: [Personalized Search GitHub](https://github.com/mem0ai/mem0/blob/main/examples/misc/personalized_search.py)

***

<CardGroup cols={2}>
  <Card title="Deep Research with Mem0" icon="magnifying-glass" href="/cookbooks/operations/deep-research">
    Build comprehensive research agents that remember findings across sessions.
  </Card>

  <Card title="Tag and Organize Memories" icon="tag" href="/cookbooks/essentials/tagging-and-organizing-memories">
    Categorize search results and user preferences for better personalization.
  </Card>
</CardGroup>


# Content Creation Workflow
Source: https://docs.mem0.ai/cookbooks/operations/content-writing

Store voice guidelines once and apply them across every draft.

This guide demonstrates how to leverage **Mem0** to streamline content writing by applying your unique writing style and preferences using persistent memory.

## Why Use Mem0?

Integrating Mem0 into your writing workflow helps you:

1. **Store persistent writing preferences** ensuring consistent tone, formatting, and structure.
2. **Automate content refinement** by retrieving preferences when rewriting or reviewing content.
3. **Scale your writing style** so it applies consistently across multiple documents or sessions.

## Setup

```python  theme={null}
import os
from openai import OpenAI
from mem0 import MemoryClient

os.environ["MEM0_API_KEY"] = "your-mem0-api-key"
os.environ["OPENAI_API_KEY"] = "your-openai-api-key"


# Set up Mem0 and OpenAI client
client = MemoryClient()
openai = OpenAI()

USER_ID = "content_writer"
RUN_ID = "smart_editing_session"
```

## Storing Your Writing Preferences in Mem0

```python  theme={null}
def store_writing_preferences():
    """Store your writing preferences in Mem0."""
    
    preferences = """My writing preferences:
1. Use headings and sub-headings for structure.
2. Keep paragraphs concise (8–10 sentences max).
3. Incorporate specific numbers and statistics.
4. Provide concrete examples.
5. Use bullet points for clarity.
6. Avoid jargon and buzzwords."""

    messages = [
        {"role": "user", "content": "Here are my writing style preferences."},
        {"role": "assistant", "content": preferences}
    ]

    response = client.add(
        messages,
        user_id=USER_ID,
        run_id=RUN_ID,
        metadata={"type": "preferences", "category": "writing_style"}
    )

    return response
```

## Editing Content Using Stored Preferences

```python  theme={null}
def apply_writing_style(original_content):
    """Use preferences stored in Mem0 to guide content rewriting."""

    results = client.search(
        query="What are my writing style preferences?",
        filters={
            "AND": [
                {"user_id": USER_ID},
                {"run_id": RUN_ID}
            ]
        }
    )

    if not results:
        print("No preferences found.")
        return None

    preferences = "\n".join(r["memory"] for r in results.get('results', []))

    system_prompt = f"""
You are a writing assistant.

Apply the following writing style preferences to improve the user's content:

Preferences:
{preferences}
"""

    messages = [
        {"role": "system", "content": system_prompt},
        {"role": "user", "content": f"""Original Content:
    {original_content}"""}
    ]

    response = openai.chat.completions.create(
        model="gpt-4.1-nano-2025-04-14",
        messages=messages
    )
    clean_response = response.choices[0].message.content.strip()

    return clean_response
```

## Complete Workflow: Content Editing

```python  theme={null}
def content_writing_workflow(content):
    """Automated workflow for editing a document based on writing preferences."""
    
    # Store writing preferences (if not already stored)
    store_writing_preferences()  # Ideally done once, or with a conditional check
    
    # Edit the document with Mem0 preferences
    edited_content = apply_writing_style(content)
    
    if not edited_content:
        return "Failed to edit document."
    
    # Display results
    print("\n=== ORIGINAL DOCUMENT ===\n")
    print(content)
    
    print("\n=== EDITED DOCUMENT ===\n")
    print(edited_content)
    
    return edited_content
```

## Example Usage

```python  theme={null}
# Define your document
original_content = """Project Proposal
    
The following proposal outlines our strategy for the Q3 marketing campaign. 
We believe this approach will significantly increase our market share.

Increase brand awareness
Boost sales by 15%
Expand our social media following

We plan to launch the campaign in July and continue through September.
"""

# Run the workflow
result = content_writing_workflow(original_content)
```

## Expected Output

Your document will be transformed into a structured, well-formatted version based on your preferences.

### Original Document

```
Project Proposal
    
The following proposal outlines our strategy for the Q3 marketing campaign. 
We believe this approach will significantly increase our market share.

Increase brand awareness
Boost sales by 15%
Expand our social media following

We plan to launch the campaign in July and continue through September.
```

### Edited Document

```
# Project Proposal

## Q3 Marketing Campaign Strategy

This proposal outlines our strategy for the Q3 marketing campaign. We aim to significantly increase our market share with this approach.

### Objectives

- **Increase Brand Awareness**: Implement targeted advertising and community engagement to enhance visibility.
- **Boost Sales by 15%**: Increase sales by 15% compared to Q2 figures.
- **Expand Social Media Following**: Grow our social media audience by 20%.

### Timeline

- **Launch Date**: July
- **Duration**: July – September

### Key Actions

- **Targeted Advertising**: Utilize platforms like Google Ads and Facebook to reach specific demographics.
- **Community Engagement**: Host webinars and live Q&A sessions.
- **Content Creation**: Produce engaging videos and infographics.

### Supporting Data

- **Previous Campaign Success**: Our Q2 campaign increased sales by 12%. We will refine similar strategies for Q3.
- **Social Media Growth**: Last year, our Instagram followers grew by 25% during a similar campaign.

### Conclusion

We believe this strategy will effectively increase our market share. To achieve these goals, we need your support and collaboration. Let’s work together to make this campaign a success. Please review the proposal and provide your feedback by the end of the week.
```

Mem0 enables a seamless, intelligent content-writing workflow, perfect for content creators, marketers, and technical writers looking to scale their personal tone and structure across work.

***

<CardGroup cols={2}>
  <Card title="Control Memory Ingestion" icon="filter" href="/cookbooks/essentials/controlling-memory-ingestion">
    Filter and curate content examples to maintain consistent writing style.
  </Card>

  <Card title="Email Automation with Mem0" icon="envelope" href="/cookbooks/operations/email-automation">
    Automate email drafting with memory-powered context and tone matching.
  </Card>
</CardGroup>


# Multi-Session Research Agent
Source: https://docs.mem0.ai/cookbooks/operations/deep-research

Run multi-session investigations that remember past findings and preferences.

Deep Research is an intelligent agent that synthesizes large amounts of online data and completes complex research tasks, customized to your unique preferences and insights. Built on Mem0's technology, it enhances AI-driven online exploration with personalized memories.

You can check out the GitHub repository here: [Personalized Deep Research](https://github.com/mem0ai/personalized-deep-research/tree/mem0)

## Overview

Deep Research leverages Mem0's memory capabilities to:

* Synthesize large amounts of online data
* Complete complex research tasks
* Customize results to your preferences
* Store and utilize personal insights
* Maintain context across research sessions

## Demo

Watch Deep Research in action:

<iframe width="700" height="400" src="https://www.youtube.com/embed/8vQlCtXzF60?si=b8iTOgummAVzR7ia" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen />

## Features

### 1. Personalized Research

* Analyzes your background and expertise
* Tailors research depth and complexity to your level
* Incorporates your previous research context

### 2. Comprehensive Data Synthesis

* Processes multiple online sources
* Extracts relevant information
* Provides coherent summaries

### 3. Memory Integration

* Stores research findings for future reference
* Maintains context across sessions
* Links related research topics

### 4. Interactive Exploration

* Allows real-time query refinement
* Supports follow-up questions
* Enables deep-diving into specific areas

## Use Cases

* **Academic Research**: Literature reviews, thesis research, paper writing
* **Market Research**: Industry analysis, competitor research, trend identification
* **Technical Research**: Technology evaluation, solution comparison
* **Business Research**: Strategic planning, opportunity analysis

## Try It Out

> To try it yourself, clone the repository and follow the instructions in the README to run it locally or deploy it.

* [Personalized Deep Research GitHub](https://github.com/mem0ai/personalized-deep-research/tree/mem0)

***

<CardGroup cols={2}>
  <Card title="Search Memory Operations" icon="magnifying-glass" href="/core-concepts/memory-operations/search">
    Master semantic search to retrieve research findings across sessions.
  </Card>

  <Card title="YouTube Research with Mem0" icon="video" href="/cookbooks/companions/youtube-research">
    Build a video research assistant that remembers insights from content.
  </Card>
</CardGroup>


# Automated Email Intelligence
Source: https://docs.mem0.ai/cookbooks/operations/email-automation

Capture, categorize, and recall inbox threads using persistent memories.

This guide demonstrates how to build an intelligent email processing system using Mem0's memory capabilities. You'll learn how to store, categorize, retrieve, and analyze emails to create a smart email management solution.

## Overview

Email overload is a common challenge for many professionals. By leveraging Mem0's memory capabilities, you can build an intelligent system that:

* Stores emails as searchable memories
* Categorizes emails automatically
* Retrieves relevant past conversations
* Prioritizes messages based on importance
* Generates summaries and action items

## Setup

Before you begin, ensure you have the required dependencies installed:

```bash  theme={null}
pip install mem0ai openai
```

## Implementation

### Basic Email Memory System

The following example shows how to create a basic email processing system with Mem0:

```python  theme={null}
import os
from mem0 import MemoryClient
from email.parser import Parser

# Configure API keys
os.environ["MEM0_API_KEY"] = "your-mem0-api-key"

# Initialize Mem0 client
client = MemoryClient()

class EmailProcessor:
    def __init__(self):
        """Initialize the Email Processor with Mem0 memory client"""
        self.client = client
        
    def process_email(self, email_content, user_id):
        """
        Process an email and store it in Mem0 memory
        
        Args:
            email_content (str): Raw email content
            user_id (str): User identifier for memory association
        """
        # Parse email
        parser = Parser()
        email = parser.parsestr(email_content)
        
        # Extract email details
        sender = email['from']
        recipient = email['to']
        subject = email['subject']
        date = email['date']
        body = self._get_email_body(email)
        
        # Create message object for Mem0
        message = {
            "role": "user",
            "content": f"Email from {sender}: {subject}\n\n{body}"
        }
        
        # Create metadata for better retrieval
        metadata = {
            "email_type": "incoming",
            "sender": sender,
            "recipient": recipient,
            "subject": subject,
            "date": date
        }
        
        # Store in Mem0 with appropriate categories
        response = self.client.add(
            messages=[message],
            user_id=user_id,
            metadata=metadata,
            categories=["email", "correspondence"],
            
        )
        
        return response
    
    def _get_email_body(self, email):
        """Extract the body content from an email"""
        # Simplified extraction - in real-world, handle multipart emails
        if email.is_multipart():
            for part in email.walk():
                if part.get_content_type() == "text/plain":
                    return part.get_payload(decode=True).decode()
        else:
            return email.get_payload(decode=True).decode()
    
    def search_emails(self, query, user_id, sender=None):
        """
        Search through stored emails

        Args:
            query (str): Search query
            user_id (str): User identifier
            sender (str, optional): Filter by sender email address
        """
        # For Platform API, all filters including user_id go in filters object
        if not sender:
            # Simple filter - just user_id and category
            filters = {
                "AND": [
                    {"user_id": user_id},
                    {"categories": {"contains": "email"}}
                ]
            }
            results = self.client.search(query=query, filters=filters)
        else:
            # Advanced filter - add sender condition
            filters = {
                "AND": [
                    {"user_id": user_id},
                    {"categories": {"contains": "email"}},
                    {"sender": sender}
                ]
            }
            results = self.client.search(query=query, filters=filters)

        return results
        
    def get_email_thread(self, subject, user_id):
        """
        Retrieve all emails in a thread based on subject

        Args:
            subject (str): Email subject to match
            user_id (str): User identifier
        """
        # For Platform API, user_id goes in the filters object
        filters = {
            "AND": [
                {"user_id": user_id},
                {"categories": {"contains": "email"}},
                {"subject": {"icontains": subject}}
            ]
        }

        thread = self.client.get_all(filters=filters)

        return thread

# Initialize the processor
processor = EmailProcessor()

# Example raw email
sample_email = """From: alice@example.com
To: bob@example.com
Subject: Meeting Schedule Update
Date: Mon, 15 Jul 2024 14:22:05 -0700

Hi Bob,

I wanted to update you on the schedule for our upcoming project meeting.
We'll be meeting this Thursday at 2pm instead of Friday.

Could you please prepare your section of the presentation?

Thanks,
Alice
"""

# Process and store the email
user_id = "bob@example.com"
processor.process_email(sample_email, user_id)

# Later, search for emails about meetings
meeting_emails = processor.search_emails("meeting schedule", user_id)
print(f"Found {len(meeting_emails['results'])} relevant emails")
```

## Key Features and Benefits

* **Long-term Email Memory**: Store and retrieve email conversations across long periods
* **Semantic Search**: Find relevant emails even if they don't contain exact keywords
* **Intelligent Categorization**: Automatically sort emails into meaningful categories
* **Action Item Extraction**: Identify and track tasks mentioned in emails
* **Priority Management**: Focus on important emails based on AI-determined priority
* **Context Awareness**: Maintain thread context for more relevant interactions

## Conclusion

By combining Mem0's memory capabilities with email processing, you can create intelligent email management systems that help users organize, prioritize, and act on their inbox effectively. The advanced capabilities like automatic categorization, action item extraction, and priority management can significantly reduce the time spent on email management, allowing users to focus on more important tasks.

***

<CardGroup cols={2}>
  <Card title="Tag and Organize Memories" icon="tag" href="/cookbooks/essentials/tagging-and-organizing-memories">
    Categorize email threads by sender, topic, and priority for faster retrieval.
  </Card>

  <Card title="Support Inbox with Mem0" icon="headset" href="/cookbooks/operations/support-inbox">
    Build customer support agents that remember context across tickets.
  </Card>
</CardGroup>


# Memory-Powered Support Agent
Source: https://docs.mem0.ai/cookbooks/operations/support-inbox

Build a support assistant that keeps past tickets and resolutions at its fingertips.

You can create a personalized Customer Support AI Agent using Mem0. This guide will walk you through the necessary steps and provide the complete code to get you started.

## Overview

The Customer Support AI Agent leverages Mem0 to retain information across interactions, enabling a personalized and efficient support experience.

## Setup

Install the necessary packages using pip:

```bash  theme={null}
pip install openai mem0ai
```

## Full Code Example

Below is the simplified code to create and interact with a Customer Support AI Agent using Mem0:

```python  theme={null}
import os
from openai import OpenAI
from mem0 import Memory

# Set the OpenAI API key
os.environ['OPENAI_API_KEY'] = 'sk-xxx'

class CustomerSupportAIAgent:
    def __init__(self):
        """
        Initialize the CustomerSupportAIAgent with memory configuration and OpenAI client.
        """
        config = {
            "vector_store": {
                "provider": "qdrant",
                "config": {
                    "host": "localhost",
                    "port": 6333,
                }
            },
        }
        self.memory = Memory.from_config(config)
        self.client = OpenAI()
        self.app_id = "customer-support"

    def handle_query(self, query, user_id=None):
        """
        Handle a customer query and store the relevant information in memory.

        :param query: The customer query to handle.
        :param user_id: Optional user ID to associate with the memory.
        """
        # Start a streaming chat completion request to the AI
        stream = self.client.chat.completions.create(
            model="gpt-4",
            stream=True,
            messages=[
                {"role": "system", "content": "You are a customer support AI agent."},
                {"role": "user", "content": query}
            ]
        )
        # Store the query in memory
        self.memory.add(query, user_id=user_id, metadata={"app_id": self.app_id})

        # Print the response from the AI in real-time
        for chunk in stream:
            if chunk.choices[0].delta.content is not None:
                print(chunk.choices[0].delta.content, end="")

    def get_memories(self, user_id=None):
        """
        Retrieve all memories associated with the given customer ID.

        :param user_id: Optional user ID to filter memories.
        :return: List of memories.
        """
        return self.memory.get_all(user_id=user_id)

# Instantiate the CustomerSupportAIAgent
support_agent = CustomerSupportAIAgent()

# Define a customer ID
customer_id = "jane_doe"

# Handle a customer query
support_agent.handle_query("I need help with my recent order. It hasn't arrived yet.", user_id=customer_id)
```

### Fetching Memories

You can fetch all the memories at any point in time using the following code:

```python  theme={null}
memories = support_agent.get_memories(user_id=customer_id)
for m in memories['results']:
    print(m['memory'])
```

### Key Points

* **Initialization**: The CustomerSupportAIAgent class is initialized with the necessary memory configuration and OpenAI client setup.
* **Handling Queries**: The handle\_query method sends a query to the AI and stores the relevant information in memory.
* **Retrieving Memories**: The get\_memories method fetches all stored memories associated with a customer.

### Conclusion

As the conversation progresses, Mem0's memory automatically updates based on the interactions, providing a continuously improving personalized support experience.

***

<CardGroup cols={2}>
  <Card title="Build a Mem0 Companion" icon="users" href="/cookbooks/essentials/building-ai-companion">
    Master the foundational patterns for building memory-powered assistants.
  </Card>

  <Card title="Email Automation with Mem0" icon="envelope" href="/cookbooks/operations/email-automation">
    Extend support capabilities with intelligent email processing and routing.
  </Card>
</CardGroup>


# Collaborative Task Assistant
Source: https://docs.mem0.ai/cookbooks/operations/team-task-agent

Coordinate multi-user projects with shared memories and roles.

## Overview

Build a multi-user collaborative chat or task management system with Mem0. Each message is attributed to its author, and all messages are stored in a shared project space. Mem0 makes it easy to track contributions, sort and group messages, and collaborate in real time.

## Setup

Install the required packages:

```bash  theme={null}
pip install openai mem0ai
```

## Full Code Example

```python  theme={null}
from openai import OpenAI
from mem0 import Memory
import os
from datetime import datetime
from collections import defaultdict

# Set your OpenAI API key
os.environ["OPENAI_API_KEY"] = "sk-your-key"

# Shared project context
RUN_ID = "project-demo"

# Initialize Mem0
mem = Memory()

class CollaborativeAgent:
    def __init__(self, run_id):
        self.run_id = run_id
        self.mem = mem

    def add_message(self, role, name, content):
        msg = {"role": role, "name": name, "content": content}
        self.mem.add([msg], run_id=self.run_id, infer=False)

    def brainstorm(self, prompt):
        # Get recent messages for context
        memories = self.mem.search(prompt, run_id=self.run_id, limit=5)["results"]
        context = "\n".join(f"- {m['memory']} (by {m.get('actor_id', 'Unknown')})" for m in memories)
        client = OpenAI()
        messages = [
            {"role": "system", "content": "You are a helpful project assistant."},
            {"role": "user", "content": f"Prompt: {prompt}\nContext:\n{context}"}
        ]
        reply = client.chat.completions.create(
            model="gpt-4.1-nano-2025-04-14",
            messages=messages
        ).choices[0].message.content.strip()
        self.add_message("assistant", "assistant", reply)
        return reply

    def get_all_messages(self):
        return self.mem.get_all(run_id=self.run_id)["results"]

    def print_sorted_by_time(self):
        messages = self.get_all_messages()
        messages.sort(key=lambda m: m.get('created_at', ''))
        print("\n--- Messages (sorted by time) ---")
        for m in messages:
            who = m.get("actor_id") or "Unknown"
            ts = m.get('created_at', 'Timestamp N/A')
            try:
                dt = datetime.fromisoformat(ts.replace('Z', '+00:00'))
                ts_fmt = dt.strftime('%Y-%m-%d %H:%M:%S')
            except Exception:
                ts_fmt = ts
            print(f"[{ts_fmt}] [{who}] {m['memory']}")

    def print_grouped_by_actor(self):
        messages = self.get_all_messages()
        grouped = defaultdict(list)
        for m in messages:
            grouped[m.get("actor_id") or "Unknown"].append(m)
        print("\n--- Messages (grouped by actor) ---")
        for actor, mems in grouped.items():
            print(f"\n=== {actor} ===")
            for m in mems:
                ts = m.get('created_at', 'Timestamp N/A')
                try:
                    dt = datetime.fromisoformat(ts.replace('Z', '+00:00'))
                    ts_fmt = dt.strftime('%Y-%m-%d %H:%M:%S')
                except Exception:
                    ts_fmt = ts
                print(f"[{ts_fmt}] {m['memory']}")
```

## Usage

```python  theme={null}
# Example usage
agent = CollaborativeAgent(RUN_ID)
agent.add_message("user", "alice", "Let's list tasks for the new landing page.")
agent.add_message("user", "bob", "I'll own the hero section copy.")
agent.add_message("user", "carol", "I'll choose product screenshots.")

# Brainstorm with context
print("\nAssistant reply:\n", agent.brainstorm("What are the current open tasks?"))

# Print all messages sorted by time
agent.print_sorted_by_time()

# Print all messages grouped by actor
agent.print_grouped_by_actor()
```

## Key Points

* Each message is attributed to a user or agent (actor)
* All messages are stored in a shared project space (`run_id`)
* You can sort messages by time, group by actor, and format timestamps for clarity
* Mem0 makes it easy to build collaborative, attributed chat/task systems

## Conclusion

Mem0 enables fast, transparent collaboration for teams and agents, with full attribution, flexible memory search, and easy message organization.

***

<CardGroup cols={2}>
  <Card title="Partition Memories by Entity" icon="layers" href="/cookbooks/essentials/entity-partitioning-playbook">
    Learn how to scope memories across users, agents, and runs for team workflows.
  </Card>

  <Card title="Support Inbox with Mem0" icon="headset" href="/cookbooks/operations/support-inbox">
    Apply collaborative memory patterns to customer support scenarios.
  </Card>
</CardGroup>


# Overview
Source: https://docs.mem0.ai/cookbooks/overview

How to use mem0 in your existing applications?

With Mem0, you can create stateful LLM-based applications such as chatbots, virtual assistants, or AI agents. Mem0 enhances your applications by providing a memory layer that makes responses:

* More personalized
* More reliable
* Cost-effective by reducing the number of LLM interactions
* More engaging
* Enables long-term memory

Here are some examples of how Mem0 can be integrated into various applications:

## Essentials

<CardGroup cols={2}>
  <Card title="Build a Companion with Mem0" icon="users" href="/cookbooks/essentials/building-ai-companion">
    Learn core memory lifecycle patterns.
  </Card>

  <Card title="Partition Memories by Entity" icon="server" href="/cookbooks/essentials/entity-partitioning-playbook">
    Balance personalization with consistent behavior across users, agents, and apps.
  </Card>

  <Card title="Control Memory Ingestion" icon="filter" href="/cookbooks/essentials/controlling-memory-ingestion">
    Filter speculation and low-confidence data.
  </Card>

  <Card title="Set Memory Expiration" icon="timer" href="/cookbooks/essentials/memory-expiration-short-and-long-term">
    Short-term vs long-term retention strategies.
  </Card>
</CardGroup>

## Companion Playbooks

<CardGroup cols={2}>
  <Card title="Interactive Memory Demo" icon="rocket" href="/cookbooks/companions/quickstart-demo">
    See Mem0 memories in action.
  </Card>

  <Card title="Research Assistant for YouTube" icon="video" href="/cookbooks/companions/youtube-research">
    Personalized context for video browsing.
  </Card>

  <Card title="Voice-First AI Companion" icon="microphone" href="/cookbooks/companions/voice-companion-openai">
    Voice-first experiences with Agents SDK.
  </Card>

  <Card title="Personalized AI Tutor" icon="graduation-cap" href="/cookbooks/companions/ai-tutor">
    Student progress persistent across sessions.
  </Card>

  <Card title="Smart Travel Assistant" icon="plane" href="/cookbooks/companions/travel-assistant">
    Itineraries that remember traveler preferences.
  </Card>

  <Card title="Build a Node.js Companion" icon="js" href="/cookbooks/companions/nodejs-companion">
    JavaScript fitness coach remembering goals.
  </Card>

  <Card title="Self-Hosted AI Companion" icon="server" href="/cookbooks/companions/local-companion-ollama">
    Run Mem0 end-to-end with Ollama.
  </Card>
</CardGroup>

## Ops & Automations

<CardGroup cols={2}>
  <Card title="Automated Email Intelligence" icon="envelope" href="/cookbooks/operations/email-automation">
    Capture and recall inbox threads.
  </Card>

  <Card title="Content Creation Workflow" icon="pencil" href="/cookbooks/operations/content-writing">
    Store tone and style guidelines.
  </Card>

  <Card title="Multi-Session Research Agent" icon="magnifying-glass" href="/cookbooks/operations/deep-research">
    Multi-session investigations without repeating.
  </Card>

  <Card title="Memory-Powered Support Agent" icon="headset" href="/cookbooks/operations/support-inbox">
    Past tickets at support fingertips.
  </Card>

  <Card title="Collaborative Task Assistant" icon="users" href="/cookbooks/operations/team-task-agent">
    Coordinate multi-user projects with roles.
  </Card>
</CardGroup>

## Integrations & Platforms

<CardGroup cols={2}>
  <Card title="Memory-Powered Agent SDK" icon="robot" href="/cookbooks/integrations/agents-sdk-tool">
    Callable tools inside agent workflows.
  </Card>

  <Card title="Memory as OpenAI Tool" icon="wrench" href="/cookbooks/integrations/openai-tool-calls">
    Memories in function-calling flows.
  </Card>

  <Card title="Persistent Mastra Agents" icon="code" href="/cookbooks/integrations/mastra-agent">
    Persistent memory for Mastra agents.
  </Card>

  <Card title="Healthcare Coach with ADK" icon="heart-pulse" href="/cookbooks/integrations/healthcare-google-adk">
    Patient history across ADK sessions.
  </Card>

  <Card title="Search with Personal Context" icon="search" href="/cookbooks/integrations/tavily-search">
    Realtime search with personal context.
  </Card>

  <Card title="Bedrock with Persistent Memory" icon="aws" href="/cookbooks/integrations/aws-bedrock">
    Mem0 with AWS Bedrock and Neptune.
  </Card>

  <Card title="Graph Memory on Neptune" icon="network-wired" href="/cookbooks/integrations/neptune-analytics">
    Graph memory with Neptune Analytics.
  </Card>
</CardGroup>

## Frameworks & Multimodal

<CardGroup cols={2}>
  <Card title="ReAct Agents with Memory" icon="brain" href="/cookbooks/frameworks/llamaindex-react">
    ReAct agents with memory storage.
  </Card>

  <Card title="Multi-Agent Collaboration" icon="users" href="/cookbooks/frameworks/llamaindex-multiagent">
    Shared memory across collaborating agents.
  </Card>

  <Card title="Visual Memory Retrieval" icon="image" href="/cookbooks/frameworks/multimodal-retrieval">
    Visual context alongside text conversations.
  </Card>

  <Card title="Persistent Eliza Characters" icon="robot" href="/cookbooks/frameworks/eliza-os-character">
    Persistent personality for Eliza agents.
  </Card>

  <Card title="Browser Extension Memory" icon="globe" href="/cookbooks/frameworks/chrome-extension">
    Universal memory layer for Chrome.
  </Card>
</CardGroup>

***

## Contribute a Cookbook

Have a unique Mem0 use case or integration? We'd love to feature your cookbook!

All cookbooks follow a standardized template to ensure consistency and quality. Check out our template to see the structure and best practices.

<CardGroup cols={2}>
  <Card title="Cookbook Template" icon="book-open" href="/templates/cookbook_template">
    Follow this structure for narrative, end-to-end Mem0 workflows.
  </Card>

  <Card title="Contribution Guide" icon="github" href="https://github.com/mem0ai/mem0/blob/main/CONTRIBUTING.md">
    Learn how to submit your cookbook to the Mem0 repository.
  </Card>
</CardGroup>


# Overview
Source: https://docs.mem0.ai/integrations

How to integrate Mem0 into other frameworks

Mem0 seamlessly integrates with popular AI frameworks and tools to enhance your LLM-based applications with persistent memory capabilities. By integrating Mem0, your applications benefit from:

* Enhanced context management across multiple frameworks
* Consistent memory persistence across different LLM interactions
* Optimized token usage through efficient memory retrieval
* Framework-agnostic memory layer
* Simple integration with existing AI tools and frameworks

Here are the available integrations for Mem0:

## Integrations

<CardGroup cols={2}>
  <Card
    title="AgentOps"
    icon={
    <svg
      xmlns="http://www.w3.org/2000/svg"
      width="25"
      height="26"
      viewBox="0 0 30 36"
      fill="none"
    >
    <path d="M10.4659 6.47277C10.45 6.37428 10.4381 6.27986 10.4303 6.18101L10.4285 6.16388C10.4212 6.09482 10.414 6.02566 10.4106 5.95626L1.18538 21.8752C0.505422 23.0493 0.323356 24.4208 0.675227 25.7289C0.849119 26.3869 1.14971 26.9859 1.55323 27.5098C1.95675 28.0338 2.46282 28.4751 3.05175 28.8143C3.83464 29.2675 4.70856 29.5 5.59028 29.5C6.03318 29.5 6.4798 29.4408 6.91899 29.3226C8.23581 28.972 9.3349 28.1326 10.0152 26.9545L15.9268 16.749V16.7449L16.5001 15.7637L17.6431 13.7936L16.5001 11.8234L15.9309 10.8381L15.9268 10.8341L13.7836 7.13406C13.6651 6.933 13.5741 6.72418 13.5109 6.51165C13.2817 5.80223 13.3292 5.04172 13.6097 4.37599L13.8115 4.02535C14.3532 3.09155 15.31 2.53987 16.3184 2.47692C16.3738 2.46915 16.4251 2.46915 16.4804 2.46915C16.5421 2.46915 16.6038 2.47257 16.6654 2.47599L16.6822 2.47692C17.6906 2.53987 18.6474 3.09155 19.1892 4.02535L21.2216 7.52838L21.8146 8.55289L21.8421 8.60399L30.1024 22.8601C30.5174 23.5814 30.6281 24.4167 30.4148 25.2205C30.1975 26.0244 29.6832 26.6942 28.9598 27.1081C28.2364 27.5258 27.3977 27.6361 26.5911 27.4195C25.7844 27.2066 25.1123 26.6905 24.6968 25.9696L18.2119 14.7788L17.069 16.7449L22.9847 26.9545C23.6646 28.1326 24.7641 28.972 26.0809 29.3226C26.5197 29.4408 26.9626 29.5 27.4096 29.5C28.2914 29.5 29.1612 29.2675 29.9482 28.8143C31.1264 28.1367 31.9728 27.0411 32.3247 25.7289C32.6766 24.4208 32.4949 23.0493 31.8145 21.8752L21.1261 3.43034C20.7029 2.51617 20.0033 1.72011 19.0621 1.18027C18.5281 0.877027 17.9708 0.675975 17.3975 0.581189C17.3027 0.565268 17.2076 0.549717 17.1129 0.537868C17.0099 0.52602 16.9074 0.518244 16.8045 0.510469C16.6027 0.498621 16.3972 0.494548 16.1914 0.510469C16.0885 0.518244 15.9859 0.52639 15.883 0.537868C15.795 0.54887 15.7067 0.563384 15.6187 0.577852L15.5984 0.581189C15.0291 0.675605 14.4673 0.876657 13.9375 1.18027C12.9885 1.72789 12.2766 2.53579 11.8537 3.46181C11.7742 3.63473 11.707 3.81282 11.6471 3.99314C11.6361 4.02668 11.6269 4.06051 11.6177 4.09435C11.612 4.11503 11.6064 4.13579 11.6003 4.15642C11.5624 4.28601 11.5275 4.41634 11.4996 4.54853C11.4885 4.60231 11.4794 4.65668 11.4703 4.71111L11.4666 4.73329C11.4443 4.86399 11.4264 4.99543 11.4145 5.12762C11.4093 5.18686 11.4045 5.24573 11.4012 5.30534C11.3934 5.44567 11.3923 5.58637 11.3963 5.72744C11.3969 5.74403 11.3962 5.76062 11.3956 5.7772C11.3949 5.79616 11.3942 5.81512 11.3952 5.83407C11.3952 5.86184 11.3952 5.88924 11.3993 5.92071C11.3998 5.9291 11.4006 5.93736 11.4014 5.94564C11.402 5.95125 11.4026 5.95687 11.403 5.96255C11.4045 5.98181 11.4064 6.00106 11.4082 6.02031C11.4097 6.03577 11.4109 6.05122 11.4122 6.06674C11.4142 6.09134 11.4163 6.11621 11.419 6.14139L11.4428 6.32282C11.4506 6.38983 11.4625 6.46092 11.4744 6.52757C11.5063 6.68863 11.5468 6.84896 11.5936 7.0078C11.5944 7.0102 11.5949 7.0127 11.5955 7.0152C11.5958 7.01662 11.5961 7.01804 11.5965 7.01944C11.5967 7.02051 11.597 7.02157 11.5974 7.02261C11.6483 7.19293 11.7081 7.36177 11.7787 7.52838C11.8619 7.72943 11.9607 7.92641 12.0715 8.11932L12.3245 8.5566V8.56067L12.4984 8.85614L12.7199 9.24232H12.7239L12.728 9.25417L14.7802 12.7927V12.7968L14.7883 12.805V12.809L15.3576 13.7943L14.7883 14.7796L8.30344 25.9703C7.88431 26.6912 7.21216 27.2077 6.40921 27.4202C6.14019 27.4913 5.86338 27.5306 5.59474 27.5306C5.053 27.5306 4.51906 27.3888 4.04085 27.1089C3.31705 26.6953 2.79909 26.0251 2.58581 25.2213C2.36845 24.4174 2.47917 23.5821 2.89829 22.8609L11.1585 8.60473L11.186 8.56141V8.55734C11.1266 8.45478 11.0753 8.35629 11.024 8.25409C11.0105 8.22496 10.9969 8.19611 10.9834 8.16739C10.9458 8.08735 10.9086 8.00836 10.8739 7.92715C10.8718 7.92504 10.8708 7.92194 10.8698 7.91887C10.8688 7.91602 10.8679 7.91319 10.8661 7.91123V7.90346C10.8423 7.8483 10.8186 7.79311 10.7989 7.73795C10.7476 7.60799 10.7041 7.47803 10.6644 7.3477C10.6012 7.15479 10.5536 6.96152 10.518 6.76861C10.4942 6.67012 10.4786 6.5757 10.4667 6.47684C10.4667 6.47684 10.47 6.47684 10.4659 6.47277Z" fill="currentColor"></path>
    </svg>
  }
    href="/integrations/agentops"
  >
    Monitor and analyze Mem0 operations with comprehensive AI agent analytics and LLM observability.
  </Card>

  <Card
    title="LangChain"
    icon={
    <svg
      role="img"
      viewBox="0 0 24 24"
      xmlns="http://www.w3.org/2000/svg"
      width="32"
      height="32"
    >
      <title>LangChain</title>
      <path
        d="M6.0988 5.9175C2.7359 5.9175 0 8.6462 0 12s2.736 6.0825 6.0988 6.0825h11.8024C21.2641 18.0825 24 15.3538 24 12s-2.736 -6.0825 -6.0988 -6.0825ZM5.9774 7.851c0.493 0.0124 1.02 0.2496 1.273 0.6228 0.3673 0.4592 0.4778 1.0668 0.8944 1.4932 0.5604 0.6118 1.199 1.1505 1.7161 1.802 0.4892 0.5954 0.8386 1.2937 1.1436 1.9975 0.1244 0.2335 0.1257 0.5202 0.31 0.7197 0.0908 0.1204 0.5346 0.4483 0.4383 0.5645 0.0555 0.1204 0.4702 0.286 0.3263 0.4027 -0.1944 0.04 -0.4129 0.0476 -0.5616 -0.1074 -0.0549 0.126 -0.183 0.0596 -0.2819 0.0432a4 4 0 0 0 -0.025 0.0736c-0.3288 0.0219 -0.5754 -0.3126 -0.732 -0.565 -0.3111 -0.168 -0.6642 -0.2702 -0.982 -0.446 -0.0182 0.2895 0.0452 0.6485 -0.231 0.8353 -0.014 0.5565 0.8436 0.0656 0.9222 0.4804 -0.061 0.0067 -0.1286 -0.0095 -0.1774 0.0373 -0.2239 0.2172 -0.4805 -0.1645 -0.7385 -0.007 -0.3464 0.174 -0.3808 0.3161 -0.8096 0.352 -0.0237 -0.0359 -0.0143 -0.0592 0.0059 -0.0811 0.1207 -0.1399 0.1295 -0.3046 0.3356 -0.3643 -0.2122 -0.0334 -0.3899 0.0833 -0.5686 0.1757 -0.2323 0.095 -0.2304 -0.2141 -0.5878 0.0164 -0.0396 -0.0322 -0.0208 -0.0615 0.0018 -0.0864 0.0908 -0.1107 0.2102 -0.127 0.345 -0.1208 -0.663 -0.3686 -0.9751 0.4507 -1.2813 0.0432 -0.092 0.0243 -0.1265 0.1068 -0.1845 0.1652 -0.05 -0.0548 -0.0123 -0.1212 -0.0099 -0.1857 -0.0598 -0.028 -0.1356 -0.041 -0.1179 -0.1366 -0.1171 -0.0395 -0.1988 0.0295 -0.286 0.0952 -0.0787 -0.0608 0.0532 -0.1492 0.0776 -0.2125 0.0702 -0.1216 0.23 -0.025 0.3111 -0.1126 0.2306 -0.1308 0.552 0.0814 0.8155 0.0455 0.203 0.0255 0.4544 -0.1825 0.3526 -0.39 -0.2171 -0.2767 -0.179 -0.6386 -0.1839 -0.9695 -0.0268 -0.1929 -0.491 -0.4382 -0.6252 -0.6462 -0.1659 -0.1873 -0.295 -0.4047 -0.4243 -0.6182 -0.4666 -0.9008 -0.3198 -2.0584 -0.9077 -2.8947 -0.266 0.1466 -0.6125 0.0774 -0.8418 -0.119 -0.1238 0.1125 -0.1292 0.2598 -0.139 0.4161 -0.297 -0.2962 -0.2593 -0.8559 -0.022 -1.1855 0.0969 -0.1302 0.2127 -0.2373 0.342 -0.3316 0.0292 -0.0213 0.0391 -0.0419 0.0385 -0.0747 0.1174 -0.5267 0.5764 -0.7391 1.0694 -0.7267m12.4071 0.46c0.5575 0 1.0806 0.2159 1.474 0.6082s0.61 0.9145 0.61 1.4704c0 0.556 -0.2167 1.078 -0.61 1.4698v0.0006l-0.902 0.8995a2.08 2.08 0 0 1 -0.8597 0.5166l-0.0164 0.0047 -0.0058 0.0164a2.05 2.05 0 0 1 -0.474 0.7308l-0.9018 0.8995c-0.3934 0.3924 -0.917 0.6083 -1.4745 0.6083s-1.0806 -0.216 -1.474 -0.6083c-0.813 -0.8107 -0.813 -2.1294 0 -2.9402l0.9019 -0.8995a2.056 2.056 0 0 1 0.858 -0.5143l0.017 -0.0053 0.0058 -0.0158a2.07 2.07 0 0 1 0.4752 -0.7337l0.9018 -0.8995c0.3934 -0.3924 0.9171 -0.6083 1.4745 -0.6083zm0 0.8965a1.18 1.18 0 0 0 -0.8388 0.3462l-0.9018 0.8995a1.181 1.181 0 0 0 -0.3427 0.9252l0.0053 0.0572c0.0323 0.2652 0.149 0.5044 0.3374 0.6917 0.13 0.1296 0.2733 0.2114 0.4471 0.2686a0.9 0.9 0 0 1 0.014 0.1582 0.884 0.884 0 0 1 -0.2609 0.6304l-0.0554 0.0554c-0.3013 -0.1028 -0.5525 -0.253 -0.7794 -0.4792a2.06 2.06 0 0 1 -0.5761 -1.0968l-0.0099 -0.0578 -0.0461 0.0368a1.1 1.1 0 0 0 -0.0876 0.0794l-0.9024 0.8995c-0.4623 0.461 -0.4623 1.212 0 1.673 0.2311 0.2305 0.535 0.346 0.8394 0.3461 0.3043 0 0.6077 -0.1156 0.8388 -0.3462l0.9019 -0.8995c0.4623 -0.461 0.4623 -1.2113 0 -1.673a1.17 1.17 0 0 0 -0.4367 -0.2749 1 1 0 0 1 -0.014 -0.1611c0 -0.2591 0.1023 -0.505 0.2901 -0.6923 0.3019 0.1028 0.57 0.2694 0.7962 0.495 0.3007 0.2999 0.4994 0.679 0.5756 1.0968l0.0105 0.0578 0.0455 -0.0373a1.1 1.1 0 0 0 0.0887 -0.0794l0.902 -0.8996c0.4622 -0.461 0.4628 -1.2124 0 -1.6735a1.18 1.18 0 0 0 -0.8395 -0.3462Zm-9.973 5.1567 -0.0006 0.0006c-0.0793 0.3078 -0.1048 0.8318 -0.506 0.847 -0.033 0.1776 0.1228 0.2445 0.2655 0.1874 0.141 -0.0645 0.2081 0.0508 0.2557 0.1657 0.2177 0.0317 0.5394 -0.0725 0.5516 -0.3298 -0.325 -0.1867 -0.4253 -0.5418 -0.5662 -0.8709"
        fill="currentColor"
      />
    </svg>
  }
    href="/integrations/langchain"
  >
    Integrate Mem0 with LangChain to build powerful agents with memory
    capabilities.
  </Card>

  <Card
    title="LlamaIndex"
    icon={
    <svg
      width="24"
      height="24"
      viewBox="0 0 80 80"
      xmlns="http://www.w3.org/2000/svg"
    >
      <path
        d="M0 16C0 7.16344 7.16925 0 16.013 0H64.0518C72.8955 0 80.0648 7.16344 80.0648 16V64C80.0648 72.8366 72.8955 80 64.0518 80H16.013C7.16924 80 0 72.8366 0 64V16Z"
        fill="currentColor"
      />
      <path
        d="M50.3091 52.6201C45.1552 54.8952 39.5718 53.963 37.4243 53.2126C37.4243 53.726 37.4009 55.3218 37.3072 57.597C37.2135 59.8721 36.4873 61.3099 36.1359 61.7444C36.1749 63.1664 36.2062 66.271 36.0188 67.3138C35.8313 68.3566 35.1598 69.2493 34.8474 69.5652H31.6848C31.9659 68.1433 33.0513 67.2348 33.5589 66.9583C33.84 64.0195 33.2856 61.4679 32.9733 60.5594C32.6609 61.6654 31.8956 64.2328 31.3334 65.6548C30.7711 67.0768 29.9278 68.3803 29.5763 68.8543H27.2337C27.1165 67.4323 27.8974 66.9583 28.405 66.9583C28.6393 66.5238 29.2015 65.1571 29.5763 63.1664C29.9512 61.1756 29.4202 57.439 29.1078 55.8195V50.7241C25.3595 48.7096 23.9539 46.6952 23.0168 44.4437C22.2672 42.6425 22.4702 39.9013 22.6654 38.7558C22.4311 38.3213 21.7481 37.217 21.4941 35.6749C21.1427 33.5419 21.3379 32.0014 21.4941 31.1719C21.2598 30.9349 20.7913 29.7263 20.7913 26.7875C20.7913 23.8488 21.6502 22.3241 22.0797 21.9291V20.6256C20.4398 20.5071 18.7999 19.7961 17.8629 18.8482C16.9258 17.9002 17.6286 16.4782 18.2143 16.0042C18.7999 15.5302 19.3856 15.8857 20.2056 15.6487C21.0255 15.4117 21.7283 15.1747 22.0797 14.4637C22.3608 13.895 21.8064 11.5408 21.494 10.4348C22.8997 10.6244 23.7977 11.8568 24.071 12.4493V10.4348C25.828 11.2643 28.9907 13.2788 30.0449 17.6632C30.8882 21.1707 31.4895 28.5255 31.6847 31.7645C36.1749 31.804 41.8755 31.1211 47.0294 32.2384C51.7148 33.2542 53.8232 35.3194 56.283 35.3194C58.7428 35.3194 60.1484 33.8974 61.9055 35.0824C63.6625 36.2674 64.5996 39.5853 64.3653 42.0738C64.1779 44.0645 62.6473 44.7202 61.9055 44.7992C60.9684 47.9276 61.9055 50.9216 62.4911 52.0276V56.5305C62.7645 56.9255 63.3111 58.1421 63.3111 59.8484C63.3111 61.5548 62.7645 62.6924 62.4911 63.0479C62.9597 65.7022 62.2959 68.4198 61.9055 69.4468H58.7428C59.1177 68.4988 59.758 68.2618 60.0313 68.2618C60.5936 65.3231 60.1875 62.6134 59.9142 61.6259C58.1337 60.5831 56.9858 58.7425 56.6344 57.9525C56.6735 58.624 56.5641 60.4883 55.8145 62.5739C55.0648 64.6595 53.9403 65.8918 53.4718 66.2473V68.7358H50.3091C50.3091 67.219 51.1681 66.9188 51.5976 66.9583C52.1443 65.9708 53.4718 64.4699 53.4718 61.5074C53.4718 59.0077 51.7148 57.834 50.4263 55.5825C49.8141 54.5128 50.1139 53.1731 50.3091 52.6201Z"
        fill="url(#paint0_linear_3021_4156)"
      />
      <defs>
        <linearGradient
          id="paint0_linear_3021_4156"
          x1="21.1546"
          y1="15.4117"
          x2="71.8865"
          y2="57.9279"
          gradientUnits="userSpaceOnUse"
        >
          <stop offset="0.0619804" stop-color="#F6DCD9" />
          <stop offset="0.325677" stop-color="#FFA5EA" />
          <stop offset="0.589257" stop-color="#45DFF8" />
          <stop offset="1" stop-color="#BC8DEB" />
        </linearGradient>
      </defs>
    </svg>
  }
    href="/integrations/llama-index"
  >
    Build RAG applications with LlamaIndex and Mem0.
  </Card>

  <Card
    title="AutoGen"
    icon={
    <svg
      xmlns="http://www.w3.org/2000/svg"
      width="24"
      height="24"
      viewBox="0 0 96 85"
      fill="none"
    >
      <rect width="96" height="85" rx="6" fill="#2D2D2F" />
      <path
        d="M32.6484 28.7109L23.3672 57H15.8906L28.5703 22.875H33.3281L32.6484 28.7109ZM40.3594 57L31.0547 28.7109L30.3047 22.875H35.1094L47.8594 57H40.3594ZM39.9375 44.2969V49.8047H21.9141V44.2969H39.9375ZM77.6484 39.1641V52.6875C77.1172 53.3281 76.2969 54.0234 75.1875 54.7734C74.0781 55.5078 72.6484 56.1406 70.8984 56.6719C69.1484 57.2031 67.0312 57.4688 64.5469 57.4688C62.3438 57.4688 60.3359 57.1094 58.5234 56.3906C56.7109 55.6562 55.1484 54.5859 53.8359 53.1797C52.5391 51.7734 51.5391 50.0547 50.8359 48.0234C50.1328 45.9766 49.7812 43.6406 49.7812 41.0156V38.8828C49.7812 36.2578 50.1172 33.9219 50.7891 31.875C51.4766 29.8281 52.4531 28.1016 53.7188 26.6953C54.9844 25.2891 56.4922 24.2188 58.2422 23.4844C59.9922 22.75 61.9375 22.3828 64.0781 22.3828C67.0469 22.3828 69.4844 22.8672 71.3906 23.8359C73.2969 24.7891 74.75 26.1172 75.75 27.8203C76.7656 29.5078 77.3906 31.4453 77.625 33.6328H70.8047C70.6328 32.4766 70.3047 31.4688 69.8203 30.6094C69.3359 29.75 68.6406 29.0781 67.7344 28.5938C66.8438 28.1094 65.6875 27.8672 64.2656 27.8672C63.0938 27.8672 62.0469 28.1094 61.125 28.5938C60.2188 29.0625 59.4531 29.7578 58.8281 30.6797C58.2031 31.6016 57.7266 32.7422 57.3984 34.1016C57.0703 35.4609 56.9062 37.0391 56.9062 38.8359V41.0156C56.9062 42.7969 57.0781 44.375 57.4219 45.75C57.7656 47.1094 58.2734 48.2578 58.9453 49.1953C59.6328 50.1172 60.4766 50.8125 61.4766 51.2812C62.4766 51.75 63.6406 51.9844 64.9688 51.9844C66.0781 51.9844 67 51.8906 67.7344 51.7031C68.4844 51.5156 69.0859 51.2891 69.5391 51.0234C70.0078 50.7422 70.3672 50.4766 70.6172 50.2266V44.1797H64.1953V39.1641H77.6484Z"
        fill="white"
      />
    </svg>
  }
    href="/integrations/autogen"
  >
    Build multi-agent systems with persistent memory capabilities.
  </Card>

  <Card
    title="CrewAI"
    icon={
    <svg
      xmlns="http://www.w3.org/2000/svg"
      width="24"
      height="24"
      viewBox="0 0 48 48"
      preserveAspectRatio="xMidYMid meet"
    >
      <g
        transform="translate(0.000000,48.000000) scale(0.100000,-0.100000)"
        fill="currentColor"
        stroke="none"
      >
        <path d="M252 469 c-103 -22 -213 -172 -214 -294 -1 -107 60 -168 168 -167 130 1 276 133 234 211 -13 25 -27 26 -52 4 -31 -27 -32 -6 -4 56 34 77 33 103 -6 146 -38 40 -78 55 -126 44z m103 -40 c44 -39 46 -82 9 -163 -27 -60 -42 -68 -74 -36 -24 24 -26 67 -5 117 22 51 19 60 -11 32 -72 -65 -125 -189 -105 -242 9 -23 16 -27 53 -27 54 0 122 33 154 76 34 44 54 44 54 1 0 -75 -125 -167 -225 -167 -121 0 -181 92 -145 222 17 58 86 153 137 187 63 42 110 42 158 0z" />
      </g>
    </svg>
  }
    href="/integrations/crewai"
  >
    Develop collaborative AI agents with shared memory using CrewAI and Mem0.
  </Card>

  <Card
    title="LangGraph"
    icon={
    <svg
      width="32"
      height="32"
      viewBox="0 0 63 33"
      xmlns="http://www.w3.org/2000/svg"
    >
      <path
        fill-rule="evenodd"
        clip-rule="evenodd"
        d="M16.0556 0.580566H46.6516C55.3698 0.580566 62.4621 7.69777 62.4621 16.4459C62.4621 25.194 55.3698 32.3112 46.6516 32.3112H16.0556C7.16924 32.3112 0.245117 25.194 0.245117 16.4459C0.245117 7.69777 7.16924 0.580566 16.0556 0.580566ZM30.103 25.1741C30.487 25.5781 31.0556 25.5581 31.5593 25.4534L31.5643 25.4559C31.7981 25.2657 31.4658 25.0248 31.1484 24.7948C30.9581 24.6569 30.7731 24.5228 30.7189 24.406C30.8946 24.1917 30.375 23.7053 29.9704 23.3266C29.8006 23.1676 29.6511 23.0276 29.5818 22.9347C29.2939 22.6213 29.1782 22.226 29.0618 21.8283C28.9846 21.5645 28.9071 21.2996 28.7788 21.0569C27.9883 19.2215 27.083 17.401 25.8137 15.8474C24.9979 14.8148 24.0669 13.8901 23.1356 12.965C22.5352 12.3687 21.9347 11.7722 21.3648 11.1466C20.7784 10.5413 20.4255 9.79548 20.072 9.04847C19.7761 8.42309 19.4797 7.79685 19.0456 7.25139C17.7314 5.30625 13.5818 4.77508 12.9733 7.52321C12.9758 7.60799 12.9484 7.66286 12.8735 7.71772C12.5369 7.9646 12.2376 8.2439 11.9858 8.58306C11.3698 9.44341 11.275 10.9023 12.0431 11.6753C12.0442 11.6587 12.0453 11.6422 12.0464 11.6257C12.0721 11.2354 12.0961 10.8705 12.4047 10.5905C12.9982 11.1018 13.8985 11.2838 14.5868 10.9023C15.4166 12.0926 15.681 13.5317 15.9462 14.9756C16.1671 16.1784 16.3887 17.3847 16.9384 18.4534C16.9497 18.4723 16.9611 18.4912 16.9725 18.5101C17.2955 19.048 17.6238 19.5946 18.0381 20.0643C18.1886 20.2976 18.4977 20.5495 18.8062 20.8009C19.2132 21.1326 19.6194 21.4636 19.6591 21.7501C19.6609 21.8748 19.6603 22.0012 19.6598 22.1283C19.6566 22.8808 19.6532 23.6601 20.1354 24.2788C20.4022 24.82 19.7489 25.3636 19.2227 25.2963C18.9342 25.3363 18.619 25.2602 18.306 25.1848C17.8778 25.0815 17.4537 24.9792 17.108 25.1766C17.011 25.2816 16.8716 25.2852 16.7316 25.2889C16.5657 25.2933 16.3987 25.2977 16.3 25.4708C16.2797 25.5223 16.2323 25.5804 16.183 25.6408C16.0748 25.7735 15.9575 25.9173 16.098 26.0269C16.1106 26.0174 16.1231 26.0078 16.1356 25.9983C16.3484 25.8358 16.5513 25.681 16.8386 25.7776C16.8004 25.9899 16.9375 26.0467 17.0745 26.1036C17.0984 26.1135 17.1224 26.1234 17.1454 26.1342C17.1439 26.1835 17.1342 26.2332 17.1245 26.2825C17.1015 26.4004 17.0789 26.516 17.1703 26.618C17.2137 26.5738 17.2521 26.5243 17.2905 26.4746C17.3846 26.353 17.4791 26.2308 17.6491 26.1865C18.023 26.6858 18.3996 26.4784 18.8721 26.2182C19.4051 25.9248 20.0601 25.5641 20.9708 26.0743C20.6217 26.0569 20.3099 26.0993 20.0755 26.3885C20.0182 26.4534 19.9683 26.5282 20.0705 26.613C20.6094 26.2639 20.8336 26.3893 21.0446 26.5074C21.1969 26.5927 21.3423 26.6741 21.5942 26.5706C21.6538 26.5395 21.7133 26.5074 21.7729 26.4752C22.1775 26.257 22.5877 26.0357 23.068 26.1117C22.7093 26.2152 22.5816 26.4426 22.4423 26.6908C22.3734 26.8136 22.3017 26.9414 22.1977 27.0619C22.1429 27.1167 22.1179 27.1815 22.1803 27.2738C22.9315 27.2114 23.2153 27.0209 23.5988 26.7636C23.7818 26.6408 23.9875 26.5027 24.2775 26.3561C24.5981 26.1587 24.9187 26.285 25.2293 26.4073C25.5664 26.54 25.8917 26.6681 26.1927 26.3736C26.2878 26.284 26.4071 26.2829 26.5258 26.2818C26.569 26.2814 26.6122 26.281 26.6541 26.2763C26.5604 25.7745 26.0319 25.7804 25.4955 25.7864C24.875 25.7933 24.2438 25.8004 24.2626 25.022C24.8391 24.6282 24.8444 23.9449 24.8494 23.299C24.8507 23.1431 24.8518 22.9893 24.8611 22.8424C25.2851 23.0788 25.7336 23.2636 26.1794 23.4473C26.5987 23.62 27.0156 23.7917 27.4072 24.0045C27.8162 24.6628 28.4546 25.5357 29.305 25.4783C29.3274 25.411 29.3474 25.3536 29.3723 25.2863C29.4213 25.2949 29.4731 25.308 29.5257 25.3213C29.7489 25.3778 29.9879 25.4384 30.103 25.1741ZM46.7702 17.6925C47.2625 18.1837 47.9304 18.4597 48.6267 18.4597C49.323 18.4597 49.9909 18.1837 50.4832 17.6925C50.9756 17.2013 51.2523 16.5351 51.2523 15.8404C51.2523 15.1458 50.9756 14.4795 50.4832 13.9883C49.9909 13.4971 49.323 13.2212 48.6267 13.2212C48.3006 13.2212 47.9807 13.2817 47.6822 13.3965L46.1773 11.1999L45.1285 11.9184L46.6412 14.1266C46.2297 14.6009 46.0011 15.2089 46.0011 15.8404C46.0011 16.5351 46.2778 17.2013 46.7702 17.6925ZM42.0587 10.5787C42.4271 10.7607 42.8332 10.8539 43.2443 10.8508C43.8053 10.8465 44.3501 10.663 44.7989 10.3274C45.2478 9.99169 45.577 9.52143 45.7385 8.9855C45.9 8.44957 45.8851 7.87615 45.6961 7.34925C45.5072 6.82235 45.154 6.36968 44.6884 6.05757C44.3471 5.82883 43.9568 5.68323 43.5488 5.6325C43.1409 5.58176 42.7266 5.62731 42.3396 5.76548C41.9525 5.90365 41.6033 6.13057 41.3202 6.42797C41.0371 6.72537 40.8279 7.08494 40.7096 7.47773C40.5913 7.87051 40.567 8.28552 40.6389 8.68935C40.7107 9.09317 40.8766 9.47453 41.1233 9.80269C41.3699 10.1309 41.6903 10.3967 42.0587 10.5787ZM42.0587 25.7882C42.4271 25.9702 42.8332 26.0634 43.2443 26.0602C43.8053 26.0559 44.3501 25.8725 44.7989 25.5368C45.2478 25.2011 45.577 24.7309 45.7385 24.195C45.9 23.659 45.8851 23.0856 45.6961 22.5587C45.5072 22.0318 45.154 21.5791 44.6884 21.267C44.3471 21.0383 43.9568 20.8927 43.5488 20.842C43.1409 20.7912 42.7266 20.8368 42.3396 20.9749C41.9525 21.1131 41.6033 21.34 41.3202 21.6374C41.0371 21.9348 40.8279 22.2944 40.7096 22.6872C40.5913 23.08 40.567 23.495 40.6389 23.8988C40.7107 24.3026 40.8766 24.684 41.1233 25.0122C41.3699 25.3403 41.6903 25.6061 42.0587 25.7882ZM44.4725 16.4916V15.1894H40.454C40.3529 14.7946 40.1601 14.4289 39.8911 14.1216L41.4029 11.8819L40.3034 11.1526L38.7916 13.3924C38.5145 13.2923 38.2224 13.2395 37.9277 13.2361C37.2333 13.2361 36.5675 13.5105 36.0765 13.9989C35.5856 14.4874 35.3097 15.1498 35.3097 15.8405C35.3097 16.5313 35.5856 17.1937 36.0765 17.6821C36.5675 18.1705 37.2333 18.4449 37.9277 18.4449C38.2224 18.4416 38.5145 18.3888 38.7916 18.2887L40.3034 20.5284L41.3899 19.7992L39.8911 17.5594C40.1601 17.2522 40.3529 16.8865 40.454 16.4916H44.4725Z"
        fill="currentColor"
      />
    </svg>
  }
    href="/integrations/langgraph"
  >
    Create complex agent workflows with memory persistence using LangGraph.
  </Card>

  <Card
    title="Vercel AI SDK"
    icon={
    <svg
      width="24"
      height="24"
      viewBox="0 0 128 128"
      xmlns="http://www.w3.org/2000/svg"
    >
      <path d="M64.002 8.576 128 119.424H0Z" fill="currentColor" />
    </svg>
  }
    href="/integrations/vercel-ai-sdk"
  >
    Build AI-powered applications with memory using the Vercel AI SDK.
  </Card>

  <Card
    title="LangChain Tools"
    icon={
    <svg
      role="img"
      viewBox="0 0 24 24"
      xmlns="http://www.w3.org/2000/svg"
      width="32"
      height="32"
    >
      <title>LangChain</title>
      <path
        d="M6.0988 5.9175C2.7359 5.9175 0 8.6462 0 12s2.736 6.0825 6.0988 6.0825h11.8024C21.2641 18.0825 24 15.3538 24 12s-2.736 -6.0825 -6.0988 -6.0825ZM5.9774 7.851c0.493 0.0124 1.02 0.2496 1.273 0.6228 0.3673 0.4592 0.4778 1.0668 0.8944 1.4932 0.5604 0.6118 1.199 1.1505 1.7161 1.802 0.4892 0.5954 0.8386 1.2937 1.1436 1.9975 0.1244 0.2335 0.1257 0.5202 0.31 0.7197 0.0908 0.1204 0.5346 0.4483 0.4383 0.5645 0.0555 0.1204 0.4702 0.286 0.3263 0.4027 -0.1944 0.04 -0.4129 0.0476 -0.5616 -0.1074 -0.0549 0.126 -0.183 0.0596 -0.2819 0.0432a4 4 0 0 0 -0.025 0.0736c-0.3288 0.0219 -0.5754 -0.3126 -0.732 -0.565 -0.3111 -0.168 -0.6642 -0.2702 -0.982 -0.446 -0.0182 0.2895 0.0452 0.6485 -0.231 0.8353 -0.014 0.5565 0.8436 0.0656 0.9222 0.4804 -0.061 0.0067 -0.1286 -0.0095 -0.1774 0.0373 -0.2239 0.2172 -0.4805 -0.1645 -0.7385 -0.007 -0.3464 0.174 -0.3808 0.3161 -0.8096 0.352 -0.0237 -0.0359 -0.0143 -0.0592 0.0059 -0.0811 0.1207 -0.1399 0.1295 -0.3046 0.3356 -0.3643 -0.2122 -0.0334 -0.3899 0.0833 -0.5686 0.1757 -0.2323 0.095 -0.2304 -0.2141 -0.5878 0.0164 -0.0396 -0.0322 -0.0208 -0.0615 0.0018 -0.0864 0.0908 -0.1107 0.2102 -0.127 0.345 -0.1208 -0.663 -0.3686 -0.9751 0.4507 -1.2813 0.0432 -0.092 0.0243 -0.1265 0.1068 -0.1845 0.1652 -0.05 -0.0548 -0.0123 -0.1212 -0.0099 -0.1857 -0.0598 -0.028 -0.1356 -0.041 -0.1179 -0.1366 -0.1171 -0.0395 -0.1988 0.0295 -0.286 0.0952 -0.0787 -0.0608 0.0532 -0.1492 0.0776 -0.2125 0.0702 -0.1216 0.23 -0.025 0.3111 -0.1126 0.2306 -0.1308 0.552 0.0814 0.8155 0.0455 0.203 0.0255 0.4544 -0.1825 0.3526 -0.39 -0.2171 -0.2767 -0.179 -0.6386 -0.1839 -0.9695 -0.0268 -0.1929 -0.491 -0.4382 -0.6252 -0.6462 -0.1659 -0.1873 -0.295 -0.4047 -0.4243 -0.6182 -0.4666 -0.9008 -0.3198 -2.0584 -0.9077 -2.8947 -0.266 0.1466 -0.6125 0.0774 -0.8418 -0.119 -0.1238 0.1125 -0.1292 0.2598 -0.139 0.4161 -0.297 -0.2962 -0.2593 -0.8559 -0.022 -1.1855 0.0969 -0.1302 0.2127 -0.2373 0.342 -0.3316 0.0292 -0.0213 0.0391 -0.0419 0.0385 -0.0747 0.1174 -0.5267 0.5764 -0.7391 1.0694 -0.7267m12.4071 0.46c0.5575 0 1.0806 0.2159 1.474 0.6082s0.61 0.9145 0.61 1.4704c0 0.556 -0.2167 1.078 -0.61 1.4698v0.0006l-0.902 0.8995a2.08 2.08 0 0 1 -0.8597 0.5166l-0.0164 0.0047 -0.0058 0.0164a2.05 2.05 0 0 1 -0.474 0.7308l-0.9018 0.8995c-0.3934 0.3924 -0.917 0.6083 -1.4745 0.6083s-1.0806 -0.216 -1.474 -0.6083c-0.813 -0.8107 -0.813 -2.1294 0 -2.9402l0.9019 -0.8995a2.056 2.056 0 0 1 0.858 -0.5143l0.017 -0.0053 0.0058 -0.0158a2.07 2.07 0 0 1 0.4752 -0.7337l0.9018 -0.8995c0.3934 -0.3924 0.9171 -0.6083 1.4745 -0.6083zm0 0.8965a1.18 1.18 0 0 0 -0.8388 0.3462l-0.9018 0.8995a1.181 1.181 0 0 0 -0.3427 0.9252l0.0053 0.0572c0.0323 0.2652 0.149 0.5044 0.3374 0.6917 0.13 0.1296 0.2733 0.2114 0.4471 0.2686a0.9 0.9 0 0 1 0.014 0.1582 0.884 0.884 0 0 1 -0.2609 0.6304l-0.0554 0.0554c-0.3013 -0.1028 -0.5525 -0.253 -0.7794 -0.4792a2.06 2.06 0 0 1 -0.5761 -1.0968l-0.0099 -0.0578 -0.0461 0.0368a1.1 1.1 0 0 0 -0.0876 0.0794l-0.9024 0.8995c-0.4623 0.461 -0.4623 1.212 0 1.673 0.2311 0.2305 0.535 0.346 0.8394 0.3461 0.3043 0 0.6077 -0.1156 0.8388 -0.3462l0.9019 -0.8995c0.4623 -0.461 0.4623 -1.2113 0 -1.673a1.17 1.17 0 0 0 -0.4367 -0.2749 1 1 0 0 1 -0.014 -0.1611c0 -0.2591 0.1023 -0.505 0.2901 -0.6923 0.3019 0.1028 0.57 0.2694 0.7962 0.495 0.3007 0.2999 0.4994 0.679 0.5756 1.0968l0.0105 0.0578 0.0455 -0.0373a1.1 1.1 0 0 0 0.0887 -0.0794l0.902 -0.8996c0.4622 -0.461 0.4628 -1.2124 0 -1.6735a1.18 1.18 0 0 0 -0.8395 -0.3462Zm-9.973 5.1567 -0.0006 0.0006c-0.0793 0.3078 -0.1048 0.8318 -0.506 0.847 -0.033 0.1776 0.1228 0.2445 0.2655 0.1874 0.141 -0.0645 0.2081 0.0508 0.2557 0.1657 0.2177 0.0317 0.5394 -0.0725 0.5516 -0.3298 -0.325 -0.1867 -0.4253 -0.5418 -0.5662 -0.8709"
        fill="currentColor"
      />
    </svg>
  }
    href="/integrations/langchain-tools"
  >
    Use Mem0 with LangChain Tools for enhanced agent capabilities.
  </Card>

  <Card
    title="Dify"
    icon={
    <svg
      xmlns="http://www.w3.org/2000/svg"
      width="24"
      height="24"
      viewBox="0 0 200 200"
      fill="none"
    >
      <path
        d="M40 20 H120 C160 20, 160 180, 120 180 H40 V20"
        fill="currentColor"
      />
    </svg>
  }
    href="/integrations/dify"
  >
    Build AI applications with persistent memory using Dify and Mem0.
  </Card>

  <Card
    title="Livekit"
    icon={
    <svg
      viewBox="0 0 24 24"
      xmlns="http://www.w3.org/2000/svg"
      width="24"
      height="24"
    >
      <text
        x="12"
        y="16"
        fontFamily="Arial"
        fontSize="12"
        textAnchor="middle"
        fill="currentColor"
        fontWeight="bold"
      >
        LK
      </text>
    </svg>
  }
    href="/integrations/livekit"
  >
    Integrate Mem0 with Livekit for voice agents.
  </Card>

  <Card
    title="ElevenLabs"
    icon={
    <svg
      xmlns="http://www.w3.org/2000/svg"
      width="24"
      height="24"
      viewBox="0 0 24 24"
      fill="none"
    >
      <rect width="24" height="24" fill="white"/>
      <rect x="8" y="4" width="2" height="16" fill="black"/>
      <rect x="14" y="4" width="2" height="16" fill="black"/>
    </svg>
  }
    href="/integrations/elevenlabs"
  >
    Build voice agents with memory using ElevenLabs Conversational AI.
  </Card>

  <Card
    title="Pipecat"
    icon={
    <svg
      viewBox="0 0 24 24"
      xmlns="http://www.w3.org/2000/svg"
      width="24"
      height="24"
    >
      <path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8z" fill="currentColor"/>
      <circle cx="8.5" cy="9" r="1.5" fill="currentColor"/>
      <circle cx="15.5" cy="9" r="1.5" fill="currentColor"/>
      <path d="M12 16c1.66 0 3-1.34 3-3H9c0 1.66 1.34 3 3 3z" fill="currentColor"/>
      <path d="M17.5 12c-.83 0-1.5-.67-1.5-1.5s.67-1.5 1.5-1.5 1.5.67 1.5 1.5-.67 1.5-1.5 1.5z" fill="currentColor"/>
      <path d="M6.5 12c-.83 0-1.5-.67-1.5-1.5S5.67 9 6.5 9s1.5.67 1.5 1.5S7.33 12 6.5 12z" fill="currentColor"/>
    </svg>
  }
    href="/integrations/pipecat"
  >
    Build conversational AI agents with memory using Pipecat.
  </Card>

  <Card
    title="Agno"
    icon={
    <svg
      xmlns="http://www.w3.org/2000/svg"
      width="24"
      height="24"
      viewBox="0 0 24 24"
      fill="none"
    >
      <path d="M8 4h8v12h8" stroke="currentColor" strokeWidth="2" fill="none" transform="rotate(15, 12, 12)"/>
    </svg>
  }
    href="/integrations/agno"
  >
    Build autonomous agents with memory using Agno framework.
  </Card>

  <Card
    title="Keywords AI"
    icon={
    <svg
      xmlns="http://www.w3.org/2000/svg"
      width="24"
      height="24"
      viewBox="0 0 24 24"
      fill="none"
    >
      <path fill-rule="evenodd" clip-rule="evenodd" d="M9.07513 1.1863C9.21663 1.07722 9.39144 1.01009 9.56624 1.01009C9.83261 1.01009 10.0823 1.12756 10.2405 1.33734L15.0101 7.4964V12.4136L16.4335 13.8401C16.7582 14.1673 16.7582 14.7043 16.4335 15.0316C16.1089 15.3588 15.5762 15.3588 15.2515 15.0316L13.3453 13.1016V8.07538L8.92529 2.36944V2.36105C8.64228 2.00024 8.70887 1.4716 9.07513 1.1863ZM18.976 14.4133C18.8344 14.3778 18.7003 14.3042 18.5894 14.1925L16.9163 12.5059C16.7249 12.3129 16.6416 12.0528 16.6749 11.8094V6.88385H16.6499L11.8553 0.691225C11.7282 0.529117 11.6716 0.333133 11.6803 0.140562C11.134 0.0481292 10.5726 0 10 0C4.47715 0 0 4.47715 0 10C0 15.5228 4.47715 20 10 20C13.9387 20 17.3456 17.7229 18.976 14.4133Z" fill="currentColor"></path>
    </svg>
  }
    href="/integrations/keywords"
  >
    Build AI applications with persistent memory and comprehensive LLM observability.
  </Card>

  <Card
    title="Raycast"
    icon={
    <svg
      xmlns="http://www.w3.org/2000/svg"
      width="24"
      height="24"
      viewBox="0 0 24 24"
      fill="none"
    >
      <path
        d="M3 12L21 12M12 3L12 21M7.5 7.5L16.5 16.5M16.5 7.5L7.5 16.5"
        stroke="currentColor"
        strokeWidth="2"
        strokeLinecap="round"
      />
    </svg>
  }
    href="/integrations/raycast"
  >
    Mem0 Raycast extension for intelligent memory management and retrieval.
  </Card>

  <Card
    title="Mastra"
    icon={
    <svg
      xmlns="http://www.w3.org/2000/svg"
      width="24"
      height="24"
      viewBox="0 0 24 24"
      fill="none"
    >
      <path
        d="M12 2L22 7L12 12L2 7L12 2Z"
        stroke="currentColor"
        strokeWidth="2"
        strokeLinejoin="round"
      />
      <path
        d="M2 17L12 22L22 17"
        stroke="currentColor"
        strokeWidth="2"
        strokeLinejoin="round"
      />
      <path
        d="M2 12L12 17L22 12"
        stroke="currentColor"
        strokeWidth="2"
        strokeLinejoin="round"
      />
    </svg>
  }
    href="/integrations/mastra"
  >
    Build AI agents with persistent memory using Mastra's framework and tools.
  </Card>
</CardGroup>


# AgentOps
Source: https://docs.mem0.ai/integrations/agentops



Integrate [**Mem0**](https://github.com/mem0ai/mem0) with [AgentOps](https://agentops.ai), a comprehensive monitoring and analytics platform for AI agents. This integration enables automatic tracking and analysis of memory operations, providing insights into agent performance and memory usage patterns.

## Overview

1. Automatic monitoring of Mem0 operations and performance metrics
2. Real-time tracking of memory add, search, and retrieval operations
3. Analytics dashboard with memory usage patterns and insights
4. Error tracking and debugging capabilities for memory operations

## Prerequisites

Before setting up Mem0 with AgentOps, ensure you have:

1. Installed the required packages:

```bash  theme={null}
pip install mem0ai agentops python-dotenv
```

2. Valid API keys:
   * [AgentOps API Key](https://app.agentops.ai/dashboard/api-keys)
   * OpenAI API Key (for LLM operations)
   * [Mem0 API Key](https://app.mem0.ai/dashboard/api-keys) (optional, for cloud operations)

## Basic Integration Example

The following example demonstrates how to integrate Mem0 with AgentOps monitoring for comprehensive memory operation tracking:

```python  theme={null}
#Import the required libraries for local memory management with Mem0
from mem0 import Memory, AsyncMemory
import os
import asyncio
import logging
from dotenv import load_dotenv
import agentops
import openai

load_dotenv()
#Set up environment variables for API keys
os.environ["AGENTOPS_API_KEY"] = os.getenv("AGENTOPS_API_KEY")
os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY")

#Set up the configuration for local memory storage and define sample user data. 
local_config = {
    "llm": {
        "provider": "openai",
        "config": {
            "model": "gpt-4.1-nano-2025-04-14",
            "temperature": 0.1,
            "max_tokens": 2000,
        },
    }
}
user_id = "alice_demo"
agent_id = "assistant_demo"
run_id = "session_001"

sample_messages = [
    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
    {"role": "assistant", "content": "How about a thriller? 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.",
    },
]

sample_preferences = [
    "I prefer dark roast coffee over light roast",
    "I exercise every morning at 6 AM",
    "I'm vegetarian and avoid all meat products",
    "I love reading science fiction novels",
    "I work in software engineering",
]

#This function demonstrates sequential memory operations using the synchronous Memory class
def demonstrate_sync_memory(local_config, sample_messages, sample_preferences, user_id):
    """
    Demonstrate synchronous Memory class operations.
    """

    agentops.start_trace("mem0_memory_example", tags=["mem0_memory_example"])
    try:
        
        memory = Memory.from_config(local_config)

        result = memory.add(
            sample_messages, user_id=user_id, metadata={"category": "movie_preferences", "session": "demo"}
        )

        for i, preference in enumerate(sample_preferences):
            result = memory.add(preference, user_id=user_id, metadata={"type": "preference", "index": i})
       
        search_queries = [
            "What movies does the user like?",
            "What are the user's food preferences?",
            "When does the user exercise?",
        ]

        for query in search_queries:
            results = memory.search(query, user_id=user_id)
        
            if results and "results" in results:
                for j, result in enumerate(results['results']): 
                    print(f"Result {j+1}: {result.get('memory', 'N/A')}")
            else:
                print("No results found")

        all_memories = memory.get_all(user_id=user_id)
        if all_memories and "results" in all_memories:
            print(f"Total memories: {len(all_memories['results'])}")

        delete_all_result = memory.delete_all(user_id=user_id)
        print(f"Delete all result: {delete_all_result}")

        agentops.end_trace(end_state="success")
    except Exception as e:
        agentops.end_trace(end_state="error")

# Execute sync demonstrations
demonstrate_sync_memory(local_config, sample_messages, sample_preferences, user_id)

```

For detailed information on this integration, refer to the official [Agentops Mem0 integration documentation](https://docs.agentops.ai/v2/integrations/mem0).

## Key Features

### 1. Automatic Operation Tracking

AgentOps automatically monitors all Mem0 operations:

* **Memory Operations**: Track add, search, get\_all, delete operations and much more
* **Performance Metrics**: Monitor response times and success rates
* **Error Tracking**: Capture and analyze operation failures

### 2. Real-time Analytics Dashboard

Access comprehensive analytics through the AgentOps dashboard:

* **Usage Patterns**: Visualize memory usage trends over time
* **User Behavior**: Analyze how different users interact with memory
* **Performance Insights**: Identify bottlenecks and optimization opportunities

### 3. Session Management

Organize your monitoring with structured sessions:

* **Session Tracking**: Group related operations into logical sessions
* **Success/Failure Rates**: Track session outcomes for reliability monitoring
* **Custom Metadata**: Add context to sessions for better analysis

## Best Practices

1. **Initialize Early**: Always initialize AgentOps before importing Mem0 classes
2. **Session Management**: Use meaningful session names and end sessions appropriately
3. **Error Handling**: Wrap operations in try-catch blocks and report failures
4. **Tagging**: Use tags to organize different types of memory operations
5. **Environment Separation**: Use different projects or tags for dev/staging/prod

<CardGroup cols={2}>
  <Card title="CrewAI Integration" icon="users" href="/integrations/crewai">
    Monitor multi-agent CrewAI systems
  </Card>

  <Card title="LangChain Integration" icon="link" href="/integrations/langchain">
    Track LangChain agent performance
  </Card>
</CardGroup>


# Agno
Source: https://docs.mem0.ai/integrations/agno



This integration of [**Mem0**](https://github.com/mem0ai/mem0) with [Agno](https://github.com/agno-agi/agno) enables persistent, multimodal memory for Agno-based agents - improving personalization, context awareness, and continuity across conversations.

## Overview

1. Store and retrieve memories from Mem0 within Agno agents
2. Support for multimodal interactions (text and images)
3. Semantic search for relevant past conversations
4. Personalized responses based on user history
5. One-line memory integration via `Mem0Tools`

## Prerequisites

Before setting up Mem0 with Agno, ensure you have:

1. Installed the required packages:

```bash  theme={null}
pip install agno mem0ai python-dotenv
```

2. Valid API keys:
   * [Mem0 API Key](https://app.mem0.ai/dashboard/api-keys)
   * OpenAI API Key (for the agent model)

## Quick Integration (Using `Mem0Tools`)

The simplest way to integrate Mem0 with Agno Agents is to use Mem0 as a tool using built-in `Mem0Tools`:

```python  theme={null}
from agno.agent import Agent
from agno.models.openai import OpenAIChat
from agno.tools.mem0 import Mem0Tools

agent = Agent(
    name="Memory Agent",
    model=OpenAIChat(id="gpt-4.1-nano-2025-04-14"),
    tools=[Mem0Tools()],
    description="An assistant that remembers and personalizes using Mem0 memory."
)
```

This enables memory functionality out of the box:

* **Persistent memory writing**: `Mem0Tools` uses `MemoryClient.add(...)` to store messages from user-agent interactions, including optional metadata such as user ID or session.
* **Contextual memory search**: Compatible queries use `MemoryClient.search(...)` to retrieve relevant past messages, improving contextual understanding.
* **Multimodal support**: Both text and image inputs are supported, allowing richer memory records.

> `Mem0Tools` uses the `MemoryClient` under the hood and requires no additional setup. You can customize its behavior by modifying your tools list or extending it in code.

## Full Manual Example

> Note: Mem0 can also be used with Agno Agents as a separate memory layer.

The following example demonstrates how to create an Agno agent with Mem0 memory integration, including support for image processing:

```python  theme={null}
import base64
from pathlib import Path
from typing import Optional

from agno.agent import Agent
from agno.media import Image
from agno.models.openai import OpenAIChat
from mem0 import MemoryClient

# Initialize the Mem0 client
client = MemoryClient()

# Define the agent
agent = Agent(
    name="Personal Agent",
    model=OpenAIChat(id="gpt-4"),
    description="You are a helpful personal agent that helps me with day to day activities."
                "You can process both text and images.",
    markdown=True
)


def chat_user(
    user_input: Optional[str] = None,
    user_id: str = "alex",
    image_path: Optional[str] = None
) -> str:
    """
    Handle user input with memory integration, supporting both text and images.

    Args:
        user_input: The user's text input
        user_id: Unique identifier for the user
        image_path: Path to an image file if provided

    Returns:
        The agent's response as a string
    """
    if image_path:
        # Convert image to base64
        with open(image_path, "rb") as image_file:
            base64_image = base64.b64encode(image_file.read()).decode("utf-8")

        # Create message objects for text and image
        messages = []

        if user_input:
            messages.append({
                "role": "user",
                "content": user_input
            })

        messages.append({
            "role": "user",
            "content": {
                "type": "image_url",
                "image_url": {
                    "url": f"data:image/jpeg;base64,{base64_image}"
                }
            }
        })

        # Store messages in memory
        client.add(messages, user_id=user_id)
        print("✅ Image and text stored in memory.")

    if user_input:
        # Search for relevant memories
        memories = client.search(user_input, user_id=user_id)
        memory_context = "\n".join(f"- {m['memory']}" for m in memories['results'])

        # Construct the prompt
        prompt = f"""
You are a helpful personal assistant who helps users with their day-to-day activities and keeps track of everything.

Your task is to:
1. Analyze the given image (if present) and extract meaningful details to answer the user's question.
2. Use your past memory of the user to personalize your answer.
3. Combine the image content and memory to generate a helpful, context-aware response.

Here is what I remember about the user:
{memory_context}

User question:
{user_input}
"""
        # Get response from agent
        if image_path:
            response = agent.run(prompt, images=[Image(filepath=Path(image_path))])
        else:
            response = agent.run(prompt)

        # Store the interaction in memory
        interaction_message = [{"role": "user", "content": f"User: {user_input}\nAssistant: {response.content}"}]
        client.add(interaction_message, user_id=user_id)
        return response.content

    return "No user input or image provided."


# Example Usage
if __name__ == "__main__":
    response = chat_user(
        "I like to travel and my favorite destination is London",
        image_path="travel_items.jpeg",
        user_id="alex"
    )
    print(response)
```

## Key Features

### 1. Multimodal Memory Storage

The integration supports storing both text and image data:

* **Text Storage**: Conversation history is saved in a structured format
* **Image Analysis**: Agents can analyze images and store visual information
* **Combined Context**: Memory retrieval combines both text and visual data

### 2. Personalized Agent Responses

Improve your agent's context awareness:

* **Memory Retrieval**: Semantic search finds relevant past interactions
* **User Preferences**: Personalize responses based on stored user information
* **Continuity**: Maintain conversation threads across multiple sessions

### 3. Flexible Configuration

Customize the integration to your needs:

* **Use `Mem0Tools()`** for drop-in memory support
* **Use `MemoryClient` directly** for advanced control
* **User Identification**: Organize memories by user ID
* **Memory Search**: Configure search relevance and result count
* **Memory Formatting**: Support for various OpenAI message formats

<CardGroup cols={2}>
  <Card title="OpenAI Agents SDK" icon="cube" href="/integrations/openai-agents-sdk">
    Build agents with OpenAI SDK and Mem0
  </Card>

  <Card title="Mastra Integration" icon="star" href="/integrations/mastra">
    Create intelligent agents with Mastra framework
  </Card>
</CardGroup>


# AutoGen
Source: https://docs.mem0.ai/integrations/autogen



Build conversational AI agents with memory capabilities. This integration combines AutoGen for creating AI agents with Mem0 for memory management, enabling context-aware and personalized interactions.

## Overview

This guide demonstrates creating a conversational AI system with memory. We'll build a customer service bot that can recall previous interactions and provide personalized responses.

## Setup and Configuration

Install necessary libraries:

```bash  theme={null}
pip install autogen mem0ai openai python-dotenv
```

First, we'll import the necessary libraries and set up our configurations.

<Note>Remember to get the Mem0 API key from [Mem0 Platform](https://app.mem0.ai).</Note>

```python  theme={null}
import os
from autogen import ConversableAgent
from mem0 import MemoryClient
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()

# Configuration
# OPENAI_API_KEY = 'sk-xxx'  # Replace with your actual OpenAI API key
# MEM0_API_KEY = 'your-mem0-key'  # Replace with your actual Mem0 API key from https://app.mem0.ai
USER_ID = "alice"

# Set up OpenAI API key
OPENAI_API_KEY = os.environ.get('OPENAI_API_KEY')
# os.environ['MEM0_API_KEY'] = MEM0_API_KEY

# Initialize Mem0 and AutoGen agents
memory_client = MemoryClient()
agent = ConversableAgent(
    "chatbot",
    llm_config={"config_list": [{"model": "gpt-4", "api_key": OPENAI_API_KEY}]},
    code_execution_config=False,
    human_input_mode="NEVER",
)
```

## Storing Conversations in Memory

Add conversation history to Mem0 for future reference:

```python  theme={null}
conversation = [
    {"role": "assistant", "content": "Hi, I'm Best Buy's chatbot! How can I help you?"},
    {"role": "user", "content": "I'm seeing horizontal lines on my TV."},
    {"role": "assistant", "content": "I'm sorry to hear that. Can you provide your TV model?"},
    {"role": "user", "content": "It's a Sony - 77\" Class BRAVIA XR A80K OLED 4K UHD Smart Google TV"},
    {"role": "assistant", "content": "Thank you for the information. Let's troubleshoot this issue..."}
]

memory_client.add(messages=conversation, user_id=USER_ID)
print("Conversation added to memory.")
```

## Retrieving and Using Memory

Create a function to get context-aware responses based on user's question and previous interactions:

```python  theme={null}
def get_context_aware_response(question):
    relevant_memories = memory_client.search(question, user_id=USER_ID)
    context = "\n".join([m["memory"] for m in relevant_memories.get('results', [])])

    prompt = f"""Answer the user question considering the previous interactions:
    Previous interactions:
    {context}

    Question: {question}
    """

    reply = agent.generate_reply(messages=[{"content": prompt, "role": "user"}])
    return reply

# Example usage
question = "What was the issue with my TV?"
answer = get_context_aware_response(question)
print("Context-aware answer:", answer)
```

## Multi-Agent Conversation

For more complex scenarios, you can create multiple agents:

```python  theme={null}
manager = ConversableAgent(
    "manager",
    system_message="You are a manager who helps in resolving complex customer issues.",
    llm_config={"config_list": [{"model": "gpt-4", "api_key": OPENAI_API_KEY}]},
    human_input_mode="NEVER"
)

def escalate_to_manager(question):
    relevant_memories = memory_client.search(question, user_id=USER_ID)
    context = "\n".join([m["memory"] for m in relevant_memories.get('results', [])])

    prompt = f"""
    Context from previous interactions:
    {context}

    Customer question: {question}

    As a manager, how would you address this issue?
    """

    manager_response = manager.generate_reply(messages=[{"content": prompt, "role": "user"}])
    return manager_response

# Example usage
complex_question = "I'm not satisfied with the troubleshooting steps. What else can be done?"
manager_answer = escalate_to_manager(complex_question)
print("Manager's response:", manager_answer)
```

## Conclusion

By integrating AutoGen with Mem0, you've created a conversational AI system with memory capabilities. This example demonstrates a customer service bot that can recall previous interactions and provide context-aware responses, with the ability to escalate complex issues to a manager agent.

This integration enables the creation of more intelligent and personalized AI agents for various applications, such as customer support, virtual assistants, and interactive chatbots.

<CardGroup cols={2}>
  <Card title="CrewAI Integration" icon="users" href="/integrations/crewai">
    Build multi-agent systems with CrewAI and Mem0
  </Card>

  <Card title="LangGraph Integration" icon="diagram-project" href="/integrations/langgraph">
    Create stateful workflows with LangGraph
  </Card>
</CardGroup>


# AWS Bedrock
Source: https://docs.mem0.ai/integrations/aws-bedrock



This integration demonstrates how to use **Mem0** with **AWS Bedrock** and **Amazon OpenSearch Service (AOSS)** to enable persistent, semantic memory in intelligent agents.

## Overview

In this guide, you'll:

1. Configure AWS credentials to enable Bedrock and OpenSearch access
2. Set up the Mem0 SDK to use Bedrock for embeddings and LLM
3. Store and retrieve memories using OpenSearch as a vector store
4. Build memory-aware applications with scalable cloud infrastructure

## Prerequisites

* AWS account with access to:
  * Bedrock foundation models (e.g., Titan, Claude)
  * OpenSearch Service with a configured domain
* Python 3.8+
* Valid AWS credentials (via environment or IAM role)

## Setup and Installation

Install required packages:

```bash  theme={null}
pip install mem0ai boto3 opensearch-py
```

Set environment variables.

Configure your AWS credentials using environment variables, IAM roles, or the AWS CLI.

```python  theme={null}
import os

os.environ['AWS_REGION'] = 'us-west-2'
os.environ['AWS_ACCESS_KEY_ID'] = 'AKIA...'
os.environ['AWS_SECRET_ACCESS_KEY'] = 'AS...'
```

## Initialize Mem0 Integration

Import necessary modules and configure Mem0:

```python  theme={null}
import boto3
from opensearchpy import OpenSearch, RequestsHttpConnection, AWSV4SignerAuth
from mem0.memory.main import Memory

region = 'us-west-2'
service = 'aoss'
credentials = boto3.Session().get_credentials()
auth = AWSV4SignerAuth(credentials, region, service)

config = {
    "embedder": {
        "provider": "aws_bedrock",
        "config": {
            "model": "amazon.titan-embed-text-v2:0"
        }
    },
    "llm": {
        "provider": "aws_bedrock",
        "config": {
            "model": "anthropic.claude-3-5-haiku-20241022-v1:0",
            "temperature": 0.1,
            "max_tokens": 2000
        }
    },
    "vector_store": {
        "provider": "opensearch",
        "config": {
            "collection_name": "mem0",
            "host": "your-opensearch-domain.us-west-2.es.amazonaws.com",
            "port": 443,
            "http_auth": auth,
            "embedding_model_dims": 1024,
            "connection_class": RequestsHttpConnection,
            "pool_maxsize": 20,
            "use_ssl": True,
            "verify_certs": True
        }
    }
}

# Initialize memory system
m = Memory.from_config(config)
```

## Memory Operations

Use Mem0 with your Bedrock-powered LLM and OpenSearch storage backend:

```python  theme={null}
# Store conversational context
messages = [
    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
    {"role": "assistant", "content": "How about a thriller?"},
    {"role": "user", "content": "I prefer sci-fi."},
    {"role": "assistant", "content": "Noted! I'll suggest sci-fi movies next time."}
]

m.add(messages, user_id="alice", metadata={"category": "movie_recommendations"})

# Search for memory
relevant = m.search("What kind of movies does Alice like?", user_id="alice")

# Retrieve all user memories
all_memories = m.get_all(user_id="alice")
```

## Key Features

1. **Serverless Memory Embeddings**: Use Titan or other Bedrock models for fast, cloud-native embeddings
2. **Scalable Vector Search**: Store and retrieve vectorized memories via OpenSearch
3. **Seamless AWS Auth**: Uses AWS IAM or environment variables to securely authenticate
4. **User-specific Memory Spaces**: Memories are isolated per user ID
5. **Persistent Memory Context**: Maintain and recall history across sessions

<CardGroup cols={2}>
  <Card title="AWS Bedrock Cookbook" icon="aws" href="/cookbooks/integrations/aws-bedrock">
    Complete guide to using Bedrock with Mem0
  </Card>

  <Card title="Neptune Analytics Cookbook" icon="database" href="/cookbooks/integrations/neptune-analytics">
    Build graph memory with AWS Neptune
  </Card>
</CardGroup>


# CrewAI
Source: https://docs.mem0.ai/integrations/crewai



Build an AI system that combines CrewAI's agent-based architecture with Mem0's memory capabilities. This integration enables persistent memory across agent interactions and personalized task execution based on user history.

## Overview

In this guide, we'll create a CrewAI agent that:

1. Uses CrewAI to manage AI agents and tasks
2. Leverages Mem0 to store and retrieve conversation history
3. Creates personalized experiences based on stored user preferences

## Setup and Configuration

Install necessary libraries:

```bash  theme={null}
pip install crewai crewai-tools mem0ai
```

Import required modules and set up configurations:

<Note>Remember to get your API keys from [Mem0 Platform](https://app.mem0.ai), [OpenAI](https://platform.openai.com) and [Serper Dev](https://serper.dev) for search capabilities.</Note>

```python  theme={null}
import os
from mem0 import MemoryClient
from crewai import Agent, Task, Crew, Process
from crewai_tools import SerperDevTool

# Configuration
os.environ["MEM0_API_KEY"] = "your-mem0-api-key"
os.environ["OPENAI_API_KEY"] = "your-openai-api-key"
os.environ["SERPER_API_KEY"] = "your-serper-api-key"

# Initialize Mem0 client
client = MemoryClient()
```

## Store User Preferences

Set up initial conversation and preferences storage:

```python  theme={null}
def store_user_preferences(user_id: str, conversation: list):
    """Store user preferences from conversation history"""
    client.add(conversation, user_id=user_id)

# Example conversation storage
messages = [
    {
        "role": "user",
        "content": "Hi there! I'm planning a vacation and could use some advice.",
    },
    {
        "role": "assistant",
        "content": "Hello! I'd be happy to help with your vacation planning. What kind of destination do you prefer?",
    },
    {"role": "user", "content": "I am more of a beach person than a mountain person."},
    {
        "role": "assistant",
        "content": "That's interesting. Do you like hotels or Airbnb?",
    },
    {"role": "user", "content": "I like Airbnb more."},
]

store_user_preferences("crew_user_1", messages)
```

## Create CrewAI Agent

Define an agent with memory capabilities:

```python  theme={null}
def create_travel_agent():
    """Create a travel planning agent with search capabilities"""
    search_tool = SerperDevTool()

    return Agent(
        role="Personalized Travel Planner Agent",
        goal="Plan personalized travel itineraries",
        backstory="""You are a seasoned travel planner, known for your meticulous attention to detail.""",
        allow_delegation=False,
        memory=True,
        tools=[search_tool],
    )
```

## Define Tasks

Create tasks for your agent:

```python  theme={null}
def create_planning_task(agent, destination: str):
    """Create a travel planning task"""
    return Task(
        description=f"""Find places to live, eat, and visit in {destination}.""",
        expected_output=f"A detailed list of places to live, eat, and visit in {destination}.",
        agent=agent,
    )
```

## Set Up Crew

Configure the crew with memory integration:

```python  theme={null}
def setup_crew(agents: list, tasks: list):
    """Set up a crew with Mem0 memory integration"""
    return Crew(
        agents=agents,
        tasks=tasks,
        process=Process.sequential,
        memory=True,
        memory_config={
            "provider": "mem0",
            "config": {"user_id": "crew_user_1"},
        }
    )
```

## Main Execution Function

Implement the main function to run the travel planning system:

```python  theme={null}
def plan_trip(destination: str, user_id: str):
    # Create agent
    travel_agent = create_travel_agent()

    # Create task
    planning_task = create_planning_task(travel_agent, destination)

    # Setup crew
    crew = setup_crew([travel_agent], [planning_task])

    # Execute and return results
    return crew.kickoff()

# Example usage
if __name__ == "__main__":
    result = plan_trip("San Francisco", "crew_user_1")
    print(result)
```

## Key Features

1. **Persistent Memory**: Uses Mem0 to maintain user preferences and conversation history
2. **Agent-Based Architecture**: Leverages CrewAI's agent system for task execution
3. **Search Integration**: Includes SerperDev tool for real-world information retrieval
4. **Personalization**: Utilizes stored preferences for tailored recommendations

## Benefits

1. **Persistent Context & Memory**: Maintains user preferences and interaction history across sessions
2. **Flexible & Scalable Design**: Easily extendable with new agents, tasks, and capabilities

## Conclusion

By combining CrewAI with Mem0, you can create sophisticated AI systems that maintain context and provide personalized experiences while leveraging the power of autonomous agents.

<CardGroup cols={2}>
  <Card title="AutoGen Integration" icon="users" href="/integrations/autogen">
    Build multi-agent systems with AutoGen and Mem0
  </Card>

  <Card title="LangGraph Integration" icon="diagram-project" href="/integrations/langgraph">
    Create stateful agent workflows with memory
  </Card>
</CardGroup>


# Dify
Source: https://docs.mem0.ai/integrations/dify



# Integrating Mem0 with Dify AI

Mem0 brings a robust memory layer to Dify AI, empowering your AI agents with persistent conversation storage and retrieval capabilities. With Mem0, your Dify applications gain the ability to recall past interactions and maintain context, ensuring more natural and insightful conversations.

***

## How to Integrate Mem0 in Your Dify Workflow

1. **Install the Mem0 Plugin:**\
   Head to the [Dify Marketplace](https://marketplace.dify.ai/plugins/yevanchen/mem0) and install the Mem0 plugin. This is your first step toward adding intelligent memory to your AI applications.

2. **Create or Open Your Dify Project:**\
   Whether you're starting fresh or updating an existing project, simply create or open your Dify workspace.

3. **Add the Mem0 Plugin to Your Project:**\
   Within your project, add the Mem0 plugin. This integration connects Mem0’s memory management capabilities directly to your Dify application.

4. **Configure Your Mem0 Settings:**\
   Customize Mem0 to suit your needs—set preferences for how conversation history is stored, the search parameters, and any other context-aware features.

5. **Leverage Mem0 in Your Workflow:**\
   Use Mem0 to store every conversation turn and retrieve past interactions seamlessly. This integration ensures that your AI agents can refer back to important context, making multi-turn dialogues more effective and user-centric.

***

<img src="https://mintcdn.com/mem0/k4LG2Flv5533NbwL/images/dify-mem0-integration.png?fit=max&auto=format&n=k4LG2Flv5533NbwL&q=85&s=3b118986ae73b9af5e12dd26eb502410" alt="Mem0 Dify Integration" data-og-width="3024" width="3024" data-og-height="1646" height="1646" data-path="images/dify-mem0-integration.png" data-optimize="true" data-opv="3" srcset="https://mintcdn.com/mem0/k4LG2Flv5533NbwL/images/dify-mem0-integration.png?w=280&fit=max&auto=format&n=k4LG2Flv5533NbwL&q=85&s=6320eaff443b4f5613d44f6e14434478 280w, https://mintcdn.com/mem0/k4LG2Flv5533NbwL/images/dify-mem0-integration.png?w=560&fit=max&auto=format&n=k4LG2Flv5533NbwL&q=85&s=dc6d8ffa43a1502bd042a75003d14683 560w, https://mintcdn.com/mem0/k4LG2Flv5533NbwL/images/dify-mem0-integration.png?w=840&fit=max&auto=format&n=k4LG2Flv5533NbwL&q=85&s=4840765e19800a61bbaefe783ce57ba5 840w, https://mintcdn.com/mem0/k4LG2Flv5533NbwL/images/dify-mem0-integration.png?w=1100&fit=max&auto=format&n=k4LG2Flv5533NbwL&q=85&s=d389b571ec5f4d4870b242cbb5e0a4b4 1100w, https://mintcdn.com/mem0/k4LG2Flv5533NbwL/images/dify-mem0-integration.png?w=1650&fit=max&auto=format&n=k4LG2Flv5533NbwL&q=85&s=345e954d75b1e4e63939c85d0122b171 1650w, https://mintcdn.com/mem0/k4LG2Flv5533NbwL/images/dify-mem0-integration.png?w=2500&fit=max&auto=format&n=k4LG2Flv5533NbwL&q=85&s=dce01795cfca0da17ed9c86bb580a020 2500w" />

Enhance your Dify-powered AI with Mem0 and transform your conversational experiences. Start integrating intelligent memory management today and give your agents the context they need to excel!

<CardGroup cols={2}>
  <Card title="Flowise Integration" icon="share-nodes" href="/integrations/flowise">
    Build visual AI workflows with Flowise
  </Card>

  <Card title="LangChain Integration" icon="link" href="/integrations/langchain">
    Create LangChain-powered applications
  </Card>
</CardGroup>


# ElevenLabs
Source: https://docs.mem0.ai/integrations/elevenlabs



Create voice-based conversational AI agents with memory capabilities by integrating ElevenLabs and Mem0. This integration enables persistent, context-aware voice interactions that remember past conversations.

## Overview

In this guide, we'll build a voice agent that:

1. Uses ElevenLabs Conversational AI for voice interaction
2. Leverages Mem0 to store and retrieve memories from past conversations
3. Provides personalized responses based on user history

## Setup and Configuration

Install necessary libraries:

```bash  theme={null}
pip install elevenlabs mem0ai python-dotenv
```

Configure your environment variables:

<Note>You'll need both an ElevenLabs API key and a Mem0 API key to use this integration.</Note>

```bash  theme={null}
# Create a .env file with these variables
AGENT_ID=your-agent-id
USER_ID=unique-user-identifier
ELEVENLABS_API_KEY=your-elevenlabs-api-key
MEM0_API_KEY=your-mem0-api-key
```

## Integration Code Breakdown

Let's break down the implementation into manageable parts:

### 1. Imports and Environment Setup

First, we import required libraries and set up the environment:

```python  theme={null}
import os
import signal
import sys
from mem0 import AsyncMemoryClient

from elevenlabs.client import ElevenLabs
from elevenlabs.conversational_ai.conversation import Conversation
from elevenlabs.conversational_ai.default_audio_interface import DefaultAudioInterface
from elevenlabs.conversational_ai.conversation import ClientTools
```

These imports provide:

* Standard Python libraries for system operations and signal handling
* `AsyncMemoryClient` from Mem0 for memory operations
* ElevenLabs components for voice interaction

### 2. Environment Variables and Validation

Next, we validate the required environment variables:

```python  theme={null}
def main():
    # Required environment variables
    AGENT_ID = os.environ.get('AGENT_ID')
    USER_ID = os.environ.get('USER_ID')
    API_KEY = os.environ.get('ELEVENLABS_API_KEY')
    MEM0_API_KEY = os.environ.get('MEM0_API_KEY')

    # Validate required environment variables
    if not AGENT_ID:
        sys.stderr.write("AGENT_ID environment variable must be set\n")
        sys.exit(1)

    if not USER_ID:
        sys.stderr.write("USER_ID environment variable must be set\n")
        sys.exit(1)

    if not API_KEY:
        sys.stderr.write("ELEVENLABS_API_KEY not set, assuming the agent is public\n")

    if not MEM0_API_KEY:
        sys.stderr.write("MEM0_API_KEY environment variable must be set\n")
        sys.exit(1)

    # Set up Mem0 API key in the environment
    os.environ['MEM0_API_KEY'] = MEM0_API_KEY
```

This section:

* Retrieves required environment variables
* Performs validation to ensure required variables are present
* Exits the application with an error message if required variables are missing
* Sets the Mem0 API key in the environment for the Mem0 client to use

### 3. Client Initialization

Initialize both the ElevenLabs and Mem0 clients:

```python  theme={null}
    # Initialize ElevenLabs client
    client = ElevenLabs(api_key=API_KEY)

    # Initialize memory client and tools
    client_tools = ClientTools()
    mem0_client = AsyncMemoryClient()
```

Here we:

* Create an ElevenLabs client with the API key
* Initialize a ClientTools object for registering function tools
* Create an AsyncMemoryClient instance for Mem0 interactions

### 4. Memory Function Definitions

Define the two key memory functions that will be registered as tools:

```python  theme={null}
    # Define memory-related functions for the agent
    async def add_memories(parameters):
        """Add a message to the memory store"""
        message = parameters.get("message")
        await mem0_client.add(
            messages=message,
            user_id=USER_ID
        )
        return "Memory added successfully"

    async def retrieve_memories(parameters):
        """Retrieve relevant memories based on the input message"""
        message = parameters.get("message")

        # For Platform API, user_id goes in filters
        filters = {"user_id": USER_ID}

        # Search for relevant memories using the message as a query
        results = await mem0_client.search(
            query=message,
            filters=filters
        )

        # Extract and join the memory texts
        memories = ' '.join([result["memory"] for result in results.get('results', [])])
        print("[ Memories ]", memories)

        if memories:
            return memories
        return "No memories found"
```

These functions:

#### `add_memories`:

* Takes a message parameter containing information to remember
* Stores the message in Mem0 using the `add` method
* Associates the memory with the specific USER\_ID
* Returns a success message to the agent

#### `retrieve_memories`:

* Takes a message parameter as the search query
* Sets up filters to only retrieve memories for the current user
* Uses semantic search to find relevant memories
* Joins all retrieved memories into a single text
* Prints retrieved memories to the console for debugging
* Returns the memories or a "No memories found" message if none are found

### 5. Registering Memory Functions as Tools

Register the memory functions with the ElevenLabs ClientTools system:

```python  theme={null}
    # Register the memory functions as tools for the agent
    client_tools.register("addMemories", add_memories, is_async=True)
    client_tools.register("retrieveMemories", retrieve_memories, is_async=True)
```

This allows the ElevenLabs agent to:

* Access these functions through function calling
* Wait for asynchronous results (is\_async=True)
* Call these functions by name ("addMemories" and "retrieveMemories")

### 6. Conversation Setup

Configure the conversation with ElevenLabs:

```python  theme={null}
    # Initialize the conversation
    conversation = Conversation(
        client,
        AGENT_ID,
        # Assume auth is required when API_KEY is set
        requires_auth=bool(API_KEY),
        audio_interface=DefaultAudioInterface(),
        client_tools=client_tools,
        callback_agent_response=lambda response: print(f"Agent: {response}"),
        callback_agent_response_correction=lambda original, corrected: print(f"Agent: {original} -> {corrected}"),
        callback_user_transcript=lambda transcript: print(f"User: {transcript}"),
        # callback_latency_measurement=lambda latency: print(f"Latency: {latency}ms"),
    )
```

This sets up the conversation with:

* The ElevenLabs client and Agent ID
* Authentication requirements based on API key presence
* DefaultAudioInterface for handling audio I/O
* The client\_tools with our memory functions
* Callback functions for:
  * Displaying agent responses
  * Showing corrected responses (when the agent self-corrects)
  * Displaying user transcripts for debugging
  * (Commented out) Latency measurements

### 7. Conversation Management

Start and manage the conversation:

```python  theme={null}
    # Start the conversation
    print(f"Starting conversation with user_id: {USER_ID}")
    conversation.start_session()

    # Handle Ctrl+C to gracefully end the session
    signal.signal(signal.SIGINT, lambda sig, frame: conversation.end_session())

    # Wait for the conversation to end and get the conversation ID
    conversation_id = conversation.wait_for_session_end()
    print(f"Conversation ID: {conversation_id}")


if __name__ == '__main__':
    main()
```

This final section:

* Prints a message indicating the conversation has started
* Starts the conversation session
* Sets up a signal handler to gracefully end the session on Ctrl+C
* Waits for the session to end and gets the conversation ID
* Prints the conversation ID for reference

## Memory Tools Overview

This integration provides two key memory functions to your conversational AI agent:

### 1. Adding Memories (`addMemories`)

The `addMemories` tool allows your agent to store important information during a conversation, including:

* User preferences
* Important facts shared by the user
* Decisions or commitments made during the conversation
* Action items to follow up on

When the agent identifies information worth remembering, it calls this function to store it in the Mem0 database with the appropriate user ID.

#### How it works:

1. The agent identifies information that should be remembered
2. It formats the information as a message string
3. It calls the `addMemories` function with this message
4. The function stores the memory in Mem0 linked to the user's ID
5. Later conversations can retrieve this memory

#### Example usage in agent prompt:

```
When the user shares important information like preferences or personal details, 
use the addMemories function to store this information for future reference.
```

### 2. Retrieving Memories (`retrieveMemories`)

The `retrieveMemories` tool allows your agent to search for and retrieve relevant memories from previous conversations. The agent can:

* Search for context related to the current topic
* Recall user preferences
* Remember previous interactions on similar topics
* Create continuity across multiple sessions

#### How it works:

1. The agent needs context for the current conversation
2. It calls `retrieveMemories` with the current conversation topic or question
3. The function performs a semantic search in Mem0
4. Relevant memories are returned to the agent
5. The agent incorporates these memories into its response

#### Example usage in agent prompt:

```
At the beginning of each conversation turn, use retrieveMemories to check if we've 
discussed this topic before or if the user has shared relevant preferences.
```

## Configuring Your ElevenLabs Agent

To enable your agent to effectively use memory:

1. Add function calling capabilities to your agent in the ElevenLabs platform:
   * Go to your agent settings in the ElevenLabs platform
   * Navigate to the "Tools" section
   * Enable function calling for your agent
   * Add the memory tools as described below

2. Add the `addMemories` and `retrieveMemories` tools to your agent with these specifications:

For `addMemories`:

```json  theme={null}
{
  "name": "addMemories",
  "description": "Stores important information from the conversation to remember for future interactions",
  "parameters": {
    "type": "object",
    "properties": {
      "message": {
        "type": "string",
        "description": "The important information to remember"
      }
    },
    "required": ["message"]
  }
}
```

For `retrieveMemories`:

```json  theme={null}
{
  "name": "retrieveMemories",
  "description": "Retrieves relevant information from past conversations",
  "parameters": {
    "type": "object",
    "properties": {
      "message": {
        "type": "string",
        "description": "The query to search for in past memories"
      }
    },
    "required": ["message"]
  }
}
```

3. Update your agent's prompt to instruct it to use these memory functions. For example:

```
You are a helpful voice assistant that remembers past conversations with the user.

You have access to memory tools that allow you to remember important information:
- Use retrieveMemories at the beginning of the conversation to recall relevant context from prior conversations
- Use addMemories to store new important information such as:
  * User preferences
  * Personal details the user shares
  * Important decisions made
  * Tasks or follow-ups promised to the user

Before responding to complex questions, always check for relevant memories first.
When the user shares important information, make sure to store it for future reference.
```

## Example Conversation Flow

Here's how a typical conversation with memory might flow:

1. **User speaks**: "Hi, do you remember my favorite color?"

2. **Agent retrieves memories**:
   ```python  theme={null}
   # Agent calls retrieve_memories
   memories = retrieve_memories({"message": "user's favorite color"})
   # If found: "The user's favorite color is blue"
   ```

3. **Agent processes with context**:
   * If memories found: Prepares a personalized response
   * If no memories: Prepares to ask and store the information

4. **Agent responds**:
   * With memory: "Yes, your favorite color is blue!"
   * Without memory: "I don't think you've told me your favorite color before. What is it?"

5. **User responds**: "It's actually green."

6. **Agent stores new information**:
   ```python  theme={null}
   # Agent calls add_memories
   add_memories({"message": "The user's favorite color is green"})
   ```

7. **Agent confirms**: "Thanks, I'll remember that your favorite color is green."

## Example Use Cases

* **Personal Assistant** - Remember user preferences, past requests, and important dates
  ```
  User: "What restaurants did I say I liked last time?"
  Agent: *retrieves memories* "You mentioned enjoying Bella Italia and The Golden Dragon."
  ```

* **Customer Support** - Recall previous issues a customer has had
  ```
  User: "I'm having that same problem again!"
  Agent: *retrieves memories* "Is this related to the login issue you reported last week?"
  ```

* **Educational AI** - Track student progress and tailor teaching accordingly
  ```
  User: "Let's continue our math lesson."
  Agent: *retrieves memories* "Last time we were working on quadratic equations. Would you like to continue with that?"
  ```

* **Healthcare Assistant** - Remember symptoms, medications, and health concerns
  ```
  User: "Have I told you about my allergy medication?"
  Agent: *retrieves memories* "Yes, you mentioned you're taking Claritin for your pollen allergies."
  ```

## Troubleshooting

* **Missing API Keys**:
  * Error: "API\_KEY environment variable must be set"
  * Solution: Ensure all environment variables are set correctly in your .env file or system environment
* **Connection Issues**:
  * Error: "Failed to connect to API"
  * Solution: Check your network connection and API key permissions. Verify the API keys are valid and have the necessary permissions.
* **Empty Memory Results**:
  * Symptom: Agent always responds with "No memories found"
  * Solution: This is normal for new users. The memory database builds up over time as conversations occur. It's also possible your query isn't semantically similar to stored memories - try different phrasing.
* **Agent Not Using Memories**:
  * Symptom: The agent retrieves memories but doesn't incorporate them in responses
  * Solution: Update the agent's prompt to explicitly instruct it to use the retrieved memories in its responses

## Conclusion

By integrating ElevenLabs Conversational AI with Mem0, you can create voice agents that maintain context across conversations and provide personalized responses based on user history. This powerful combination enables:

* More natural, context-aware conversations
* Personalized user experiences that improve over time
* Reduced need for users to repeat information
* Long-term relationship building between users and AI agents

<CardGroup cols={2}>
  <Card title="LiveKit Integration" icon="video" href="/integrations/livekit">
    Build real-time voice and video agents
  </Card>

  <Card title="Pipecat Integration" icon="waveform" href="/integrations/pipecat">
    Create voice-first AI applications
  </Card>
</CardGroup>


# Flowise
Source: https://docs.mem0.ai/integrations/flowise



The [**Mem0 Memory**](https://github.com/mem0ai/mem0) integration with [Flowise](https://github.com/FlowiseAI/Flowise) enables persistent memory capabilities for your AI chatflows. [Flowise](https://flowiseai.com/) is an open-source low-code tool for developers to build customized LLM orchestration flows & AI agents using a drag & drop interface.

## Overview

1. Provides persistent memory storage for Flowise chatflows
2. Seamless integration with existing Flowise templates
3. Compatible with various LLM nodes in Flowise
4. Supports custom memory configurations
5. Easy to set up and manage

## Prerequisites

Before setting up Mem0 with Flowise, ensure you have:

1. [Flowise installed](https://github.com/FlowiseAI/Flowise#⚡quick-start) (NodeJS >= 18.15.0 required):

```bash  theme={null}
npm install -g flowise
npx flowise start
```

2. Access to the Flowise UI at [http://localhost:3000](http://localhost:3000)
3. Basic familiarity with [Flowise's LLM orchestration](https://flowiseai.com/#features) concepts

## Setup and Configuration

### 1. Set Up Flowise

1. Open the Flowise application and create a new canvas, or select a template from the Flowise marketplace.
2. In this example, we use the **Conversation Chain** template.
3. Replace the default **Buffer Memory** with **Mem0 Memory**.

![Flowise Memory Integration](https://raw.githubusercontent.com/FlowiseAI/FlowiseDocs/main/en/.gitbook/assets/mem0/flowise-flow.png)

### 2. Obtain Your Mem0 API Key

1. Navigate to the [Mem0 API Key dashboard](https://app.mem0.ai/dashboard/api-keys).
2. Generate or copy your existing Mem0 API Key.

![Mem0 API Key](https://raw.githubusercontent.com/FlowiseAI/FlowiseDocs/main/en/.gitbook/assets/mem0/api-key.png)

### 3. Configure Mem0 Credentials

1. Enter the **Mem0 API Key** in the Mem0 Credentials section.
2. Configure additional settings as needed:

```typescript  theme={null}
{
  "apiKey": "m0-xxx",
  "userId": "user-123",  // Optional: Specify user ID
  "projectId": "proj-xxx",  // Optional: Specify project ID
  "orgId": "org-xxx"  // Optional: Specify organization ID
}
```

<figure>
  <img src="https://raw.githubusercontent.com/FlowiseAI/FlowiseDocs/main/en/.gitbook/assets/mem0/creds.png" alt="Mem0 Credentials" />

  <figcaption>Configure API Credentials</figcaption>
</figure>

## Memory Features

### 1. Basic Memory Storage

Test your memory configuration:

1. Save your Flowise configuration
2. Run a test chat and store some information
3. Verify the stored memories in the [Mem0 Dashboard](https://app.mem0.ai/dashboard/requests)

![Flowise Test Chat](https://raw.githubusercontent.com/FlowiseAI/FlowiseDocs/main/en/.gitbook/assets/mem0/flowise-chat-1.png)

### 2. Memory Retention

Validate memory persistence:

1. Clear the chat history in Flowise
2. Ask a question about previously stored information
3. Confirm that the AI remembers the context

![Testing Memory Retention](https://raw.githubusercontent.com/FlowiseAI/FlowiseDocs/main/en/.gitbook/assets/mem0/flowise-chat-2.png)

## Advanced Configuration

### Memory Settings

![Mem0 Settings](https://raw.githubusercontent.com/FlowiseAI/FlowiseDocs/main/en/.gitbook/assets/mem0/settings.png)

Available settings include:

1. **Search Only Mode**: Enable memory retrieval without creating new memories
2. **Mem0 Entities**: Configure identifiers:
   * `user_id`: Unique identifier for each user
   * `run_id`: Specific conversation session ID
   * `app_id`: Application identifier
   * `agent_id`: AI agent identifier
3. **Project ID**: Assign memories to specific projects
4. **Organization ID**: Organize memories by organization

### Platform Configuration

Additional settings available in [Mem0 Project Settings](https://app.mem0.ai/dashboard/project-settings):

1. **Custom Instructions**: Define memory extraction rules
2. **Expiration Date**: Set automatic memory cleanup periods

![Mem0 Project Settings](https://raw.githubusercontent.com/FlowiseAI/FlowiseDocs/main/en/.gitbook/assets/mem0/mem0-settings.png)

## Best Practices

1. **User Identification**: Use consistent `user_id` values for reliable memory retrieval
2. **Memory Organization**: Utilize projects and organizations for better memory management
3. **Regular Maintenance**: Monitor and clean up unused memories periodically

<CardGroup cols={2}>
  <Card title="LangChain Integration" icon="link" href="/integrations/langchain">
    Build LangChain-powered flows with memory
  </Card>

  <Card title="Dify Integration" icon="blocks" href="/integrations/dify">
    Create AI workflows with Dify platform
  </Card>
</CardGroup>


# Google ADK
Source: https://docs.mem0.ai/integrations/google-ai-adk



Integrate [**Mem0**](https://github.com/mem0ai/mem0) with [Google ADK (Agent Development Kit)](https://github.com/google/adk-python), an open-source framework for building multi-agent workflows. This integration enables agents to access persistent memory across conversations, enhancing context retention and personalization.

## Overview

1. Store and retrieve memories from Mem0 within Google ADK agents
2. Multi-agent workflows with shared memory across hierarchies
3. Retrieve relevant memories from past conversations
4. Personalized responses based on user history

## Prerequisites

Before setting up Mem0 with Google ADK, ensure you have:

1. Installed the required packages:

```bash  theme={null}
pip install google-adk mem0ai python-dotenv
```

2. Valid API keys:
   * [Mem0 API Key](https://app.mem0.ai/dashboard/api-keys)
   * Google AI Studio API Key

## Basic Integration Example

The following example demonstrates how to create a Google ADK agent with Mem0 memory integration:

```python  theme={null}
import os
import asyncio
from google.adk.agents import Agent
from google.adk.runners import Runner
from google.adk.sessions import InMemorySessionService
from google.genai import types
from mem0 import MemoryClient
from dotenv import load_dotenv

load_dotenv()

# Set up environment variables
# os.environ["GOOGLE_API_KEY"] = "your-google-api-key"
# os.environ["MEM0_API_KEY"] = "your-mem0-api-key"

# Initialize Mem0 client
mem0 = MemoryClient()

# Define memory function tools
def search_memory(query: str, user_id: str) -> dict:
    """Search through past conversations and memories"""
    # For Platform API, user_id goes in filters
    filters = {"user_id": user_id}
    memories = mem0.search(query, filters=filters)
    if memories.get('results', []):
        memory_list = memories['results']
        memory_context = "\n".join([f"- {mem['memory']}" for mem in memory_list])
        return {"status": "success", "memories": memory_context}
    return {"status": "no_memories", "message": "No relevant memories found"}

def save_memory(content: str, user_id: str) -> dict:
    """Save important information to memory"""
    try:
        result = mem0.add([{"role": "user", "content": content}], user_id=user_id)
        return {"status": "success", "message": "Information saved to memory", "result": result}
    except Exception as e:
        return {"status": "error", "message": f"Failed to save memory: {str(e)}"}

# Create agent with memory capabilities
personal_assistant = Agent(
    name="personal_assistant",
    model="gemini-2.0-flash",
    instruction="""You are a helpful personal assistant with memory capabilities.
    Use the search_memory function to recall past conversations and user preferences.
    Use the save_memory function to store important information about the user.
    Always personalize your responses based on available memory.""",
    description="A personal assistant that remembers user preferences and past interactions",
    tools=[search_memory, save_memory]
)

async def chat_with_agent(user_input: str, user_id: str) -> str:
    """
    Handle user input with automatic memory integration.

    Args:
        user_input: The user's message
        user_id: Unique identifier for the user

    Returns:
        The agent's response
    """
    # Set up session and runner
    session_service = InMemorySessionService()
    session = await session_service.create_session(
        app_name="memory_assistant",
        user_id=user_id,
        session_id=f"session_{user_id}"
    )
    runner = Runner(agent=personal_assistant, app_name="memory_assistant", session_service=session_service)

    # Create content and run agent
    content = types.Content(role='user', parts=[types.Part(text=user_input)])
    events = runner.run(user_id=user_id, session_id=session.id, new_message=content)

    # Extract final response
    for event in events:
        if event.is_final_response():
            response = event.content.parts[0].text

            return response

    return "No response generated"

# Example usage
if __name__ == "__main__":
    response = asyncio.run(chat_with_agent(
        "I love Italian food and I'm planning a trip to Rome next month",
        user_id="alice"
    ))
    print(response)
```

## Multi-Agent Hierarchy with Shared Memory

Create specialized agents in a hierarchy that share memory:

```python  theme={null}
from google.adk.tools.agent_tool import AgentTool

# Travel specialist agent
travel_agent = Agent(
    name="travel_specialist",
    model="gemini-2.0-flash",
    instruction="""You are a travel planning specialist. Use search_memory to
    understand the user's travel preferences and history before making recommendations.
    After providing advice, use save_memory to save travel-related information.""",
    description="Specialist in travel planning and recommendations",
    tools=[search_memory, save_memory]
)

# Health advisor agent
health_agent = Agent(
    name="health_advisor",
    model="gemini-2.0-flash",
    instruction="""You are a health and wellness advisor. Use search_memory to
    understand the user's health goals and dietary preferences.
    After providing advice, use save_memory to save health-related information.""",
    description="Specialist in health and wellness advice",
    tools=[search_memory, save_memory]
)

# Coordinator agent that delegates to specialists
coordinator_agent = Agent(
    name="coordinator",
    model="gemini-2.0-flash",
    instruction="""You are a coordinator that delegates requests to specialist agents.
    For travel-related questions (trips, hotels, flights, destinations), delegate to the travel specialist.
    For health-related questions (fitness, diet, wellness, exercise), delegate to the health advisor.
    Use search_memory to understand the user before delegation.""",
    description="Coordinates requests between specialist agents",
    tools=[
        AgentTool(agent=travel_agent, skip_summarization=False),
        AgentTool(agent=health_agent, skip_summarization=False)
    ]
)

def chat_with_specialists(user_input: str, user_id: str) -> str:
    """
    Handle user input with specialist agent delegation and memory.

    Args:
        user_input: The user's message
        user_id: Unique identifier for the user

    Returns:
        The specialist agent's response
    """
    session_service = InMemorySessionService()
    session = session_service.create_session(
        app_name="specialist_system",
        user_id=user_id,
        session_id=f"session_{user_id}"
    )
    runner = Runner(agent=coordinator_agent, app_name="specialist_system", session_service=session_service)

    content = types.Content(role='user', parts=[types.Part(text=user_input)])
    events = runner.run(user_id=user_id, session_id=session.id, new_message=content)

    for event in events:
        if event.is_final_response():
            response = event.content.parts[0].text

            # Store the conversation in shared memory
            conversation = [
                {"role": "user", "content": user_input},
                {"role": "assistant", "content": response}
            ]
            mem0.add(conversation, user_id=user_id)

            return response

    return "No response generated"

# Example usage
response = chat_with_specialists("Plan a healthy meal for my Italy trip", user_id="alice")
print(response)
```

## Quick Start Chat Interface

Simple interactive chat with memory and Google ADK:

```python  theme={null}
def interactive_chat():
    """Interactive chat interface with memory and ADK"""
    user_id = input("Enter your user ID: ") or "demo_user"
    print(f"Chat started for user: {user_id}")
    print("Type 'quit' to exit")
    print("=" * 50)

    while True:
        user_input = input("\nYou: ")

        if user_input.lower() == 'quit':
            print("Goodbye! Your conversation has been saved to memory.")
            break
        else:
            response = chat_with_specialists(user_input, user_id)
            print(f"Assistant: {response}")

if __name__ == "__main__":
    interactive_chat()
```

## Key Features

### 1. Memory-Enhanced Function Tools

* **Function Tools**: Standard Python functions that can search and save memories
* **Tool Context**: Access to session state and memory through function parameters
* **Structured Returns**: Dictionary-based returns with status indicators for better LLM understanding

### 2. Multi-Agent Memory Sharing

* **Agent-as-a-Tool**: Specialists can be called as tools while maintaining shared memory
* **Hierarchical Delegation**: Coordinator agents route to specialists based on context
* **Memory Categories**: Store interactions with metadata for better organization

### 3. Flexible Memory Operations

* **Search Capabilities**: Retrieve relevant memories through conversation history
* **User Segmentation**: Organize memories by user ID
* **Memory Management**: Built-in tools for saving and retrieving information

## Configuration Options

Customize memory behavior and agent setup:

```python  theme={null}
# Configure memory search with filters
# For Platform API, all filters including user_id go in filters object
memories = mem0.search(
    query="travel preferences",
    filters={
        "AND": [
            {"user_id": "alice"},
            {"categories": {"contains": "travel"}}
        ]
    },
    limit=5
)

# Configure agent with custom model settings
agent = Agent(
    name="custom_agent",
    model="gemini-2.0-flash",  # or use LiteLLM for other models
    instruction="Custom agent behavior",
    tools=[memory_tools],
    # Additional ADK configurations
)

# Use Google Cloud Vertex AI instead of AI Studio
os.environ["GOOGLE_GENAI_USE_VERTEXAI"] = "True"
os.environ["GOOGLE_CLOUD_PROJECT"] = "your-project-id"
os.environ["GOOGLE_CLOUD_LOCATION"] = "us-central1"
```

<CardGroup cols={2}>
  <Card title="Healthcare Agent Cookbook" icon="heart-pulse" href="/cookbooks/integrations/healthcare-google-adk">
    Build HIPAA-compliant healthcare agents with Google ADK
  </Card>

  <Card title="OpenAI Agents SDK" icon="cube" href="/integrations/openai-agents-sdk">
    Compare with OpenAI's agent framework
  </Card>
</CardGroup>


# Keywords AI
Source: https://docs.mem0.ai/integrations/keywords



Build AI applications with persistent memory and comprehensive LLM observability by integrating Mem0 with Keywords AI.

## Overview

Mem0 is a self-improving memory layer for LLM applications, enabling personalized AI experiences that save costs and delight users. Keywords AI provides complete LLM observability.

Combining Mem0 with Keywords AI allows you to:

1. Add persistent memory to your AI applications
2. Track interactions across sessions
3. Monitor memory usage and retrieval with Keywords AI observability
4. Optimize token usage and reduce costs

<Note>
  You can get your Mem0 API key, user\_id, and org\_id from the [Mem0 dashboard](https://app.mem0.ai/). These are required for proper integration.
</Note>

## Setup and Configuration

Install the necessary libraries:

```bash  theme={null}
pip install mem0 keywordsai-sdk
```

Set up your environment variables:

```python  theme={null}
import os

# Set your API keys
os.environ["MEM0_API_KEY"] = "your-mem0-api-key"
os.environ["KEYWORDSAI_API_KEY"] = "your-keywords-api-key"
os.environ["KEYWORDSAI_BASE_URL"] = "https://api.keywordsai.co/api/"
```

## Basic Integration Example

Here's a simple example of using Mem0 with Keywords AI:

```python  theme={null}
from mem0 import Memory
import os

# Configuration
api_key = os.getenv("MEM0_API_KEY")
keywordsai_api_key = os.getenv("KEYWORDSAI_API_KEY")
base_url = os.getenv("KEYWORDSAI_BASE_URL") # "https://api.keywordsai.co/api/"

# Set up Mem0 with Keywords AI as the LLM provider
config = {
    "llm": {
        "provider": "openai",
        "config": {
            "model": "gpt-4.1-nano-2025-04-14",
            "temperature": 0.0,
            "api_key": keywordsai_api_key,
            "openai_base_url": base_url,
        },
    }
}

# Initialize Memory
memory = Memory.from_config(config_dict=config)

# Add a memory
result = memory.add(
    "I like to take long walks on weekends.",
    user_id="alice",
    metadata={"category": "hobbies"},
)

print(result)
```

## Advanced Integration with OpenAI SDK

For more advanced use cases, you can integrate Keywords AI with Mem0 through the OpenAI SDK:

```python  theme={null}
from openai import OpenAI
import os
import json

# Initialize client
client = OpenAI(
    api_key=os.environ.get("KEYWORDSAI_API_KEY"),
    base_url=os.environ.get("KEYWORDSAI_BASE_URL"),
)

# Sample conversation messages
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."}
]

# Add memory and generate a response
response = client.chat.completions.create(
    model="openai/gpt-4.1-nano",
    messages=messages,
    extra_body={
        "mem0_params": {
            "user_id": "test_user",
            "org_id": "org_1",
            "api_key": os.environ.get("MEM0_API_KEY"),
            "add_memories": {
                "messages": messages,
            },
        }
    },
)

print(json.dumps(response.model_dump(), indent=4))
```

For detailed information on this integration, refer to the official [Keywords AI Mem0 integration documentation](https://docs.keywordsai.co/integration/development-frameworks/mem0).

## Key Features

1. **Memory Integration**: Store and retrieve relevant information from past interactions
2. **LLM Observability**: Track memory usage and retrieval patterns with Keywords AI
3. **Session Persistence**: Maintain context across multiple user sessions
4. **Cost Optimization**: Reduce token usage through efficient memory retrieval

## Conclusion

Integrating Mem0 with Keywords AI provides a powerful combination for building AI applications with persistent memory and comprehensive observability. This integration enables more personalized user experiences while providing insights into your application's memory usage.

<CardGroup cols={2}>
  <Card title="OpenAI Agents SDK" icon="cube" href="/integrations/openai-agents-sdk">
    Build monitored agents with OpenAI SDK
  </Card>

  <Card title="AgentOps Integration" icon="chart-line" href="/integrations/agentops">
    Monitor agent performance with AgentOps
  </Card>
</CardGroup>


# Langchain
Source: https://docs.mem0.ai/integrations/langchain



Build a personalized Travel Agent AI using LangChain for conversation flow and Mem0 for memory retention. This integration enables context-aware and efficient travel planning experiences.

## Overview

In this guide, we'll create a Travel Agent AI that:

1. Uses LangChain to manage conversation flow
2. Leverages Mem0 to store and retrieve relevant information from past interactions
3. Provides personalized travel recommendations based on user history

## Setup and Configuration

Install necessary libraries:

```bash  theme={null}
pip install langchain langchain_openai mem0ai python-dotenv
```

Import required modules and set up configurations:

<Note>Remember to get the Mem0 API key from [Mem0 Platform](https://app.mem0.ai).</Note>

```python  theme={null}
import os
from typing import List, Dict
from langchain_openai import ChatOpenAI
from langchain_core.messages import SystemMessage, HumanMessage, AIMessage
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from mem0 import MemoryClient
from dotenv import load_dotenv

load_dotenv()

# Configuration
# os.environ["OPENAI_API_KEY"] = "your-openai-api-key"
# os.environ["MEM0_API_KEY"] = "your-mem0-api-key"

# Initialize LangChain and Mem0
llm = ChatOpenAI(model="gpt-4.1-nano-2025-04-14")
mem0 = MemoryClient()
```

## Create Prompt Template

Set up the conversation prompt template:

```python  theme={null}
prompt = ChatPromptTemplate.from_messages([
    SystemMessage(content="""You are a helpful travel agent AI. Use the provided context to personalize your responses and remember user preferences and past interactions. 
    Provide travel recommendations, itinerary suggestions, and answer questions about destinations. 
    If you don't have specific information, you can make general suggestions based on common travel knowledge."""),
    MessagesPlaceholder(variable_name="context"),
    HumanMessage(content="{input}")
])
```

## Define Helper Functions

Create functions to handle context retrieval, response generation, and addition to Mem0:

```python  theme={null}
def retrieve_context(query: str, user_id: str) -> List[Dict]:
    """Retrieve relevant context from Mem0"""
    try:
        memories = mem0.search(query, user_id=user_id)
        memory_list = memories['results']
        
        serialized_memories = ' '.join([mem["memory"] for mem in memory_list])
        context = [
            {
                "role": "system", 
                "content": f"Relevant information: {serialized_memories}"
            },
            {
                "role": "user",
                "content": query
            }
        ]
        return context
    except Exception as e:
        print(f"Error retrieving memories: {e}")
        # Return empty context if there's an error
        return [{"role": "user", "content": query}]

def generate_response(input: str, context: List[Dict]) -> str:
    """Generate a response using the language model"""
    chain = prompt | llm
    response = chain.invoke({
        "context": context,
        "input": input
    })
    return response.content

def save_interaction(user_id: str, user_input: str, assistant_response: str):
    """Save the interaction to Mem0"""
    try:
        interaction = [
            {
              "role": "user",
              "content": user_input
            },
            {
                "role": "assistant",
                "content": assistant_response
            }
        ]
        result = mem0.add(interaction, user_id=user_id)
        print(f"Memory saved successfully: {len(result.get('results', []))} memories added")
    except Exception as e:
        print(f"Error saving interaction: {e}")
```

## Create Chat Turn Function

Implement the main function to manage a single turn of conversation:

```python  theme={null}
def chat_turn(user_input: str, user_id: str) -> str:
    # Retrieve context
    context = retrieve_context(user_input, user_id)
    
    # Generate response
    response = generate_response(user_input, context)
    
    # Save interaction
    save_interaction(user_id, user_input, response)
    
    return response
```

## Main Interaction Loop

Set up the main program loop for user interaction:

```python  theme={null}
if __name__ == "__main__":
    print("Welcome to your personal Travel Agent Planner! How can I assist you with your travel plans today?")
    user_id = "alice"
    
    while True:
        user_input = input("You: ")
        if user_input.lower() in ['quit', 'exit', 'bye']:
            print("Travel Agent: Thank you for using our travel planning service. Have a great trip!")
            break
        
        response = chat_turn(user_input, user_id)
        print(f"Travel Agent: {response}")
```

## Key Features

1. **Memory Integration**: Uses Mem0 to store and retrieve relevant information from past interactions.
2. **Personalization**: Provides context-aware responses based on user history and preferences.
3. **Flexible Architecture**: LangChain structure allows for easy expansion of the conversation flow.
4. **Continuous Learning**: Each interaction is stored, improving future responses.

## Conclusion

By integrating LangChain with Mem0, you can build a personalized Travel Agent AI that can maintain context across interactions and provide tailored travel recommendations and assistance.

<CardGroup cols={2}>
  <Card title="LangGraph Integration" icon="diagram-project" href="/integrations/langgraph">
    Build stateful agents with LangGraph and Mem0
  </Card>

  <Card title="LangChain Tools" icon="wrench" href="/integrations/langchain-tools">
    Use Mem0 as LangChain tools for agent workflows
  </Card>
</CardGroup>


# Langchain Tools
Source: https://docs.mem0.ai/integrations/langchain-tools

Integrate Mem0 with LangChain tools to enable AI agents to store, search, and manage memories through structured interfaces

## Overview

Mem0 provides a suite of tools for storing, searching, and retrieving memories, enabling agents to maintain context and learn from past interactions. The tools are built as Langchain tools, making them easily integrable with any AI agent implementation.

## Installation

Install the required dependencies:

```bash  theme={null}
pip install langchain_core
pip install mem0ai
```

## Authentication

Import the necessary dependencies and initialize the client:

```python  theme={null}
from langchain_core.tools import StructuredTool
from mem0 import MemoryClient
from pydantic import BaseModel, Field
from typing import List, Dict, Any, Optional
import os

os.environ["MEM0_API_KEY"] = "your-api-key"

client = MemoryClient(
    org_id=your_org_id,
    project_id=your_project_id
)
```

## Available Tools

Mem0 provides three main tools for memory management:

### 1. ADD Memory Tool

The ADD tool allows you to store new memories with associated metadata. It's particularly useful for saving conversation history and user preferences.

#### Schema

```python  theme={null}
class Message(BaseModel):
    role: str = Field(description="Role of the message sender (user or assistant)")
    content: str = Field(description="Content of the message")

class AddMemoryInput(BaseModel):
    messages: List[Message] = Field(description="List of messages to add to memory")
    user_id: str = Field(description="ID of the user associated with these messages")
    metadata: Optional[Dict[str, Any]] = Field(description="Additional metadata for the messages", default=None)

    class Config:
        json_schema_extra = {
            "examples": [{
                "messages": [
                    {"role": "user", "content": "Hi, I'm Alex. I'm a vegetarian and I'm allergic to nuts."},
                    {"role": "assistant", "content": "Hello Alex! I've noted that you're a vegetarian and have a nut allergy."}
                ],
                "user_id": "alex",
                "metadata": {"food": "vegan"}
            }]
        }
```

#### Implementation

```python  theme={null}
def add_memory(messages: List[Message], user_id: str, metadata: Optional[Dict[str, Any]] = None) -> Any:
    """Add messages to memory with associated user ID and metadata."""
    message_dicts = [msg.dict() for msg in messages]
    return client.add(message_dicts, user_id=user_id, metadata=metadata)

add_tool = StructuredTool(
    name="add_memory",
    description="Add new messages to memory with associated metadata",
    func=add_memory,
    args_schema=AddMemoryInput
)
```

#### Example Usage

<CodeGroup>
  ```python Code theme={null}
  add_input = {
      "messages": [
          {"role": "user", "content": "Hi, I'm Alex. I'm a vegetarian and I'm allergic to nuts."},
          {"role": "assistant", "content": "Hello Alex! I've noted that you're a vegetarian and have a nut allergy."}
      ],
      "user_id": "alex",
      "metadata": {"food": "vegan"}
  }
  add_result = add_tool.invoke(add_input)
  ```

  ```json Output theme={null}
  {
    "results": [
      {
        "memory": "Name is Alex",
        "event": "ADD"
      },
      {
        "memory": "Is a vegetarian", 
        "event": "ADD"
      },
      {
        "memory": "Is allergic to nuts",
        "event": "ADD"
      }
    ]
  }
  ```
</CodeGroup>

### 2. SEARCH Memory Tool

The SEARCH tool enables querying stored memories using natural language queries and advanced filtering options.

#### Schema

```python  theme={null}
class SearchMemoryInput(BaseModel):
    query: str = Field(description="The search query string")
    filters: Dict[str, Any] = Field(description="Filters to apply to the search")

    class Config:
        json_schema_extra = {
            "examples": [{
                "query": "tell me about my allergies?",
                "filters": {
                    "AND": [
                        {"user_id": "alex"},
                        {"created_at": {"gte": "2024-01-01", "lte": "2024-12-31"}}
                    ]
                }
            }]
        }
```

#### Implementation

```python  theme={null}
def search_memory(query: str, filters: Dict[str, Any]) -> Any:
    """Search memory with the given query and filters."""
    return client.search(query=query, filters=filters)

search_tool = StructuredTool(
    name="search_memory",
    description="Search through memories with a query and filters",
    func=search_memory,
    args_schema=SearchMemoryInput
)
```

#### Example Usage

<CodeGroup>
  ```python Code theme={null}
  search_input = {
      "query": "what is my name?",
      "filters": {
          "AND": [
              {"user_id": "alex"},
              {"created_at": {"gte": "2024-07-20", "lte": "2024-12-10"}}
          ]
      }
  }
  result = search_tool.invoke(search_input)
  ```

  ```json Output theme={null}
  [
    {
      "id": "1a75e827-7eca-45ea-8c5c-cfd43299f061",
      "memory": "Name is Alex",
      "user_id": "alex", 
      "hash": "d0fccc8fa47f7a149ee95750c37bb0ca",
      "metadata": {
        "food": "vegan"
      },
      "categories": [
        "personal_details"
      ],
      "created_at": "2024-11-27T16:53:43.276872-08:00",
      "updated_at": "2024-11-27T16:53:43.276885-08:00",
      "score": 0.3810526501504994
    }
  ]
  ```
</CodeGroup>

### 3. GET\_ALL Memory Tool

The GET\_ALL tool retrieves all memories matching specified criteria, with support for pagination.

#### Schema

```python  theme={null}
class GetAllMemoryInput(BaseModel):
    filters: Dict[str, Any] = Field(description="Filters to apply to the retrieval")
    page: Optional[int] = Field(description="Page number for pagination", default=1)
    page_size: Optional[int] = Field(description="Number of items per page", default=50)

    class Config:
        json_schema_extra = {
            "examples": [{
                "filters": {
                    "AND": [
                        {"user_id": "alex"},
                        {"created_at": {"gte": "2024-07-01", "lte": "2024-07-31"}},
                        {"categories": {"contains": "food_preferences"}}
                    ]
                },
                "page": 1,
                "page_size": 50
            }]
        }
```

#### Implementation

```python  theme={null}
def get_all_memory(filters: Dict[str, Any], page: int = 1, page_size: int = 50) -> Any:
    """Retrieve all memories matching the specified criteria."""
    return client.get_all(filters=filters, page=page, page_size=page_size)

get_all_tool = StructuredTool(
    name="get_all_memory",
    description="Retrieve all memories matching specified filters",
    func=get_all_memory,
    args_schema=GetAllMemoryInput
)
```

#### Example Usage

<CodeGroup>
  ```python Code theme={null}
  get_all_input = {
      "filters": {
          "AND": [
              {"user_id": "alex"},
              {"created_at": {"gte": "2024-07-01", "lte": "2024-12-31"}}
          ]
      },
      "page": 1,
      "page_size": 50
  }
  get_all_result = get_all_tool.invoke(get_all_input)
  ```

  ```json Output theme={null}
  {
    "count": 3,
    "next": null,
    "previous": null,
    "results": [
      {
        "id": "1a75e827-7eca-45ea-8c5c-cfd43299f061",
        "memory": "Name is Alex",
        "user_id": "alex", 
        "hash": "d0fccc8fa47f7a149ee95750c37bb0ca",
        "metadata": {
          "food": "vegan"
        },
        "categories": [
          "personal_details"
        ],
        "created_at": "2024-11-27T16:53:43.276872-08:00",
        "updated_at": "2024-11-27T16:53:43.276885-08:00"
      },
      {
        "id": "91509588-0b39-408a-8df3-84b3bce8c521",
        "memory": "Is a vegetarian",
        "user_id": "alex",
        "hash": "ce6b1c84586772ab9995a9477032df99", 
        "metadata": {
          "food": "vegan"
        },
        "categories": [
          "user_preferences",
          "food"
        ],
        "created_at": "2024-11-27T16:53:43.308027-08:00",
        "updated_at": "2024-11-27T16:53:43.308037-08:00"
      },
      {
        "id": "8d74f7a0-6107-4589-bd6f-210f6bf4fbbb",
        "memory": "Is allergic to nuts",
        "user_id": "alex",
        "hash": "7873cd0e5a29c513253d9fad038e758b",
        "metadata": {
          "food": "vegan"
        },
        "categories": [
          "health"
        ],
        "created_at": "2024-11-27T16:53:43.337253-08:00",
        "updated_at": "2024-11-27T16:53:43.337262-08:00"
      }
    ]
  }
  ```
</CodeGroup>

## Integration with AI Agents

All tools are implemented as Langchain `StructuredTool` instances, making them compatible with any AI agent that supports the Langchain tools interface. To use these tools with your agent:

1. Initialize the tools as shown above
2. Add the tools to your agent's toolset
3. The agent can now use these tools to manage memories through natural language interactions

Each tool provides structured input validation through Pydantic models and returns consistent responses that can be processed by your agent.

<CardGroup cols={2}>
  <Card title="LangChain Integration" icon="link" href="/integrations/langchain">
    Build conversational agents with LangChain and Mem0
  </Card>

  <Card title="LangGraph Integration" icon="diagram-project" href="/integrations/langgraph">
    Create stateful workflows with LangGraph
  </Card>
</CardGroup>


# LangGraph
Source: https://docs.mem0.ai/integrations/langgraph



Build a personalized Customer Support AI Agent using LangGraph for conversation flow and Mem0 for memory retention. This integration enables context-aware and efficient support experiences.

## Overview

In this guide, we'll create a Customer Support AI Agent that:

1. Uses LangGraph to manage conversation flow
2. Leverages Mem0 to store and retrieve relevant information from past interactions
3. Provides personalized responses based on user history

## Setup and Configuration

Install necessary libraries:

```bash  theme={null}
pip install langgraph langchain-openai mem0ai python-dotenv
```

Import required modules and set up configurations:

<Note>Remember to get the Mem0 API key from [Mem0 Platform](https://app.mem0.ai).</Note>

```python  theme={null}
from typing import Annotated, TypedDict, List
from langgraph.graph import StateGraph, START
from langgraph.graph.message import add_messages
from langchain_openai import ChatOpenAI
from mem0 import MemoryClient
from langchain_core.messages import SystemMessage, HumanMessage, AIMessage
from dotenv import load_dotenv

load_dotenv()

# Configuration
# OPENAI_API_KEY = 'sk-xxx'  # Replace with your actual OpenAI API key
# MEM0_API_KEY = 'your-mem0-key'  # Replace with your actual Mem0 API key

# Initialize LangChain and Mem0
llm = ChatOpenAI(model="gpt-4")
mem0 = MemoryClient()
```

## Define State and Graph

Set up the conversation state and LangGraph structure:

```python  theme={null}
class State(TypedDict):
    messages: Annotated[List[HumanMessage | AIMessage], add_messages]
    mem0_user_id: str

graph = StateGraph(State)
```

## Create Chatbot Function

Define the core logic for the Customer Support AI Agent:

```python  theme={null}
def chatbot(state: State):
    messages = state["messages"]
    user_id = state["mem0_user_id"]

    try:
        # Retrieve relevant memories
        memories = mem0.search(messages[-1].content, user_id=user_id)
        
        # Handle dict response format
        memory_list = memories['results']

        context = "Relevant information from previous conversations:\n"
        for memory in memory_list:
            context += f"- {memory['memory']}\n"

        system_message = SystemMessage(content=f"""You are a helpful customer support assistant. Use the provided context to personalize your responses and remember user preferences and past interactions.
{context}""")

        full_messages = [system_message] + messages
        response = llm.invoke(full_messages)

        # Store the interaction in Mem0
        try:
            interaction = [
                {
                    "role": "user",
                    "content": messages[-1].content
                },
                {
                    "role": "assistant", 
                    "content": response.content
                }
            ]
            result = mem0.add(interaction, user_id=user_id)
            print(f"Memory saved: {len(result.get('results', []))} memories added")
        except Exception as e:
            print(f"Error saving memory: {e}")
            
        return {"messages": [response]}
        
    except Exception as e:
        print(f"Error in chatbot: {e}")
        # Fallback response without memory context
        response = llm.invoke(messages)
        return {"messages": [response]}
```

## Set Up Graph Structure

Configure the LangGraph with appropriate nodes and edges:

```python  theme={null}
graph.add_node("chatbot", chatbot)
graph.add_edge(START, "chatbot")
graph.add_edge("chatbot", "chatbot")

compiled_graph = graph.compile()
```

## Create Conversation Runner

Implement a function to manage the conversation flow:

```python  theme={null}
def run_conversation(user_input: str, mem0_user_id: str):
    config = {"configurable": {"thread_id": mem0_user_id}}
    state = {"messages": [HumanMessage(content=user_input)], "mem0_user_id": mem0_user_id}

    for event in compiled_graph.stream(state, config):
        for value in event.values():
            if value.get("messages"):
                print("Customer Support:", value["messages"][-1].content)
                return
```

## Main Interaction Loop

Set up the main program loop for user interaction:

```python  theme={null}
if __name__ == "__main__":
    print("Welcome to Customer Support! How can I assist you today?")
    mem0_user_id = "alice"  # You can generate or retrieve this based on your user management system
    while True:
        user_input = input("You: ")
        if user_input.lower() in ['quit', 'exit', 'bye']:
            print("Customer Support: Thank you for contacting us. Have a great day!")
            break
        run_conversation(user_input, mem0_user_id)
```

## Key Features

1. **Memory Integration**: Uses Mem0 to store and retrieve relevant information from past interactions.
2. **Personalization**: Provides context-aware responses based on user history.
3. **Flexible Architecture**: LangGraph structure allows for easy expansion of the conversation flow.
4. **Continuous Learning**: Each interaction is stored, improving future responses.

## Conclusion

By integrating LangGraph with Mem0, you can build a personalized Customer Support AI Agent that can maintain context across interactions and provide personalized assistance.

<CardGroup cols={2}>
  <Card title="LangChain Integration" icon="link" href="/integrations/langchain">
    Build conversational agents with LangChain and Mem0
  </Card>

  <Card title="CrewAI Integration" icon="users" href="/integrations/crewai">
    Create multi-agent systems with CrewAI
  </Card>
</CardGroup>


# Livekit
Source: https://docs.mem0.ai/integrations/livekit



This guide demonstrates how to create a memory-enabled voice assistant using LiveKit, Deepgram, OpenAI, and Mem0, focusing on creating an intelligent, context-aware travel planning agent.

## Prerequisites

Before you begin, make sure you have:

1. Installed Livekit Agents SDK with voice dependencies of silero and deepgram:

```bash  theme={null}
pip install livekit livekit-agents \
livekit-plugins-silero \
livekit-plugins-deepgram \
livekit-plugins-openai \
livekit-plugins-turn-detector \
livekit-plugins-noise-cancellation
```

2. Installed Mem0 SDK:

```bash  theme={null}
pip install mem0ai
```

3. Set up your API keys in a `.env` file:

```sh  theme={null}
LIVEKIT_URL=your_livekit_url
LIVEKIT_API_KEY=your_livekit_api_key
LIVEKIT_API_SECRET=your_livekit_api_secret
DEEPGRAM_API_KEY=your_deepgram_api_key
MEM0_API_KEY=your_mem0_api_key
OPENAI_API_KEY=your_openai_api_key
```

> **Note**: Make sure to have a Livekit and Deepgram account. You can find these variables `LIVEKIT_URL`, `LIVEKIT_API_KEY`, and `LIVEKIT_API_SECRET` from the [LiveKit Cloud Console](https://cloud.livekit.io/). For more information, refer to the [LiveKit Documentation](https://docs.livekit.io/home/cloud/keys-and-tokens/). For `DEEPGRAM_API_KEY`, you can get it from the [Deepgram Console](https://console.deepgram.com/). Refer to the [Deepgram Documentation](https://developers.deepgram.com/docs/create-additional-api-keys) for more details.

## Code Breakdown

Let's break down the key components of this implementation using LiveKit Agents:

### 1. Setting Up Dependencies and Environment

```python  theme={null}
import os
import logging
from pathlib import Path
from dotenv import load_dotenv

from mem0 import AsyncMemoryClient

from livekit.agents import (
    JobContext,
    WorkerOptions,
    cli,
    ChatContext,
    ChatMessage,
    RoomInputOptions,
    Agent,
    AgentSession,
)
from livekit.plugins import openai, silero, deepgram, noise_cancellation
from livekit.plugins.turn_detector.english import EnglishModel

# Load environment variables
load_dotenv()

```

### 2. Mem0 Client and Agent Definition

```python  theme={null}
# User ID for RAG data in Mem0
RAG_USER_ID = "livekit-mem0"
mem0_client = AsyncMemoryClient()

class MemoryEnabledAgent(Agent):
    """
    An agent that can answer questions using RAG (Retrieval Augmented Generation) with Mem0.
    """
    def __init__(self) -> None:
        super().__init__(
            instructions="""
                You are a helpful voice assistant.
                You are a travel guide named George and will help the user to plan a travel trip of their dreams.
                You should help the user plan for various adventures like work retreats, family vacations or solo backpacking trips.
                You should be careful to not suggest anything that would be dangerous, illegal or inappropriate.
                You can remember past interactions and use them to inform your answers.
                Use semantic memory retrieval to provide contextually relevant responses.
            """,
        )
        self._seen_results = set()  # Track previously seen result IDs
        logger.info(f"Mem0 Agent initialized. Using user_id: {RAG_USER_ID}")

    async def on_enter(self):
        self.session.generate_reply(
            instructions="Briefly greet the user and offer your assistance."
        )

    async def on_user_turn_completed(self, turn_ctx: ChatContext, new_message: ChatMessage) -> None:
        # Persist the user message in Mem0
        try:
            logger.info(f"Adding user message to Mem0: {new_message.text_content}")
            add_result = await mem0_client.add(
                [{"role": "user", "content": new_message.text_content}],
                user_id=RAG_USER_ID
            )
            logger.info(f"Mem0 add result (user): {add_result}")
        except Exception as e:
            logger.warning(f"Failed to store user message in Mem0: {e}")

        # RAG: Retrieve relevant context from Mem0 and inject as assistant message
        try:
            logger.info("About to await mem0_client.search for RAG context")
            search_results = await mem0_client.search(
                new_message.text_content,
                user_id=RAG_USER_ID,
            )
            logger.info(f"mem0_client.search returned: {search_results}")
            if search_results and search_results.get('results', []):
                context_parts = []
                for result in search_results.get('results', []):
                    paragraph = result.get("memory") or result.get("text")
                    if paragraph:
                        source = "mem0 Memories"
                        if "from [" in paragraph:
                            source = paragraph.split("from [")[1].split("]")[0]
                            paragraph = paragraph.split("]")[1].strip()
                        context_parts.append(f"Source: {source}\nContent: {paragraph}\n")
                if context_parts:
                    full_context = "\n\n".join(context_parts)
                    logger.info(f"Injecting RAG context: {full_context}")
                    turn_ctx.add_message(role="assistant", content=full_context)
                    await self.update_chat_ctx(turn_ctx)
        except Exception as e:
            logger.warning(f"Failed to inject RAG context from Mem0: {e}")

        await super().on_user_turn_completed(turn_ctx, new_message)
```

### 3. Entrypoint and Session Setup

```python  theme={null}
async def entrypoint(ctx: JobContext):
    """Main entrypoint for the agent."""
    await ctx.connect()

    session = AgentSession(
        stt=deepgram.STT(),
        llm=openai.LLM(model="gpt-4.1-nano-2025-04-14"),
        tts=openai.TTS(voice="ash",),
        turn_detection=EnglishModel(),
        vad=silero.VAD.load(),
    )

    await session.start(
        agent=MemoryEnabledAgent(),
        room=ctx.room,
        room_input_options=RoomInputOptions(
            noise_cancellation=noise_cancellation.BVC(),
        ),
    )

    # Initial greeting
    await session.generate_reply(
        instructions="Greet the user warmly as George the travel guide and ask how you can help them plan their next adventure.",
        allow_interruptions=True
    )

# Run the application
if __name__ == "__main__":
    cli.run_app(WorkerOptions(entrypoint_fnc=entrypoint))
```

## Key Features of This Implementation

1. **Semantic Memory Retrieval**: Uses Mem0 to store and retrieve contextually relevant memories
2. **Voice Interaction**: Leverages LiveKit for voice communication with proper turn detection
3. **Intelligent Context Management**: Augments conversations with past interactions
4. **Travel Planning Specialization**: Focused on creating a helpful travel guide assistant
5. **Function Tools**: Modern tool definition for enhanced capabilities

## Running the Example

To run this example:

1. Install all required dependencies
2. Set up your `.env` file with the necessary API keys
3. Ensure your microphone and audio setup are configured
4. Run the script with Python 3.11 or newer and with the following command:

```sh  theme={null}
python mem0-livekit-voice-agent.py start
```

or to start your agent in console mode to run inside your terminal:

```sh  theme={null}
python mem0-livekit-voice-agent.py console
```

5. After the script starts, you can interact with the voice agent using [LiveKit's Agent Platform](https://agents-playground.livekit.io/) and connect to the agent to start conversations.

## Best Practices for Voice Agents with Memory

1. **Context Preservation**: Store enough context with each memory for effective retrieval
2. **Privacy Considerations**: Implement secure memory management
3. **Relevant Memory Filtering**: Use semantic search to retrieve only the most relevant memories
4. **Error Handling**: Implement robust error handling for memory operations

## Debugging Function Tools

* To run the script in debug mode simply start the assistant with `dev` mode:

```sh  theme={null}
python mem0-livekit-voice-agent.py dev
```

* When working with memory-enabled voice agents, use Python's `logging` module for effective debugging:

```python  theme={null}
import logging

# Set up logging
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger("memory_voice_agent")
```

* Check the logs for any issues with API keys, connectivity, or memory operations.
* Ensure your `.env` file is correctly configured and loaded.

<CardGroup cols={2}>
  <Card title="ElevenLabs Integration" icon="volume" href="/integrations/elevenlabs">
    Build conversational voice agents with ElevenLabs
  </Card>

  <Card title="Pipecat Integration" icon="waveform" href="/integrations/pipecat">
    Create real-time voice applications with Pipecat
  </Card>
</CardGroup>


# LlamaIndex
Source: https://docs.mem0.ai/integrations/llama-index



LlamaIndex supports Mem0 as a [memory store](https://llamahub.ai/l/memory/llama-index-memory-mem0). In this guide, we'll show you how to use it.

<Note type="info">
  [**Mem0Memory**](https://docs.llamaindex.ai/en/stable/examples/memory/Mem0Memory/) now supports **ReAct** and **FunctionCalling** agents.
</Note>

### Installation

To install the required package, run:

```bash  theme={null}
pip install llama-index-core llama-index-memory-mem0 python-dotenv
```

### Setup with Mem0 Platform

Set your Mem0 Platform API key as an environment variable. You can replace `<your-mem0-api-key>` with your actual API key:

<Note type="info">
  You can obtain your Mem0 Platform API key from the [Mem0 Platform](https://app.mem0.ai/login).
</Note>

```python  theme={null}
from dotenv import load_dotenv
import os

load_dotenv()

# os.environ["MEM0_API_KEY"] = "<your-mem0-api-key>"
```

Import the necessary modules and create a Mem0Memory instance:

```python  theme={null}
from llama_index.memory.mem0 import Mem0Memory

context = {"user_id": "alice"}
memory_from_client = Mem0Memory.from_client(
    context=context,
    search_msg_limit=4,  # optional, default is 5
)
```

Context is used to identify the user, agent or the conversation in the Mem0. It is required to be passed in the at least one of the fields in the `Mem0Memory` constructor. It can be any of the following:

```python  theme={null}
context = {
    "user_id": "alice", 
    "agent_id": "llama_agent_1",
    "run_id": "run_1",
}
```

`search_msg_limit` is optional, default is 5. It is the number of messages from the chat history to be used for memory retrieval from Mem0. More number of messages will result in more context being used for retrieval but will also increase the retrieval time and might result in some unwanted results.

<Note type="info">
  `search_msg_limit` is different from `limit`. `limit` is the number of messages to be retrieved from Mem0 and is used in search.
</Note>

### Setup with Mem0 OSS

Set your Mem0 OSS by providing configuration details:

<Note type="info">
  To know more about Mem0 OSS, read [Mem0 OSS Quickstart](https://docs.mem0.ai/open-source/overview).
</Note>

```python  theme={null}
config = {
    "vector_store": {
        "provider": "qdrant",
        "config": {
            "collection_name": "test_9",
            "host": "localhost",
            "port": 6333,
            "embedding_model_dims": 1536,  # Change this according to your local model's dimensions
        },
    },
    "llm": {
        "provider": "openai",
        "config": {
            "model": "gpt-4.1-nano-2025-04-14",
            "temperature": 0.2,
            "max_tokens": 2000,
        },
    },
    "embedder": {
        "provider": "openai",
        "config": {"model": "text-embedding-3-small"},
    },
    "version": "v1.1",
}
```

Create a Mem0Memory instance:

```python  theme={null}
memory_from_config = Mem0Memory.from_config(
    context=context,
    config=config,
    search_msg_limit=4,  # optional, default is 5
    # Remove deprecation warnings
)
```

Initialize the LLM

```python  theme={null}
from llama_index.llms.openai import OpenAI
from dotenv import load_dotenv

load_dotenv()

# os.environ["OPENAI_API_KEY"] = "<your-openai-api-key>"
llm = OpenAI(model="gpt-4.1-nano-2025-04-14")
```

### SimpleChatEngine

Use the `SimpleChatEngine` to start a chat with the agent with the memory.

```python  theme={null}
from llama_index.core.chat_engine import SimpleChatEngine

agent = SimpleChatEngine.from_defaults(
    llm=llm, memory=memory_from_client  # or memory_from_config
)

# Start the chat
response = agent.chat("Hi, My name is Alice")
print(response)
```

Now we will learn how to use Mem0 with FunctionCalling and ReAct agents.

Initialize the tools:

```python  theme={null}
from llama_index.core.tools import FunctionTool


def call_fn(name: str):
    """Call the provided name.
    Args:
        name: str (Name of the person)
    """
    print(f"Calling... {name}")


def email_fn(name: str):
    """Email the provided name.
    Args:
        name: str (Name of the person)
    """
    print(f"Emailing... {name}")


call_tool = FunctionTool.from_defaults(fn=call_fn)
email_tool = FunctionTool.from_defaults(fn=email_fn)
```

### FunctionCallingAgent

```python  theme={null}
from llama_index.core.agent import FunctionCallingAgent

agent = FunctionCallingAgent.from_tools(
    [call_tool, email_tool],
    llm=llm,
    memory=memory_from_client,  # or memory_from_config
    verbose=True,
)

# Start the chat
response = agent.chat("Hi, My name is Alice")
print(response)
```

### ReActAgent

```python  theme={null}
from llama_index.core.agent import ReActAgent

agent = ReActAgent.from_tools(
    [call_tool, email_tool],
    llm=llm,
    memory=memory_from_client,  # or memory_from_config
    verbose=True,
)

# Start the chat
response = agent.chat("Hi, My name is Alice")
print(response)
```

## Key Features

1. **Memory Integration**: Uses Mem0 to store and retrieve relevant information from past interactions.
2. **Personalization**: Provides context-aware agent responses based on user history and preferences.
3. **Flexible Architecture**: LlamaIndex allows for easy integration of the memory with the agent.
4. **Continuous Learning**: Each interaction is stored, improving future responses.

## Conclusion

By integrating LlamaIndex with Mem0, you can build a personalized agent that can maintain context across interactions with the agent and provide tailored recommendations and assistance.

<CardGroup cols={2}>
  <Card title="LlamaIndex Multiagent Cookbook" icon="brain" href="/cookbooks/frameworks/llamaindex-multiagent">
    Build multi-agent systems with LlamaIndex and Mem0
  </Card>

  <Card title="LlamaIndex ReAct Cookbook" icon="bolt" href="/cookbooks/frameworks/llamaindex-react">
    Create ReAct agents with LlamaIndex
  </Card>
</CardGroup>


# Mastra
Source: https://docs.mem0.ai/integrations/mastra



The [**Mastra**](https://mastra.ai/) integration demonstrates how to use Mastra's agent system with Mem0 as the memory backend through custom tools. This enables agents to remember and recall information across conversations.

## Overview

In this guide, we'll create a Mastra agent that:

1. Uses Mem0 to store information using a memory tool
2. Retrieves relevant memories using a search tool
3. Provides personalized responses based on past interactions
4. Maintains context across conversations and sessions

## Setup and Configuration

Install the required libraries:

```bash  theme={null}
npm install @mastra/core @mastra/mem0 @ai-sdk/openai zod
```

Set up your environment variables:

<Note>Remember to get the Mem0 API key from [Mem0 Platform](https://app.mem0.ai).</Note>

```bash  theme={null}
MEM0_API_KEY=your-mem0-api-key
OPENAI_API_KEY=your-openai-api-key
```

## Initialize Mem0 Integration

Import required modules and set up the Mem0 integration:

```typescript  theme={null}
import { Mem0Integration } from '@mastra/mem0';
import { createTool } from '@mastra/core/tools';
import { Agent } from '@mastra/core/agent';
import { openai } from '@ai-sdk/openai';
import { z } from 'zod';

// Initialize Mem0 integration
const mem0 = new Mem0Integration({
  config: {
    apiKey: process.env.MEM0_API_KEY || '',
    user_id: 'alice', // Unique user identifier
  },
});
```

## Create Memory Tools

Set up tools for memorizing and remembering information:

```typescript  theme={null}
// Tool for remembering saved memories
const mem0RememberTool = createTool({
  id: 'Mem0-remember',
  description: "Remember your agent memories that you've previously saved using the Mem0-memorize tool.",
  inputSchema: z.object({
    question: z.string().describe('Question used to look up the answer in saved memories.'),
  }),
  outputSchema: z.object({
    answer: z.string().describe('Remembered answer'),
  }),
  execute: async ({ context }) => {
    console.log(`Searching memory "${context.question}"`);
    const memory = await mem0.searchMemory(context.question);
    console.log(`\nFound memory "${memory}"\n`);

    return {
      answer: memory,
    };
  },
});

// Tool for saving new memories
const mem0MemorizeTool = createTool({
  id: 'Mem0-memorize',
  description: 'Save information to mem0 so you can remember it later using the Mem0-remember tool.',
  inputSchema: z.object({
    statement: z.string().describe('A statement to save into memory'),
  }),
  execute: async ({ context }) => {
    console.log(`\nCreating memory "${context.statement}"\n`);
    // To reduce latency, memories can be saved async without blocking tool execution
    void mem0.createMemory(context.statement).then(() => {
      console.log(`\nMemory "${context.statement}" saved.\n`);
    });
    return { success: true };
  },
});
```

## Create Mastra Agent

Initialize an agent with memory tools and clear instructions:

```typescript  theme={null}
// Create an agent with memory tools
const mem0Agent = new Agent({
  name: 'Mem0 Agent',
  instructions: `
    You are a helpful assistant that has the ability to memorize and remember facts using Mem0.
    Use the Mem0-memorize tool to save important information that might be useful later.
    Use the Mem0-remember tool to recall previously saved information when answering questions.
  `,
  model: openai('gpt-4.1-nano'),
  tools: { mem0RememberTool, mem0MemorizeTool },
});
```

## Key Features

1. **Tool-based Memory Control**: The agent decides when to save and retrieve information using specific tools
2. **Semantic Search**: Mem0 finds relevant memories based on semantic similarity, not just exact matches
3. **User-specific Memory Spaces**: Each user\_id maintains separate memory contexts
4. **Asynchronous Saving**: Memories are saved in the background to reduce response latency
5. **Cross-conversation Persistence**: Memories persist across different conversation threads
6. **Transparent Operations**: Memory operations are visible through tool usage

## Conclusion

By integrating Mastra with Mem0, you can build intelligent agents that learn and remember information across conversations. The tool-based approach provides transparency and control over memory operations, making it easy to create personalized and context-aware AI experiences.

<CardGroup cols={2}>
  <Card title="Mastra Agent Cookbook" icon="star" href="/cookbooks/integrations/mastra-agent">
    Build a complete Mastra agent with persistent memory
  </Card>

  <Card title="Vercel AI SDK Integration" icon="triangle" href="/integrations/vercel-ai-sdk">
    Create web applications with Vercel AI SDK
  </Card>
</CardGroup>


# OpenAI Agents SDK
Source: https://docs.mem0.ai/integrations/openai-agents-sdk



Integrate [**Mem0**](https://github.com/mem0ai/mem0) with [OpenAI Agents SDK](https://github.com/openai/openai-agents-python), a lightweight framework for building multi-agent workflows. This integration enables agents to access persistent memory across conversations, enhancing context retention and personalization.

## Overview

1. Store and retrieve memories from Mem0 within OpenAI agents
2. Multi-agent workflows with shared memory
3. Retrieve relevant memories for past conversations
4. Personalized responses based on user history

## Prerequisites

Before setting up Mem0 with OpenAI Agents SDK, ensure you have:

1. Installed the required packages:

```bash  theme={null}
pip install openai-agents mem0ai
```

2. Valid API keys:
   * [Mem0 API Key](https://app.mem0.ai/dashboard/api-keys)
   * [OpenAI API Key](https://platform.openai.com/api-keys)

## Basic Integration Example

The following example demonstrates how to create an OpenAI agent with Mem0 memory integration:

```python  theme={null}
import os
from agents import Agent, Runner, function_tool
from mem0 import MemoryClient

# Set up environment variables
os.environ["OPENAI_API_KEY"] = "your-openai-api-key"
os.environ["MEM0_API_KEY"] = "your-mem0-api-key"

# Initialize Mem0 client
mem0 = MemoryClient()

# Define memory tools for the agent
@function_tool
def search_memory(query: str, user_id: str) -> str:
    """Search through past conversations and memories"""
    memories = mem0.search(query, user_id=user_id, limit=3)
    if memories and memories.get('results'):
        return "\n".join([f"- {mem['memory']}" for mem in memories['results']])
    return "No relevant memories found."

@function_tool
def save_memory(content: str, user_id: str) -> str:
    """Save important information to memory"""
    mem0.add([{"role": "user", "content": content}], user_id=user_id)
    return "Information saved to memory."

# Create agent with memory capabilities
agent = Agent(
    name="Personal Assistant",
    instructions="""You are a helpful personal assistant with memory capabilities.
    Use the search_memory tool to recall past conversations and user preferences.
    Use the save_memory tool to store important information about the user.
    Always personalize your responses based on available memory.""",
    tools=[search_memory, save_memory],
    model="gpt-4.1-nano-2025-04-14"
)

def chat_with_agent(user_input: str, user_id: str) -> str:
    """
    Handle user input with automatic memory integration.

    Args:
        user_input: The user's message
        user_id: Unique identifier for the user

    Returns:
        The agent's response
    """
    # Run the agent (it will automatically use memory tools when needed)
    result = Runner.run_sync(agent, user_input)

    return result.final_output

# Example usage
if __name__ == "__main__":

    # preferences will be saved in memory (using save_memory tool)
    response_1 = chat_with_agent(
        "I love Italian food and I'm planning a trip to Rome next month",
        user_id="alice"
    )
    print(response_1)

    # memory will be retrieved using search_memory tool to answer the user query
    response_2 = chat_with_agent(
        "Give me some recommendations for food",
        user_id="alice"
    )
    print(response_2)
```

## Multi-Agent Workflow with Handoffs

Create multiple specialized agents with proper handoffs and shared memory:

```python  theme={null}
from agents import Agent, Runner, handoffs, function_tool

# Specialized agents
travel_agent = Agent(
    name="Travel Planner",
    instructions="""You are a travel planning specialist. Use get_user_context to
    understand the user's travel preferences and history before making recommendations.
    After providing your response, use store_conversation to save important details.""",
    tools=[search_memory, save_memory],
    model="gpt-4.1-nano-2025-04-14"
)

health_agent = Agent(
    name="Health Advisor",
    instructions="""You are a health and wellness advisor. Use get_user_context to
    understand the user's health goals and dietary preferences.
    After providing advice, use store_conversation to save relevant information.""",
    tools=[search_memory, save_memory],
    model="gpt-4.1-nano-2025-04-14"
)

# Triage agent with handoffs
triage_agent = Agent(
    name="Personal Assistant",
    instructions="""You are a helpful personal assistant that routes requests to specialists.
    For travel-related questions (trips, hotels, flights, destinations), hand off to the Travel Planner.
    For health-related questions (fitness, diet, wellness, exercise), hand off to the Health Advisor.
    For general questions, handle them directly using available tools.""",
    handoffs=[travel_agent, health_agent],
    model="gpt-4.1-nano-2025-04-14"
)

def chat_with_handoffs(user_input: str, user_id: str) -> str:
    """
    Handle user input with automatic agent handoffs and memory integration.

    Args:
        user_input: The user's message
        user_id: Unique identifier for the user

    Returns:
        The agent's response
    """
    # Run the triage agent (it will automatically handoff when needed)
    result = Runner.run_sync(triage_agent, user_input)

    # Store the original conversation in memory
    conversation = [
        {"role": "user", "content": user_input},
        {"role": "assistant", "content": result.final_output}
    ]
    mem0.add(conversation, user_id=user_id)

    return result.final_output

# Example usage
response = chat_with_handoffs("Plan a healthy meal for my Italy trip", user_id="alex")
print(response)
```

## Quick Start Chat Interface

Simple interactive chat with memory:

```python  theme={null}
def interactive_chat():
    """Interactive chat interface with memory and handoffs"""
    user_id = input("Enter your user ID: ") or "demo_user"
    print(f"Chat started for user: {user_id}")
    print("Type 'quit' to exit\n")

    while True:
        user_input = input("You: ")
        if user_input.lower() == 'quit':
            break

        response = chat_with_handoffs(user_input, user_id)
        print(f"Assistant: {response}\n")

if __name__ == "__main__":
    interactive_chat()
```

## Key Features

### 1. Automatic Memory Integration

* **Tool-Based Memory**: Agents use function tools to search and save memories
* **Conversation Storage**: All interactions are automatically stored
* **Context Retrieval**: Agents can access relevant past conversations

### 2. Multi-Agent Memory Sharing

* **Shared Context**: Multiple agents access the same memory store
* **Specialized Agents**: Create domain-specific agents with shared memory
* **Seamless Handoffs**: Agents maintain context across handoffs

### 3. Flexible Memory Operations

* **Retrieve Capabilities**: Retrieve relevant memories from previous conversations
* **User Segmentation**: Organize memories by user ID
* **Memory Management**: Built-in tools for saving and retrieving information

## Configuration Options

Customize memory behavior:

```python  theme={null}
# Configure memory search
memories = mem0.search(
    query="travel preferences",
    user_id="alex",
    limit=5  # Number of memories to retrieve
)

# Add metadata to memories
mem0.add(
    messages=[{"role": "user", "content": "I prefer luxury hotels"}],
    user_id="alex",
    metadata={"category": "travel", "importance": "high"}
)
```

<CardGroup cols={2}>
  <Card title="OpenAI Tool Calls Cookbook" icon="wrench" href="/cookbooks/integrations/openai-tool-calls">
    Learn how to integrate Mem0 with OpenAI function calling
  </Card>

  <Card title="Agents SDK Tool Cookbook" icon="cube" href="/cookbooks/integrations/agents-sdk-tool">
    Build agents with OpenAI SDK tools
  </Card>
</CardGroup>


# Pipecat
Source: https://docs.mem0.ai/integrations/pipecat

Integrate Mem0 with Pipecat for conversational memory in AI agents

# Pipecat Integration

Mem0 seamlessly integrates with [Pipecat](https://pipecat.ai), providing long-term memory capabilities for conversational AI agents. This integration allows your Pipecat-powered applications to remember past conversations and provide personalized responses based on user history.

## Installation

To use Mem0 with Pipecat, install the required dependencies:

```bash  theme={null}
pip install "pipecat-ai[mem0]"
```

You'll also need to set up your Mem0 API key as an environment variable:

```bash  theme={null}
export MEM0_API_KEY=your_mem0_api_key
```

You can obtain a Mem0 API key by signing up at [mem0.ai](https://mem0.ai).

## Configuration

Mem0 integration is provided through the `Mem0MemoryService` class in Pipecat. Here's how to configure it:

```python  theme={null}
from pipecat.services.mem0 import Mem0MemoryService

memory = Mem0MemoryService(
    api_key=os.getenv("MEM0_API_KEY"),  # Your Mem0 API key
    user_id="unique_user_id",           # Unique identifier for the end user
    agent_id="my_agent",                # Identifier for the agent using the memory
    run_id="session_123",               # Optional: specific conversation session ID
    params={                            # Optional: configuration parameters
        "search_limit": 10,             # Maximum memories to retrieve per query
        "search_threshold": 0.1,        # Relevance threshold (0.0 to 1.0)
        "system_prompt": "Here are your past memories:", # Custom prefix for memories
        "add_as_system_message": True,  # Add memories as system (True) or user (False) message
        "position": 1,                  # Position in context to insert memories
    }
)
```

## Pipeline Integration

The `Mem0MemoryService` should be positioned between your context aggregator and LLM service in the Pipecat pipeline:

```python  theme={null}
pipeline = Pipeline([
    transport.input(),
    stt,                # Speech-to-text for audio input
    user_context,       # User context aggregator
    memory,             # Mem0 Memory service enhances context here
    llm,                # LLM for response generation
    tts,                # Optional: Text-to-speech
    transport.output(),
    assistant_context   # Assistant context aggregator
])
```

## Example: Voice Agent with Memory

Here's a complete example of a Pipecat voice agent with Mem0 memory integration:

```python  theme={null}
import asyncio
import os
from fastapi import FastAPI, WebSocket

from pipecat.frames.frames import TextFrame
from pipecat.pipeline.pipeline import Pipeline
from pipecat.pipeline.task import PipelineTask
from pipecat.pipeline.runner import PipelineRunner
from pipecat.services.mem0 import Mem0MemoryService
from pipecat.services.openai import OpenAILLMService, OpenAIUserContextAggregator, OpenAIAssistantContextAggregator
from pipecat.transports.network.fastapi_websocket import (
    FastAPIWebsocketTransport,
    FastAPIWebsocketParams
)
from pipecat.serializers.protobuf import ProtobufFrameSerializer
from pipecat.audio.vad.silero import SileroVADAnalyzer
from pipecat.services.whisper import WhisperSTTService

app = FastAPI()

@app.websocket("/chat")
async def websocket_endpoint(websocket: WebSocket):
    await websocket.accept()
    
    # Basic setup with minimal configuration
    user_id = "alice"
    
    # WebSocket transport
    transport = FastAPIWebsocketTransport(
        websocket=websocket,
        params=FastAPIWebsocketParams(
            audio_out_enabled=True,
            vad_enabled=True,
            vad_analyzer=SileroVADAnalyzer(),
            vad_audio_passthrough=True,
            serializer=ProtobufFrameSerializer(),
        )
    )
    
    # Core services
    user_context = OpenAIUserContextAggregator()
    assistant_context = OpenAIAssistantContextAggregator()
    stt = WhisperSTTService(api_key=os.getenv("OPENAI_API_KEY"))
    
    # Memory service - the key component
    memory = Mem0MemoryService(
        api_key=os.getenv("MEM0_API_KEY"),
        user_id=user_id,
        agent_id="fastapi_memory_bot"
    )
    
    # LLM for response generation
    llm = OpenAILLMService(
        api_key=os.getenv("OPENAI_API_KEY"),
        model="gpt-3.5-turbo",
        system_prompt="You are a helpful assistant that remembers past conversations."
    )
    
    # Simple pipeline
    pipeline = Pipeline([
        transport.input(),
        stt,                # Speech-to-text for audio input
        user_context,
        memory,             # Memory service enhances context here
        llm,
        transport.output(),
        assistant_context
    ])
    
    # Run the pipeline
    runner = PipelineRunner()
    task = PipelineTask(pipeline)
    
    # Event handlers for WebSocket connections
    @transport.event_handler("on_client_connected")
    async def on_client_connected(transport, client):
        # Send welcome message when client connects
        await task.queue_frame(TextFrame("Hello! I'm a memory bot. I'll remember our conversation."))
    
    @transport.event_handler("on_client_disconnected")
    async def on_client_disconnected(transport, client):
        # Clean up when client disconnects
        await task.cancel()
    
    await runner.run(task)

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)
```

## How It Works

When integrated with Pipecat, Mem0 provides two key functionalities:

### 1. Message Storage

All conversation messages are automatically stored in Mem0 for future reference:

* Captures the full message history from context frames
* Associates messages with the specified user, agent, and run IDs
* Stores metadata to enable efficient retrieval

### 2. Memory Retrieval

When a new user message is detected:

1. The message is used as a search query to find relevant past memories
2. Relevant memories are retrieved from Mem0's database
3. Memories are formatted and added to the conversation context
4. The enhanced context is passed to the LLM for response generation

## Additional Configuration Options

### Memory Search Parameters

You can customize how memories are retrieved and used:

```python  theme={null}
memory = Mem0MemoryService(
    api_key=os.getenv("MEM0_API_KEY"),
    user_id="user123",
    params={
        "search_limit": 5,            # Retrieve up to 5 memories
        "search_threshold": 0.2,      # Higher threshold for more relevant matches
    }
)
```

### Memory Presentation Options

Control how memories are presented to the LLM:

```python  theme={null}
memory = Mem0MemoryService(
    api_key=os.getenv("MEM0_API_KEY"),
    user_id="user123",
    params={
        "system_prompt": "Previous conversations with this user:",
        "add_as_system_message": True,  # Add as system message instead of user message
        "position": 0,                  # Insert at the beginning of the context
    }
)
```

<CardGroup cols={2}>
  <Card title="LiveKit Integration" icon="video" href="/integrations/livekit">
    Build real-time voice and video agents
  </Card>

  <Card title="ElevenLabs Integration" icon="volume" href="/integrations/elevenlabs">
    Create conversational voice agents
  </Card>
</CardGroup>


# Raycast Extension
Source: https://docs.mem0.ai/integrations/raycast

Mem0 Raycast extension for intelligent memory management

Mem0 is a self-improving memory layer for LLM applications, enabling personalized AI experiences that save costs and delight users. This extension lets you store and retrieve text snippets using Mem0's intelligent memory system. Find Mem0 in [Raycast Store](https://www.raycast.com/dev_khant/mem0) for using it.

## Getting Started

**Get your API Key**: You'll need a Mem0 API key to use this extension:

a. Sign up at [app.mem0.ai](https://app.mem0.ai)

b. Navigate to your API Keys page

c. Copy your API key

d. Enter this key in the extension preferences

**Basic Usage**:

* Store memories and text snippets
* Retrieve context-aware information
* Manage persistent user preferences
* Search through stored memories

## Features

**Remember Everything**: Never lose important information. Store notes, preferences, and conversations that your AI can recall later.

**Smart Connections**: Automatically links related topics, helping you discover useful connections.

**Cost Saver**: Spend less on AI usage by efficiently retrieving relevant information instead of regenerating responses.

## How This Helps You

**More Personal Experience**: Your AI remembers your preferences and past conversations, making interactions feel more natural.

**Learn Your Style**: Adapts to how you work and what you like, becoming more helpful over time.

**No More Repetition**: Stop explaining the same things repeatedly. Your AI remembers your context and preferences.

<CardGroup cols={2}>
  <Card title="OpenAI Agents SDK" icon="cube" href="/integrations/openai-agents-sdk">
    Build desktop AI agents with OpenAI SDK
  </Card>

  <Card title="Mastra Integration" icon="star" href="/integrations/mastra">
    Create intelligent desktop workflows
  </Card>
</CardGroup>


# Vercel AI SDK
Source: https://docs.mem0.ai/integrations/vercel-ai-sdk



The [**Mem0 AI SDK Provider**](https://www.npmjs.com/package/@mem0/vercel-ai-provider) is a library developed by **Mem0** to integrate with the Vercel AI SDK. This library brings enhanced AI interaction capabilities to your applications by introducing persistent memory functionality.

<Note type="info">
  Mem0 AI SDK now supports <strong>Vercel AI SDK V5</strong>.
</Note>

## Overview

1. Offers persistent memory storage for conversational AI
2. Enables smooth integration with the Vercel AI SDK
3. Ensures compatibility with multiple LLM providers
4. Supports structured message formats for clarity
5. Facilitates streaming response capabilities

## Setup and Configuration

Install the SDK provider using npm:

```bash  theme={null}
npm install @mem0/vercel-ai-provider
```

## Getting Started

### Setting Up Mem0

1. Get your **Mem0 API Key** from the [Mem0 Dashboard](https://app.mem0.ai/dashboard/api-keys).

2. Initialize the Mem0 Client in your application:

   ```typescript  theme={null}
   import { createMem0 } from "@mem0/vercel-ai-provider";

   const mem0 = createMem0({
     provider: "openai",
     mem0ApiKey: "m0-xxx",
     apiKey: "provider-api-key",
     config: {
       // Options for LLM Provider
     },
     // Optional Mem0 Global Config
     mem0Config: {
       user_id: "mem0-user-id",
     },
   });
   ```

   > **Note**: The `openai` provider is set as default. Consider using `MEM0_API_KEY` and `OPENAI_API_KEY` as environment variables for security.

   > **Note**: The `mem0Config` is optional. It is used to set the global config for the Mem0 Client (eg. `user_id`, `agent_id`, `app_id`, `run_id`, `org_id`, `project_id` etc).

3. Add Memories to Enhance Context:

   ```typescript  theme={null}
   import { LanguageModelV2Prompt } from "@ai-sdk/provider";
   import { addMemories } from "@mem0/vercel-ai-provider";

   const messages: LanguageModelV2Prompt = [
     { role: "user", content: [{ type: "text", text: "I love red cars." }] },
   ];

   await addMemories(messages, { user_id: "borat" });
   ```

### Standalone Features:

```typescript  theme={null}
await addMemories(messages, { user_id: "borat", mem0ApiKey: "m0-xxx" });
await retrieveMemories(prompt, { user_id: "borat", mem0ApiKey: "m0-xxx" });
await getMemories(prompt, { user_id: "borat", mem0ApiKey: "m0-xxx" });
```

> For standalone features, such as `addMemories`, `retrieveMemories`, and `getMemories`, you must either set `MEM0_API_KEY` as an environment variable or pass it directly in the function call.

> `getMemories` will return raw memories in the form of an array of objects, while `retrieveMemories` will return a response in string format with a system prompt ingested with the retrieved memories.

> `getMemories` is an object with two keys: `results` and `relations` if `enable_graph` is enabled. Otherwise, it will return an array of objects.

### 1. Basic Text Generation with Memory Context

```typescript  theme={null}
import { generateText } from "ai";
import { createMem0 } from "@mem0/vercel-ai-provider";

const mem0 = createMem0();

const { text } = await generateText({
  model: mem0("gpt-4-turbo", { user_id: "borat" }),
  prompt: "Suggest me a good car to buy!",
});
```

### 2. Combining OpenAI Provider with Memory Utils

```typescript  theme={null}
import { generateText } from "ai";
import { openai } from "@ai-sdk/openai";
import { retrieveMemories } from "@mem0/vercel-ai-provider";

const prompt = "Suggest me a good car to buy.";
const memories = await retrieveMemories(prompt, { user_id: "borat" });

const { text } = await generateText({
  model: openai("gpt-4-turbo"),
  prompt: prompt,
  system: memories,
});
```

### 3. Structured Message Format with Memory

```typescript  theme={null}
import { generateText } from "ai";
import { createMem0 } from "@mem0/vercel-ai-provider";

const mem0 = createMem0();

const { text } = await generateText({
  model: mem0("gpt-4-turbo", { user_id: "borat" }),
  messages: [
    {
      role: "user",
      content: [
        { type: "text", text: "Suggest me a good car to buy." },
        { type: "text", text: "Why is it better than the other cars for me?" },
      ],
    },
  ],
});
```

### 3. Streaming Responses with Memory Context

```typescript  theme={null}
import { streamText } from "ai";
import { createMem0 } from "@mem0/vercel-ai-provider";

const mem0 = createMem0();

const { textStream } = streamText({
    model: mem0("gpt-4-turbo", {
        user_id: "borat",
    }),
    prompt: "Suggest me a good car to buy! Why is it better than the other cars for me? Give options for every price range.",
});

for await (const textPart of textStream) {
    process.stdout.write(textPart);
}
```

### 4. Generate Responses with Tools Call

```typescript  theme={null}
import { generateText } from "ai";
import { createMem0 } from "@mem0/vercel-ai-provider";
import { z } from "zod";

const mem0 = createMem0({
  provider: "anthropic",
  apiKey: "anthropic-api-key",
  mem0Config: {
    // Global User ID
    user_id: "borat"
  }
});

const prompt = "What the temperature in the city that I live in?"

const result = await generateText({
  model: mem0('claude-3-5-sonnet-20240620'),
  tools: {
    weather: tool({
      description: 'Get the weather in a location',
      parameters: z.object({
        location: z.string().describe('The location to get the weather for'),
      }),
      execute: async ({ location }) => ({
        location,
        temperature: 72 + Math.floor(Math.random() * 21) - 10,
      }),
    }),
  },
  prompt: prompt,
});

console.log(result);
```

### 5. Get sources from memory

```typescript  theme={null}
const { text, sources } = await generateText({
    model: mem0("gpt-4-turbo"),
    prompt: "Suggest me a good car to buy!",
});

console.log(sources);
```

The same can be done for `streamText` as well.

### 6. File Support with Memory Context

Mem0 AI SDK supports file processing with memory context. Here's an example of analyzing a PDF file:

```typescript  theme={null}
import { streamText } from "ai";
import { createMem0 } from "@mem0/vercel-ai-provider";
import { readFileSync } from 'fs';
import { join } from 'path';

const mem0 = createMem0({
  provider: "google",
  mem0ApiKey: "m0-xxx",
  config: {
    apiKey: "google-api-key"
  },
  mem0Config: {
    user_id: "alice",
  },
});

async function main() {
  // Read the PDF file
  const filePath = join(process.cwd(), 'my_pdf.pdf');
  const fileBuffer = readFileSync(filePath);

  // Convert the file's arrayBuffer to a Base64 data URL
  const arrayBuffer = fileBuffer.buffer.slice(fileBuffer.byteOffset, fileBuffer.byteOffset + fileBuffer.byteLength);
  const uint8Array = new Uint8Array(arrayBuffer);

  // Convert Uint8Array to an array of characters
  const charArray = Array.from(uint8Array, byte => String.fromCharCode(byte));
  const binaryString = charArray.join('');
  const base64Data = Buffer.from(binaryString, 'binary').toString('base64');
  const fileDataUrl = `data:application/pdf;base64,${base64Data}`;

  const { textStream } = streamText({
    model: mem0("gemini-2.5-flash"),
    messages: [
      {
        role: 'user',
        content: [
          {
            type: 'text',
            text: 'Analyze the following PDF and generate a summary.',
          },
          {
            type: 'file',
            data: fileDataUrl,
            mediaType: 'application/pdf',
          },
        ],
      },
    ],
  });

  for await (const textPart of textStream) {
    process.stdout.write(textPart);
  }
}

main();
```

> **Note**: File support is available with providers that support multimodal capabilities like Google's Gemini models. The example shows how to process PDF files, but you can also work with images, text files, and other supported formats.

## Graph Memory

Mem0 AI SDK now supports Graph Memory. You can enable it by setting `enable_graph` to `true` in the `mem0Config` object.

```typescript  theme={null}
const mem0 = createMem0({
  mem0Config: { enable_graph: true },
});
```

You can also pass `enable_graph` in the standalone functions. This includes `getMemories`, `retrieveMemories`, and `addMemories`.

```typescript  theme={null}
const memories = await getMemories(prompt, { user_id: "borat", mem0ApiKey: "m0-xxx", enable_graph: true });
```

The `getMemories` function will return an object with two keys: `results` and `relations`, if `enable_graph` is set to `true`. Otherwise, it will return an array of objects.

## Supported LLM Providers

| Provider  | Configuration Value |
| --------- | ------------------- |
| OpenAI    | openai              |
| Anthropic | anthropic           |
| Google    | google              |
| Groq      | groq                |

> **Note**: You can use `google` as provider for Gemini (Google) models. They are same and internally they use `@ai-sdk/google` package.

## Key Features

* `createMem0()`: Initializes a new Mem0 provider instance.
* `retrieveMemories()`: Retrieves memory context for prompts.
* `getMemories()`: Get memories from your profile in array format.
* `addMemories()`: Adds user memories to enhance contextual responses.

## Best Practices

1. **User Identification**: Use a unique `user_id` for consistent memory retrieval.
2. **Memory Cleanup**: Regularly clean up unused memory data.

   > **Note**: We also have support for `agent_id`, `app_id`, and `run_id`. Refer [Docs](/api-reference/memory/add-memories).

## Conclusion

Mem0's Vercel AI SDK enables the creation of intelligent, context-aware applications with persistent memory and seamless integration.

<CardGroup cols={2}>
  <Card title="OpenAI Agents SDK" icon="cube" href="/integrations/openai-agents-sdk">
    Build agents with OpenAI SDK and Mem0
  </Card>

  <Card title="Mastra Integration" icon="star" href="/integrations/mastra">
    Create intelligent agents with Mastra framework
  </Card>
</CardGroup>


# MCP Client Integration Guide
Source: https://docs.mem0.ai/openmemory/integrations



## Connecting an MCP Client

Once your OpenMemory server is running locally, you can connect any compatible MCP client to your personal memory stream. This enables a seamless memory layer integration for AI tools and agents.

Ensure the following environment variables are correctly set in your configuration files:

**In `/ui/.env`:**

```env  theme={null}
NEXT_PUBLIC_API_URL=http://localhost:8765
NEXT_PUBLIC_USER_ID=<user-id>
```

**In `/api/.env`:**

```env  theme={null}
OPENAI_API_KEY=sk-xxx
USER=<user-id>
```

These values define where your MCP server is running and which user's memory is accessed.

### MCP Client Setup

Use the following one-step command to configure OpenMemory Local MCP to a client. The general command format is as follows:

```bash  theme={null}
npx @openmemory/install local http://localhost:8765/mcp/<client-name>/sse/<user-id> --client <client-name>
```

Replace `<client-name>` with the desired client name and `<user-id>` with the value specified in your environment variables.

### Example Commands for Supported Clients

| Client   | Command                                                                              |
| -------- | ------------------------------------------------------------------------------------ |
| Claude   | `npx install-mcp http://localhost:8765/mcp/claude/sse/<user-id> --client claude`     |
| Cursor   | `npx install-mcp http://localhost:8765/mcp/cursor/sse/<user-id> --client cursor`     |
| Cline    | `npx install-mcp http://localhost:8765/mcp/cline/sse/<user-id> --client cline`       |
| RooCline | `npx install-mcp http://localhost:8765/mcp/roocline/sse/<user-id> --client roocline` |
| Windsurf | `npx install-mcp http://localhost:8765/mcp/windsurf/sse/<user-id> --client windsurf` |
| Witsy    | `npx install-mcp http://localhost:8765/mcp/witsy/sse/<user-id> --client witsy`       |
| Enconvo  | `npx install-mcp http://localhost:8765/mcp/enconvo/sse/<user-id> --client enconvo`   |
| Augment  | `npx install-mcp http://localhost:8765/mcp/augment/sse/<user-id> --client augment`   |

### What This Does

Running one of the above commands registers the specified MCP client and connects it to your OpenMemory server. This enables the client to stream and store contextual memory for the provided user ID.

The connection status and memory activity can be monitored via the OpenMemory UI at [http://localhost:3000](http://localhost:3000).


# Overview
Source: https://docs.mem0.ai/openmemory/overview



## Hosted OpenMemory MCP Now Available

#### Sign Up Now - [app.openmemory.dev](https://app.openmemory.dev)

Everything you love about OpenMemory MCP but with zero setup.

* Works with all MCP-compatible tools (Claude Desktop, Cursor, etc.)
* Same standard memory operations: `add_memories`, `search_memory`, etc.
* One-click provisioning, no Docker required
* Powered by Mem0

Add shared, persistent, low-friction memory to your MCP-compatible clients in seconds.

### Get Started Now

Sign up and get your access key at [app.openmemory.dev](https://app.openmemory.dev).

Example installation: `npx @openmemory/install --client claude --env OPENMEMORY_API_KEY=your-key`

OpenMemory is a local memory infrastructure powered by Mem0 that lets you carry your memory across any AI app. It provides a unified memory layer that stays with you, enabling agents and assistants to remember what matters across applications.

<img src="https://github.com/user-attachments/assets/3c701757-ad82-4afa-bfbe-e049c2b4320b" alt="OpenMemory UI" />

## What is the OpenMemory MCP Server

The OpenMemory MCP Server is a private, local-first memory server that creates a shared, persistent memory layer for your MCP-compatible tools. It runs entirely on your machine, enabling seamless context handoff across tools. Whether you're switching between development, planning, or debugging environments, your AI assistants can access relevant memory without needing repeated instructions.

The OpenMemory MCP Server ensures all memory stays local, structured, and under your control with no cloud sync or external storage.

## OpenMemory Easy Setup

### Prerequisites

* Docker
* OpenAI API Key

You can quickly run OpenMemory by running the following command:

```bash  theme={null}
curl -sL https://raw.githubusercontent.com/mem0ai/mem0/main/openmemory/run.sh | bash
```

You should set the `OPENAI_API_KEY` as a global environment variable:

```bash  theme={null}
export OPENAI_API_KEY=your_api_key
```

You can also set the `OPENAI_API_KEY` as a parameter to the script:

```bash  theme={null}
curl -sL https://raw.githubusercontent.com/mem0ai/mem0/main/openmemory/run.sh | OPENAI_API_KEY=your_api_key bash
```

This will start the OpenMemory server and the OpenMemory UI. Deleting the container will lead to the deletion of the memory store. We suggest you follow the instructions [here](/openmemory/quickstart#setting-up-openmemory) to set up OpenMemory on your local machine with a more persistent memory store.

## How the OpenMemory MCP Server Works

Built around the Model Context Protocol (MCP), the OpenMemory MCP Server exposes a standardized set of memory tools:

* `add_memories`: Store new memory objects
* `search_memory`: Retrieve relevant memories
* `list_memories`: View all stored memory
* `delete_all_memories`: Clear memory entirely

Any MCP-compatible tool can connect to the server and use these APIs to persist and access memory.

## What It Enables

### Cross-Client Memory Access

Store context in Cursor and retrieve it later in Claude or Windsurf without repeating yourself.

### Fully Local Memory Store

All memory is stored on your machine. Nothing goes to the cloud. You maintain full ownership and control.

### Unified Memory UI

The built-in OpenMemory dashboard provides a central view of everything stored. Add, browse, delete, and control memory access to clients directly from the dashboard.

## Supported Clients

The OpenMemory MCP Server is compatible with any client that supports the Model Context Protocol. This includes:

* Cursor
* Claude Desktop
* Windsurf
* Cline
* And more

As more AI systems adopt MCP, your private memory becomes more valuable.

## Real-World Examples

### Scenario 1: Cross-Tool Project Flow

Define technical requirements of a project in Claude Desktop. Build in Cursor. Debug issues in Windsurf - all with shared context passed through OpenMemory.

### Scenario 2: Preferences That Persist

Set your preferred code style or tone in one tool. When you switch to another MCP client, it can access those same preferences without redefining them.

### Scenario 3: Project Knowledge

Save important project details once, then access them from any compatible AI tool - no more repetitive explanations.

## Conclusion

The OpenMemory MCP Server brings memory to MCP-compatible tools without giving up control or privacy. It solves a foundational limitation in modern LLM workflows: the loss of context across tools, sessions, and environments.

By standardizing memory operations and keeping all data local, it reduces token overhead, improves performance, and unlocks more intelligent interactions across the growing ecosystem of AI assistants.

This is just the beginning. The MCP server is the first core layer in the OpenMemory platform, a broader effort to make memory portable, private, and interoperable across AI systems.

## Getting Started Today

* Repository: [GitHub](https://github.com/mem0ai/mem0/tree/main/openmemory)
* Join our community: [Discord](https://discord.gg/6PzXDgEjG5)

With OpenMemory, your AI memories stay private, portable, and under your control, exactly where they belong.

OpenMemory: Your memories, your control.

## Contributing

OpenMemory is open source and we welcome contributions. Please see the [CONTRIBUTING.md](https://github.com/mem0ai/mem0/blob/main/openmemory/CONTRIBUTING.md) file for more information.


# Quickstart
Source: https://docs.mem0.ai/openmemory/quickstart



## Hosted OpenMemory MCP Now Available

#### Sign Up Now - [app.openmemory.dev](https://app.openmemory.dev)

Everything you love about OpenMemory MCP but with zero setup.

* Works with all MCP-compatible tools (Claude Desktop, Cursor, etc.)
* Same standard memory operations: `add_memories`, `search_memory`, etc.
* One-click provisioning, no Docker required
* Powered by Mem0

Add shared, persistent, low-friction memory to your MCP-compatible clients in seconds.

### Get Started Now

Sign up and get your access key at [app.openmemory.dev](https://app.openmemory.dev).

Example installation: `npx @openmemory/install --client claude --env OPENMEMORY_API_KEY=your-key`

## Getting Started with Hosted OpenMemory

The fastest way to get started is with our hosted version - no setup required.

### 1. Get Your API Key

Visit [app.openmemory.dev](https://app.openmemory.dev) to sign up and get your `OPENMEMORY_API_KEY`.

### 2. Install and Connect to Your Preferred Client

Example commands (replace `your-key` with your actual API key):

**For Claude Desktop:**

```bash  theme={null}
npx @openmemory/install --client claude --env OPENMEMORY_API_KEY=your-key
```

**For Cursor:**

```bash  theme={null}
npx @openmemory/install --client cursor --env OPENMEMORY_API_KEY=your-key
```

**For Windsurf:**

```bash  theme={null}
npx @openmemory/install --client windsurf --env OPENMEMORY_API_KEY=your-key
```

That's it! Your AI client now has persistent memory across sessions.

## Local Setup (Self-Hosted)

Prefer to run OpenMemory locally? Follow the instructions below for a self-hosted setup.

## OpenMemory Easy Setup

### Prerequisites

* Docker
* OpenAI API Key

You can quickly run OpenMemory by running the following command:

```bash  theme={null}
curl -sL https://raw.githubusercontent.com/mem0ai/mem0/main/openmemory/run.sh | bash
```

You should set the `OPENAI_API_KEY` as a global environment variable:

```bash  theme={null}
export OPENAI_API_KEY=your_api_key
```

You can also set the `OPENAI_API_KEY` as a parameter to the script:

```bash  theme={null}
curl -sL https://raw.githubusercontent.com/mem0ai/mem0/main/openmemory/run.sh | OPENAI_API_KEY=your_api_key bash
```

This will start the OpenMemory server and the OpenMemory UI. Deleting the container will lead to the deletion of the memory store. We suggest you follow the instructions below to set up OpenMemory on your local machine with a more persistent memory store.

## Setting Up OpenMemory

Getting started with OpenMemory is straightforward and takes just a few minutes to set up on your local machine. Follow these steps:

### 1. Clone the Repository

```bash  theme={null}
# Clone the repository
git clone https://github.com/mem0ai/mem0.git
cd mem0/openmemory
```

### 2. Set Up Environment Variables

Before running the project, you need to configure environment variables for both the API and the UI.

You can do this in one of the following ways:

* **Manually:** Create a `.env` file in each of the following directories:
  * `/api/.env`
  * `/ui/.env`

* **Using `.env.example` files:** Copy and rename the example files:
  ```bash  theme={null}
  cp api/.env.example api/.env
  cp ui/.env.example ui/.env
  ```

* **Using Makefile** (if supported): Run:
  ```bash  theme={null}
  make env
  ```

#### Example `/api/.env`

```bash  theme={null}
OPENAI_API_KEY=sk-xxx
USER=<user-id> # The User ID you want to associate the memories with
```

#### Example `/ui/.env`

```bash  theme={null}
NEXT_PUBLIC_API_URL=http://localhost:8765
NEXT_PUBLIC_USER_ID=<user-id> # Same as the user ID for environment variable in api
```

### 3. Build and Run the Project

You can run the project using the following two commands:

```bash  theme={null}
make build # Builds the MCP server and UI
make up    # Runs OpenMemory MCP server and UI
```

After running these commands, you will have:

* OpenMemory MCP server running at [http://localhost:8765](http://localhost:8765) (API documentation available at [http://localhost:8765/docs](http://localhost:8765/docs))
* OpenMemory UI running at [http://localhost:3000](http://localhost:3000)

#### UI Not Working on [http://localhost:3000](http://localhost:3000)?

If the UI does not start properly on [http://localhost:3000](http://localhost:3000), try running it manually:

```bash  theme={null}
cd ui
pnpm install
pnpm dev
```

You can configure the MCP client using the following command (replace `username` with your username):

```bash  theme={null}
npx @openmemory/install local "http://localhost:8765/mcp/cursor/sse/username" --client cursor
```

The OpenMemory dashboard will be available at [http://localhost:3000](http://localhost:3000). From here, you can view and manage your memories and check connection status with your MCP clients.

Once set up, OpenMemory runs locally on your machine, ensuring all your AI memories remain private and secure while being accessible across any compatible MCP client.

## Getting Started Today

GitHub Repository: [https://github.com/mem0ai/mem0/tree/main/openmemory](https://github.com/mem0ai/mem0/tree/main/openmemory)


# Add Member
Source: https://docs.mem0.ai/api-reference/project/add-project-member

post /api/v1/orgs/organizations/{org_id}/projects/{project_id}/members/
Add a new member to a specific project within an organization.

The API provides two roles for project members:

* `READER`: Allows viewing of project resources.
* `OWNER`: Grants full administrative access to manage the project and its resources.


# Delete Project
Source: https://docs.mem0.ai/api-reference/project/delete-project

delete /api/v1/orgs/organizations/{org_id}/projects/{project_id}/
Delete a specific project and its related data.



# Get Members
Source: https://docs.mem0.ai/api-reference/project/get-project-members

get /api/v1/orgs/organizations/{org_id}/projects/{project_id}/members/
Retrieve a list of members for a specific project.



# Create Webhook
Source: https://docs.mem0.ai/api-reference/webhook/create-webhook

post /api/v1/webhooks/projects/{project_id}/
Create a new webhook for a specific project



# Delete Webhook
Source: https://docs.mem0.ai/api-reference/webhook/delete-webhook

delete /api/v1/webhooks/{webhook_id}/
Delete an existing webhook



# Get Webhook
Source: https://docs.mem0.ai/api-reference/webhook/get-webhook

get /api/v1/webhooks/projects/{project_id}/
Retrieve all webhooks for a specific project



# Update Webhook
Source: https://docs.mem0.ai/api-reference/webhook/update-webhook

put /api/v1/webhooks/{webhook_id}/
Update an existing webhook



# Product Updates
Source: https://docs.mem0.ai/changelog



<Tabs>
  <Tab title="Python">
    <Update label="2025-10-16" description="v1.0.0">
      **New Features & Updates:**

      * **Vector Stores:**
        * Added Azure MySQL support
        * Added Azure AI Search Vector Store support
      * **LLMs:**
        * Added Tool Call support for LangchainLLM
        * Enabled custom model and parameters for Hugging Face with huggingface\_base\_url
        * Updated default LLM configuration
      * **Rerankers:**
        * Added reranker support: Cohere, ZeroEntropy, Hugging Face, Sentence Transformers, and LLMs
      * **Core:**
        * Added metadata filtering for OSS
        * Added Assistant memory retrieval
        * Enabled async mode as default

      **Improvements:**

      * **Prompts:**
        * Improved prompt for better memory retrieval
      * **Dependencies:**
        * Updated dependency compatibility with OpenAI 2.x
      * **Validation:**
        * Validated embedding\_dims for Kuzu integration

      **Bug Fixes:**

      * **Vector Stores:**
        * Fixed Databricks Vector Store integration
        * Fixed Milvus DB bug and added test coverage
        * Fixed Weaviate search method
      * **LLMs:**
        * Fixed bug with thinking LLM in vLLM
    </Update>

    <Update label="2025-09-25" description="v0.1.118">
      **New Features & Updates:**

      * **Vector Stores:**
        * Added Valkey vector store support
        * Added support for ChromaDB Cloud
        * Added Mem0 vector store backend integration for Neptune Analytics
      * **Graph Store:**
        * Added Neptune-DB graph store with vector store
      * **Core:**
        * Implemented structured exception classes with error codes and suggested actions

      **Improvements:**

      * **Dependencies:**
        * Updated OpenAI dependency and improved Ollama compatibility
      * **Testing:**
        * Added Weaviate DB test
        * Added comprehensive test suite for SQLiteManager
      * **Documentation:**
        * Updated category docs
        * Updated Search V2 / Get All V2 filters documentation
        * Refactored AWS example title
        * Fixed Quickstart cURL example

      **Bug Fixes:**

      * **Vector Stores:**
        * Databricks bug fixes
        * Fixed S3 Vectors memory initialization issue from configuration
      * **Core:**
        * Fixed JSON parsing with new memories
        * Replaced hardcoded LLM provider with provider from configuration
      * **LLMs:**
        * Fixed Bedrock Anthropic models to use system field
    </Update>

    <Update label="2025-09-03" description="v0.1.117">
      **New Features & Updates:**

      * **OpenMemory:**
        * Added memory export / import feature
        * Added vector store integrations: Weaviate, FAISS, PGVector, Chroma, Redis, Elasticsearch, Milvus
        * Added `export_openmemory.sh` migration script
      * **Vector Stores:**
        * Added Amazon S3 Vectors support
        * Added Databricks Mosaic AI vector store support
        * Added support for OpenAI Store
      * **Graph Memory:** Added support for graph memory using Kuzu
      * **Azure:** Added Azure Identity for Azure OpenAI and Azure AI Search authentication
      * **Elasticsearch:** Added headers configuration support

      **Improvements:**

      * Added custom connection client to enable connecting to local containers for Weaviate
      * Updated configuration AWS Bedrock
      * Fixed dependency issues and tests; updated docstrings
      * **Documentation:**
        * Fixed Graph Docs page missing in sidebar
        * Updated integration documentation
        * Added version param in Search V2 API documentation
        * Updated Databricks documentation and refactored docs
        * Updated favicon logo
        * Fixed typos and Typescript docs

      **Bug Fixes:**

      * Baidu: Added missing provider for Baidu vector DB
      * MongoDB: Replaced `query_vector` args in search method
      * Fixed new memory mistaken for current
      * AsyncMemory.\_add\_to\_vector\_store: handled edge case when no facts found
      * Fixed missing commas in Kuzu graph INSERT queries
      * Fixed inconsistent created and updated properties for Graph
      * Fixed missing `app_id` on client for Neptune Analytics
      * Correctly pick AWS region from environment variable
      * Fixed Ollama model existence check

      **Refactoring:**

      * **PGVector:** Use internal connection pools and context managers
    </Update>

    <Update label="2025-08-14" description="v0.1.116">
      **New Features & Updates:**

      * **Pinecone:** Added namespace support and improved type safety
      * **Milvus:** Added db\_name field to MilvusDBConfig
      * **Vector Stores:** Added multi-id filters support
      * **Vercel AI SDK:** Migration to AI SDK V5.0
      * **Python Support:** Added Python 3.12 support
      * **Graph Memory:** Added sanitizer methods for nodes and relationships
      * **LLM Monitoring:** Added monitoring callback support

      **Improvements:**

      * **Performance:**
        * Improved async handling in AsyncMemory class
      * **Documentation:**
        * Added async add announcement
        * Added personalized search docs
        * Added Neptune examples
        * Added V5 migration docs
      * **Configuration:**
        * Refactored base class config for LLMs
        * Added sslmode for pgvector
      * **Dependencies:**
        * Updated psycopg to version 3
        * Updated Docker compose

      **Bug Fixes:**

      * **Tests:**
        * Fixed failing tests
        * Restricted package versions
      * **Memgraph:**
        * Fixed async attribute errors
        * Fixed n\_embeddings usage
        * Fixed indexing issues
      * **Vector Stores:**
        * Fixed Qdrant cloud indexing
        * Fixed Neo4j Cypher syntax
        * Fixed LLM parameters
      * **Graph Store:**
        * Fixed LM config prioritization
      * **Dependencies:**
        * Fixed JSON import for psycopg

      **Refactoring:**

      * **Google AI:** Refactored from Gemini to Google AI
      * **Base Classes:** Refactored LLM base class configuration
    </Update>

    <Update label="2025-07-24" description="v0.1.115">
      **New Features & Updates:**

      * Enhanced project management via `client.project` and `AsyncMemoryClient.project` interfaces
      * Full support for project CRUD operations (create, read, update, delete)
      * Project member management: add, update, remove, and list members
      * Manage project settings including custom instructions, categories, retrieval criteria, and graph enablement
      * Both sync and async support for all project management operations

      **Improvements:**

      * **Documentation:**
        * Added detailed API reference and usage examples for new project management methods.
        * Updated all docs to use `client.project.get()` and `client.project.update()` instead of deprecated methods.
      * **Deprecation:**
        * Marked `get_project()` and `update_project()` as deprecated (these methods were already present); added warnings to guide users to the new API.

      **Bug Fixes:**

      * **Tests:**
        * Fixed Gemini embedder and LLM test mocks for correct error handling and argument structure.
      * **vLLM:**
        * Fixed duplicate import in vLLM module.
    </Update>

    <Update label="2025-07-05" description="v0.1.114">
      **New Features:**

      * **OpenAI Agents:** Added OpenAI agents SDK support
      * **Amazon Neptune:** Added Amazon Neptune Analytics graph\_store configuration and integration
      * **vLLM:** Added vLLM support

      **Improvements:**

      * **Documentation:**
        * Added SOC2 and HIPAA compliance documentation
        * Enhanced group chat feature documentation for platform
        * Added Google AI ADK Integration documentation
        * Fixed documentation images and links
      * **Setup:** Fixed Mem0 setup, logging, and documentation issues

      **Bug Fixes:**

      * **MongoDB:** Fixed MongoDB Vector Store misaligned strings and classes
      * **vLLM:** Fixed missing OpenAI import in vLLM module and call errors
      * **Dependencies:** Fixed CI issues related to missing dependencies
      * **Installation:** Reverted pip install changes
    </Update>

    <Update label="2025-06-30" description="v0.1.113">
      **Bug Fixes:**

      * **Gemini:** Fixed Gemini embedder configuration
    </Update>

    <Update label="2025-06-27" description="v0.1.112">
      **New Features:**

      * **Memory:** Added immutable parameter to add method
      * **OpenMemory:** Added async\_mode parameter support

      **Improvements:**

      * **Documentation:**
        * Enhanced platform feature documentation
        * Fixed documentation links
        * Added async\_mode documentation
      * **MongoDB:** Fixed MongoDB configuration name

      **Bug Fixes:**

      * **Bedrock:** Fixed Bedrock LLM, embeddings, tools, and temporary credentials
      * **Memory:** Fixed memory categorization by updating dependencies and correcting API usage
      * **Gemini:** Fixed Gemini Embeddings and LLM issues
    </Update>

    <Update label="2025-06-23" description="v0.1.111">
      **New Features:**

      * **OpenMemory:**
        * Added OpenMemory augment support
        * Added OpenMemory Local Support using new library
      * **vLLM:** Added vLLM support integration

      **Improvements:**

      * **Documentation:**
        * Added MCP Client Integration Guide and updated installation commands
        * Improved Agent Id documentation for Mem0 OSS Graph Memory
      * **Core:** Added JSON parsing to solve hallucination errors

      **Bug Fixes:**

      * **Gemini:** Fixed Gemini Embeddings migration
    </Update>

    <Update label="2025-06-20" description="v0.1.110">
      **New Features:**

      * **Baidu:** Added Baidu vector database integration

      **Improvements:**

      * **Documentation:**
        * Updated changelog
        * Fixed example in quickstart page
        * Updated client.update() method documentation in OpenAPI specification
      * **OpenSearch:** Updated logger warning

      **Bug Fixes:**

      * **CI:** Fixed failing CI pipeline
    </Update>

    <Update label="2025-06-19" description="v0.1.109">
      **New Features:**

      * **AgentOps:** Added AgentOps integration
      * **LM Studio:** Added response\_format parameter for LM Studio configuration
      * **Examples:** Added Memory agent powered by voice (Cartesia + Agno)

      **Improvements:**

      * **AI SDK:** Added output\_format parameter
      * **Client:** Enhanced update method to support metadata
      * **Google:** Added Google Genai library support

      **Bug Fixes:**

      * **Build:** Fixed Build CI failure
      * **Pinecone:** Fixed pinecone for async memory
    </Update>

    <Update label="2025-06-14" description="v0.1.108">
      **New Features:**

      * **MongoDB:** Added MongoDB Vector Store support
      * **Client:** Added client support for summary functionality

      **Improvements:**

      * **Pinecone:** Fixed pinecone version issues
      * **OpenSearch:** Added logger support
      * **Testing:** Added python version test environments
    </Update>

    <Update label="2025-06-11" description="v0.1.107">
      **Improvements:**

      * **Documentation:**
        * Updated Livekit documentation migration
        * Updated OpenMemory hosted version documentation
      * **Core:** Updated categorization flow
      * **Storage:** Fixed migration issues
    </Update>

    <Update label="2025-06-09" description="v0.1.106">
      **New Features:**

      * **Cloudflare:** Added Cloudflare vector store support
      * **Search:** Added threshold parameter to search functionality
      * **API:** Added wildcard character support for v2 Memory APIs

      **Improvements:**

      * **Documentation:** Updated README docs for OpenMemory environment setup
      * **Core:** Added support for unique user IDs

      **Bug Fixes:**

      * **Core:** Fixed error handling exceptions
    </Update>

    <Update label="2025-06-03" description="v0.1.104">
      **Bug Fixes:**

      * **Vector Stores:** Fixed GET\_ALL functionality for FAISS and OpenSearch
    </Update>

    <Update label="2025-06-02" description="v0.1.103">
      **New Features:**

      * **LLM:** Added support for OpenAI compatible LLM providers with baseUrl configuration

      **Improvements:**

      * **Documentation:**
        * Fixed broken links
        * Improved Graph Memory features documentation clarity
        * Updated enable\_graph documentation
      * **TypeScript SDK:** Updated Google SDK peer dependency version
      * **Client:** Added async mode parameter
    </Update>

    <Update label="2025-05-26" description="v0.1.102">
      **New Features:**

      * **Examples:** Added Neo4j example
      * **AI SDK:** Added Google provider support
      * **OpenMemory:** Added LLM and Embedding Providers support

      **Improvements:**

      * **Documentation:**
        * Updated memory export documentation
        * Enhanced role-based memory attribution rules documentation
        * Updated API reference and messages documentation
        * Added Mastra and Raycast documentation
        * Added NOT filter documentation for Search and GetAll V2
        * Announced Claude 4 support
      * **Core:**
        * Removed support for passing string as input in client.add()
        * Added support for sarvam-m model
      * **TypeScript SDK:** Fixed types from message interface

      **Bug Fixes:**

      * **Memory:** Prevented saving prompt artifacts as memory when no new facts are present
      * **OpenMemory:** Fixed typos in MCP tool description
    </Update>

    <Update label="2025-05-15" description="v0.1.101">
      **New Features:**

      * **Neo4j:** Added base label configuration support

      **Improvements:**

      * **Documentation:**
        * Updated Healthcare example index
        * Enhanced collaborative task agent documentation clarity
        * Added criteria-based filtering documentation
      * **OpenMemory:** Added cURL command for easy installation
      * **Build:** Migrated to Hatch build system
    </Update>

    <Update label="2025-05-10" description="v0.1.100">
      **New Features:**

      * **Memory:** Added Group Chat Memory Feature support
      * **Examples:** Added Healthcare assistant using Mem0 and Google ADK

      **Bug Fixes:**

      * **SSE:** Fixed SSE connection issues
      * **MCP:** Fixed memories not appearing in MCP clients added from Dashboard
    </Update>

    <Update label="2025-05-07" description="v0.1.99">
      **New Features:**

      * **OpenMemory:** Added OpenMemory support
      * **Neo4j:** Added weights to Neo4j model
      * **AWS:** Added support for Opsearch Serverless
      * **Examples:** Added ElizaOS Example

      **Improvements:**

      * **Documentation:** Updated Azure AI documentation
      * **AI SDK:** Added missing parameters and updated demo application
      * **OSS:** Fixed AOSS and AWS BedRock LLM
    </Update>

    <Update label="2025-04-30" description="v0.1.98">
      **New Features:**

      * **Neo4j:** Added support for Neo4j database
      * **AWS:** Added support for AWS Bedrock Embeddings

      **Improvements:**

      * **Client:** Updated delete\_users() to use V2 API endpoints
      * **Documentation:** Updated timestamp and dual-identity memory management docs
      * **Neo4j:** Improved Neo4j queries and removed warnings
      * **AI SDK:** Added support for graceful failure when services are down

      **Bug Fixes:**

      * Fixed AI SDK filters
      * Fixed new memories wrong type
      * Fixed duplicated metadata issue while adding/updating memories
    </Update>

    <Update label="2025-04-23" description="v0.1.97">
      **New Features:**

      * **HuggingFace:** Added support for HF Inference

      **Bug Fixes:**

      * Fixed proxy for Mem0
    </Update>

    <Update label="2025-04-16" description="v0.1.96">
      **New Features:**

      * **Vercel AI SDK:** Added Graph Memory support

      **Improvements:**

      * **Documentation:** Fixed timestamp and README links
      * **Client:** Updated TS client to use proper types for deleteUsers
      * **Dependencies:** Removed unnecessary dependencies from base package
    </Update>

    <Update label="2025-04-09" description="v0.1.95">
      **Improvements:**

      * **Client:** Fixed Ping Method for using default org\_id and project\_id
      * **Documentation:** Updated documentation

      **Bug Fixes:**

      * Fixed mem0-migrations issue
    </Update>

    <Update label="2025-04-26" description="v0.1.94">
      **New Features:**

      * **Integrations:** Added Memgraph integration
      * **Memory:** Added timestamp support
      * **Vector Stores:** Added reset function for VectorDBs

      **Improvements:**

      * **Documentation:**
        * Updated timestamp and expiration\_date documentation
        * Fixed v2 search documentation
        * Added "memory" in EC "Custom config" section
        * Fixed typos in the json config sample
    </Update>

    <Update label="2025-04-21" description="v0.1.93">
      **Improvements:**

      * **Vector Stores:** Initialized embedding\_model\_dims in all vectordbs

      **Bug Fixes:**

      * **Documentation:** Fixed agno link
    </Update>

    <Update label="2025-04-18" description="v0.1.92">
      **New Features:**

      * **Memory:** Added Memory Reset functionality
      * **Client:** Added support for Custom Instructions
      * **Examples:** Added Fitness Checker powered by memory

      **Improvements:**

      * **Core:** Updated capture\_event
      * **Documentation:** Fixed curl for v2 get\_all

      **Bug Fixes:**

      * **Vector Store:** Fixed user\_id functionality
      * **Client:** Various client improvements
    </Update>

    <Update label="2025-04-16" description="v0.1.91">
      **New Features:**

      * **LLM Integrations:** Added Azure OpenAI Embedding Model
      * **Examples:**
        * Added movie recommendation using grok3
        * Added Voice Assistant using Elevenlabs

      **Improvements:**

      * **Documentation:**
        * Added keywords AI
        * Reformatted navbar page URLs
        * Updated changelog
        * Updated openai.mdx
      * **FAISS:** Silenced FAISS info logs
    </Update>

    <Update label="2025-04-11" description="v0.1.90">
      **New Features:**

      * **LLM Integrations:** Added Mistral AI as LLM provider

      **Improvements:**

      * **Documentation:**
        * Updated changelog
        * Fixed memory exclusion example
        * Updated xAI documentation
        * Updated YouTube Chrome extension example documentation

      **Bug Fixes:**

      * **Core:** Fixed EmbedderFactory.create() in GraphMemory
      * **Azure OpenAI:** Added patch to fix Azure OpenAI
      * **Telemetry:** Fixed telemetry issue
    </Update>

    <Update label="2025-04-11" description="v0.1.89">
      **New Features:**

      * **Langchain Integration:** Added support for Langchain VectorStores
      * **Examples:**
        * Added personal assistant example
        * Added personal study buddy example
        * Added YouTube assistant Chrome extension example
        * Added agno example
        * Updated OpenAI Responses API examples
      * **Vector Store:** Added capability to store user\_id in vector database
      * **Async Memory:** Added async support for OSS

      **Improvements:**

      * **Documentation:** Updated formatting and examples
    </Update>

    <Update label="2025-04-09" description="v0.1.87">
      **New Features:**

      * **Upstash Vector:** Added support for Upstash Vector store

      **Improvements:**

      * **Code Quality:** Removed redundant code lines
      * **Build:** Updated MAKEFILE
      * **Documentation:** Updated memory export documentation
    </Update>

    <Update label="2025-04-07" description="v0.1.86">
      **Improvements:**

      * **FAISS:** Added embedding\_dims parameter to FAISS vector store
    </Update>

    <Update label="2025-04-07" description="v0.1.84">
      **New Features:**

      * **Langchain Embedder:** Added Langchain embedder integration

      **Improvements:**

      * **Langchain LLM:** Updated Langchain LLM integration to directly pass the Langchain object LLM
    </Update>

    <Update label="2025-04-07" description="v0.1.83">
      **Bug Fixes:**

      * **Langchain LLM:** Fixed issues with Langchain LLM integration
    </Update>

    <Update label="2025-04-07" description="v0.1.82">
      **New Features:**

      * **LLM Integrations:** Added support for Langchain LLMs, Google as new LLM and embedder
      * **Development:** Added development docker compose

      **Improvements:**

      * **Output Format:** Set output\_format='v1.1' and updated documentation

      **Documentation:**

      * **Integrations:** Added LMStudio and Together.ai documentation
      * **API Reference:** Updated output\_format documentation
      * **Integrations:** Added PipeCat integration documentation
      * **Integrations:** Added Flowise integration documentation for Mem0 memory setup

      **Bug Fixes:**

      * **Tests:** Fixed failing unit tests
    </Update>

    <Update label="2025-04-02" description="v0.1.79">
      **New Features:**

      * **FAISS Support:** Added FAISS vector store support
    </Update>

    <Update label="2025-04-02" description="v0.1.78">
      **New Features:**

      * **Livekit Integration:** Added Mem0 livekit example
      * **Evaluation:** Added evaluation framework and tools

      **Documentation:**

      * **Multimodal:** Updated multimodal documentation
      * **Examples:** Added examples for email processing
      * **API Reference:** Updated API reference section
      * **Elevenlabs:** Added Elevenlabs integration example

      **Bug Fixes:**

      * **OpenAI Environment Variables:** Fixed issues with OpenAI environment variables
      * **Deployment Errors:** Added `package.json` file to fix deployment errors
      * **Tools:** Fixed tools issues and improved formatting
      * **Docs:** Updated API reference section for `expiration date`
    </Update>

    <Update label="2025-03-26" description="v0.1.77">
      **Bug Fixes:**

      * **OpenAI Environment Variables:** Fixed issues with OpenAI environment variables
      * **Deployment Errors:** Added `package.json` file to fix deployment errors
      * **Tools:** Fixed tools issues and improved formatting
      * **Docs:** Updated API reference section for `expiration date`
    </Update>

    <Update label="2025-03-19" description="v0.1.76">
      **New Features:**

      * **Supabase Vector Store:** Added support for Supabase Vector Store
      * **Supabase History DB:** Added Supabase History DB to run Mem0 OSS on Serverless
      * **Feedback Method:** Added feedback method to client

      **Bug Fixes:**

      * **Azure OpenAI:** Fixed issues with Azure OpenAI
      * **Azure AI Search:** Fixed test cases for Azure AI Search
    </Update>
  </Tab>

  <Tab title="TypeScript">
    <Update label="2025-09-04" description="v2.1.38">
      **New Features:**

      * **Client:** Added `metadata` param to `update` method.
    </Update>

    <Update label="2025-08-04" description="v2.1.37">
      **New Features:**

      * **OSS:** Added `RedisCloud` search module check
    </Update>

    <Update label="2025-07-08" description="v2.1.36">
      **New Features:**

      * **Client:** Added `structured_data_schema` param to `add` method.
    </Update>

    <Update label="2025-07-08" description="v2.1.35">
      **New Features:**

      * **Client:** Added `createMemoryExport` and `getMemoryExport` methods.
    </Update>

    <Update label="2025-07-03" description="v2.1.34">
      **New Features:**

      * **OSS:** Added Gemini support
    </Update>

    <Update label="2025-06-24" description="v2.1.33">
      **Improvement:**

      * **Client:** Added `immutable` param to `add` method.
    </Update>

    <Update label="2025-06-20" description="v2.1.32">
      **Improvement:**

      * **Client:** Made `api_version` V2 as default.
    </Update>

    <Update label="2025-06-17" description="v2.1.31">
      **Improvement:**

      * **Client:** Added param `filter_memories`.
    </Update>

    <Update label="2025-06-06" description="v2.1.30">
      **New Features:**

      * **OSS:** Added Cloudflare support

      **Improvements:**

      * **OSS:** Fixed baseURL param in LLM Config.
    </Update>

    <Update label="2025-05-30" description="v2.1.29">
      **Improvements:**

      * **Client:** Added Async Mode Param for `add` method.
    </Update>

    <Update label="2025-05-30" description="v2.1.28">
      **Improvements:**

      * **SDK:** Update Google SDK Peer Dependency Version.
    </Update>

    <Update label="2025-05-27" description="v2.1.27">
      **Improvements:**

      * **OSS:** Added baseURL param in LLM Config.
    </Update>

    <Update label="2025-05-23" description="v2.1.26">
      **Improvements:**

      * **Client:** Removed type `string` from `messages` interface
    </Update>

    <Update label="2025-05-08" description="v2.1.25">
      **Improvements:**

      * **Client:** Improved error handling in client.
    </Update>

    <Update label="2025-05-06" description="v2.1.24">
      **New Features:**

      * **Client:** Added new param `output_format` to match Python SDK.
      * **Client:** Added new enum `OutputFormat` for `v1.0` and `v1.1`
    </Update>

    <Update label="2025-05-05" description="v2.1.23">
      **New Features:**

      * **Client:** Updated `deleteUsers` to use `v2` API.
      * **Client:** Deprecated `deleteUser` and added deprecation warning.
    </Update>

    <Update label="2025-05-02" description="v2.1.22">
      **New Features:**

      * **Client:** Updated `deleteUser` to use `entity_id` and `entity_type`
    </Update>

    <Update label="2025-05-01" description="v2.1.21">
      **Improvements:**

      * **OSS SDK:** Bumped version of `@anthropic-ai/sdk` to `0.40.1`
    </Update>

    <Update label="2025-04-28" description="v2.1.20">
      **Improvements:**

      * **Client:** Fixed `organizationId` and `projectId` being assigned to default in `ping` method
    </Update>

    <Update label="2025-04-22" description="v2.1.19">
      **Improvements:**

      * **Client:** Added support for `timestamps`
    </Update>

    <Update label="2025-04-17" description="v2.1.18">
      **Improvements:**

      * **Client:** Added support for custom instructions
    </Update>

    <Update label="2025-04-15" description="v2.1.17">
      **New Features:**

      * **OSS SDK:** Added support for Langchain LLM
      * **OSS SDK:** Added support for Langchain Embedder
      * **OSS SDK:** Added support for Langchain Vector Store
      * **OSS SDK:** Added support for Azure OpenAI Embedder

      **Improvements:**

      * **OSS SDK:** Changed `model` in LLM and Embedder to use type any from `string` to use langchain llm models
      * **OSS SDK:** Added client to vector store config for langchain vector store
      * **OSS SDK:** - Updated Azure OpenAI to use new OpenAI SDK
    </Update>

    <Update label="2025-04-11" description="v2.1.16-patch.1">
      **Bug Fixes:**

      * **Azure OpenAI:** Fixed issues with Azure OpenAI
    </Update>

    <Update label="2025-04-11" description="v2.1.16">
      **New Features:**

      * **Azure OpenAI:** Added support for Azure OpenAI
      * **Mistral LLM:** Added Mistral LLM integration in OSS

      **Improvements:**

      * **Zod:** Updated Zod to 3.24.1 to avoid conflicts with other packages
    </Update>

    <Update label="2025-04-09" description="v2.1.15">
      **Improvements:**

      * **Client:** Added support for Mem0 to work with Chrome Extensions
    </Update>

    <Update label="2025-04-01" description="v2.1.14">
      **New Features:**

      * **Mastra Example:** Added Mastra example
      * **Integrations:** Added Flowise integration documentation for Mem0 memory setup

      **Improvements:**

      * **Demo:** Updated Demo Mem0AI
      * **Client:** Enhanced Ping method in Mem0 Client
      * **AI SDK:** Updated AI SDK implementation
    </Update>

    <Update label="2025-03-29" description="v2.1.13">
      **Improvements:**

      * **Introduced `ping` method to check if API key is valid and populate org/project id**
    </Update>

    <Update label="2025-03-29" description="AI SDK v1.0.0">
      **New Features:**

      * **Vercel AI SDK Update:** Support threshold and rerank

      **Improvements:**

      * **Made add calls async to avoid blocking**
      * **Bump `mem0ai` to use `2.1.12`**
    </Update>

    <Update label="2025-03-26" description="v2.1.12">
      **New Features:**

      * **Mem0 OSS:** Support infer param

      **Improvements:**

      * **Updated Supabase TS Docs**
      * **Made package size smaller**
    </Update>

    <Update label="2025-03-19" description="v2.1.11">
      **New Features:**

      * **Supabase Vector Store Integration**
      * **Feedback Method**
    </Update>
  </Tab>

  <Tab title="Platform">
    <Update label="2025-07-23" description="">
      **Bug Fixes:**

      * **Memory:** Fixed ADD functionality
    </Update>

    <Update label="2025-07-19" description="">
      **New Features:**

      * **UI:** Added Settings UI and latency display
      * **Performance:** Neo4j query optimization

      **Bug Fixes:**

      * **OpenMemory:** Fixed OMM raising unnecessary exceptions
    </Update>

    <Update label="2025-07-18" description="">
      **Improvements:**

      * **UI:** Updated Event UI
      * **Performance:** Fixed N+1 query issue in semantic\_search\_v2 by optimizing MemorySerializer field selection

      **Bug Fixes:**

      * **Memory:** Fixed duplicate memory index sentry error
    </Update>

    <Update label="2025-07-17" description="">
      **New Features:**

      * **UI:** New Settings Page
      * **Memory:** Duplicate memories entities support

      **Improvements:**

      * **Performance:** Optimized semantic search and get\_all APIs by eliminating N+1 queries
    </Update>

    <Update label="2025-07-16" description="">
      **New Features:**

      * **Database:** Implemented read replica routing with enhanced logging and app-specific DB routing

      **Improvements:**

      * **Performance:** Improved query performance in search v2 and get all v2 endpoints

      **Bug Fixes:**

      * **API:** Fixed pagination for get all API
    </Update>

    <Update label="2025-07-12" description="">
      **Bug Fixes:**

      * **Graph:** Fixed social graph bugs and connection issues
    </Update>

    <Update label="2025-07-11" description="">
      **Improvements:**

      * **Rate Limiting:** New rate limit for V2 Search

      **Bug Fixes:**

      * **Slack:** Fixed Slack rate limit error with backend improvements
    </Update>

    <Update label="2025-07-10" description="">
      **Improvements:**

      * **Performance:**
        * Changed connection pooling time to 5 minutes
        * Separated graph lambdas for better performance
    </Update>

    <Update label="2025-07-09" description="">
      **Improvements:**

      * **Graph:** Graph Optimizations V2 and memory improvements
    </Update>

    <Update label="2025-07-08" description="">
      **New Features:**

      * **Database:** Added read replica support for improved database performance
      * **UI:** Implemented UI changes for Users Page
      * **Feedback:** Enabled feedback functionality

      **Bug Fixes:**

      * **Serializer:** Fixed GET ALL Serializer
    </Update>

    <Update label="2025-07-05" description="">
      **New Features:**

      * **UI:** User Page Revamp and New Users Page
    </Update>

    <Update label="2025-07-04" description="">
      **New Features:**

      * **Users:** New Users Page implementation
      * **Tools:** Added script to backfill memory categories

      **Bug Fixes:**

      * **Filters:** Fixed Filters Get All functionality
    </Update>

    <Update label="2025-07-03" description="">
      **Improvements:**

      * **Graph:** Graph Memory optimization
      * **Memory:** Fixed exact memories and semantically similar memories retrieval
    </Update>

    <Update label="2025-07-02" description="">
      **Improvements:**

      * **Categorization:** Refactored categorization logic to utilize Gemini 2.5 Flash and improve message handling
    </Update>

    <Update label="2025-07-01" description="">
      **Bug Fixes:**

      * **Memory:** Fixed old\_memory issue in Async memory addition lambda
      * **Events:** Fixed missing events
    </Update>

    <Update label="2025-06-30" description="">
      **Improvements:**

      * **Graph:** Improvements to graph memory and added user to LTM-STM
    </Update>

    <Update label="2025-06-28" description="">
      **New Features:**

      * **Graph:** Added support for SQS in graph memory addition
      * **Testing:** Added Locust load testing script and Grafana Dashboard
    </Update>

    <Update label="2025-06-27" description="">
      **Improvements:**

      * **Rate Limiting:** Updated rate limiting for ADD API to 1000/min
      * **Performance:** Improved Neo4j performance
    </Update>

    <Update label="2025-06-26" description="">
      **New Features:**

      * **Memory:** Edit Memory From Drawer functionality
      * **API:** Added Topic Suggestions API Endpoint
    </Update>

    <Update label="2025-06-25" description="">
      **New Features:**

      * **Group Chat:** Group-Chat v2 with Actor-Aware Memories
      * **Memory:** Editable Metadata in Memories
      * **UI:** Memory Actions Badges
    </Update>

    <Update label="2025-06-19" description="">
      **New Features:**

      * **Rate Limiting:** Implemented comprehensive rate limiting system

      **Improvements:**

      * **Performance:** Added performance indexes for memory stats query

      **Bug Fixes:**

      * **Search:** Fixed search events not respecting top-k parameter
    </Update>

    <Update label="2025-06-18" description="">
      **New Features:**

      * **Memory Management:** Implemented OpenAI Batch API for Memory Cleaning with fallback
      * **Playground:** Added Claude 4 support on Playground

      **Improvements:**

      * **Memory:** Added ability to update memory metadata
    </Update>

    <Update label="2025-06-17" description="">
      **New Features:**

      * **UI:** New Memories Page UI design
    </Update>

    <Update label="2025-06-16" description="">
      **Improvements:**

      * **Infrastructure:** Migrated to Application Load Balancer (ALB)
    </Update>

    <Update label="2025-06-13" description="">
      **Improvements:**

      * **Memory Management:** Enhanced Memory Management with Cosine Similarity Fallback
    </Update>

    <Update label="2025-06-11" description="">
      **New Features:**

      * **OMM:** Added OMM Script and UI functionality

      **Improvements:**

      * **API:** Added filters validation to semantic\_search\_v2 endpoint
    </Update>

    <Update label="2025-06-09" description="">
      **New Features:**

      * **Intercom:** Set Intercom events for ADD and SEARCH operations
      * **OpenMemory:** Added Posthog integration and feedback functionality
      * **MCP:** New JavaScript MCP Server with feedback support

      **Improvements:**

      * **Structured Data:** Enhanced structured data handling in memory management
    </Update>

    <Update label="2025-06-06" description="">
      **New Features:**

      * **OAuth:** Added Mem0 OAuth integration
      * **OMM:** Added OMM-Mem0 sync for deleted memories
    </Update>

    <Update label="2025-06-05" description="">
      **New Features:**

      * **Filters:** Implemented Wildcard Filters and refactored filter logic in V2 Views
    </Update>

    <Update label="2025-06-02" description="">
      **New Features:**

      * **OpenMemory Cloud:** Added OpenMemory Cloud support
      * **Structured Data:** Added 'structured\_attributes' field to Memory model
    </Update>

    <Update label="2025-05-30" description="">
      **New Features:**

      * **Projects:** Added version and enable\_graph to project views
      * **OpenMemory:** Added Postgres support for OpenMemory
    </Update>

    <Update label="2025-05-19" description="">
      **Bug Fixes:**

      * **Core:** Fixed unicode error in user\_id, agent\_id, run\_id and app\_id
    </Update>
  </Tab>

  <Tab title="Vercel AI SDK">
    <Update label="2025-09-25" description="v2.0.4">
      **Bug Fix:**

      * **Vercel AI SDK:** Fixed version parameter in the AI SDK to use V2 for addition.
    </Update>

    <Update label="2025-09-25" description="v2.0.3">
      **New Features:**

      * **Vercel AI SDK:** Added file support for multimodal capabilities with memory context
    </Update>

    <Update label="2025-09-03" description="v2.0.2">
      **Bug Fix:**

      * **Vercel AI SDK:** Fixed streaming response in the AI SDK.
    </Update>

    <Update label="2025-08-05" description="v2.0.1">
      **New Features:**

      * **Vercel AI SDK:** Added a new param `host` to the config.
    </Update>

    <Update label="2025-08-05" description="v2.0.0">
      **New Features:**

      * **Vercel AI SDK:** Migration to AI SDK V5.
    </Update>

    <Update label="2025-06-15" description="v1.0.6">
      **New Features:**

      * **Vercel AI SDK:** Added param `filter_memories`.
    </Update>

    <Update label="2025-05-23" description="v1.0.5">
      **New Features:**

      * **Vercel AI SDK:** Added support for Google provider.
    </Update>

    <Update label="2025-05-10" description="v1.0.4">
      **New Features:**

      * **Vercel AI SDK:** Added support for new param `output_format`.
    </Update>

    <Update label="2025-05-08" description="v1.0.3">
      **Improvements:**

      * **Vercel AI SDK:** Added support for graceful failure in cases services are down.
    </Update>

    <Update label="2025-05-01" description="v1.0.1">
      **New Features:**

      * **Vercel AI SDK:** Added support for graph memories
    </Update>
  </Tab>
</Tabs>


# Introduction to Mem0 v0.x
Source: https://docs.mem0.ai/v0x/introduction

Legacy documentation for Mem0 version 0.x

<Warning>
  **This is legacy documentation for Mem0 v0.x.** For the latest features and improvements, please refer to [v1.0.0  documentation](/).
</Warning>

## Welcome to Mem0 v0.x

Mem0 (pronounced "mem-zero") is a self-improving memory layer for Large Language Models, enabling developers to create personalized AI experiences that save costs and delight users.

## What is Mem0?

Mem0 provides an intelligent, adaptive memory system that learns and evolves with each interaction. Unlike traditional RAG approaches that rely on static embeddings, Mem0's memory system understands context, relationships, and user preferences to deliver truly personalized experiences.

### Key Features (v0.x)

* **Adaptive Learning**: Memory that improves with each user interaction
* **Cross-Platform**: Python and JavaScript SDKs
* **Flexible Integration**: Works with any LLM and vector database
* **User Personalization**: Learns individual user preferences and patterns
* **Developer Friendly**: Simple APIs with powerful customization options

## How Mem0 Works

```python  theme={null}
from mem0 import Memory

# Initialize memory
m = Memory()

# Add memories
m.add("I am working on improving my tennis skills. Suggest some online courses.", user_id="alice")

# Query memories
results = m.search("What can you tell me about alice?", user_id="alice")
# Returns: "Alice is working on improving her tennis skills and is interested in online courses"
```

## Getting Started

<CardGroup cols={2}>
  <Card title="Quick Start" icon="rocket" href="/v0x/quickstart">
    Get up and running with Mem0 in minutes
  </Card>

  <Card title="Core Concepts" icon="brain" href="/v0x/core-concepts/memory-types">
    Understand how Mem0's memory system works
  </Card>
</CardGroup>

## Use Cases

* **Personalized AI Assistants**: Create assistants that remember user preferences and context
* **Customer Support**: Build systems that recall previous interactions and issues
* **Educational Platforms**: Develop tutors that adapt to individual learning styles
* **Content Recommendation**: Generate suggestions based on historical preferences
* **Healthcare Applications**: Maintain patient interaction history and preferences

## Memory Persistence

In v0.x, memories are automatically stored and persist across sessions:

```python  theme={null}
# Session 1
m.add("I prefer vegetarian restaurants", user_id="alice")

# Session 2 (later)
results = m.search("restaurant recommendations", user_id="alice")
# Automatically considers vegetarian preference
```

## Platform vs Open Source

### Mem0 Platform (Managed)

* Hosted solution with enhanced features
* Enterprise-grade reliability and security
* Advanced analytics and monitoring
* Team collaboration features

### Mem0 Open Source

* Self-hosted deployment
* Full customization control
* Community-driven development
* Free for personal and commercial use

## Next Steps

1. **Try the Quickstart**: Follow our [quickstart guide](/v0x/quickstart) to build your first memory-enabled application
2. **Explore Examples**: Check out our practical examples and use cases
3. **Join the Community**: Connect with other developers building with Mem0

<Info>
  **Need to migrate to v1.0?** Check out our [migration guide](/migration/v0-to-v1) for step-by-step instructions.
</Info>