Mem0

https://docs.mem0.ai/
Admin
Mem0 is a universal, self-improving memory layer for LLM applications, providing managed,...
Tokens:313,064
Snippets:2,992
Trust Score:8.8
Update:1 month ago
Show doc for...
Tokens:
Raw
### Start the stack with browser-first setup

Source: https://docs.mem0.ai/open-source/setup

Initializes containers and database migrations for the browser-based setup wizard.

```bash
cd server
make up
```

--------------------------------

### GET /auth/setup-status

Source: https://docs.mem0.ai/open-source/features/rest-api

Checks if the system needs setup. No authentication required.

```APIDOC
## GET /auth/setup-status

### Description
Returns {needsSetup: bool}. Open, no auth required.

### Method
GET

### Endpoint
/auth/setup-status

### Response
#### Success Response (200)
- **needsSetup** (bool) - Indicates if the system requires setup
```

--------------------------------

### Install and Start Flowise

Source: https://docs.mem0.ai/integrations/flowise

Use these commands to install the Flowise package globally and launch the application server.

```bash
npm install -g flowise
npx flowise start
```

--------------------------------

### Install Cassandra on macOS

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

Commands to install and start Cassandra using Homebrew.

```bash
# Using Homebrew
brew install cassandra

# Start Cassandra
brew services start cassandra

# Connect to CQL shell
cqlsh
```

--------------------------------

### Install Qdrant vector store dependencies

Source: https://docs.mem0.ai/open-source/configuration

Install the Qdrant client for Python and start the Qdrant server using Docker.

```bash
pip install qdrant-client   # Python only
docker run -p 6333:6333 qdrant/qdrant
```

--------------------------------

### Install Weaviate Client

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

Install the necessary client library for your environment.

```bash
pip install weaviate-client
```

```bash
npm install weaviate-client
```

--------------------------------

### Launch Evaluation UI

Source: https://docs.mem0.ai/core-concepts/memory-evaluation

Commands to install dependencies and start the local development server for the evaluation dashboard.

```bash
npm install
npm run dev -- -p 3001
# Open http://localhost:3001
```

--------------------------------

### Install Integration SDKs

Source: https://docs.mem0.ai/templates/integration_guide_template

Package installation commands for the integration.

```bash
pip install mem0ai [partner-package]
```

```bash
npm install mem0ai [partner-package]
```

--------------------------------

### Run Server Directly

Source: https://docs.mem0.ai/open-source/features/rest-api

Install dependencies and start the FastAPI server with auto-reload enabled.

```bash
pip install -r requirements.txt
uvicorn main:app --reload
```

--------------------------------

### Install Mem0 SDK

Source: https://docs.mem0.ai/platform/advanced-memory-operations

Install the required SDK package for your environment.

```bash
pip install mem0ai
```

```bash
npm install mem0ai
```

--------------------------------

### Install dependencies

Source: https://docs.mem0.ai/cookbooks/integrations/tavily-search

Install the required packages for Mem0, LangChain, and Tavily integration.

```bash
pip install langchain mem0ai langchain-tavily langchain-openai
```

--------------------------------

### Install Dependencies

Source: https://docs.mem0.ai/cookbooks/companions/ai-tutor

Install the required packages for Mem0 and OpenAI integration.

```bash
pip install openai mem0ai
```

--------------------------------

### Install Vertex AI SDK

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

Install the required SDK for the Vertex AI provider.

```bash
pip install vertexai
```

```bash
npm install @google-cloud/aiplatform
```

--------------------------------

### Create Webhook SDK Examples

Source: https://docs.mem0.ai/api-reference/webhook/create-webhook

Examples for creating a webhook using the Python and JavaScript SDKs.

```python
# To use the Python SDK, install the package:
# pip install mem0ai

from mem0 import MemoryClient
client = MemoryClient(api_key="your_api_key")

# Create a webhook
webhook = client.create_webhook(
    url="https://your-webhook-url.com",
    name="My Webhook",
    project_id="your_project_id",
    event_types=["memory_add", "memory_categorize"]
)
print(webhook)
```

```javascript
// To use the JavaScript SDK, install the package:
// npm i mem0ai

import MemoryClient from 'mem0ai';
const client = new MemoryClient({ apiKey: "your-api-key" });
```

--------------------------------

### Install Hermes Agent

Source: https://docs.mem0.ai/integrations/hermes

Execute the installation script to set up the Hermes Agent environment.

```bash
curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash
source ~/.bashrc
```

--------------------------------

### Special field filter example

Source: https://docs.mem0.ai/platform/features/v2-memory-filters

Example of filtering by a list of memory identifiers.

```json
{"memory_ids": ["id1", "id2"]}
```

--------------------------------

### Install Frontend Dependencies

Source: https://docs.mem0.ai/integrations/chatdev

Install necessary Node.js packages for the ChatDev web console.

```bash
cd frontend && npm install && cd ..
```

--------------------------------

### Add Memory Implementation Examples

Source: https://docs.mem0.ai/templates/parameters_reference_template

Practical examples for adding a memory and retrieving the resulting memory ID.

```python
response = client.memories.add(
    user_id="alex",
    memory="I am training for a marathon.",
)
print(response["memory_id"])
```

```typescript
const { memoryId } = await mem0.memories.add({
  userId: "alex",
  memory: "I am training for a marathon.",
});
console.log(memoryId);
```

--------------------------------

### Install Cassandra on Ubuntu/Debian

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

Commands to add the repository, install, and verify Cassandra on Debian-based systems.

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

--------------------------------

### Install Baidu VectorDB SDKs

Source: https://docs.mem0.ai/components/vectordbs/dbs/baidu

Install the necessary client libraries for Python or TypeScript environments.

```bash
pip install pymochow
```

```bash
npm install @mochow/mochow-sdk-node
```

--------------------------------

### Install Required Packages

Source: https://docs.mem0.ai/integrations/aws-bedrock

Install the necessary Python packages to enable Mem0, Boto3, and OpenSearch connectivity.

```bash
pip install mem0ai boto3 opensearch-py
```

--------------------------------

### Initialize Fresh Install

Source: https://docs.mem0.ai/migration/server-pgvector-upgrade

Commands to set up a new Mem0 server instance.

```bash
cd server
cp .env.example .env
# Edit .env: set POSTGRES_PASSWORD (required) and OPENAI_API_KEY at minimum
make up
```

--------------------------------

### Content field filter examples

Source: https://docs.mem0.ai/platform/features/v2-memory-filters

Examples of filtering by content attributes like categories, metadata, and keywords.

```json
{"categories": {"in": ["finance"]}}
```

```json
{"metadata": {"key": "value"}}
```

```json
{"keywords": {"icontains": "invoice"}}
```

--------------------------------

### Setup Environment

Source: https://docs.mem0.ai/templates/cookbook_template

Initial configuration and imports for the cookbook workflow.

```python
default_language = "python"  # replace with real imports
```

```typescript
// Equivalent TypeScript setup goes here
```

--------------------------------

### Entity field filter examples

Source: https://docs.mem0.ai/platform/features/v2-memory-filters

Examples of filtering by entity identifiers using equality, inclusion, and wildcard operators.

```json
{"user_id": "user_123"}
```

```json
{"agent_id": "*"}
```

```json
{"app_id": {"in": ["app1", "app2"]}}
```

```json
{"run_id": "*"}
```

--------------------------------

### Time field filter examples

Source: https://docs.mem0.ai/platform/features/v2-memory-filters

Examples of filtering by temporal fields using comparison operators. Note that explicit 'eq' is rejected for these fields.

```json
{"created_at": {"gte": "2024-01-01"}}
```

```json
{"updated_at": {"lt": "2024-12-31"}}
```

```json
{"timestamp": {"gt": "2024-01-01"}}
```

```json
{"expiration_date": {"lte": "2026-12-31"}}
```

--------------------------------

### Interactive OSS Setup

Source: https://docs.mem0.ai/integrations/hermes

Run the interactive wizard to configure self-hosted Mem0.

```bash
hermes memory setup
# Select "mem0", then "Open Source (self-hosted)"
# Follow the prompts for LLM, embedder, and vector store
```

--------------------------------

### Start Docker Compose Stack

Source: https://docs.mem0.ai/open-source/features/rest-api

Start the stack in detached mode to complete setup via the browser wizard.

```bash
cd server
docker compose up -d
```

--------------------------------

### Start the Agent

Source: https://docs.mem0.ai/cookbooks/frameworks/eliza-os-character

Launch the Eliza OS agent.

```bash
pnpm start
```

--------------------------------

### SDK Examples for Retrieving Users

Source: https://docs.mem0.ai/api-reference/entities/get-users

Examples showing how to initialize the client and retrieve users using the Python and JavaScript SDKs.

```python
# To use the Python SDK, install the package:
# pip install mem0ai

from mem0 import MemoryClient
client = MemoryClient(api_key="your_api_key")
users = client.users()
print(users)
```

```javascript
// To use the JavaScript SDK, install the package:
// npm i mem0ai

import MemoryClient from 'mem0ai';
const client = new MemoryClient({ apiKey: "your-api-key" });
```

--------------------------------

### Initialize Dependencies and Environment

Source: https://docs.mem0.ai/cookbooks/companions/voice-companion-openai

Import necessary modules, configure API keys, and initialize the Mem0 client.

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

--------------------------------

### Filtering by date range

Source: https://docs.mem0.ai/platform/features/v2-memory-filters

Use gte and lt operators to define inclusive start and exclusive end boundaries for date filtering.

```python
{"AND": [
    {"created_at": {"gte": "2024-01-01"}},
    {"created_at": {"lt": "2024-02-01"}}
]}
```

--------------------------------

### Initialize Mem0 and OpenAI clients

Source: https://docs.mem0.ai/cookbooks/integrations/openai-tool-calls

Set up the client instances for both services.

```javascript
const USER_ID = "sample-user";

const openAIClient = new OpenAI();
const mem0Client = new MemoryClient({ apiKey: process.env.MEM0_API_KEY });
```

--------------------------------

### Get Organization API Examples

Source: https://docs.mem0.ai/api-reference/organization/get-org

Code examples for retrieving organization details using various programming languages. Replace {org_id} with the actual organization ID and <api-key> with your valid API token.

```Python
import requests

url = "https://api.mem0.ai/api/v1/orgs/organizations/{org_id}/"

headers = {"Authorization": "Token <api-key>"}

response = requests.request("GET", url, headers=headers)

print(response.text)
```

```JavaScript
const options = {method: 'GET', headers: {Authorization: 'Token
<api-key>'}};


fetch('https://api.mem0.ai/api/v1/orgs/organizations/{org_id}/',
options)
  .then(response => response.json())
  .then(response => console.log(response))
  .catch(err => console.error(err));
```

```cURL
curl --request GET \
  --url https://api.mem0.ai/api/v1/orgs/organizations/{org_id}/ \
  --header 'Authorization: Token <api-key>'
```

```Go
package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "https://api.mem0.ai/api/v1/orgs/organizations/{org_id}/"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Token <api-key>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```PHP
<?php

$curl = curl_init();
```

--------------------------------

### Interactive Platform Setup

Source: https://docs.mem0.ai/integrations/hermes

Use the interactive wizard to configure Mem0 Platform mode.

```bash
hermes memory setup
```

--------------------------------

### Define Custom Instructions

Source: https://docs.mem0.ai/open-source/features/custom-instructions

Define a string containing extraction rules and few-shot examples to guide the model's output format.

```python
custom_instructions = """
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
const customInstructions = `
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.
`;
```

--------------------------------

### Start API and Verify

Source: https://docs.mem0.ai/migration/server-pgvector-upgrade

Launch the Mem0 API and confirm the service is operational.

```bash
docker compose up -d mem0
```

```bash
# Check service health
cd server && make health

# Confirm memories are accessible
curl -s http://localhost:8888/memories?user_id=<your-user-id> \
  -H "X-API-Key: <your-api-key>"
```

--------------------------------

### Get Events in Java

Source: https://docs.mem0.ai/api-reference/events/get-events

A concise Java example using Unirest to retrieve events. Replace '<api-key>' with your Mem0 API key for authentication.

```Java
HttpResponse<String> response = Unirest.get("https://api.mem0.ai/v1/events/")
  .header("Authorization", "Token <api-key>")
  .asString();
```

--------------------------------

### Install Dependencies

Source: https://docs.mem0.ai/cookbooks/frameworks/gemini-3-with-mem0-mcp

Install the required Python packages for the agent.

```bash
pip install pydantic-ai nest-asyncio python-dotenv google-genai
```

--------------------------------

### OSS Setup with Flags

Source: https://docs.mem0.ai/integrations/hermes

Configure self-hosted Mem0 using command-line flags.

```bash
hermes memory setup mem0 --mode oss \
  --oss-llm openai --oss-llm-key sk-... \
  --oss-vector qdrant
```

--------------------------------

### Start the development server

Source: https://docs.mem0.ai/cookbooks/companions/quickstart-demo

Launch the application in development mode.

```bash
pnpm run dev
```

--------------------------------

### Install vLLM

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

Install the vLLM package via pip.

```bash
pip install vllm
```

--------------------------------

### Initialize Mem0 with LLM Configuration

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

Use these examples to set up the Memory client with a specific LLM provider and configuration object.

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

--------------------------------

### Install project dependencies

Source: https://docs.mem0.ai/cookbooks/companions/quickstart-demo

Install required packages using pnpm.

```bash
pnpm install
```

--------------------------------

### Run Mintlify Development Server

Source: https://docs.mem0.ai/contributing/documentation

Start the local documentation development server. Navigate to the 'docs/' directory before running this command.

```bash
mintlify dev
```

--------------------------------

### Initialize Clients

Source: https://docs.mem0.ai/integrations/elevenlabs

Set up the ElevenLabs client and the Mem0 memory client.

```python
# Initialize ElevenLabs client
client = ElevenLabs(api_key=API_KEY)

# Initialize memory client and tools
client_tools = ClientTools()
mem0_client = AsyncMemoryClient()
```

--------------------------------

### Install Required Libraries

Source: https://docs.mem0.ai/integrations/crewai

Install the necessary packages for CrewAI and Mem0 integration.

```bash
pip install crewai crewai-tools mem0ai
```

--------------------------------

### Bootstrap the stack via command line

Source: https://docs.mem0.ai/open-source/setup

Automates container startup, admin account creation, and API key generation without browser interaction.

```bash
cd server
make bootstrap
```

```bash
make bootstrap EMAIL=admin@company.com PASSWORD='strong-password' NAME='Admin'
```

--------------------------------

### Install mem0-strands package

Source: https://docs.mem0.ai/integrations/strands

Install the required integration package via pip.

```bash
pip install mem0-strands
```

--------------------------------

### Install Mem0 Plugin

Source: https://docs.mem0.ai/integrations/opencode

Install the Mem0 plugin via the OpenCode CLI.

```bash
opencode plugin @mem0/opencode-plugin
```

--------------------------------

### Configuring the Agent Entrypoint

Source: https://docs.mem0.ai/integrations/livekit

Sets up the LiveKit session with STT, LLM, and TTS components, and starts the worker application.

```python
async def entrypoint(ctx: JobContext):
    """Main entrypoint for the agent."""
    await ctx.connect()

    session = AgentSession(
        stt=deepgram.STT(),
        llm=openai.LLM(model="gpt-5-mini"),
        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))
```

--------------------------------

### Install Dependencies

Source: https://docs.mem0.ai/integrations/elevenlabs

Install the required Python packages for ElevenLabs and Mem0 integration.

```bash
pip install elevenlabs mem0ai python-dotenv
```

--------------------------------

### Initialize Mem0 with Interactive Wizard

Source: https://docs.mem0.ai/integrations/openclaw

Run the guided 4-step wizard to configure Mem0 providers and user ID.

```bash
openclaw mem0 init --mode open-source
```

--------------------------------

### Full Usage Example in Python

Source: https://docs.mem0.ai/components/rerankers/models/cohere

Complete workflow for initializing memory, adding data, and searching with reranking.

```python
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-5-mini"}},
    "rerank": {
        "provider": "cohere",
        "config": {
            "model": "rerank-v3.5",
            "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?", filters={"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()
```

--------------------------------

### Install Required Packages

Source: https://docs.mem0.ai/integrations/agno

Install the necessary dependencies for Agno and Mem0 integration.

```bash
pip install agno mem0ai python-dotenv
```

--------------------------------

### Install Required Packages

Source: https://docs.mem0.ai/integrations/agentops

Install the necessary dependencies for Mem0 and AgentOps integration.

```bash
pip install mem0ai agentops python-dotenv
```

--------------------------------

### Install OpenSearch Client Libraries

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

Install the necessary client library for your specific SDK to enable OpenSearch support.

```bash
pip install opensearch-py
```

```bash
npm install @opensearch-project/opensearch
```

--------------------------------

### Install Mem0 Integration

Source: https://docs.mem0.ai/cookbooks/integrations/mastra-agent

Install the required npm package for the Mem0 integration.

```bash
npm install @mastra/mem0
```

--------------------------------

### Initialize Mem0 configuration

Source: https://docs.mem0.ai/platform/cli

Use the init command to set up your environment. The force flag is recommended for non-interactive CI/CD environments.

```bash
mem0 init
mem0 init --api-key m0-xxx --user-id alice
mem0 init --email alice@company.com
```

```bash
mem0 init --api-key m0-xxx --user-id alice --force
```

--------------------------------

### Setup Mem0 Evaluation Environment

Source: https://docs.mem0.ai/core-concepts/memory-evaluation

Initialize the benchmark repository and configure environment variables for either cloud or local Docker-based execution.

```bash
git clone https://github.com/mem0ai/memory-benchmarks.git
cd memory-benchmarks
pip install -r requirements.txt

# Set your API keys
export MEM0_API_KEY=m0-your-key
export OPENAI_API_KEY=sk-your-key
```

```bash
git clone https://github.com/mem0ai/memory-benchmarks.git
cd memory-benchmarks
pip install -r requirements.txt

# Copy and configure environment
cp .env.example .env
# Edit .env to add OPENAI_API_KEY

# Start local Mem0 server + Qdrant
docker compose up -d
# Mem0 server: http://localhost:8888
# Qdrant:      http://localhost:6333
```

--------------------------------

### Install Dependencies

Source: https://docs.mem0.ai/cookbooks/frameworks/llamaindex-react

Install the required LlamaIndex core and Mem0 memory packages.

```bash
pip install llama-index-core llama-index-memory-mem0
```

--------------------------------

### Install Redis and redisvl

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

Install the necessary Python packages for Redis and redisvl.

```bash
pip install redis redisvl
```

--------------------------------

### Start Local Infrastructure for Mem0

Source: https://docs.mem0.ai/cookbooks/operations/content-writing

Commands to launch the Qdrant vector store and pull required Ollama models.

```bash
docker run -d -p 6333:6333 qdrant/qdrant
ollama pull llama3.1:latest
ollama pull nomic-embed-text:latest
```
Tokens:
Raw