diff --git a/docs/docs.json b/docs/docs.json index 3d1865687..3a3cae859 100644 --- a/docs/docs.json +++ b/docs/docs.json @@ -24,7 +24,9 @@ { "group": "Start Here", "icon": "home", - "pages": ["introduction"] + "pages": [ + "introduction" + ] } ] }, @@ -69,11 +71,12 @@ }, { "group": "Advanced Features", - "icon": "sparkles", + "icon": "bolt", "pages": [ "platform/features/graph-memory", "platform/features/graph-threshold", "platform/features/advanced-retrieval", + "platform/advanced-memory-operations", "platform/features/criteria-retrieval", "platform/features/contextual-add", "platform/features/custom-instructions" @@ -103,7 +106,9 @@ { "group": "Support & Troubleshooting", "icon": "life-buoy", - "pages": ["platform/faqs", "platform/advanced-memory-operations"] + "pages": [ + "platform/faqs" + ] }, { "group": "Migration Guide", @@ -274,7 +279,10 @@ { "group": "Community & Support", "icon": "users", - "pages": ["contributing/development", "contributing/documentation"] + "pages": [ + "contributing/development", + "contributing/documentation" + ] } ] }, @@ -298,7 +306,9 @@ { "group": "Overview", "icon": "lightbulb", - "pages": ["examples"] + "pages": [ + "examples" + ] }, { "group": "Getting Started Examples", @@ -355,7 +365,10 @@ { "group": "Cloud & Infrastructure", "icon": "cloud", - "pages": ["examples/aws_example", "examples/aws_neptune_analytics_hybrid_store"] + "pages": [ + "examples/aws_example", + "examples/aws_neptune_analytics_hybrid_store" + ] } ] }, @@ -365,7 +378,9 @@ { "group": "Overview", "icon": "plug", - "pages": ["integrations"] + "pages": [ + "integrations" + ] }, { "group": "Agent Frameworks", @@ -395,7 +410,9 @@ { "group": "Cloud & Infrastructure", "icon": "cloud", - "pages": ["integrations/aws-bedrock"] + "pages": [ + "integrations/aws-bedrock" + ] }, { "group": "Developer Tools", @@ -417,7 +434,10 @@ { "group": "Getting Started", "icon": "rocket", - "pages": ["api-reference", "api-reference/organizations-projects"] + "pages": [ + "api-reference", + "api-reference/organizations-projects" + ] }, { "group": "Core Memory Operations", @@ -495,12 +515,16 @@ { "group": "Changelog", "icon": "rocket", - "pages": ["changelog"] + "pages": [ + "changelog" + ] }, { "group": "Legacy Docs", "icon": "archive", - "pages": ["v0x/introduction"] + "pages": [ + "v0x/introduction" + ] } ], "icon": "clock" @@ -522,7 +546,11 @@ { "group": "Getting Started", "icon": "rocket", - "pages": ["v0x/introduction", "v0x/quickstart", "v0x/faqs"] + "pages": [ + "v0x/introduction", + "v0x/quickstart", + "v0x/faqs" + ] }, { "group": "Core Concepts", diff --git a/docs/open-source/configuration.mdx b/docs/open-source/configuration.mdx index 8fbaab2fd..d5e4271d2 100644 --- a/docs/open-source/configuration.mdx +++ b/docs/open-source/configuration.mdx @@ -1,336 +1,173 @@ --- -title: "Configuration" -description: "Configure Mem0 with custom LLMs, vector stores, embedders, and rerankers for production deployments" +title: "Configure the OSS Stack" +description: "Wire up Mem0 OSS with your preferred LLM, vector store, embedder, and reranker." icon: "sliders" -iconType: "solid" --- -Mem0 is highly configurable, allowing you to customize every component of your memory system. Choose from **51+ supported providers** across LLMs, vector databases, embedders, and rerankers. +# Configure Mem0 OSS Components -## Quick Start + + **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 + -The simplest setup uses OpenAI defaults: + + Start from the Python quickstart if you still need the base CLI and repository. + -```python -import os -from mem0 import Memory +## Install dependencies -os.environ["OPENAI_API_KEY"] = "your-api-key" -m = Memory() + + + + +```bash +pip install mem0ai ``` + + +```bash +pip install qdrant-client openai +``` + + + + + + +```bash +git clone https://github.com/mem0ai/mem0.git +cd mem0/examples/docker-compose +``` + + +```bash +pip install -r requirements.txt +``` + + + + -For production or custom setups, configure specific components: +## Define your configuration + + + + ```python from mem0 import Memory config = { "vector_store": { "provider": "qdrant", - "config": { - "host": "localhost", - "port": 6333 - } + "config": {"host": "localhost", "port": 6333}, }, "llm": { "provider": "openai", - "config": { - "model": "gpt-4.1-nano-2025-04-14", - "temperature": 0.1 - } - } -} - -m = Memory.from_config(config) -``` - -## Configuration Components - -Mem0 has four configurable components. Click any to see all supported providers and detailed configuration options. - - - -**17 providers** including OpenAI, Anthropic, Ollama, Groq, and more - -Configure the language model for memory extraction and processing - - - - -**25+ databases** including Qdrant, Chroma, Pinecone, Weaviate, and more - -Choose where to store and retrieve memory embeddings - - - - -**9 providers** including OpenAI, HuggingFace, Ollama, and more - -Select the model to convert memories into vector embeddings - - - - -**4 models** including Cohere, Zero Entropy, and LLM-based - -Improve search relevance by re-scoring retrieved memories - - - - -## Configuration Recipes - -### Production Setup with Qdrant - -For production deployments, use a dedicated vector store: - - - -```bash -docker pull qdrant/qdrant - -docker run -p 6333:6333 -p 6334:6334 \ - -v $(pwd)/qdrant_storage:/qdrant/storage:z \ - qdrant/qdrant - -```` - - - -```python -import os -from mem0 import Memory - -os.environ["OPENAI_API_KEY"] = "your-api-key" - -config = { - "vector_store": { - "provider": "qdrant", - "config": { - "host": "localhost", - "port": 6333, - } - } -} - -m = Memory.from_config(config) -```` - - - - -### Fully Local Setup - -Run Mem0 completely offline with Ollama (no external APIs): - - - Step-by-step guide to run Mem0 with local LLM and embeddings - - -### Multi-Cloud Setup - -Mix providers from different clouds: - -```python -config = { - "llm": { - "provider": "azure_openai", - "config": { - "api_key": "azure-key", - "deployment_name": "gpt-4.1-nano-2025-04-14" - } - }, - "vector_store": { - "provider": "pinecone", - "config": { - "api_key": "pinecone-key", - "index_name": "mem0" - } + "config": {"model": "gpt-4.1-mini", "temperature": 0.1}, }, "embedder": { "provider": "vertexai", - "config": { - "model": "textembedding-gecko@003" - } - } -} -``` - -### Graph Memory Setup - -Enable relationship tracking with Neo4j: - -```python -config = { - "graph_store": { - "provider": "neo4j", - "config": { - "url": "neo4j+s://your-instance.databases.neo4j.io", - "username": "neo4j", - "password": "your-password" - } - } -} - -m = Memory.from_config(config) -``` - - - Learn how to use graph memory for relationship-based retrieval - - -## Advanced Configuration - -### Custom Prompts - -Override default prompts for memory processing: - -```python -config = { - "custom_fact_extraction_prompt": """ - Extract key facts from the conversation. - Focus on: preferences, decisions, and context. - Output as a single sentence. - """, - "custom_update_memory_prompt": """ - Update the existing memory with new information. - Preserve important context from the old memory. - """ -} -``` - - - -Customize how memories are extracted from conversations - - - -Control how existing memories are modified - - - -### Reranking for Better Search - -Add reranking to improve search relevance: - -```python -config = { - "rerank": { + "config": {"model": "textembedding-gecko@003"}, + }, + "reranker": { "provider": "cohere", - "config": { - "model": "rerank-english-v3.0", - "top_k": 5 - } - } + "config": {"model": "rerank-english-v3.0"}, + }, } + +memory = Memory.from_config(config) ``` + + +```bash +export QDRANT_API_KEY="..." +export OPENAI_API_KEY="..." +export COHERE_API_KEY="..." +``` + + + + + + +```yaml +vector_store: + provider: qdrant + config: + host: localhost + port: 6333 - - Learn how reranking improves memory search accuracy - +llm: + provider: azure_openai + config: + api_key: ${AZURE_OPENAI_KEY} + deployment_name: gpt-4.1-mini -### History Database - -Configure where operation history is stored: +embedder: + provider: ollama + config: + model: nomic-embed-text +reranker: + provider: zero_entropy + config: + api_key: ${ZERO_ENTROPY_KEY} +``` + + ```python -config = { - "history_db_path": "/custom/path/to/history.db" -} -``` +from mem0 import Memory -## All Configuration Options +memory = Memory.from_config_file("config.yaml") +``` + + + + + + + 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. + + +## Tune component settings - -| Parameter | Description | Provider | -|-----------------------|-----------------------------------------------|-------------------| -| `provider` | LLM provider (e.g., "openai", "anthropic") | All | -| `model` | Model to use | All | -| `temperature` | Temperature of the model (0.0-2.0) | All | -| `api_key` | API key to use | Most | -| `max_tokens` | Maximum tokens to generate | All | -| `top_p` | Nucleus sampling threshold | All | -| `top_k` | Top-k sampling parameter | Some | -| `ollama_base_url` | Base URL for Ollama API | Ollama | -| `openai_base_url` | Base URL for OpenAI API | OpenAI | -| `azure_kwargs` | Azure-specific initialization args | Azure OpenAI | - -**See all 17 LLM providers:** [LLMs Overview](/components/llms/overview) - - - - -Common parameters (provider-specific options vary): - -| Parameter | Description | Example | -| ----------------- | -------------------------- | ----------- | -| `provider` | Vector store provider | "qdrant" | -| `host` | Host address | "localhost" | -| `port` | Port number | 6333 | -| `collection_name` | Collection/index name | "memories" | -| `api_key` | API key (for cloud stores) | "your-key" | - -**See all 25+ vector stores:** [Vector Databases Overview](/components/vectordbs/overview) - - - - -| Parameter | Description | Default | -|-------------|---------------------------------|------------------------------| -| `provider` | Embedding provider | "openai" | -| `model` | Embedding model to use | "text-embedding-3-small" | -| `api_key` | API key for embedding service | None | - -**See all 9 embedder providers:** [Embedders Overview](/components/embedders/overview) - - - - -| Parameter | Description | Example | -|-------------|---------------------------------|------------------------------| -| `provider` | Reranker provider | "cohere" | -| `model` | Reranker model to use | "rerank-english-v3.0" | -| `top_k` | Number of results to return | 5 | -| `api_key` | API key for reranker service | "your-key" | - -**See all reranker options:** [Rerankers Overview](/components/rerankers/overview) - - - - -| Parameter | Description | Example | -|-------------|---------------------------------|------------------------------| -| `provider` | Graph store provider | "neo4j" | -| `url` | Connection URL | "neo4j+s://..." | -| `username` | Authentication username | "neo4j" | -| `password` | Authentication password | "your-password" | - -**Learn more:** [Graph Memory Overview](/open-source/features/graph-memory) - - - - -| Parameter | Description | Default | -|------------------|--------------------------------------|----------------------------| -| `history_db_path` | Path to the history database | "{mem0_dir}/history.db" | -| `custom_fact_extraction_prompt` | Custom prompt for memory extraction | None | -| `custom_update_memory_prompt` | Custom prompt for memory updates | None | - + + Name collections explicitly in production (`collection_name`) to isolate tenants and enable per-tenant retention policies. + + + Keep extraction temperatures ≤0.2 so advanced memories stay deterministic. Raise it only when you see missing facts. + + + Limit `top_k` to 10–20 results; sending more adds latency without meaningful gains. + -## Next Steps + + 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. + - - -Get started with the Python SDK - +## Quick recovery - - Explore OSS-specific capabilities - +- 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. - -See configuration examples in action - + + + diff --git a/docs/platform/advanced-memory-operations.mdx b/docs/platform/advanced-memory-operations.mdx index 3f457f529..c8c3a14b6 100644 --- a/docs/platform/advanced-memory-operations.mdx +++ b/docs/platform/advanced-memory-operations.mdx @@ -1,1388 +1,216 @@ --- title: Advanced Memory Operations -description: 'Comprehensive guide to advanced memory operations and features' -icon: "gear" -iconType: "solid" +description: "Run richer add/search/update/delete flows on the managed platform with metadata, rerankers, and per-request controls." --- -This guide covers advanced memory operations including complex filtering, batch operations, and detailed API usage. If you're just getting started, check out the [Quickstart](/platform/quickstart) first. +# Make Platform Memory Operations Smarter -## Advanced Memory Creation + + **Prerequisites** + - Platform workspace with API key + - Python 3.10+ and Node.js 18+ + - Async memories enabled in your dashboard (Settings → Memory Options) + -### Async Client (Python) + + Need a refresher on the core concepts first? Review the Add Memory overview, then come back for the advanced flow. + -For asynchronous operations in Python, use the `AsyncMemoryClient`: +## Install and authenticate -```python Python + + + + +```bash +pip install "mem0ai[async]" +``` + + +```bash +export MEM0_API_KEY="sk-platform-..." +``` + + +```python import os from mem0 import AsyncMemoryClient -os.environ["MEM0_API_KEY"] = "your-api-key" -client = AsyncMemoryClient() - -async def main(): - messages = [ - {"role": "user", "content": "I'm travelling to SF"} - ] - response = await client.add(messages, user_id="john") - print(response) - -await main() +memory = AsyncMemoryClient(api_key=os.environ["MEM0_API_KEY"]) ``` + + + + + + +```bash +npm install mem0ai +``` + + +```bash +export MEM0_API_KEY="sk-platform-..." +``` + + +```typescript +import { Memory } from "mem0ai"; -### Detailed Memory Creation Examples +const memory = new Memory({ apiKey: process.env.MEM0_API_KEY!, async: true }); +``` + + + + -#### Long-term memory with full context +## Add memories with metadata and graph context - - -```python Python -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. I'll keep this in mind for any food-related recommendations or discussions."} + + + + +```python +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."}, ] -client.add(messages, user_id="alex", metadata={"food": "vegan"}) -``` - -```javascript JavaScript -const 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. I'll keep this in mind for any food-related recommendations or discussions."} -]; -client.add(messages, { user_id: "alex", metadata: { food: "vegan" } }) - .then(response => console.log(response)) - .catch(error => console.error(error)); -``` - -```bash cURL -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": "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. I'll keep this in mind for any food-related recommendations or discussions."} - ], - "user_id": "alex", - "metadata": { - "food": "vegan" - } - }' -``` - -```json Output -{ - "results": [ - { - "memory": "Name is Alex", - "event": "ADD" - }, - { - "memory": "Is a vegetarian", - "event": "ADD" - }, - { - "memory": "Is allergic to nuts", - "event": "ADD" - } - ] -} -``` - - - - - When passing `user_id`, memories are primarily created based on user messages, but may be influenced by assistant messages for contextual understanding. For example, in a conversation about food preferences, both the user's stated preferences and their responses to the assistant's questions would form user memories. Similarly, when using `agent_id`, assistant messages are prioritized, but user messages might influence the agent's memories based on context. - - **Example:** - ``` - User: My favorite cuisine is Italian - Assistant: Nice! What about Indian cuisine? - User: Don't like it much since I cannot eat spicy food - - Resulting user memories: - memory1 - Likes Italian food - memory2 - Doesn't like Indian food since cannot eat spicy - - (memory2 comes from user's response about Indian cuisine) - ``` - - -Metadata allows you to store structured information (location, timestamp, user state) with memories. Add it during creation to enable precise filtering and retrieval during searches. - -#### Short-term memory for sessions - - - -```python Python -messages = [ - {"role": "user", "content": "I'm planning a trip to Japan next month."}, - {"role": "assistant", "content": "That's exciting, Alex! A trip to Japan next month sounds wonderful. Would you like some recommendations for vegetarian-friendly restaurants in Japan?"}, - {"role": "user", "content": "Yes, please! Especially in Tokyo."}, - {"role": "assistant", "content": "Great! I'll remember that you're interested in vegetarian restaurants in Tokyo for your upcoming trip. I'll prepare a list for you in our next interaction."} -] - -client.add(messages, user_id="alex", run_id="trip-planning-2024") -``` - -```javascript JavaScript -const messages = [ - {"role": "user", "content": "I'm planning a trip to Japan next month."}, - {"role": "assistant", "content": "That's exciting, Alex! A trip to Japan next month sounds wonderful. Would you like some recommendations for vegetarian-friendly restaurants in Japan?"}, - {"role": "user", "content": "Yes, please! Especially in Tokyo."}, - {"role": "assistant", "content": "Great! I'll remember that you're interested in vegetarian restaurants in Tokyo for your upcoming trip. I'll prepare a list for you in our next interaction."} -]; -client.add(messages, { user_id: "alex", run_id: "trip-planning-2024" }) - .then(response => console.log(response)) - .catch(error => console.error(error)); -``` - -```bash cURL -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 planning a trip to Japan next month."}, - {"role": "assistant", "content": "That's exciting, Alex! A trip to Japan next month sounds wonderful. Would you like some recommendations for vegetarian-friendly restaurants in Japan?"}, - {"role": "user", "content": "Yes, please! Especially in Tokyo."}, - {"role": "assistant", "content": "Great! I'll remember that you're interested in vegetarian restaurants in Tokyo for your upcoming trip. I'll prepare a list for you in our next interaction."} - ], - "user_id": "alex", - "run_id": "trip-planning-2024" - }' -``` - -```json Output -{ - "results": [ - { - "memory": "Planning a trip to Japan next month", - "event": "ADD" - }, - { - "memory": "Interested in vegetarian restaurants in Tokyo", - "event": "ADD" - } - ] -} -``` - - - -#### Agent memories - - - -```python Python -messages = [ - {"role": "system", "content": "You are an AI tutor with a personality. Give yourself a name for the user."}, - {"role": "assistant", "content": "Understood. I'm an AI tutor with a personality. My name is Alice."} -] - -client.add(messages, agent_id="ai-tutor") -``` - -```javascript JavaScript -const messages = [ - {"role": "system", "content": "You are an AI tutor with a personality. Give yourself a name for the user."}, - {"role": "assistant", "content": "Understood. I'm an AI tutor with a personality. My name is Alice."} -]; -client.add(messages, { agent_id: "ai-tutor" }) - .then(response => console.log(response)) - .catch(error => console.error(error)); -``` - -```bash cURL -curl -X POST "https://api.mem0.ai/v1/memories/" \ - -H "Authorization: Token your-api-key" \ - -H "Content-Type: application/json" \ - -d '{ - "messages": [ - {"role": "system", "content": "You are an AI tutor with a personality. Give yourself a name for the user."}, - {"role": "assistant", "content": "Understood. I'm an AI tutor with a personality. My name is Alice."} - ], - "agent_id": "ai-tutor" - }' -``` - - - - - The `agent_id` retains memories exclusively based on messages generated by the assistant or those explicitly provided as input to the assistant. Messages outside these criteria are not stored as memory. - - -#### Dual user and agent memories - -When you provide both `user_id` and `agent_id`, Mem0 will store memories for both identifiers separately: -- Memories from messages with `"role": "user"` are automatically tagged with the provided `user_id` -- Memories from messages with `"role": "assistant"` are automatically tagged with the provided `agent_id` -- During retrieval, you can provide either `user_id` or `agent_id` to access the respective memories -- You can continuously enrich existing memory collections by adding new memories to the same `user_id` or `agent_id` in subsequent API calls, either together or separately, allowing for progressive memory building over time -- This dual-tagging approach enables personalized experiences for both users and AI agents in your application - - - -```python Python -messages = [ - {"role": "user", "content": "I'm travelling to San Francisco"}, - {"role": "assistant", "content": "That's great! I'm going to Dubai next month."}, -] - -client.add(messages=messages, user_id="user1", agent_id="agent1") -``` - -```javascript JavaScript -const messages = [ - {"role": "user", "content": "I'm travelling to San Francisco"}, - {"role": "assistant", "content": "That's great! I'm going to Dubai next month."}, -] - -client.add(messages, { user_id: "user1", agent_id: "agent1" }) - .then(response => console.log(response)) - .catch(error => console.error(error)); -``` - -```bash cURL -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 San Francisco"}, - {"role": "assistant", "content": "That's great! I'm going to Dubai next month."}, - ], - "user_id": "user1", - "agent_id": "agent1" - }' -``` - -```json Output -{ - "results": [ - { - // memory from user1 - "id": "c57abfa2-f0ac-48af-896a-21728dbcecee0", - "data": {"memory": "Travelling to San Francisco"}, - "event": "ADD" - }, - { - // memory from agent1 - "id": "0e8c003f-7db7-426a-9fdc-a46f9331a0c2", - "data": {"memory": "Going to Dubai next month"}, - "event": "ADD" - } - ] -} -``` - - - -## Advanced Search Operations - -### Search with Custom Filters - -Our advanced search allows you to set custom search filters for precise memory retrieval. You can filter by `user_id`, `agent_id`, `app_id`, `run_id`, `created_at`, `updated_at`, `categories`, and `text`. The filters support logical operators (AND, OR) and comparison operators (`in`, `gte`, `lte`, `gt`, `lt`, `ne`, `contains`, `icontains`, `*`). The wildcard character (`*`) matches everything for a specific field. - -#### Filterable Fields - -You can filter by the following fields: -- **Session identifiers**: `user_id`, `agent_id`, `run_id`, `app_id` -- **Timestamps**: `created_at`, `updated_at` -- **Content**: `categories`, `metadata` fields -- **Text**: Memory content (platform-specific) - -#### Filter Operators - -**Logical Operators:** -- `AND`: All conditions must match -- `OR`: At least one condition must match -- `NOT`: Exclude matching conditions (platform-specific) - -**Comparison Operators:** -- `in`: Match any value in array (e.g., `{"agent_id": {"in": ["bot1", "bot2"]}}`) -- `gte`, `lte`: Greater/less than or equal (dates, numbers) -- `gt`, `lt`: Greater/less than (dates, numbers) -- `ne`: Not equal to -- `contains`: Partial text match (e.g., `{"categories": {"contains": "finance"}}`) -- `icontains`: Case-insensitive partial match -- `*`: Wildcard - matches any value for the field - -#### Using Filters - -**Method 1: Direct Parameters (Recommended for simple queries)** -```python -# Search for a specific user -client.search("query", user_id="alice") - -# Search with agent context -client.search("query", user_id="alice", agent_id="travel-bot") -``` - -**Method 2: Filters Object (For complex queries)** -```python -# Combine multiple conditions -filters = { - "AND": [ - {"user_id": "alice"}, - {"agent_id": {"in": ["bot1", "bot2"]}} - ] -} -client.search("query", filters=filters) -``` - -#### Example 1: OR Logic - Multiple User or Agent IDs - -Search memories from either a specific user OR from specific agents: - - - -```python Python -query = "What do you know about me?" -filters = { - "OR": [ - {"user_id": "alex"}, - {"agent_id": {"in": ["travel-assistant", "customer-support"]}} - ] -} -client.search(query, filters=filters) -``` - -```javascript JavaScript -const query = "What do you know about me?"; -const filters = { - "OR":[ - { - "user_id":"alex" - }, - { - "agent_id":{ - "in":[ - "travel-assistant", - "customer-support" - ] - } - } - ] -}; -client.search(query, { filters }) - .then(results => console.log(results)) - .catch(error => console.error(error)); -``` - -```bash cURL -curl -X POST "https://api.mem0.ai/v2/memories/search/" \ - -H "Authorization: Token your-api-key" \ - -H "Content-Type: application/json" \ - -d '{ - "query": "What do you know about me?", - "filters": { - "OR": [ - { - "user_id": "alex" - }, - { - "agent_id": { - "in": ["travel-assistant", "customer-support"] - } - } - ] - } - }' -``` - - - -#### Example 2: Search using date filters - - -```python Python -query = "What do you know about me?" -filters = { - "AND": [ - {"user_id": "alex"}, - {"created_at": {"gte": "2024-07-01", "lte": "2024-07-31"}} - ] -} -client.search(query, filters=filters) -``` - -```javascript JavaScript -const query = "What do you know about me?"; -const filters = { - "AND": [ - {"user_id": "alex"}, - {"created_at": {"gte": "2024-07-01", "lte": "2024-07-31"}} - ] -}; - -client.search(query, { filters }) - .then(results => console.log(results)) - .catch(error => console.error(error)); -``` - -```bash cURL -curl -X POST "https://api.mem0.ai/v2/memories/search/" \ - -H "Authorization: Token your-api-key" \ - -H "Content-Type: application/json" \ - -d '{ - "query": "What do you know about me?", - "filters": { - "AND": [ - {"user_id": "alex"}, - { - "created_at": { - "gte": "2024-07-01", - "lte": "2024-07-31" - } - } - ] - } - }' -``` - - -#### Example 3: Search using categories filters - - -```python Python -# Example 3a: Using 'contains' for partial matching -query = "What are my financial goals?" -filters = { - "AND": [ - { "user_id": "alice" }, - { - "categories": { - "contains": "finance" - } - } - ] -} -client.search(query, filters=filters) - -# Example 3b: Using 'in' for exact matching -query = "What personal information do you have?" -filters = { - "AND": [ - { "user_id": "alice" }, - { - "categories": { - "in": ["personal_information"] - } - } - ] -} -client.search(query, filters=filters) -``` - -```javascript JavaScript -// Example 3a: Using 'contains' for partial matching -const query1 = "What are my financial goals?"; -const filters1 = { - "AND": [ - { "user_id": "alice" }, - { - "categories": { - "contains": "finance" - } - } - ] -}; - -client.search(query1, { filters: filters1 }) - .then(results => console.log(results)) - .catch(error => console.error(error)); - -// Example 3b: Using 'in' for exact matching -const query2 = "What personal information do you have?"; -const filters2 = { - "AND": [ - { "user_id": "alice" }, - { - "categories": { - "in": ["personal_information"] - } - } - ] -}; - -client.search(query2, { filters: filters2 }) - .then(results => console.log(results)) - .catch(error => console.error(error)); -``` - -```bash cURL -# Example 3a: Using 'contains' for partial matching -curl -X POST "https://api.mem0.ai/v2/memories/search/" \ - -H "Authorization: Token your-api-key" \ - -H "Content-Type: application/json" \ - -d '{ - "query": "What are my financial goals?", - "filters": { - "AND": [ - { "user_id": "alice" }, - { - "categories": { - "contains": "finance" - } - } - ] - } - }' - -# Example 3b: Using 'in' for exact matching -curl -X POST "https://api.mem0.ai/v2/memories/search/" \ - -H "Authorization: Token your-api-key" \ - -H "Content-Type: application/json" \ - -d '{ - "query": "What personal information do you have?", - "filters": { - "AND": [ - { "user_id": "alice" }, - { - "categories": { - "in": ["personal_information"] - } - } - ] - } - }' -``` - - -#### Example 4: Search using NOT filters - - -```python Python -query = "What do you know about me?" -filters = { - "AND": [ - {"user_id": "alex"}, - { - "NOT": [ - {"categories": {"contains": "food_preferences"}} - ] - } - ] -} -client.search(query, filters=filters) -``` - -```javascript JavaScript -const query = "What do you know about me?"; -const filters = { - "AND": [ - {"user_id": "alex"}, - { - "NOT": [ - {"categories": {"contains": "food_preferences"}} - ] - } - ] -}; - -client.search(query, { filters }) - .then(results => console.log(results)) - .catch(error => console.error(error)); -``` - -```bash cURL -curl -X POST "https://api.mem0.ai/v2/memories/search/" \ - -H "Authorization: Token your-api-key" \ - -H "Content-Type: application/json" \ - -d '{ - "query": "What do you know about me?", - "filters": { - "NOT": [ - { - "categories": { - "contains": "food_preferences" - } - } - ] - } - }' -``` - - -#### Example 5: Wildcard Filters - Match Any Value - -Use `*` wildcard to match memories that have any value for a specific field: - - -```python Python -query = "What do you know about me?" -filters = { - "AND": [ - {"user_id": "alex"}, - {"run_id": "*"} # Only memories that have a run_id (any value) - ] -} -client.search(query, filters=filters) -``` - -```javascript JavaScript -const query = "What do you know about me?"; -const filters = { - "AND": [ - { - "user_id": "alex" - }, - { - "run_id": "*" // Matches all run_ids - } - ] -}; - -client.search(query, { filters }) - .then(results => console.log(results)) - .catch(error => console.error(error)); -``` - -```bash cURL -curl -X POST "https://api.mem0.ai/v2/memories/search/" \ - -H "Authorization: Token your-api-key" \ - -H "Content-Type: application/json" \ - -d '{ - "query": "What do you know about me?", - "filters": { - "AND": [ - { - "user_id": "alex" - }, - { - "run_id": "*" - } - ] - } - }' -``` - - -### Filter Best Practices - -**1. Always Scope to User or Agent** - -Always include at least a `user_id`, `agent_id`, or `run_id` to scope your search: - -```python -# Good: Scoped to user -client.search("query", user_id="alice") - -# Better: Scoped to user and agent -client.search("query", user_id="alice", agent_id="travel-bot") - -# Best: Scoped to specific session -client.search("query", user_id="alice", agent_id="travel-bot", run_id="session-123") -``` - -**2. Use Direct Parameters for Simple Queries** - -For single-condition filters, use direct parameters instead of the filters object: - -```python -# Simple and clean -client.search("query", user_id="alice", agent_id="bot") - -# Unnecessarily complex -client.search("query", filters={"AND": [{"user_id": "alice"}, {"agent_id": "bot"}]}) -``` - -**3. Use Filters Object for Complex Logic** - -Use the `filters` parameter when you need OR logic, comparison operators, or nested conditions: - -```python -# Multiple agents OR specific run -filters = { - "OR": [ - {"agent_id": {"in": ["bot1", "bot2"]}}, - {"run_id": "special-session"} - ] -} -client.search("query", user_id="alice", filters=filters) -``` - -**4. Combine Direct Parameters with Filters** - -You can mix direct parameters with filters for cleaner code: - -```python -# User is required, plus complex date/category logic -filters = { - "AND": [ - {"created_at": {"gte": "2024-07-01"}}, - {"categories": {"contains": "important"}} - ] -} -client.search("query", user_id="alice", filters=filters) -``` - -**5. Platform vs OSS Differences** - -Some features are Platform-only: -- **Categories**: Auto-generated on Platform, manual on OSS -- **Date filters**: Platform tracks timestamps automatically -- **NOT operator**: Only available on Platform -- **Wildcard (`*`)**: Behavior may vary - -```python -# This works everywhere -m.search("query", user_id="alice", agent_id="bot") - -# This is Platform-only -client.search("query", filters={ - "AND": [ - {"user_id": "alice"}, - {"categories": {"contains": "travel"}} # Platform only - ] -}) -``` - ---- - -## Advanced Retrieval Operations - -### Get All Memories with Pagination - -The `get_all` method supports two output formats: `v1.0` (default) and `v1.1`. To use the latest format, which provides more detailed information about each memory operation, set the `output_format` parameter to `v1.1`. - -We're soon deprecating the default output format for the `get_all()` method, which returned a list. Once the changes are live, paginated response will be the only supported format, with 100 memories per page by default. You can customize this using the `page` and `page_size` parameters. - -#### Get all memories of a user - - - -```python Python -memories = client.get_all(user_id="alex", page=1, page_size=50) -``` - -```javascript JavaScript -client.getAll({ user_id: "alex", page: 1, page_size: 50 }) - .then(memories => console.log(memories)) - .catch(error => console.error(error)); -``` - -```bash cURL -curl -X GET "https://api.mem0.ai/v1/memories/?user_id=alex&page=1&page_size=50" \ - -H "Authorization: Token your-api-key" -``` - -```json Output (v1.1) -{ - "count": 204, - "next": "https://api.mem0.ai/v1/memories/?user_id=alex&output_format=v1.1&page=2&page_size=50", - "previous": null, - "results": [ - { - "id":"f38b689d-6b24-45b7-bced-17fbb4d8bac7", - "memory":"Is a vegetarian and allergic to nuts.", - "agent_id":"travel-assistant", - "hash":"62bc074f56d1f909f1b4c2b639f56f6a", - "metadata":null, - "immutable": false, - "expiration_date": null, - "created_at":"2024-07-25T23:57:00.108347-07:00", - "updated_at":"2024-07-25T23:57:00.108367-07:00", - "categories":null - } - ] -} -``` - - - -#### Get all memories by categories - -You can filter memories by their categories when using get_all: - - - -```python Python -# Get memories with specific categories -memories = client.get_all(user_id="alex", categories=["likes"]) - -# Get memories with multiple categories -memories = client.get_all(user_id="alex", categories=["likes", "food_preferences"]) - -# Custom pagination with categories -memories = client.get_all(user_id="alex", categories=["likes"], page=1, page_size=50) - -# Get memories with specific keywords -memories = client.get_all(user_id="alex", keywords="to play", page=1, page_size=50) -``` - -```javascript JavaScript -// Get memories with specific categories -client.getAll({ user_id: "alex", categories: ["likes"] }) - .then(memories => console.log(memories)) - .catch(error => console.error(error)); - -// Get memories with multiple categories -client.getAll({ user_id: "alex", categories: ["likes", "food_preferences"] }) - .then(memories => console.log(memories)) - .catch(error => console.error(error)); - -// Custom pagination with categories -client.getAll({ user_id: "alex", categories: ["likes"], page: 1, page_size: 50 }) - .then(memories => console.log(memories)) - .catch(error => console.error(error)); - -// Get memories with specific keywords -client.getAll({ user_id: "alex", keywords: "to play", page: 1, page_size: 50 }) - .then(memories => console.log(memories)) - .catch(error => console.error(error)); -``` - -```bash cURL -# Get memories with specific categories -curl -X GET "https://api.mem0.ai/v1/memories/?user_id=alex&categories=likes" \ - -H "Authorization: Token your-api-key" - -# Get memories with multiple categories -curl -X GET "https://api.mem0.ai/v1/memories/?user_id=alex&categories=likes,food_preferences" \ - -H "Authorization: Token your-api-key" - -# Custom pagination with categories -curl -X GET "https://api.mem0.ai/v1/memories/?user_id=alex&categories=likes&page=1&page_size=50" \ - -H "Authorization: Token your-api-key" - -# Get memories with specific keywords -curl -X GET "https://api.mem0.ai/v1/memories/?user_id=alex&keywords=to play&page=1&page_size=50" \ - -H "Authorization: Token your-api-key" -``` - - - -#### Get all memories using custom filters - -Our advanced retrieval allows you to set custom filters when fetching memories. You can filter by user_id, agent_id, app_id, run_id, created_at, updated_at, categories, and keywords. The filters support logical operators (AND, OR) and comparison operators (in, gte, lte, gt, lt, ne, contains, icontains, `*`). The wildcard character (`*`) matches everything for a specific field. - -For the **categories** field specifically: -- Use `contains` for partial matching (e.g., `{"categories": {"contains": "finance"}}`) -- Use `in` for exact matching (e.g., `{"categories": {"in": ["personal_information"]}}`). - -You need to define `version` as `v2` in the `get_all` method. - - - -```python Python -filters = { - "AND":[ - { - "user_id":"alex" - }, - { - "created_at":{ - "gte":"2024-07-01", - "lte":"2024-07-31" - } - }, - { - "categories":{ - "contains": "food_preferences" - } - } - ] -} - -# Default (No Pagination) -client.get_all(filters=filters) - -# Pagination (You can also use the page and page_size parameters) -client.get_all(filters=filters, page=1, page_size=50) -``` - -```javascript JavaScript -const filters = { - "AND":[ - { - "user_id":"alex" - }, - { - "created_at":{ - "gte":"2024-07-01", - "lte":"2024-07-31" - } - }, - { - "categories":{ - "contains": "food_preferences" - } - } - ] -}; - -// Default (No Pagination) -client.getAll({ filters }) - .then(memories => console.log(memories)) - .catch(error => console.error(error)); - -// Pagination (You can also use the page and page_size parameters) -client.getAll({ filters, page: 1, page_size: 50 }) - .then(memories => console.log(memories)) - .catch(error => console.error(error)); -``` - -```bash cURL -# Default (No Pagination) -curl -X GET "https://api.mem0.ai/v2/memories/" \ - -H "Authorization: Token your-api-key" \ - -H "Content-Type: application/json" \ - -d '{ - "filters": { - "AND": [ - {"user_id":"alex"}, - {"created_at":{ - "gte":"2024-07-01", - "lte":"2024-07-31" - }}, - {"categories":{ - "contains": "food_preferences" - }} - ] - } - }' - -# Pagination (You can also use the page and page_size parameters) -curl -X GET "https://api.mem0.ai/v2/memories/&page=1&page_size=50" \ - -H "Authorization: Token your-api-key" \ - -H "Content-Type: application/json" \ - -d '{ - "filters": { - "AND": [ - {"user_id":"alex"}, - {"created_at":{ - "gte":"2024-07-01", - "lte":"2024-07-31" - }}, - {"categories":{ - "contains": "food_preferences" - }} - ] - } - }' -``` - - - -## Memory Management Operations - -### Memory History - -Get history of how a memory has changed over time. - - - -```python Python -# Add some message to create history -messages = [{"role": "user", "content": "I recently tried chicken and I loved it. I'm thinking of trying more non-vegetarian dishes.."}] -client.add(messages, user_id="alex") - -# Add second message to update history -messages.append({'role': 'user', 'content': 'I turned vegetarian now.'}) -client.add(messages, user_id="alex") - -# Get history of how memory changed over time -memory_id = "" -history = client.history(memory_id) -``` - -```javascript JavaScript -// Add some message to create history -let messages = [{ role: "user", content: "I recently tried chicken and I loved it. I'm thinking of trying more non-vegetarian dishes.." }]; -client.add(messages, { user_id: "alex" }) - .then(result => { - // Add second message to update history - messages.push({ role: 'user', content: 'I turned vegetarian now.' }); - return client.add(messages, { user_id: "alex" }); - }) - .then(result => { - // Get history of how memory changed over time - const memoryId = result.id; // Assuming the API returns the memory ID - return client.history(memoryId); - }) - .then(history => console.log(history)) - .catch(error => console.error(error)); -``` - -```bash cURL -# First, add the initial memory -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 recently tried chicken and I loved it. I'm thinking of trying more non-vegetarian dishes.."}], - "user_id": "alex" - }' - -# Then, update the memory -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 recently tried chicken and I loved it. I'm thinking of trying more non-vegetarian dishes.."}, - {"role": "user", "content": "I turned vegetarian now."} - ], - "user_id": "alex" - }' - -# Finally, get the history (replace with the actual memory ID) -curl -X GET "https://api.mem0.ai/v1/memories//history/" \ - -H "Authorization: Token your-api-key" -``` - -```json Output -[ - { - "id":"d6306e85-eaa6-400c-8c2f-ab994a8c4d09", - "memory_id":"b163df0e-ebc8-4098-95df-3f70a733e198", - "input":[ - { - "role":"user", - "content":"I recently tried chicken and I loved it. I'm thinking of trying more non-vegetarian dishes.." - }, - { - "role":"user", - "content":"I turned vegetarian now." - } - ], - "old_memory":"None", - "new_memory":"Turned vegetarian.", - "user_id":"alex", - "event":"ADD", - "metadata":"None", - "created_at":"2024-07-26T01:02:41.737310-07:00", - "updated_at":"2024-07-26T01:02:41.726073-07:00" - } -] -``` - - -### Update Memory - -Update a memory with new data. You can update the memory's text, metadata, or both. - - - -```python Python -client.update( - memory_id="", - text="I am now a vegetarian.", - metadata={"diet": "vegetarian"} +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", ) ``` - -```javascript JavaScript -client.update("memory-id-here", { text: "I am now a vegetarian.", metadata: { diet: "vegetarian" } }) - .then(result => console.log(result)) - .catch(error => console.error(error)); -``` - -```bash cURL -curl -X PUT "https://api.mem0.ai/v1/memories/" \ - -H "Authorization: Token your-api-key" \ - -H "Content-Type: application/json" \ - -d '{ - "message": "I recently tried chicken and I loved it. I'm thinking of trying more non-vegetarian dishes.." - }' -``` - -```json Output -{ - "id":"c190ab1a-a2f1-4f6f-914a-495e9a16b76e", - "memory":"I recently tried chicken and I loved it. I'm thinking of trying more non-vegetarian dishes..", - "agent_id":"travel-assistant", - "hash":"af1161983e03667063d1abb60e6d5c06", - "metadata":"None", - "created_at":"2024-07-30T22:46:40.455758-07:00", - "updated_at":"2024-07-30T22:48:35.257828-07:00" -} -``` - - - -## Batch Operations - -### Batch Update Memories - -Update multiple memories in a single API call. You can update up to 1000 memories at once. - - -```python Python -update_memories = [ - { - "memory_id": "285ed74b-6e05-4043-b16b-3abd5b533496", - "text": "Watches football" - }, - { - "memory_id": "2c9bd859-d1b7-4d33-a6b8-94e0147c4f07", - "text": "Loves to travel" - } -] - -response = client.batch_update(update_memories) -print(response) -``` - -```javascript JavaScript -const updateMemories = [ - { - "memory_id": "285ed74b-6e05-4043-b16b-3abd5b533496", - text: "Watches football" - }, - { - "memory_id": "2c9bd859-d1b7-4d33-a6b8-94e0147c4f07", - text: "Loves to travel" - } + + + + + + +```typescript +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." }, ]; -client.batchUpdate(updateMemories) - .then(response => console.log('Batch update response:', response)) - .catch(error => console.error(error)); +const result = await memory.add(conversation, { + userId: "traveler-42", + metadata: { trip: "japan-2025", preferences: ["boutique", "no-shellfish"] }, + enableGraph: true, + runId: "planning-call-1", +}); ``` + + + + -```bash cURL -curl -X PUT "https://api.mem0.ai/v1/memories/batch/" \ - -H "Authorization: Token your-api-key" \ - -H "Content-Type: application/json" \ - -d '{ - "memories": [ - { - "memory_id": "285ed74b-6e05-4043-b16b-3abd5b533496", - "text": "Watches football" - }, - { - "memory_id": "2c9bd859-d1b7-4d33-a6b8-94e0147c4f07", - "text": "Loves to travel" - } - ] - }' + + 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. + + +## Retrieve and refine + + + + + +```python +matches = await memory.search( + "Any food alerts?", + user_id="traveler-42", + filters={"metadata.trip": "japan-2025"}, + rerank=True, + include_vectors=False, +) ``` - -```json Output -{ - "message": "Successfully updated 2 memories" -} + + +```python +await memory.update( + memory_id=matches["results"][0]["id"], + content="Morgan avoids shellfish and prefers boutique hotels in central Tokyo.", +) ``` - - -### Batch Delete Memories - -Delete multiple memories in a single API call. You can delete up to 1000 memories at once. - - -```python Python -delete_memories = [ - {"memory_id": "285ed74b-6e05-4043-b16b-3abd5b533496"}, - {"memory_id": "2c9bd859-d1b7-4d33-a6b8-94e0147c4f07"} -] - -response = client.batch_delete(delete_memories) -print(response) + + + + + + +```typescript +const matches = await memory.search("Any food alerts?", { + userId: "traveler-42", + filters: { "metadata.trip": "japan-2025" }, + rerank: true, + includeVectors: false, +}); ``` - -```javascript JavaScript -const deleteMemories = [ - {"memory_id": "285ed74b-6e05-4043-b16b-3abd5b533496"}, - {"memory_id": "2c9bd859-d1b7-4d33-a6b8-94e0147c4f07"} -]; - -client.batchDelete(deleteMemories) - .then(response => console.log('Batch delete response:', response)) - .catch(error => console.error(error)); + + +```typescript +await memory.update(matches.results[0].id, { + content: "Morgan avoids shellfish and prefers boutique hotels in central Tokyo.", +}); ``` + + + + -```bash cURL -curl -X DELETE "https://api.mem0.ai/v1/memories/batch/" \ - -H "Authorization: Token your-api-key" \ - -H "Content-Type: application/json" \ - -d '{ - "memory_ids": [ - {"memory_id": "285ed74b-6e05-4043-b16b-3abd5b533496"}, - {"memory_id": "2c9bd859-d1b7-4d33-a6b8-94e0147c4f07"} - ] - }' + + 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. + + +## Clean up + + + + + +```python +await memory.delete_all(user_id="traveler-42", run_id="planning-call-1") ``` - -```json Output -{ - "message": "Successfully deleted 2 memories" -} + + + + + + +```typescript +await memory.deleteAll({ userId: "traveler-42", runId: "planning-call-1" }); ``` - + + + + -## Entity Management +## Quick recovery -### Get All Users +- `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). -Get all users, agents, and runs which have memories associated with them. + + Metadata keys become part of your filtering schema. Stick to lowercase snake_case (`trip_id`, `preferences`) to avoid collisions down the road. + - - -```python Python -client.users() -``` - -```javascript JavaScript -client.users() - .then(users => console.log(users)) - .catch(error => console.error(error)); -``` - -```bash cURL -curl -X GET "https://api.mem0.ai/v1/entities/" \ - -H "Authorization: Token your-api-key" -``` - -```json Output -[ - { - "id": "1", - "name": "user123", - "created_at": "2024-07-17T16:47:23.899900-07:00", - "updated_at": "2024-07-17T16:47:23.899918-07:00", - "total_memories": 5, - "owner": "alex", - "metadata": {"foo": "bar"}, - "type": "user" - }, - { - "id": "2", - "name": "travel-agent", - "created_at": "2024-07-01T17:59:08.187250-07:00", - "updated_at": "2024-07-01T17:59:08.187266-07:00", - "total_memories": 10, - "owner": "alex", - "metadata": {"agent_id": "123"}, - "type": "agent" - } -] -``` - - - -### Delete Operations - -Delete specific memory: - - - -```python Python -client.delete(memory_id) -``` - -```javascript JavaScript -client.delete("memory-id-here") - .then(result => console.log(result)) - .catch(error => console.error(error)); -``` - -```bash cURL -curl -X DELETE "https://api.mem0.ai/v1/memories/memory-id-here" \ - -H "Authorization: Token your-api-key" -``` - - - -Delete all memories of a user: - - - -```python Python -client.delete_all(user_id="alex") -``` - -```javascript JavaScript -client.deleteAll({ user_id: "alex" }) - .then(result => console.log(result)) - .catch(error => console.error(error)); -``` - -```bash cURL -curl -X DELETE "https://api.mem0.ai/v1/memories/?user_id=alex" \ - -H "Authorization: Token your-api-key" -``` - - - -Delete specific user or agent: - - -```python Python -# Delete specific user -client.delete_users(user_id="alex") - -# Delete specific agent -# client.delete_users(agent_id="travel-assistant") -``` - -```javascript JavaScript -client.delete_users({ user_id: "alex" }) - .then(result => console.log(result)) - .catch(error => console.error(error)); -``` - -```bash cURL -curl -X DELETE "https://api.mem0.ai/v2/entities/user/alex" \ - -H "Authorization: Token your-api-key" -``` - - -### Reset Client - - - -```python Python -client.reset() -``` - -```json Output -{'message': 'Client reset successful. All users and memories deleted.'} -``` - - - -### Natural Language Delete - -You can also delete memories using natural language commands: - - - -```python Python -messages = [ - {"role": "user", "content": "Delete all of my food preferences"} -] -client.add(messages, user_id="alex") -``` - -```javascript JavaScript -const messages = [ - {"role": "user", "content": "Delete all of my food preferences"} -] -client.add(messages, { user_id: "alex" }) - .then(result => console.log(result)) - .catch(error => console.error(error)); -``` - -```bash cURL -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": "Delete all of my food preferences"}], - "user_id": "alex" - }' -``` - - - -## Monitor Memory Operations - -You can monitor memory operations on the platform dashboard: - -![Mem0 Platform Activity](/images/platform/activity.png) - -For more detailed information, see our [API Reference](/api-reference) or explore specific features in the [Platform Features](/platform/features/platform-overview) section. \ No newline at end of file + + + + diff --git a/docs/platform/features/platform-overview.mdx b/docs/platform/features/platform-overview.mdx index cba077f9c..e17fa8bad 100644 --- a/docs/platform/features/platform-overview.mdx +++ b/docs/platform/features/platform-overview.mdx @@ -1,46 +1,55 @@ --- +description: "See how Mem0 Platform features evolve from baseline filters to graph-powered retrieval." +icon: "sparkles" title: Overview --- -Learn about the key features and capabilities that make Mem0 a powerful platform for memory management and 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. -## Core Features + + New to the platform? Start with the Platform quickstart, then dive into the journeys below. + - - - Superior search results using state-of-the-art algorithms, including keyword search, reranking, and filtering capabilities. +## Choose your path + + + + Control which memories surface with field-level filtering and async defaults. - - Only send your latest conversation history - we automatically retrieve the rest and generate properly contextualized memories. + + Stream add/search requests without blocking your agents. - - Process and analyze various types of content including images. + + Layer relationships on top of vectors for richer recalls. - - Customize and curate stored memories to focus on relevant information while excluding unnecessary data, enabling improved accuracy, privacy control, and resource efficiency. + + Combine metadata filtering, rerankers, and per-request toggles. - - Create and manage custom categories to organize memories based on your specific needs and requirements. + + Handle imports, exports, timestamps, and expirations at scale. - - Define specific guidelines for your project to ensure consistent handling of information and requirements. - - - Tailor the behavior of your Mem0 instance with custom prompts for specific use cases or domains. - - - Asynchronous client for non-blocking operations and high concurrency applications. - - - Export memories in structured formats using customizable Pydantic schemas. - - - Add memories in the form of nodes and edges in a graph database and search for related memories. + + Wire webhook callbacks, feedback loops, and multi-agent chat. -## Getting Help + + Self-hosting instead? Jump to the OSS feature overview for equivalent capabilities. + -If you have any questions about these features or need assistance, our team is here to help: +## Keep going - + + + + diff --git a/docs/templates/api_reference_template.mdx b/docs/templates/api_reference_template.mdx index 5043a1f56..133d631f9 100644 --- a/docs/templates/api_reference_template.mdx +++ b/docs/templates/api_reference_template.mdx @@ -124,7 +124,7 @@ const response = await fetch("https://api.mem0.ai/v1/memories", { - [Build a Customer Support Agent](/cookbooks/customer-support-agent) - +{/* DEBUG: verify CTA targets */} +{/* Optional: delete if not needed */} ```mermaid graph LR - A[Input] --> B[Concept] - B --> C[Outcome] + A[Input] */} B[Concept] + B */} C[Outcome] ``` ## How does it work? @@ -91,7 +91,7 @@ graph LR - [Cookbook or integration demonstrating the concept] - [Recording, demo, or sample repo] - +{/* DEBUG: verify CTA targets */} - +{/* Optional: remove if no diagram is needed */} ```mermaid %% Diagram the moving parts (delete when you fill this out) graph TD - A[Input] --> B[Feature] - B --> C[Output] + A[Input] */} B[Feature] + B */} C[Output] ``` ## Feature anatomy diff --git a/docs/templates/integration_guide_template.mdx b/docs/templates/integration_guide_template.mdx index cd01bbc32..4206c5117 100644 --- a/docs/templates/integration_guide_template.mdx +++ b/docs/templates/integration_guide_template.mdx @@ -45,11 +45,11 @@ Combine Mem0’s memory layer with [Partner] to [describe the joint outcome]. [Use only if access is gated or breaking changes exist. Delete when not needed.] - +{/* Optional architecture diagram */} ```mermaid graph LR - A[Mem0] --> B[Connector] - B --> C[Partner workflow] + A[Mem0] */} B[Connector] + B */} C[Partner workflow] ``` ## Configure credentials @@ -170,7 +170,7 @@ partner.registerTool("recallPreferences", async (userId: string) => { - **[Issue]** — `[Fix or link to partner docs]` - **[Issue]** — `[Fix or link to Mem0 troubleshooting guide]` - +{/* DEBUG: verify CTA targets */} +{/* Optional: delete if not needed */} ```mermaid graph LR - A[Plan] --> B[Migrate] - B --> C[Validate] - C --> D[Roll back if needed] + A[Plan] */} B[Migrate] + B */} C[Validate] + C */} D[Roll back if needed] ``` ## Plan diff --git a/docs/templates/operation_guide_template.mdx b/docs/templates/operation_guide_template.mdx index 058996c6d..6a4e752b8 100644 --- a/docs/templates/operation_guide_template.mdx +++ b/docs/templates/operation_guide_template.mdx @@ -141,7 +141,7 @@ const response = await memory.add(payload); - [Link to complementary operation] - [Link to troubleshooting playbook section] - +{/* DEBUG: verify CTA targets */} +{/* DEBUG: verify CTA targets */} - +{/* Optional: delete if not needed */} ```mermaid graph LR - A[Install] --> B[Configure keys] - B --> C[Add memory] - C --> D[Search] - D --> E[Delete] + A[Install] */} B[Configure keys] + B */} C[Add memory] + C */} D[Search] + D */} E[Delete] ``` ## Install dependencies @@ -212,7 +212,7 @@ await memory.deleteAll({ userId: "alex" }); - `[Error message]` → `[One-line fix or link to troubleshooting guide]` - `[Second error]` → `[How to resolve]` - +{/* DEBUG: verify CTA targets */} +{/* DEBUG: verify CTA targets */} - +{/* Optional: delete if not needed */} ```mermaid graph LR - A[Get set up] --> B[Learn concepts] - B --> C[Build workflows] - C --> D[Support & scale] + A[Get set up] */} B[Learn concepts] + B */} C[Build workflows] + C */} D[Support & scale] ``` ## Choose your path @@ -73,7 +73,7 @@ graph LR ## Keep going - +{/* DEBUG: verify CTA targets */} +{/* DEBUG: verify CTA targets */}