Mem0 Platform

https://docs.mem0.ai/platform
Admin
Mem0 Platform is a fully managed memory engine for AI agents that maintains contextual...
Tokens:77,834
Snippets:639
Trust Score:8.8
Update:1 week ago
Show doc for...
Tokens:
Raw
### Quick start mem0 CLI commands

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

Quick start commands for adding, searching, listing, getting, updating, and deleting memories via the mem0 CLI. Each command requires a user ID except get, update, and delete which use a memory ID.

```bash
# Add a memory
mem0 add "I prefer dark mode and use vim keybindings" --user-id alice

# Search memories
mem0 search "What are Alice's preferences?" --user-id alice

# List all memories for a user
mem0 list --user-id alice

# Get a specific memory
mem0 get <memory-id>

# Update a memory
mem0 update <memory-id> "I prefer light mode now"

# Delete a memory
mem0 delete <memory-id>

```

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

### Install mem0 CLI with npm

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

Install the mem0 CLI globally via npm. Requires Node.js and npm.

```bash
npm install -g @mem0/cli

```

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

### Install mem0ai Python SDK

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

Install the Python SDK using pip. Requires Python 3.10+ and a platform workspace with API key.

```bash
pip install mem0ai

```

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

### mem0 init: Interactive setup wizard

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

Interactive setup wizard that prompts for API key and default user ID. Flags allow skipping prompts: --api-key, -u/--user-id, --email, --code, --agent, --agent-caller. If existing config is detected, confirmation is required unless --force is used.

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

```

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

### Install mem0ai OSS SDK (TypeScript)

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

Install the TypeScript SDK using npm. Requires Node.js 18+.

```bash
npm install mem0ai

```

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

### Install mem0 CLI with pip

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

Install the mem0 CLI via pip. Requires Python and pip.

```bash
pip install mem0-cli

```

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

### Install Mem0 CLI

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

Installs the Mem0 CLI globally with npm, or with pip if preferred. Requires Node.js 18+ or Python 3.10+.

```bash
npm install -g @mem0/cli
# or, if you prefer Python: pip install mem0-cli

```

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

### Example output of retrieved memories with categories

Source: https://docs.mem0.ai/platform/features/custom-categories

Shows the output of the retrieval example. The exact wording and number of memories vary between runs because extraction is model driven.

```text
User introduced herself as Alice and expressed a desire for help organizing her daily schedule. ['lifestyle_management_concerns', 'seeking_structure', 'personal_information']
User feels overwhelmed trying to balance work responsibilities, regular exercise, and a social life, indicating difficulty managing time across these areas. ['lifestyle_management_concerns']
User's goals include becoming more productive at work, maintaining a consistent workout routine, and preserving enough energy for friends and hobbies. ['lifestyle_management_concerns', 'seeking_structure']
```

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

### Initialize mem0 CLI interactively

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

Run the interactive setup wizard to configure your API key and default user ID. Validates the connection and saves configuration locally.

```bash
mem0 init

```

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

### Get Webhooks Output

Source: https://docs.mem0.ai/platform/features/webhooks

Example response from retrieving webhooks, showing an array of webhook objects with fields such as webhook_id, url, name, owner, event_types, project, is_active, and timestamps.

```json
[
    {
        "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"
    }
]
```

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

### Sign up as an agent (npm)

Source: https://docs.mem0.ai/platform/agent-signup

Install the Mem0 CLI via npm, initialize as an agent with --agent-caller, add a memory, and search it back. Replace 'claude-code' with your agent name.

```bash
# 1. Install
npm install -g @mem0/cli

# 2. Sign up as an agent (replace `claude-code` with your name)
mem0 init --agent --agent-caller claude-code

# 3. Store a memory
mem0 add "Prefers TypeScript over JavaScript for new projects"

# 4. Search it back
mem0 search "what language should I use"
```

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

### Sign up as an agent (pip)

Source: https://docs.mem0.ai/platform/agent-signup

Install the Mem0 CLI via pip, initialize as an agent with --agent-caller, add a memory, and search it back. Replace 'claude-code' with your agent name.

```bash
# 1. Install
pip install mem0-cli

# 2. Sign up as an agent (replace `claude-code` with your name)
mem0 init --agent --agent-caller claude-code

# 3. Store a memory
mem0 add "Prefers TypeScript over JavaScript for new projects"

# 4. Search it back
mem0 search "what language should I use"
```

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

### Example scenarios for memory extraction

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

Shows two input examples: one definitional question that yields no memories, and one personal experience that yields a memory. Use to understand what content Mem0 classifies as memorable.

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

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

### Create Webhook Output

Source: https://docs.mem0.ai/platform/features/webhooks

Example response from creating a webhook, showing the webhook object with fields such as webhook_id, name, url, owner, event_types, project, is_active, and timestamps.

```json
{
  "webhook_id": "wh_123",
  "name": "Memory Logger",
  "url": "https://your-app.com/webhook",
  "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"
}
```

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

### Submit Memory Export Job in Python

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

Python example showing basic export with user_id filter and an advanced export with custom instructions and AND filters. Uses client.create_memory_export with schema, filters, and optional export_instructions.

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

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

### Mem0 CLI Commands

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

This section documents the command-line interface (CLI) commands for the Mem0 platform. Each command is presented with its syntax, flags, and examples as provided in the source documentation.

```APIDOC
## `mem0 init`

### Description
Interactive setup wizard to configure the Mem0 CLI with your API key and default user ID.

### Syntax
```
mem0 init [flags]
```

### Flags
| Flag | Description |
|------|-------------|
| `--api-key` | API key (skip prompt) |
| `-u, --user-id` | Default user ID (skip prompt) |
| `--email` | Login via email verification code |
| `--code` | Verification code (use with `--email` for non-interactive login) |
| `--agent` | Create an Agent Mode account, with no email needed |
| `--agent-caller` | Name the agent running the command, such as `claude-code` |
| `--force` | Overwrite existing config without confirmation |

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

```APIDOC
## `mem0 add`

### Description
Add a memory from text, a JSON messages array, a file, or stdin.

### Syntax
```
mem0 add [text] [flags]
```

### Flags
| Flag | Description |
|------|-------------|
| `-u, --user-id` | Scope to a user |
| `--agent-id` | Scope to an agent |
| `--app-id` | Scope to an app |
| `--run-id` | Scope to a single run or session |
| `--messages` | Conversation messages as JSON |
| `-f, --file` | Read messages from a JSON file |
| `-m, --metadata` | Custom metadata as JSON |
| `--categories` | Rejected on `add`. Use `--custom-categories` instead |
| `--custom-categories` | Custom categories as a JSON array of `{name: description}` objects |
| `--custom-instructions` | Custom instructions for fact extraction |
| `--structured-data-schema` | Schema for structured data extraction, as JSON |
| `--timestamp` | Unix timestamp for the memory |
| `--expires` | Expiration date, after which the memory stops being returned |
| `--immutable` | Store the memory so it can never be updated or overwritten |
| `--no-infer` | Store the text exactly as given, skipping fact extraction |
| `-o, --output` | Output format: `text`, `json`, `quiet` |

### Examples
```
mem0 add "I prefer dark mode" --user-id alice
mem0 add --file conversation.json --user-id alice
echo "Loves hiking on weekends" | mem0 add --user-id alice
```
```

```APIDOC
## `mem0 search`

### Description
Search memories using natural language.

### Syntax
```
mem0 search <query> [flags]
```

### Flags
| Flag | Description |
|------|-------------|
| `-u, --user-id` | Filter by user |
| `--agent-id` | Filter by agent |
| `--app-id` | Filter by app |
| `--run-id` | Filter by run or session |
| `-k, --top-k` | Number of results (default: 10). `--limit` does the same thing |
| `--threshold` | Minimum similarity score (default: 0.3) |
| `--rerank` | Enable reranking |
| `--keyword` | Use keyword search instead of semantic |
| `--filter` | Advanced filter as JSON: `{"AND": [...]}` or `{"OR": [...]}`, e.g. `{"AND": [{"categories": {"in": ["work"]}}]}` |
| `--fields` | Return only the named fields |
| `--show-expired` | Include expired memories |
| `--reference-date` | Reference date for relative queries (`YYYY-MM-DD` or Unix timestamp) |
| `--latest-only` | Only return the latest version of each memory |
| `-o, --output` | Output format: `text`, `json`, `table` |

### Examples
```
mem0 search "dietary restrictions" --user-id alice
mem0 search "preferred tools" --user-id alice --output json --top-k 5
mem0 search "invoices" --user-id alice --filter '{"AND": [{"categories": {"in": ["work"]}}]}'
```
```

```APIDOC
## `mem0 list`

### Description
List memories with optional filters and pagination.

### Syntax
```
mem0 list [flags]
```

### Flags
| Flag | Description |
|------|-------------|
| `-u, --user-id` | Filter by user |
| `--agent-id` | Filter by agent |
| `--app-id` | Filter by app |
| `--run-id` | Filter by run or session |
| `--page` | Page number (default: 1) |
| `--page-size` | Results per page (default: 100) |
| `--category` | Filter by category |
| `--after` | Created after date (YYYY-MM-DD) |
| `--before` | Created before date (YYYY-MM-DD) |
| `--show-expired` | Include expired memories |
| `--latest-only` | Only return the latest version of each memory |
| `-o, --output` | Output format: `text`, `json`, `table` |

### Examples
```
mem0 list --user-id alice
mem0 list --user-id alice --category preferences --output json
mem0 list --user-id alice --after 2024-01-01 --page-size 50
```
```

```APIDOC
## `mem0 get`

### Description
Retrieve a specific memory by ID.

### Syntax
```
mem0 get <memory-id> [flags]
```

### Flags
| Flag | Description |
|------|-------------|
| `-o, --output` | Output format: `text`, `json` |

### Examples
```
mem0 get 7b3c1a2e-4d5f-6789-abcd-ef0123456789
mem0 get 7b3c1a2e-4d5f-6789-abcd-ef0123456789 --output json
```
```

```APIDOC
## `mem0 update`

### Description
Update the text or metadata of an existing memory.

### Syntax
```
mem0 update <memory-id> [new-text] [flags]
```

### Flags
| Flag | Description |
|------|-------------|
| `-m, --metadata` | Replace the memory’s metadata with this JSON |
| `--expires` | Expiration date (YYYY-MM-DD) |
| `--timestamp` | Unix timestamp for the memory |
| `-o, --output` | Output format: `text`, `json`, `quiet` |

### Examples
```
mem0 update <memory-id> "Updated preference text"
mem0 update <memory-id> --metadata '{"priority": "high"}'
echo "new text" | mem0 update <memory-id>
```
```

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

### Output for export by ID

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

Example JSON response returned when retrieving an export by ID. Contains user profile fields such as full_name, current_role, and skills.

```json
{
    "full_name": "John Doe",
    "current_role": "Senior Software Engineer",
    "years_experience": 8,
    "employment_status": "full_time",
    "education_level": "masters",
    "skills": ["Python", "AWS", "Machine Learning"]
}

```

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

### Performance monitoring example in Python

Source: https://docs.mem0.ai/platform/features/advanced-retrieval

Measures search latency when reranking is enabled. Adds approximately 150ms overhead. Use to benchmark advanced retrieval in real-time applications.

```python
# Performance monitoring example
import time

start_time = time.time()
results = client.search(
    query="user preferences",
    rerank=True,         # +150ms
    filters={"user_id": "user123"},
)
latency = time.time() - start_time
print(f"Search completed in {latency:.2f}s")

```

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

### Submit Memory Export Job in JavaScript

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

JavaScript example showing basic export with user_id filter and an advanced export with custom instructions and AND filters. Uses client.createMemoryExport with schema, filters, and optional exportInstructions.

```javascript
// Basic Export request
const basicFilters = {"user_id": "alice"};
const response = await client.createMemoryExport({
    schema: json_schema,
    filters: basicFilters
});

// 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 exportFilters = {
    "AND": [
        {"user_id": "alex"},
        {"created_at": {"gte": "2024-01-01"}}
    ]
};

const responseWithInstructions = await client.createMemoryExport({
    schema: json_schema,
    filters: exportFilters,
    exportInstructions: export_instructions
});

console.log(responseWithInstructions);
```

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

### Add image_url content to memory with MemoryClient.add

Source: https://docs.mem0.ai/platform/features/multimodal-support

Add a multimodal image message to memory using the MemoryClient add method. The example includes an API key setup and a message list containing a text exchange followed by an image_url content block. Requires infer=True (the default); do not combine structured multimodal content with infer=False. The output shows a response with status PENDING and an event_id.

```Python
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
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, { userId: "alice" })
```

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

### Quick setup command for Mem0 MCP server

Source: https://docs.mem0.ai/platform/mem0-mcp

Run this command to add the Mem0 MCP server to your MCP clients. It uses the `mcp-add` helper to write the server configuration into each client's config file. Name only the clients you actually use. Restart each client afterwards to pick up the new server.

```bash
npx mcp-add \
  --name mem0-mcp \
  --type http \
  --url "https://mcp.mem0.ai/mcp" \
  --clients "claude code,cursor,windsurf,vscode,opencode"

```

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

### Testing Custom Instructions with Sample Messages

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

Creates a list of sample messages, adds them to the client, retrieves extracted memories, and prints them to review if the right information was extracted.

```Python
# 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']}")
```

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

### Output of mem0 init --agent

Source: https://docs.mem0.ai/platform/agent-signup

Shows the default user_id and the command to claim the account later.

```bash
✓ Agent Mode active. Default user_id: swift-otter-4821

  To claim this account later: mem0 init --email <your-email>
```

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

### Initialize AsyncMemoryClient (Python)

Source: https://docs.mem0.ai/platform/features/async-client

Sets the MEM0_API_KEY environment variable and creates an AsyncMemoryClient instance.

```python
import os
from mem0 import AsyncMemoryClient

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

client = AsyncMemoryClient()

```

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

### Configure Mem0 MemoryClient

Source: https://docs.mem0.ai/platform/features/entity-scoped-memory

Initialize the MemoryClient with your API key. Call client.project.get() to verify your connection; it returns project details including org_id and project_id. A 401 error indicates an invalid key.

```python
from mem0 import MemoryClient

client = MemoryClient(api_key="m0-...")

```

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

### history

Source: https://docs.mem0.ai/platform/features/async-client

Get the history of a specific memory asynchronously.

```APIDOC
## history

### Description
Gets the history of a specific memory asynchronously.

### Method
Async method

### Endpoint
N/A

### Parameters
- **memory_id** (string) - Required - The ID of the memory.

### Request Example
```python
await client.history(memory_id="memory-id-here")
```

```javascript
await client.history("memory-id-here");
```

### Response
Returns the history of the memory (not specified in source).
```

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

### users

Source: https://docs.mem0.ai/platform/features/async-client

Get all users, agents, and runs which have memories associated with them asynchronously.

```APIDOC
## users

### Description
Gets all users, agents, and runs which have memories associated with them asynchronously.

### Method
Async method

### Endpoint
N/A

### Parameters
None

### Request Example
```python
await client.users()
```

```javascript
await client.users();
```

### Response
Returns a list of users, agents, and runs (not specified in source).
```

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

### AsyncMemoryClient Initialization

Source: https://docs.mem0.ai/platform/features/async-client

Initialize the AsyncMemoryClient with your API key.

```APIDOC
## AsyncMemoryClient Initialization

### Description
Initializes the AsyncMemoryClient for asynchronous interaction with the Mem0 API.

### Method
Constructor

### Endpoint
N/A

### Parameters
- **api_key** (string) - Required - Your Mem0 API key. Set via environment variable `MEM0_API_KEY` or passed directly.

### Request Example
```python
import os
from mem0 import AsyncMemoryClient

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

client = AsyncMemoryClient()
```

```javascript
const { MemoryClient } = require('mem0ai');
const client = new MemoryClient({ apiKey: 'your-api-key'});
```

### Response
No response body. The client is ready for use.
```

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

### Set API key with Python

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

Initializes the Mem0 MemoryClient with an API key in Python. Replace 'your-api-key' with the key from the dashboard.

```python
from mem0 import MemoryClient

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

```

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

### Delete Webhook Output

Source: https://docs.mem0.ai/platform/features/webhooks

Example response from deleting a webhook, showing a success message.

```json
{
  "message": "Webhook deleted successfully"
}
```

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

### Update Webhook Output

Source: https://docs.mem0.ai/platform/features/webhooks

Example response from updating a webhook, showing a success message.

```json
{
  "message": "Webhook updated successfully"
}
```

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

### Best practice template for custom instructions

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

A proven template for structuring custom instructions, including task description, categories to extract, guidelines, and exclusions.

```text
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]

```

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

### Get all users asynchronously (JavaScript)

Source: https://docs.mem0.ai/platform/features/async-client

Retrieves all users, agents, and runs that have memories associated with them.

```javascript
await client.users();

```

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

### Get all users asynchronously (Python)

Source: https://docs.mem0.ai/platform/features/async-client

Retrieves all users, agents, and runs that have memories associated with them.

```python
await client.users()

```

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

### Set and retrieve custom instructions (Python)

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

Sets project-level custom instructions and retrieves them. Note that project.get() returns the full project object; the fields parameter is accepted but has no filtering effect server-side.

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

```

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

### Get memory history asynchronously (Python)

Source: https://docs.mem0.ai/platform/features/async-client

Retrieves the history of a specific memory by its memory_id.

```python
await client.history(memory_id="memory-id-here")

```

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

### Create AsyncMemoryClient (Python)

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

Create an async client for the Mem0 platform using the AsyncMemoryClient class. Requires the MEM0_API_KEY environment variable.

```python
import os
from mem0 import AsyncMemoryClient

memory = AsyncMemoryClient(api_key=os.environ["MEM0_API_KEY"])

```

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

### Get memory history asynchronously (JavaScript)

Source: https://docs.mem0.ai/platform/features/async-client

Retrieves the history of a specific memory by its memory ID.

```javascript
await client.history("memory-id-here");

```

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

### Get all memories asynchronously (JavaScript)

Source: https://docs.mem0.ai/platform/features/async-client

Retrieves all memories for a user. Note: getAll() now requires filters to be specified.

```javascript
await client.getAll({ filters: {"AND": [{"user_id": "alice"}]} });

```

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

### Initialize MemoryClient (JavaScript)

Source: https://docs.mem0.ai/platform/features/async-client

Creates a MemoryClient instance with an API key for JavaScript.

```javascript
const { MemoryClient } = require('mem0ai');
const client = new MemoryClient({ apiKey: 'your-api-key'});

```

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

### Get all memories asynchronously (Python)

Source: https://docs.mem0.ai/platform/features/async-client

Retrieves all memories for a user. Note: get_all() now requires filters to be specified.

```python
await client.get_all(filters={"AND": [{"user_id": "alice"}]})

```

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

### Read a profile with client.get_profile / client.getProfile

Source: https://docs.mem0.ai/platform/features/user-profiles

Reads a user profile by entity ID and checks the status field before using the profile. The Python example uses client.get_profile("alice") and the TypeScript example uses client.getProfile({ entityId: "alice" }). Both print the profile when status is "succeeded" and otherwise print "not ready:" with the status.

```python
result = client.get_profile("alice")

if result["status"] == "succeeded":
    print(result["profile"])
else:
    print("not ready:", result["status"])

```

```typescript
const result = await client.getProfile({ entityId: "alice" });

if (result.status === "succeeded") {
  console.log(result.profile);
} else {
  console.log("not ready:", result.status);
}

```

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

### Get Webhooks

Source: https://docs.mem0.ai/platform/features/webhooks

Retrieves all webhooks for a specific project. Each webhook includes an owner field that is set automatically and cannot be changed.

```APIDOC
## Get Webhooks

### Description
Retrieves all webhooks for a specific project. Each webhook includes an owner field that is set automatically and cannot be changed.

### Method
GET

### Endpoint
Not specified

### Parameters
#### Query Parameters
- **project_id** (string) - Required - The ID of the project to retrieve webhooks for.

### Request Example
```python
# Get webhooks for a specific project
webhooks = client.get_webhooks(project_id="proj_123")
print(webhooks)
```

### Response
#### Success Response (200)
- **webhook_id** (string) - The unique identifier of the webhook.
- **url** (string) - The URL to which events are sent.
- **name** (string) - The name of the webhook.
- **owner** (string) - The username of the account that created the webhook.
- **event_types** (array of strings) - The event types the webhook is subscribed to.
- **project** (string) - The project associated with the webhook.
- **is_active** (boolean) - Whether the webhook is active.
- **created_at** (string) - The creation timestamp.
- **updated_at** (string) - The last update timestamp.

#### Response Example
```json
[
    {
        "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"
    }
]
```
```

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

### mem0 init --force: Overwrite config without prompt

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

Overwrites existing configuration without confirmation. Useful in CI/CD pipelines. Requires --api-key and --user-id to skip prompts.

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

```

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

### Use a profile in a prompt

Source: https://docs.mem0.ai/platform/features/user-profiles

Fetches a user profile and builds a system prompt that adapts the assistant's communication style, expertise areas, and current goals. Handles the case where the profile is not available by falling back to a generic helpful assistant prompt.

```python
result = client.get_profile(user_id)

if result["status"] == "succeeded":
    profile = result["profile"]
    system_prompt = f"""You are helping {user_id}.
Communication style: {profile.get("communication_style", "unknown")}
Areas of expertise: {", ".join(profile.get("expertise_areas", []))}
Current goals: {", ".join(profile.get("current_goals", []))}

Match their style and do not explain what they already know."""
else:
    system_prompt = "You are a helpful assistant."

```

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

### Get Memories for a Specific Participant

Source: https://docs.mem0.ai/platform/features/group-chat

Retrieves memories from a specific participant in a group chat session by filtering on user_id.

```APIDOC
## Get Memories for a Specific Participant

### Description
Retrieve memories from a specific participant in a group chat session.

### Method
GET

### Endpoint
client.get_all

### Parameters
#### Query Parameters
- **filters** (object) - Required - Filter conditions. Must include an "AND" array with user_id and run_id.
- **page** (integer) - Required - Page number for pagination.

### Request Example
```python
filters = {
    "AND": [
        {"user_id": "charlie"},
        {"run_id": "group_chat_1"}
    ]
}

charlie_memories = client.get_all(filters=filters, page=1)
```

### Response
#### Success Response (200)
- **count** (integer) - Number of results returned.
- **next** (string/null) - URL for next page, or null.
- **previous** (string/null) - URL for previous page, or null.
- **results** (array) - List of memory objects. Each object contains:
  - **id** (string) - Unique identifier.
  - **memory** (string) - The memory content.
  - **user_id** (string) - The participant's user ID.
  - **run_id** (string) - The session run ID.
  - **created_at** (string) - Creation timestamp.
  - **updated_at** (string) - Last update timestamp.

#### Response Example
```json
{
    "count": 1,
    "next": null,
    "previous": null,
    "results": [
        {
            "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"
        }
    ]
}
```
```

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

### mem0 get: Retrieve memory by ID

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

Retrieves a specific memory by ID. Supports output formats text and json.

```bash
mem0 get 7b3c1a2e-4d5f-6789-abcd-ef0123456789
mem0 get 7b3c1a2e-4d5f-6789-abcd-ef0123456789 --output json

```

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

### Add image, text, and PDF URLs to memory with MemoryClient

Source: https://docs.mem0.ai/platform/features/multimodal-support

Shows how to add image, text, and PDF URLs to Mem0 memory using the MemoryClient. Defines a file_to_base64 helper (though it is not used in the URL examples) and calls client.add with each message type and a user_id. Use this to incorporate various media types into memory interactions.

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

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

### Get All Memories for a Session

Source: https://docs.mem0.ai/platform/features/group-chat

Retrieves all memories from a specific group chat session using a wildcard user_id to match all participants.

```APIDOC
## Get All Memories for a Session

### Description
Retrieve all memories from a specific group chat session. Use wildcard "*" for user_id to match all participants.

### Method
GET

### Endpoint
client.get_all

### Parameters
#### Query Parameters
- **filters** (object) - Required - Filter conditions. Must include an "AND" array with user_id and run_id.
- **page** (integer) - Required - Page number for pagination.

### Request Example
```python
filters = {
    "AND": [
        {"user_id": "*"},
        {"run_id": "group_chat_1"}
    ]
}

all_memories = client.get_all(filters=filters, page=1)
```

### Response
#### Success Response (200)
- **count** (integer) - Number of results returned.
- **next** (string/null) - URL for next page, or null.
- **previous** (string/null) - URL for previous page, or null.
- **results** (array) - List of memory objects. Each object contains:
  - **id** (string) - Unique identifier.
  - **memory** (string) - The memory content.
  - **user_id** (string) - The participant's user ID.
  - **run_id** (string) - The session run ID.
  - **created_at** (string) - Creation timestamp.
  - **updated_at** (string) - Last update timestamp.

#### Response Example
```json
{
    "count": 3,
    "next": null,
    "previous": null,
    "results": [
        {
            "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"
        }
    ]
}
```
```

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

### Set MEM0_API_KEY environment variable

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

Set the Mem0 API key via environment variable as an alternative to interactive setup.

```bash
export MEM0_API_KEY="m0-xxx"

```

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

### Set API key with JavaScript

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

Initializes the Mem0 MemoryClient in JavaScript using the API key.

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

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

### Memory Filter Structure

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

Describes the JSON structure for memory filters, including logical operators and examples of valid and invalid filters.

```APIDOC
## Memory Filter Structure

### Description
Filters use a nested JSON structure with logical operators at the root. A single bare condition needs no wrapper. Sibling top-level keys are implicitly ANDed. Explicit AND, OR, or NOT wrappers are used for OR/NOT semantics or nesting. Unknown top-level keys are rejected with a 400 error.

### Structure
```json
{
    "AND": [  // or "OR", "NOT"
        { "field": "value" },
        { "field": { "operator": "value" } }
    ]
}
```

### Examples

#### Single condition (no wrapper)
```json
{"user_id": "user_123"}
```

#### Sibling keys (implicit AND)
```json
{
    "user_id": "user_123",
    "categories": {"in": ["finance"]}
}
```

#### Explicit AND form (equivalent to above)
```json
{
    "AND": [
        {"user_id": "user_123"},
        {"categories": {"in": ["finance"]}}
    ]
}
```

#### Rejected: unknown top-level key
```json
{"user_id": "user_123", "bogus_key": "z"}
```

### Allowed Top-Level Keys
- `AND`
- `OR`
- `NOT`
- `user_id`
- `agent_id`
- `app_id`
- `run_id`
- `created_at`
- `updated_at`
- `timestamp`
- `expiration_date`
- `text`
- `categories`
- `metadata`
- `keywords_search`
- `memory_ids`
- `keywords`

### Error Handling
- **400 Bad Request**: Returned when a top-level key is not in the allowed list.

### Platform Differences
- The hosted Platform API validates each top-level key against a fixed allow-list and returns a 400 for anything else.
- The Platform API has no `nin` operator.
- Both the hosted Platform API and the self-hosted OSS SDK implicitly AND sibling top-level keys.
```

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

### Set and retrieve custom instructions (JavaScript)

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

Sets project-level custom instructions and retrieves them using the JavaScript SDK. The fields parameter is accepted but has no filtering effect server-side.

```javascript
// Set instructions for your project
await client.project.update({ customInstructions: "Your guidelines here..." });

// Retrieve current instructions
const response = await client.project.get({ fields: ["customInstructions"] });
console.log(response.customInstructions);

```
Tokens:
Raw