Mem0 1.0.0 (#3545)

Signed-off-by: Andrew Carbonetto <andrew.carbonetto@improving.com>
Co-authored-by: Siddhartha Sahu <dev@sdht.in>

LLM.md

@@ -103,7 +103,7 @@ memory = Memory()
 # With custom configuration
 config = MemoryConfig(
     vector_store={"provider": "qdrant", "config": {"host": "localhost"}},
-    llm={"provider": "openai", "config": {"model": "gpt-4o-mini"}},
+    llm={"provider": "openai", "config": {"model": "gpt-4.1-nano-2025-04-14"}},
     embedder={"provider": "openai", "config": {"model": "text-embedding-3-small"}}
 )
 memory = Memory(config)
@@ -339,7 +339,7 @@ config = MemoryConfig(
     llm={
         "provider": "openai",
         "config": {
-            "model": "gpt-4o-mini",
+            "model": "gpt-4.1-nano-2025-04-14",
             "temperature": 0.1,
             "max_tokens": 1000
         }
@@ -527,7 +527,7 @@ const memory = new Memory({
   },
   llm: {
     provider: 'openai',
-    config: { model: 'gpt-4o-mini' }
+    config: { model: 'gpt-4.1-nano' }
   }
 });
 

MIGRATION_GUIDE_v1.0.md

@@ -1,347 +1,221 @@
-# Migration Guide: Upgrading to mem0ai 1.0.0
+# Migration Guide: Upgrading to mem0 1.0.0
 
-This guide will help you migrate from mem0ai 0.x to the new 1.0.0 version.
+## TL;DR
 
-## Breaking Changes
+**What changed?** We simplified the API by removing confusing version parameters. Now everything returns a consistent format: `{"results": [...]}`.
 
-### 1. API Version Changes
+**What you need to do:**
+1. Upgrade: `pip install mem0ai==1.0.0`
+2. Remove `version` and `output_format` parameters from your code
+3. Update response handling to use `result["results"]` instead of treating responses as lists
 
-**Before (0.x):**
-```python
-# Multiple API versions supported
-memory = Memory(config=MemoryConfig(version="v1.1"))
+**Time needed:** ~5-10 minutes for most projects
 
-# Client with output_format parameter
-client.add(messages, output_format="v1.1")
-client.search(query, version="v1", output_format="v1.1") 
-client.get_all(version="v1", output_format="v1.1")
-```
+---
 
-**After (1.0.0):**
-```python
-# v1.1 format is default (v1.0 is deprecated)
-memory = Memory()  # Defaults to v1.1 format
+## Quick Migration Guide
 
-# Client API with correct versioning behavior:
-client.add(messages)  # Uses v1 API endpoint, returns v1.1 format
-client.search(query)  # Uses v2 API endpoint, returns v1.1 format  
-client.get_all()  # Uses v2 API endpoint, returns v1.1 format
-```
-
-### 2. API Versioning Strategy Clarification
-
-**IMPORTANT: Understanding the New Versioning Strategy**
-
-The API versioning strategy in mem0ai 1.0.0 has been unified and simplified:
-
-#### **Endpoint vs Format Distinction**
-- **API Endpoints** (`/v1/`, `/v2/`): Control which REST API version to use
-- **Response Formats** (v1.0, v1.1): Control the structure of the returned data
-
-#### **New Unified Strategy:**
-- **Add operations**: Always use `/v1/` endpoint with v1.1 response format (no more output_format parameter)
-- **Search operations**: Always use `/v2/` endpoint with v1.1 response format  
-- **Get_all operations**: Always use `/v2/` endpoint with v1.1 response format
-- **Response format**: All operations now return v1.1 format (`{"results": [...]}`)
-
-#### **What Changed:**
-- ✅ **Consistent response format**: Everything returns v1.1 format
-- ✅ **Simplified API**: No more `output_format` or `version` parameters to manage
-- ✅ **Endpoint optimization**: Add uses v1, Search/Get use v2 for best performance
-- ❌ **Removed v1.0 support**: v1.0 response format is no longer supported
-
-### 3. Response Format Standardization
-
-**Before (0.x):**
-```python
-# Inconsistent response formats based on api_version
-result = memory.add(messages)
-# Could return list or dict depending on version
-
-memories = memory.get_all()  
-# Could return list or dict depending on version
-```
-
-**After (1.0.0):**
-```python
-# v1.1 format is now default (consistent dict format)
-result = memory.add(messages)
-# Returns: {"results": [...], "relations": [...] (if graph enabled)}
-
-memories = memory.get_all()
-# Returns: {"results": [...], "relations": [...] (if graph enabled)}
-
-# v1.0 format still works but shows deprecation warning
-memory_v1 = Memory(config=MemoryConfig(version="v1.0"))
-result = memory_v1.add(messages)  # Returns raw list [{...}] (with warning)
-```
-
-## Migration Steps
-
-### Step 1: Update Dependencies
+### 1. Install the Update
 
 ```bash
 pip install mem0ai==1.0.0
 ```
 
-### Step 2: Update Code
+### 2. Update Your Code
 
-#### Memory API Changes
+**If you're using the Memory API:**
 
 ```python
 # Before
-from mem0 import Memory
-
 memory = Memory(config=MemoryConfig(version="v1.1"))
-
-# After - no changes needed, v1.1 is automatic
-from mem0 import Memory
-
-memory = Memory()  # Defaults to v1.1 format
-```
-
-#### Client API Changes
-
-```python
-# Before
-from mem0 import MemoryClient
-
-client = MemoryClient(api_key="your-key")
-
-# Remove all version and output_format parameters
-result = client.add(messages, output_format="v1.1")
-memories = client.search(query, version="v2", output_format="v1.1")
-all_memories = client.get_all(version="v2", output_format="v1.1")
+result = memory.add("I like pizza")
 
 # After
-from mem0 import MemoryClient
-
-client = MemoryClient(api_key="your-key")
-
-# Simplified API calls
-result = client.add(messages)
-memories = client.search(query)
-all_memories = client.get_all()
+memory = Memory()  # That's it - version is automatic now
+result = memory.add("I like pizza")
 ```
 
-#### Response Handling
+**If you're using the Client API:**
 
 ```python
-# Before - inconsistent response formats
-result = memory.add(messages)
-if isinstance(result, list):
-    # Handle v1.0 format
-    for item in result:
-        print(item)
-else:
-    # Handle v1.1+ format
-    for item in result["results"]:
-        print(item)
+# Before
+client.add(messages, output_format="v1.1")
+client.search(query, version="v2", output_format="v1.1")
 
-# After - consistent response format
-result = memory.add(messages)
-for item in result["results"]:
+# After
+client.add(messages)  # Just remove those extra parameters
+client.search(query)
+```
+
+### 3. Update How You Handle Responses
+
+All responses now use the same format: a dictionary with `"results"` key.
+
+```python
+# Before - you might have done this
+result = memory.add("I like pizza")
+for item in result:  # Treating it as a list
     print(item)
 
-# Access graph relations if enabled
+# After - do this instead
+result = memory.add("I like pizza")
+for item in result["results"]:  # Access the results key
+    print(item)
+
+# Graph relations (if you use them)
 if "relations" in result:
     for relation in result["relations"]:
         print(relation)
 ```
 
-### Step 3: Remove Deprecated Code
+---
 
-Remove any code that handled multiple API versions:
+## Enhanced Message Handling
+
+The platform client (MemoryClient) now supports the same flexible message formats as the OSS version:
 
 ```python
-# Remove these patterns
-if version == "v1.0":
-    # handle old format
-elif version == "v1.1":
-    # handle new format
+from mem0 import MemoryClient
 
-# Remove version-specific logic
-def handle_response(response, api_version):
-    if api_version == "v1.0":
-        return response  # list format
-    else:
-        return response["results"]  # dict format
+client = MemoryClient(api_key="your-key")
+
+# All three formats now work:
+
+# 1. Single string (automatically converted to user message)
+client.add("I like pizza", user_id="alice")
+
+# 2. Single message dictionary
+client.add({"role": "user", "content": "I like pizza"}, user_id="alice")
+
+# 3. List of messages (conversation)
+client.add([
+    {"role": "user", "content": "I like pizza"},
+    {"role": "assistant", "content": "I'll remember that!"}
+], user_id="alice")
 ```
 
-### Step 4: Update Configuration
+### Async Mode Configuration
 
-#### Vector Store Configuration
+The `async_mode` parameter now defaults to `True` but can be configured:
 
 ```python
-# Before - version in config
+# Default behavior (async_mode=True)
+client.add(messages, user_id="alice")
+
+# Explicitly set async mode
+client.add(messages, user_id="alice", async_mode=True)
+
+# Disable async mode if needed
+client.add(messages, user_id="alice", async_mode=False)
+```
+
+**Note:** `async_mode=True` provides better performance for most use cases. Only set it to `False` if you have specific synchronous processing requirements.
+
+---
+
+## That's It!
+
+For most users, that's all you need to know. The changes are:
+- ✅ No more `version` or `output_format` parameters
+- ✅ Consistent `{"results": [...]}` response format
+- ✅ Cleaner, simpler API
+
+---
+
+## Common Issues
+
+**Getting `KeyError: 'results'`?**
+
+Your code is still treating the response as a list. Update it:
+```python
+# Change this:
+for memory in response:
+
+# To this:
+for memory in response["results"]:
+```
+
+**Getting `TypeError: unexpected keyword argument`?**
+
+You're still passing old parameters. Remove them:
+```python
+# Change this:
+client.add(messages, output_format="v1.1")
+
+# To this:
+client.add(messages)
+```
+
+**Seeing deprecation warnings?**
+
+Remove any explicit `version="v1.0"` from your config:
+```python
+# Change this:
+memory = Memory(config=MemoryConfig(version="v1.0"))
+
+# To this:
+memory = Memory()
+```
+
+---
+
+## What's New in 1.0.0
+
+- **Better vector stores:** Fixed OpenSearch and improved reliability across all stores
+- **Cleaner API:** One way to do things, no more confusing options
+- **Enhanced GCP support:** Better Vertex AI configuration options
+- **Flexible message input:** Platform client now accepts strings, dicts, and lists (aligned with OSS)
+- **Configurable async_mode:** Now defaults to `True` but users can override if needed
+
+---
+
+## Need Help?
+
+- Check [GitHub Issues](https://github.com/mem0ai/mem0/issues)
+- Read the [documentation](https://docs.mem0.ai/)
+- Open a new issue if you're stuck
+
+---
+
+## Advanced: Configuration Changes
+
+**If you configured vector stores with version:**
+
+```python
+# Before
 config = MemoryConfig(
     version="v1.1",
     vector_store=VectorStoreConfig(...)
 )
 
-# After - no version needed
+# After
 config = MemoryConfig(
     vector_store=VectorStoreConfig(...)
 )
 ```
 
-#### Enhanced GCP Support
-
-```python
-# New: Enhanced Vertex AI configuration options
-from mem0.configs.vector_stores.vertex_ai_vector_search import GoogleMatchingEngineConfig
-
-# Option 1: Using credentials file (existing)
-config = GoogleMatchingEngineConfig(
-    project_id="your-project",
-    credentials_path="/path/to/service-account.json",
-    # ... other params
-)
-
-# Option 2: Using credentials dict (new in v1.0.0)
-service_account_info = {
-    "type": "service_account",
-    "project_id": "your-project",
-    # ... rest of service account JSON
-}
-
-config = GoogleMatchingEngineConfig(
-    project_id="your-project",
-    service_account_json=service_account_info,
-    # ... other params
-)
-```
+---
 
 ## Testing Your Migration
 
-### 1. Test Basic Functionality
+Quick sanity check:
 
 ```python
 from mem0 import Memory
 
-# Test memory operations
 memory = Memory()
 
-# Test adding memories
-result = memory.add("I like pizza")
+# Add should return a dict with "results"
+result = memory.add("I like pizza", user_id="test")
 assert "results" in result
-assert len(result["results"]) > 0
 
-# Test searching
-search_result = memory.search("food preferences", user_id="test_user")
-assert "results" in search_result
+# Search should return a dict with "results"
+search = memory.search("food", user_id="test")
+assert "results" in search
 
-# Test listing all
-all_memories = memory.get_all(user_id="test_user")
+# Get all should return a dict with "results"
+all_memories = memory.get_all(user_id="test")
 assert "results" in all_memories
+
+print("✅ Migration successful!")
 ```
-
-### 2. Test Client Operations
-
-```python
-from mem0 import MemoryClient
-
-client = MemoryClient(api_key="your-api-key")
-
-# Test all client methods work without deprecated parameters
-messages = [{"role": "user", "content": "I love traveling"}]
-result = client.add(messages, user_id="test_user")
-assert "results" in result or isinstance(result, list)  # Platform may vary
-
-memories = client.search("travel", user_id="test_user")
-all_memories = client.get_all(user_id="test_user")
-```
-
-## New Features in v1.0.0
-
-### 1. Improved Vector Store Support
-
-- Fixed OpenSearch vector store integration
-- Enhanced error handling across all vector stores
-- Better performance and reliability
-
-### 2. Enhanced GCP Integration
-
-- Support for service account JSON dict (in addition to file path)
-- Improved Vertex AI Vector Search configuration
-
-### 3. Simplified API
-
-- Default API version is now v1.1 (v1.0 deprecated)
-- Removed deprecated parameters
-- Standardized response formats
-
-## Deprecation Warning for v1.0 Users
-
-If you're currently using `version="v1.0"`, you'll see a deprecation warning:
-
-```
-DeprecationWarning: The v1.0 API format is deprecated and will be removed in mem0ai 2.0.0. 
-Please upgrade to v1.1 format which returns a dict with 'results' key. 
-Set version='v1.1' in your MemoryConfig.
-```
-
-**To resolve this:**
-```python
-# Before (shows warning)
-memory = Memory(config=MemoryConfig(version="v1.0"))
-
-# After (no warning)
-memory = Memory()  # Uses v1.1 by default
-# OR explicitly set v1.1
-memory = Memory(config=MemoryConfig(version="v1.1"))
-```
-
-## Common Issues and Solutions
-
-### Issue 1: "KeyError: 'results'"
-
-**Problem:** Your code expects the old list format response.
-
-**Solution:** Update response handling:
-```python
-# Before
-for memory in response:  # Assuming response is a list
-    print(memory)
-
-# After  
-for memory in response["results"]:
-    print(memory)
-```
-
-### Issue 2: "TypeError: unexpected keyword argument 'output_format'"
-
-**Problem:** Code still passing deprecated parameters.
-
-**Solution:** Remove all deprecated parameters:
-```python
-# Before
-client.add(messages, output_format="v1.1", async_mode=True)
-
-# After
-client.add(messages)
-```
-
-### Issue 3: Vector Store Connection Issues
-
-**Problem:** Vector store tests failing after upgrade.
-
-**Solution:** The OpenSearch integration has been fixed. Update your test configurations and retry.
-
-## Support
-
-If you encounter issues during migration:
-
-1. Check the [GitHub Issues](https://github.com/mem0ai/mem0/issues) for similar problems
-2. Review the updated [API documentation](https://docs.mem0.ai/)  
-3. Create a new issue with your specific migration problem
-
-## Summary
-
-mem0ai 1.0.0 provides a cleaner, more consistent API while removing deprecated features. The migration primarily involves:
-
-1. Removing deprecated parameters (`output_format`, `version`, `async_mode`)
-2. Updating response handling to expect consistent `{"results": [...]}` format
-3. Updating dependencies to v1.0.0
-
-Most applications will require minimal changes, mainly removing deprecated parameters and updating response parsing logic.

README.md

@@ -97,7 +97,7 @@ npm install mem0ai
 
 ### Basic Usage
 
-Mem0 requires an LLM to function, with `gpt-4o-mini` from OpenAI as the default. However, it supports a variety of LLMs; for details, refer to our [Supported LLMs documentation](https://docs.mem0.ai/components/llms/overview).
+Mem0 requires an LLM to function, with `gpt-4.1-nano-2025-04-14 from OpenAI as the default. However, it supports a variety of LLMs; for details, refer to our [Supported LLMs documentation](https://docs.mem0.ai/components/llms/overview).
 
 First step is to instantiate the memory:
 
@@ -116,7 +116,7 @@ def chat_with_memories(message: str, user_id: str = "default_user") -> str:
     # Generate Assistant response
     system_prompt = f"You are a helpful AI. Answer the question based on query and memories.\nUser Memories:\n{memories_str}"
     messages = [{"role": "system", "content": system_prompt}, {"role": "user", "content": message}]
-    response = openai_client.chat.completions.create(model="gpt-4o-mini", messages=messages)
+    response = openai_client.chat.completions.create(model="gpt-4.1-nano-2025-04-14", messages=messages)
     assistant_response = response.choices[0].message.content
 
     # Create new memories from the conversation
@@ -168,4 +168,4 @@ We now have a paper you can cite:
 
 ## ⚖️ License
 
-Apache 2.0 — see the [LICENSE](LICENSE) file for details.
+Apache 2.0 — see the [LICENSE](https://github.com/mem0ai/mem0/blob/main/LICENSE) file for details.

docs/_snippets/paper-release.mdx

@@ -1,3 +1,3 @@
 <Note type="info">
-  📢 Announcing our research paper: Mem0 achieves <strong>26%</strong> higher accuracy than OpenAI Memory, <strong>91%</strong> lower latency, and <strong>90%</strong> token savings! [Read the paper](https://mem0.ai/research) to learn how we're revolutionizing AI agent memory.
+  <strong>🎉 Mem0 1.0.0 is here!</strong> Enhanced filtering, reranking, and smarter memory management.
 </Note>

docs/api-reference.mdx

@@ -6,35 +6,58 @@ iconType: "solid"
 
 Mem0 provides a powerful set of APIs that allow you to integrate advanced memory management capabilities into your applications. Our APIs are designed to be intuitive, efficient, and scalable, enabling you to create, retrieve, update, and delete memories across various entities such as users, agents, apps, and runs.
 
-## Key Features
+## Quick Start Guide
 
-- **Memory Management**: Add, retrieve, update, and delete memories with ease.
-- **Entity-based Operations**: Perform operations on memories associated with specific users, agents, apps, or runs.
-- **Advanced Search**: Utilize our search API to find relevant memories based on various criteria.
-- **History Tracking**: Access the history of memory interactions for comprehensive analysis.
-- **User Management**: Manage user entities and their associated memories.
+Get started with Mem0 API in three simple steps:
+
+1. **[Add Memories](/api-reference/memory/add-memories)** - Store information and context from user conversations
+2. **[Search Memories](/api-reference/memory/v2-search-memories)** - Retrieve relevant memories based on queries
+3. **[Get Memories](/api-reference/memory/v2-get-memories)** - Fetch all memories for a specific entity
+
+### Common Operations
+
+<CardGroup cols={2}>
+  <Card title="Add Memories" icon="plus" href="/api-reference/memory/add-memories">
+    Store new memories from conversations and interactions
+  </Card>
+  <Card title="Search Memories" icon="magnifying-glass" href="/api-reference/memory/v2-search-memories">
+    Find relevant memories using semantic search
+  </Card>
+  <Card title="Update Memory" icon="pen" href="/api-reference/memory/update-memory">
+    Modify existing memory content
+  </Card>
+  <Card title="Delete Memory" icon="trash" href="/api-reference/memory/delete-memory">
+    Remove specific memories or batch delete
+  </Card>
+</CardGroup>
 
 ## API Structure
 
 Our API is organized into several main categories:
 
-1. **Memory APIs**: Core operations for managing individual memories and collections.
-2. **Entities APIs**: Manage different entity types (users, agents, etc.) and their associated memories.
-3. **Search API**: Advanced search functionality to retrieve relevant memories.
-4. **History API**: Track and retrieve the history of memory interactions.
+1. **[Memory APIs](#memory-apis)**: Core operations for managing individual memories and collections
+2. **[Entities APIs](#entities-apis)**: Manage different entity types (users, agents, etc.) and their associated memories
+3. **[Organizations APIs](#organizations-apis)**: Manage organizations and their members (optional)
+4. **[Project APIs](#project-apis)**: Manage projects within organizations (optional)
 
 ## Authentication
 
-All API requests require authentication using HTTP Basic Auth. Ensure you include your API key in the Authorization header of each request.
+All API requests require authentication using Token-based authentication. Include your API key in the Authorization header:
+
+```bash
+Authorization: Token <your-api-key>
+```
+
+Get your API key from the [Mem0 Dashboard](https://app.mem0.ai/dashboard/api-keys).
 
 ## Organizations and projects (optional)
 
 Organizations and projects provide the following capabilities:
 
-- **Multi-org/project Support**: Specify organization and project when initializing the Mem0 client to attribute API usage appropriately
-- **Member Management**: Control access to data through organization and project membership
-- **Access Control**: Only members can access memories and data within their organization/project scope
-- **Team Isolation**: Maintain data separation between different teams and projects for secure collaboration
+- **Multi-org/project Support**: Specify organization and project when initializing the Mem0 client to attribute API usage appropriately.
+- **Member Management**: Control access to data through organization and project membership.
+- **Access Control**: Only members can access memories and data within their organization/project scope.
+- **Team Isolation**: Maintain data separation between different teams and projects for secure collaboration.
 
 Example with the mem0 Python package:
 
@@ -157,8 +180,8 @@ client.project.remove_member(email="colleague@company.com")
 
 #### Member Roles
 
-- **READER**: Can view and search memories, but cannot modify project settings or manage members
-- **OWNER**: Full access including project modification, member management, and all reader permissions
+- **READER**: Can view and search memories, but cannot modify project settings or manage members.
+- **OWNER**: Full access including project modification, member management, and all reader permissions.
 
 #### Async Support
 

docs/api-reference/memory/add-memories.mdx

@@ -1,4 +1,12 @@
 ---
 title: 'Add Memories'
 openapi: post /v1/memories/
----
+---
+
+## Graph Memory
+
+To enable graph-based memory relationships, pass the `enable_graph=True` parameter. This creates relationships between entities in your memories for more contextual retrieval.
+
+<Note>
+Learn more in the [Graph Memory documentation](/platform/features/graph-memory).
+</Note>

docs/api-reference/memory/create-memory-export.mdx

@@ -3,4 +3,4 @@ title: 'Create Memory Export'
 openapi: post /v1/exports/
 ---
 
-Submit a job to create a structured export of memories using a customizable Pydantic schema. This process may take some time to complete, especially if you’re exporting a large number of memories. You can tailor the export by applying various filters (e.g., user_id, agent_id, run_id, or session_id) and by modifying the Pydantic schema to ensure the final data matches your exact needs.
+Submit a job to create a structured export of memories using a customizable Pydantic schema. This process may take some time to complete, especially if you're exporting a large number of memories. You can tailor the export by applying various filters (e.g., `user_id`, `agent_id`, `run_id`, or `session_id`) and by modifying the Pydantic schema to ensure the final data matches your exact needs.

docs/api-reference/memory/get-memories.mdx

@@ -25,8 +25,7 @@ memories = m.get_all(
                 "created_at": {"gte": "2024-07-01", "lte": "2024-07-31"}
             }
         ]
-    },
-    version="v2"
+    }
 )
 ```
 
@@ -58,8 +57,15 @@ memories = m.get_all(
                 "run_id": "*"
             }
         ]
-    },
-    version="v2"
+    }
 )
 ```
 </CodeGroup>
+
+## Graph Memory
+
+To retrieve memories with graph-based relationships, pass the `enable_graph=True` parameter. This includes relationship data in the response for more contextual results.
+
+<Note>
+Learn more in the [Graph Memory documentation](/platform/features/graph-memory).
+</Note>

docs/api-reference/memory/search-memories.mdx

@@ -0,0 +1,104 @@
+---
+title: 'Search Memories'
+openapi: post /v2/memories/search/
+---
+
+The v2 search API is powerful and flexible, allowing for more precise memory retrieval. It supports complex logical operations (AND, OR, NOT) and comparison operators for advanced filtering capabilities. The comparison operators include:
+- `in`: Matches any of the values specified
+- `gte`: Greater than or equal to
+- `lte`: Less than or equal to
+- `gt`: Greater than
+- `lt`: Less than
+- `ne`: Not equal to
+- `icontains`: Case-insensitive containment check
+- `*`: Wildcard character that matches everything
+
+<CodeGroup>
+```python Code
+related_memories = m.search(
+    query="What are Alice's hobbies?",
+    filters={
+        "OR": [
+            {
+              "user_id": "alice"
+            },
+            {
+              "agent_id": {"in": ["travel-agent", "sports-agent"]}
+            }
+        ]
+    },
+)
+```
+
+```json Output
+{
+  "memories": [
+    {
+      "id": "ea925981-272f-40dd-b576-be64e4871429",
+      "memory": "Likes to play cricket and plays cricket on weekends.",
+      "metadata": {
+        "category": "hobbies"
+      },
+      "score": 0.32116443111457704,
+      "created_at": "2024-07-26T10:29:36.630547-07:00",
+      "updated_at": null,
+      "user_id": "alice",
+      "agent_id": "sports-agent"
+    }
+  ],
+}
+```
+</CodeGroup>
+
+<CodeGroup>
+```python Wildcard Example
+# Using wildcard to match all run_ids for a specific user
+all_memories = m.search(
+    query="What are Alice's hobbies?",
+    filters={
+        "AND": [
+            {
+                "user_id": "alice"
+            },
+            {
+                "run_id": "*"
+            }
+        ]
+    },
+)
+```
+</CodeGroup>
+
+<CodeGroup>
+```python Categories Filter Examples
+# Example 1: Using 'contains' for partial matching
+finance_memories = m.search(
+    query="What are my financial goals?",
+    filters={
+        "AND": [
+            { "user_id": "alice" },
+            {
+                "categories": {
+                    "contains": "finance"
+                }
+            }
+        ]
+    },
+)
+
+# Example 2: Using 'in' for exact matching
+personal_memories = m.search(
+    query="What personal information do you have?",
+    filters={
+        "AND": [
+            { "user_id": "alice" },
+            {
+                "categories": {
+                    "in": ["personal_information"]
+                }
+            }
+        ]
+    },
+)
+```
+</CodeGroup>

docs/api-reference/memory/v1-get-memories.mdx

@@ -1,4 +0,0 @@
----
-title: 'Get Memories (v1 - Deprecated)'
-openapi: get /v1/memories/
----

docs/api-reference/memory/v1-search-memories.mdx

@@ -1,4 +0,0 @@
----
-title: 'Search Memories (v1 - Deprecated)'
-openapi: post /v1/memories/search/
----

docs/api-reference/memory/v2-search-memories.mdx

@@ -1,108 +0,0 @@
----
-title: 'Search Memories (v2)'
-openapi: post /v2/memories/search/
----
-
-The v2 search API is powerful and flexible, allowing for more precise memory retrieval. It supports complex logical operations (AND, OR, NOT) and comparison operators for advanced filtering capabilities. The comparison operators include:
-- `in`: Matches any of the values specified
-- `gte`: Greater than or equal to
-- `lte`: Less than or equal to
-- `gt`: Greater than
-- `lt`: Less than
-- `ne`: Not equal to
-- `icontains`: Case-insensitive containment check
-- `*`: Wildcard character that matches everything
-
-  <CodeGroup>
-  ```python Code
-  related_memories = m.search(
-      query="What are Alice's hobbies?",
-      version="v2",
-      filters={
-          "OR": [
-              {
-                "user_id": "alice"
-              },
-              {
-                "agent_id": {"in": ["travel-agent", "sports-agent"]}
-              }
-          ]
-      },
-  )
-  ```
-
-  ```json Output
-  {
-    "memories": [
-      {
-        "id": "ea925981-272f-40dd-b576-be64e4871429",
-        "memory": "Likes to play cricket and plays cricket on weekends.",
-        "metadata": {
-          "category": "hobbies"
-        },
-        "score": 0.32116443111457704,
-        "created_at": "2024-07-26T10:29:36.630547-07:00",
-        "updated_at": null,
-        "user_id": "alice",
-        "agent_id": "sports-agent"
-      }
-    ],
-  }
-  ```
-  </CodeGroup>
-
-  <CodeGroup>
-  ```python Wildcard Example
-  # Using wildcard to match all run_ids for a specific user
-  all_memories = m.search(
-      query="What are Alice's hobbies?",
-      version="v2",
-      filters={
-          "AND": [
-              {
-                  "user_id": "alice"
-              },
-              {
-                  "run_id": "*"
-              }
-          ]
-      },
-  )
-  ```
-  </CodeGroup>
-
-  <CodeGroup>
-  ```python Categories Filter Examples
-  # Example 1: Using 'contains' for partial matching
-  finance_memories = m.search(
-      query="What are my financial goals?",
-      version="v2",
-      filters={
-          "AND": [
-              { "user_id": "alice" },
-              {
-                  "categories": {
-                      "contains": "finance"
-                  }
-              }
-          ]
-      },
-  )
-
-  # Example 2: Using 'in' for exact matching
-  personal_memories = m.search(
-      query="What personal information do you have?",
-      version="v2",
-      filters={
-          "AND": [
-              { "user_id": "alice" },
-              {
-                  "categories": {
-                      "in": ["personal_information"]
-                  }
-              }
-          ]
-      },
-  )
-  ```
-  </CodeGroup>

docs/api-reference/webhook/create-webhook.mdx

@@ -3,7 +3,3 @@ title: 'Create Webhook'
 openapi: post /api/v1/webhooks/projects/{project_id}/
 ---
 
-## Create Webhook
-
-Create a webhook by providing the project ID and the webhook details.
-

docs/api-reference/webhook/delete-webhook.mdx

@@ -2,7 +2,3 @@
 title: 'Delete Webhook'
 openapi: delete /api/v1/webhooks/{webhook_id}/
 ---
-
-## Delete Webhook
-
-Delete a webhook by providing the webhook ID.

docs/api-reference/webhook/get-webhook.mdx

@@ -3,7 +3,3 @@ title: 'Get Webhook'
 openapi: get /api/v1/webhooks/projects/{project_id}/
 ---
 
-## Get Webhook
-
-Get a webhook by providing the project ID.
-

docs/api-reference/webhook/update-webhook.mdx

@@ -3,7 +3,3 @@ title: 'Update Webhook'
 openapi: put /api/v1/webhooks/{webhook_id}/
 ---
 
-## Update Webhook
-
-Update a webhook by providing the webhook ID and the fields to update.
-

docs/changelog.mdx

@@ -7,6 +7,42 @@ mode: "wide"
 <Tabs>
 <Tab title="Python">
 
+<Update label="2025-09-25" description="v0.1.118">
+
+**New Features & Updates:**
+- **Vector Stores:**
+  - Added Valkey vector store support
+  - Added support for ChromaDB Cloud
+  - Added Mem0 vector store backend integration for Neptune Analytics
+- **Graph Store:**
+  - Added Neptune-DB graph store with vector store
+- **Core:**
+  - Implemented structured exception classes with error codes and suggested actions
+
+**Improvements:**
+- **Dependencies:**
+  - Updated OpenAI dependency and improved Ollama compatibility
+- **Testing:**
+  - Added Weaviate DB test
+  - Added comprehensive test suite for SQLiteManager
+- **Documentation:**
+  - Updated category docs
+  - Updated Search V2 / Get All V2 filters documentation
+  - Refactored AWS example title
+  - Fixed Quickstart cURL example
+
+**Bug Fixes:**
+- **Vector Stores:**
+  - Databricks bug fixes
+  - Fixed S3 Vectors memory initialization issue from configuration
+- **Core:**
+  - Fixed JSON parsing with new memories
+  - Replaced hardcoded LLM provider with provider from configuration
+- **LLMs:**
+  - Fixed Bedrock Anthropic models to use system field
+
+</Update>
+
 <Update label="2025-09-03" description="v0.1.117">
 
 **New Features & Updates:**
@@ -637,17 +673,17 @@ mode: "wide"
 </Update>
 
 <Update label="2025-06-24" description="v2.1.33">
-**Improvement :**
+**Improvement:**
 - **Client:** Added `immutable` param to `add` method.
 </Update>
 
 <Update label="2025-06-20" description="v2.1.32">
-**Improvement :**
+**Improvement:**
 - **Client:** Made `api_version` V2 as default.
 </Update>
 
 <Update label="2025-06-17" description="v2.1.31">
-**Improvement :**
+**Improvement:**
 - **Client:** Added param `filter_memories`.
 </Update>
 
@@ -1087,6 +1123,16 @@ mode: "wide"
 
 <Tab title="Vercel AI SDK">
 
+<Update label="2025-09-25" description="v2.0.4">
+**Bug Fix:**
+- **Vercel AI SDK:** Fixed version parameter in the AI SDK to use V2 for addition.
+</Update>
+
+<Update label="2025-09-25" description="v2.0.3">
+**New Features:**
+- **Vercel AI SDK:** Added file support for multimodal capabilities with memory context
+</Update>
+
 <Update label="2025-09-03" description="v2.0.2">
 **Bug Fix:**
 - **Vercel AI SDK:** Fixed streaming response in the AI SDK.

docs/components/embedders/models/aws_bedrock.mdx

@@ -41,7 +41,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]

docs/components/embedders/models/azure_openai.mdx

@@ -23,7 +23,7 @@ config = {
     "embedder": {
         "provider": "azure_openai",
         "config": {
-            "model": "text-embedding-3-large"
+            "model": "text-embedding-3-large",
             "azure_kwargs": {
                   "api_version": "",
                   "azure_deployment": "",
@@ -40,7 +40,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]
@@ -68,7 +68,7 @@ const memory = new Memory(config);
 
 const messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]
@@ -117,9 +117,20 @@ Refer to [Azure Identity troubleshooting tips](https://github.com/Azure/azure-sd
 ### Config
 
 Here are the parameters available for configuring Azure OpenAI embedder:
-
+<Tabs>
+<Tab title="Python">
 | Parameter | Description | Default Value |
 | --- | --- | --- |
 | `model` | The name of the embedding model to use | `text-embedding-3-small` |
 | `embedding_dims` | Dimensions of the embedding model | `1536` |
 | `azure_kwargs` | The Azure OpenAI configs | `config_keys` |
+</Tab>
+<Tab title="TypeScript">
+| Parameter         | Description                                   | Default Value              |
+| ----------------- | --------------------------------------------- | -------------------------- |
+| `model`           | The name of the embedding model to use        | `text-embedding-3-small`   |
+| `embeddingDims`   | Dimensions of the embedding model             | `1536`                     |
+| `apiKey`          | Azure OpenAI API key                          | `None`                     |
+| `modelProperties` | Object containing endpoint and other settings | `{ endpoint: "",...rest   }`|
+</Tab>
+</Tabs>

docs/components/embedders/models/google_AI.mdx

@@ -26,7 +26,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]
@@ -38,19 +38,19 @@ import { Memory } from 'mem0ai/oss';
 
 const config = {
   embedder: {
-    provider: 'google',
-    config: {
-      apiKey: process.env.GOOGLE_API_KEY || '',
-      model: 'text-embedding-004',
-      // The output dimensionality is fixed at 768 for Google AI embeddings
+      provider: "google",
+      config: {
+        apiKey: process.env["GOOGLE_API_KEY"],
+        model: "gemini-embedding-001",
+        embeddingDims: 1536,
+      },
     },
-  },
 };
 
 const memory = new Memory(config);
 const messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]
@@ -61,9 +61,19 @@ await memory.add(messages, { userId: "john" });
 ### Config
 
 Here are the parameters available for configuring Gemini embedder:
-
-| Parameter | Description | Default Value |
-| --- | --- | --- |
-| `model` | The name of the embedding model to use | `models/text-embedding-004` |
-| `embedding_dims` | Dimensions of the embedding model (output_dimensionality will be considered as embedding_dims, so please set embedding_dims accordingly) | `768` |
-| `api_key` | The Google API key | `None` |
+<Tabs>
+<Tab title="Python">
+| Parameter        | Description                          | Default Value           |
+| ---------------- | ------------------------------------ | ----------------------- |
+| `model`          | The name of the embedding model to use| `models/text-embedding-004` |
+| `embedding_dims` | Dimensions of the embedding model     | `1536`                  |
+| `api_key`        | The Google API key                   | `None`                  |
+</Tab>
+<Tab title="TypeScript">
+| Parameter         | Description                                   | Default Value              |
+| ----------------- | --------------------------------------------- | -------------------------- |
+| `model`           | The name of the embedding model to use        | `gemini-embedding-001`     |
+| `embeddingDims`   | Dimensions of the embedding model             | `1536`                     |
+| `apiKey`          | Google API key                                | `None`                     |
+</Tab>
+</Tabs>

docs/components/embedders/models/huggingface.mdx

@@ -24,7 +24,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]

docs/components/embedders/models/langchain.mdx

@@ -36,7 +36,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]
@@ -66,7 +66,7 @@ const config = {
 const memory = new Memory(config);
 const messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]

docs/components/embedders/models/lmstudio.mdx

@@ -20,7 +20,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]
@@ -29,10 +29,10 @@ m.add(messages, user_id="john")
 
 ### Config
 
-Here are the parameters available for configuring Ollama embedder:
+Here are the parameters available for configuring LM Studio embedder:
 
 | Parameter | Description | Default Value |
 | --- | --- | --- |
-| `model` | The name of the OpenAI model to use | `nomic-embed-text-v1.5-GGUF/nomic-embed-text-v1.5.f16.gguf` |
+| `model` | The name of the LM Studio model to use | `nomic-embed-text-v1.5-GGUF/nomic-embed-text-v1.5.f16.gguf` |
 | `embedding_dims` | Dimensions of the embedding model | `1536` |
 | `lmstudio_base_url` | Base URL for LM Studio connection | `http://localhost:1234/v1` |

docs/components/embedders/models/ollama.mdx

@@ -21,7 +21,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]
@@ -44,7 +44,7 @@ const config = {
 const memory = new Memory(config);
 const messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]
@@ -69,5 +69,6 @@ Here are the parameters available for configuring Ollama embedder:
 | --- | --- | --- |
 | `model` | The name of the Ollama model to use | `nomic-embed-text:latest` |
 | `url` | Base URL for Ollama server | `http://localhost:11434` |
+| `embeddingDims` | Dimensions of the embedding model | 768
 </Tab>
 </Tabs>

docs/components/embedders/models/openai.mdx

@@ -25,7 +25,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]

docs/components/embedders/models/together.mdx

@@ -27,7 +27,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]

docs/components/embedders/models/vertexai.mdx

@@ -27,7 +27,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]

docs/components/embedders/overview.mdx

@@ -29,6 +29,6 @@ See the list of supported embedders below.
 
 ## Usage
 
-To utilize a embedder, you must provide a configuration to customize its usage. If no configuration is supplied, a default configuration will be applied, and `OpenAI` will be used as the embedder.
+To utilize an embedding model, you must provide a configuration to customize its usage. If no configuration is supplied, a default configuration will be applied, and `OpenAI` will be used as the embedding model.
 
-For a comprehensive list of available parameters for embedder configuration, please refer to [Config](./config).
+For a comprehensive list of available parameters for embedding model configuration, please refer to [Config](./config).

docs/components/llms/models/anthropic.mdx

@@ -29,7 +29,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]
@@ -54,7 +54,7 @@ const config = {
 const memory = new Memory(config);
 const messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]

docs/components/llms/models/aws_bedrock.mdx

@@ -31,7 +31,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]

docs/components/llms/models/azure_openai.mdx

@@ -48,7 +48,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]
@@ -77,7 +77,7 @@ const config = {
 const memory = new Memory(config);
 const messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]

docs/components/llms/models/deepseek.mdx

@@ -28,7 +28,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]

docs/components/llms/models/groq.mdx

@@ -30,7 +30,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]
@@ -55,7 +55,7 @@ const config = {
 const memory = new Memory(config);
 const messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]

docs/components/llms/models/langchain.mdx

@@ -20,7 +20,7 @@ os.environ["OPENAI_API_KEY"] = "your-api-key"
 
 # Initialize a LangChain model directly
 openai_model = ChatOpenAI(
-    model="gpt-4o",
+    model="gpt-4.1-nano-2025-04-14",
     temperature=0.2,
     max_tokens=2000
 )
@@ -38,7 +38,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]
@@ -69,7 +69,7 @@ const config = {
 const memory = new Memory(config);
 const messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]

docs/components/llms/models/litellm.mdx

@@ -12,7 +12,7 @@ config = {
     "llm": {
         "provider": "litellm",
         "config": {
-            "model": "gpt-4o-mini",
+            "model": "gpt-4.1-nano-2025-04-14",
             "temperature": 0.2,
             "max_tokens": 2000,
         }
@@ -22,7 +22,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]

docs/components/llms/models/lmstudio.mdx

@@ -29,7 +29,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]
@@ -57,7 +57,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]

docs/components/llms/models/mistral_AI.mdx

@@ -28,7 +28,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]
@@ -53,7 +53,7 @@ const config = {
 const memory = new Memory(config);
 const messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]

docs/components/llms/models/ollama.mdx

@@ -1,4 +1,8 @@
-You can use LLMs from Ollama to run Mem0 locally. These [models](https://ollama.com/search?c=tools) support tool support.
+---
+title: Ollama
+---
+
+You can use LLMs from Ollama to run Mem0 locally. These [models](https://ollama.com/search?c=tools) support tool calling.
 
 ## Usage
 
@@ -23,7 +27,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]
@@ -47,7 +51,7 @@ const config = {
 const memory = new Memory(config);
 const messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]

docs/components/llms/models/openai.mdx

@@ -19,7 +19,7 @@ config = {
     "llm": {
         "provider": "openai",
         "config": {
-            "model": "gpt-4o",
+            "model": "gpt-4.1-nano-2025-04-14",
             "temperature": 0.2,
             "max_tokens": 2000,
         }
@@ -40,7 +40,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]
@@ -65,7 +65,7 @@ const config = {
 const memory = new Memory(config);
 const messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]
@@ -85,7 +85,7 @@ config = {
     "llm": {
         "provider": "openai_structured",
         "config": {
-            "model": "gpt-4o-2024-08-06",
+            "model": "gpt-4.1-nano-2025-04-14",
             "temperature": 0.0,
         }
     }

docs/components/llms/models/sarvam.mdx

@@ -28,7 +28,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]

docs/components/llms/models/together.mdx

@@ -1,4 +1,8 @@
-To use TogetherAI LLM models, you have to set the `TOGETHER_API_KEY` environment variable. You can obtain the TogetherAI API key from their [Account settings page](https://api.together.xyz/settings/api-keys).
+---
+title: Together
+---
+
+To use Together LLM models, you have to set the `TOGETHER_API_KEY` environment variable. You can obtain the Together API key from their [Account settings page](https://api.together.xyz/settings/api-keys).
 
 ## Usage
 
@@ -23,7 +27,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]
@@ -32,4 +36,4 @@ m.add(messages, user_id="alice", metadata={"category": "movies"})
 
 ## Config
 
-All available parameters for the `togetherai` config are present in [Master List of All Params in Config](../config).
+All available parameters for the `together` config are present in [Master List of All Params in Config](../config).

docs/components/llms/models/xAI.mdx

@@ -29,7 +29,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]

docs/components/llms/overview.mdx

@@ -28,8 +28,8 @@ See the list of supported LLMs below.
   <Card title="Together" href="/components/llms/models/together" />
   <Card title="Groq" href="/components/llms/models/groq" />
   <Card title="Litellm" href="/components/llms/models/litellm" />
-  <Card title="Mistral AI" href="/components/llms/models/mistral_ai" />
-  <Card title="Google AI" href="/components/llms/models/google_ai" />
+  <Card title="Mistral AI" href="/components/llms/models/mistral_AI" />
+  <Card title="Google AI" href="/components/llms/models/google_AI" />
   <Card title="AWS bedrock" href="/components/llms/models/aws_bedrock" />
   <Card title="DeepSeek" href="/components/llms/models/deepseek" />
   <Card title="xAI" href="/components/llms/models/xAI" />

docs/components/rerankers/config.mdx

@@ -42,6 +42,14 @@ All rerankers share these common configuration parameters:
 | `batch_size` | Batch size for processing | `int` | `32` |
 | `show_progress_bar` | Show progress during processing | `bool` | `False` |
 
+### Hugging Face
+
+| Parameter | Description | Type | Default |
+|-----------|-------------|------|---------|
+| `model` | HuggingFace reranker model name | `str` | `"BAAI/bge-reranker-large"` |
+| `api_key` | HuggingFace API token | `str` | `None` |
+| `device` | Device to run model on (`cpu`, `cuda`, etc.) | `str` | `None` |
+
 ### LLM-based
 
 | Parameter | Description | Type | Default |
@@ -53,12 +61,21 @@ All rerankers share these common configuration parameters:
 | `max_tokens` | Maximum tokens for LLM response | `int` | `100` |
 | `scoring_prompt` | Custom prompt template for scoring | `str` | Default scoring prompt |
 
+### LLM Reranker
+
+| Parameter | Description | Type | Default |
+|-----------|-------------|------|---------|
+| `llm.provider` | LLM provider for reranking | `str` | Required |
+| `llm.config` | LLM configuration object | `dict` | Required |
+| `top_n` | Number of results to return | `int` | `None` |
+
 ## Environment Variables
 
 You can set API keys using environment variables:
 
 - `ZERO_ENTROPY_API_KEY` - Zero Entropy API key
 - `COHERE_API_KEY` - Cohere API key
+- `HUGGINGFACE_API_KEY` - HuggingFace API token
 - `OPENAI_API_KEY` - OpenAI API key (for LLM-based reranker)
 - `ANTHROPIC_API_KEY` - Anthropic API key (for LLM-based reranker)
 
@@ -87,4 +104,4 @@ config = {
         }
     }
 }
-```
+```

docs/components/rerankers/custom-prompts.mdx

@@ -0,0 +1,217 @@
+---
+title: Custom Prompts
+icon: "pencil"
+iconType: "solid"
+---
+
+When using LLM rerankers, you can customize the prompts used for ranking to better suit your specific use case and domain.
+
+## Default Prompt
+
+The default LLM reranker prompt is designed to be general-purpose:
+
+```
+Given a query and a list of memory entries, rank the memory entries based on their relevance to the query.
+Rate each memory on a scale of 1-10 where 10 is most relevant.
+
+Query: {query}
+
+Memory entries:
+{memories}
+
+Provide your ranking as a JSON array with scores for each memory.
+```
+
+## Custom Prompt Configuration
+
+You can provide a custom prompt template when configuring the LLM reranker:
+
+```python
+from mem0 import Memory
+
+custom_prompt = """
+You are an expert at ranking memories for a personal AI assistant.
+Given a user query and a list of memory entries, rank each memory based on:
+1. Direct relevance to the query
+2. Temporal relevance (recent memories may be more important)
+3. Emotional significance
+4. Actionability
+
+Query: {query}
+User Context: {user_context}
+
+Memory entries:
+{memories}
+
+Rate each memory from 1-10 and provide reasoning.
+Return as JSON: {{"rankings": [{{"index": 0, "score": 8, "reason": "..."}}]}}
+"""
+
+config = {
+    "reranker": {
+        "provider": "llm_reranker",
+        "config": {
+            "llm": {
+                "provider": "openai",
+                "config": {
+                    "model": "gpt-4",
+                    "api_key": "your-openai-key"
+                }
+            },
+            "custom_prompt": custom_prompt,
+            "top_n": 5
+        }
+    }
+}
+
+memory = Memory.from_config(config)
+```
+
+## Prompt Variables
+
+Your custom prompt can use the following variables:
+
+| Variable | Description |
+|----------|-------------|
+| `{query}` | The search query |
+| `{memories}` | The list of memory entries to rank |
+| `{user_id}` | The user ID (if available) |
+| `{user_context}` | Additional user context (if provided) |
+
+## Domain-Specific Examples
+
+### Customer Support
+```python
+customer_support_prompt = """
+You are ranking customer support conversation memories.
+Prioritize memories that:
+- Relate to the current customer issue
+- Show previous resolution patterns
+- Indicate customer preferences or constraints
+
+Query: {query}
+Customer Context: Previous interactions with this customer
+
+Memories:
+{memories}
+
+Rank each memory 1-10 based on support relevance.
+"""
+```
+
+### Educational Content
+```python
+educational_prompt = """
+Rank these learning memories for a student query.
+Consider:
+- Prerequisite knowledge requirements
+- Learning progression and difficulty
+- Relevance to current learning objectives
+
+Student Query: {query}
+Learning Context: {user_context}
+
+Available memories:
+{memories}
+
+Score each memory for educational value (1-10).
+"""
+```
+
+### Personal Assistant
+```python
+personal_assistant_prompt = """
+Rank personal memories for relevance to the user's query.
+Consider:
+- Recent vs. historical importance
+- Personal preferences and habits
+- Contextual relationships between memories
+
+Query: {query}
+Personal context: {user_context}
+
+Memories to rank:
+{memories}
+
+Provide relevance scores (1-10) with brief explanations.
+"""
+```
+
+## Advanced Prompt Techniques
+
+### Multi-Criteria Ranking
+```python
+multi_criteria_prompt = """
+Evaluate memories using multiple criteria:
+
+1. RELEVANCE (40%): How directly related to the query
+2. RECENCY (20%): How recent the memory is
+3. IMPORTANCE (25%): Personal or business significance
+4. ACTIONABILITY (15%): How useful for next steps
+
+Query: {query}
+Context: {user_context}
+
+Memories:
+{memories}
+
+For each memory, provide:
+- Overall score (1-10)
+- Breakdown by criteria
+- Final ranking recommendation
+
+Format: JSON with detailed scoring
+"""
+```
+
+### Contextual Ranking
+```python
+contextual_prompt = """
+Consider the following context when ranking memories:
+- Current user situation: {user_context}
+- Time of day: {current_time}
+- Recent activities: {recent_activities}
+
+Query: {query}
+
+Rank these memories considering both direct relevance and contextual appropriateness:
+{memories}
+
+Provide contextually-aware relevance scores (1-10).
+"""
+```
+
+## Best Practices
+
+1. **Be Specific**: Clearly define what makes a memory relevant for your use case
+2. **Use Examples**: Include examples in your prompt for better model understanding
+3. **Structure Output**: Specify the exact JSON format you want returned
+4. **Test Iteratively**: Refine your prompt based on actual ranking performance
+5. **Consider Token Limits**: Keep prompts concise while being comprehensive
+
+## Prompt Testing
+
+You can test different prompts by comparing ranking results:
+
+```python
+# Test multiple prompt variations
+prompts = [
+    default_prompt,
+    custom_prompt_v1,
+    custom_prompt_v2
+]
+
+for i, prompt in enumerate(prompts):
+    config["reranker"]["config"]["custom_prompt"] = prompt
+    memory = Memory.from_config(config)
+
+    results = memory.search("test query", user_id="test_user")
+    print(f"Prompt {i+1} results: {results}")
+```
+
+## Common Issues
+
+- **Too Long**: Keep prompts under token limits for your chosen LLM
+- **Too Vague**: Be specific about ranking criteria
+- **Inconsistent Format**: Ensure JSON output format is clearly specified
+- **Missing Context**: Include relevant variables for your use case

docs/components/rerankers/models/cohere.mdx

@@ -1,6 +1,6 @@
 ---
 title: Cohere
-description: 'Enterprise-grade reranking with Cohere'
+description: 'Reranking with Cohere'
 icon: "building"
 iconType: "solid"
 ---
@@ -40,7 +40,7 @@ config = {
             "model": "gpt-4o-mini"
         }
     },
-    "rerank": {
+    "reranker": {
         "provider": "cohere",
         "config": {
             "model": "rerank-english-v3.0",

docs/components/rerankers/models/huggingface.mdx

@@ -0,0 +1,352 @@
+---
+title: Hugging Face Reranker
+description: 'Access thousands of reranking models from Hugging Face Hub'
+icon: "face-smile"
+iconType: "solid"
+---
+
+## Overview
+
+The Hugging Face reranker provider gives you access to thousands of reranking models available on the Hugging Face Hub. This includes popular models like BAAI's BGE rerankers and other state-of-the-art cross-encoder models.
+
+## Configuration
+
+### Basic Setup
+
+```python
+from mem0 import Memory
+
+config = {
+    "reranker": {
+        "provider": "huggingface",
+        "config": {
+            "model": "BAAI/bge-reranker-base",
+            "device": "cpu"
+        }
+    }
+}
+
+m = Memory.from_config(config)
+```
+
+### Configuration Parameters
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `model` | str | Required | Hugging Face model identifier |
+| `device` | str | "cpu" | Device to run model on ("cpu", "cuda", "mps") |
+| `batch_size` | int | 32 | Batch size for processing |
+| `max_length` | int | 512 | Maximum input sequence length |
+| `trust_remote_code` | bool | False | Allow remote code execution |
+
+### Advanced Configuration
+
+```python
+config = {
+    "reranker": {
+        "provider": "huggingface",
+        "config": {
+            "model": "BAAI/bge-reranker-large",
+            "device": "cuda",
+            "batch_size": 16,
+            "max_length": 512,
+            "trust_remote_code": False,
+            "model_kwargs": {
+                "torch_dtype": "float16"
+            }
+        }
+    }
+}
+```
+
+## Popular Models
+
+### BGE Rerankers (Recommended)
+
+```python
+# Base model - good balance of speed and quality
+config = {
+    "reranker": {
+        "provider": "huggingface",
+        "config": {
+            "model": "BAAI/bge-reranker-base",
+            "device": "cuda"
+        }
+    }
+}
+
+# Large model - better quality, slower
+config = {
+    "reranker": {
+        "provider": "huggingface",
+        "config": {
+            "model": "BAAI/bge-reranker-large",
+            "device": "cuda"
+        }
+    }
+}
+
+# v2 models - latest improvements
+config = {
+    "reranker": {
+        "provider": "huggingface",
+        "config": {
+            "model": "BAAI/bge-reranker-v2-m3",
+            "device": "cuda"
+        }
+    }
+}
+```
+
+### Multilingual Models
+
+```python
+# Multilingual BGE reranker
+config = {
+    "reranker": {
+        "provider": "huggingface",
+        "config": {
+            "model": "BAAI/bge-reranker-v2-multilingual",
+            "device": "cuda"
+        }
+    }
+}
+```
+
+### Domain-Specific Models
+
+```python
+# For code search
+config = {
+    "reranker": {
+        "provider": "huggingface",
+        "config": {
+            "model": "microsoft/codebert-base",
+            "device": "cuda"
+        }
+    }
+}
+
+# For biomedical content
+config = {
+    "reranker": {
+        "provider": "huggingface",
+        "config": {
+            "model": "dmis-lab/biobert-base-cased-v1.1",
+            "device": "cuda"
+        }
+    }
+}
+```
+
+## Usage Examples
+
+### Basic Usage
+
+```python
+from mem0 import Memory
+
+m = Memory.from_config(config)
+
+# Add some memories
+m.add("I love hiking in the mountains", user_id="alice")
+m.add("Pizza is my favorite food", user_id="alice")
+m.add("I enjoy reading science fiction books", user_id="alice")
+
+# Search with reranking
+results = m.search(
+    "What outdoor activities do I enjoy?",
+    user_id="alice",
+    rerank=True
+)
+
+for result in results["results"]:
+    print(f"Memory: {result['memory']}")
+    print(f"Score: {result['score']:.3f}")
+```
+
+### Batch Processing
+
+```python
+# Process multiple queries efficiently
+queries = [
+    "What are my hobbies?",
+    "What food do I like?",
+    "What books interest me?"
+]
+
+results = []
+for query in queries:
+    result = m.search(query, user_id="alice", rerank=True)
+    results.append(result)
+```
+
+## Performance Optimization
+
+### GPU Acceleration
+
+```python
+# Use GPU for better performance
+config = {
+    "reranker": {
+        "provider": "huggingface",
+        "config": {
+            "model": "BAAI/bge-reranker-base",
+            "device": "cuda",
+            "batch_size": 64,  # Increase batch size for GPU
+        }
+    }
+}
+```
+
+### Memory Optimization
+
+```python
+# For limited memory environments
+config = {
+    "reranker": {
+        "provider": "huggingface",
+        "config": {
+            "model": "BAAI/bge-reranker-base",
+            "device": "cpu",
+            "batch_size": 8,   # Smaller batch size
+            "max_length": 256, # Shorter sequences
+            "model_kwargs": {
+                "torch_dtype": "float16"  # Half precision
+            }
+        }
+    }
+}
+```
+
+## Model Comparison
+
+| Model | Size | Quality | Speed | Memory | Best For |
+|-------|------|---------|-------|---------|----------|
+| bge-reranker-base | 278M | Good | Fast | Low | General use |
+| bge-reranker-large | 560M | Better | Medium | Medium | High quality needs |
+| bge-reranker-v2-m3 | 568M | Best | Medium | Medium | Latest improvements |
+| bge-reranker-v2-multilingual | 568M | Good | Medium | Medium | Multiple languages |
+
+## Error Handling
+
+```python
+try:
+    results = m.search(
+        "test query",
+        user_id="alice",
+        rerank=True
+    )
+except Exception as e:
+    print(f"Reranking failed: {e}")
+    # Fall back to vector search only
+    results = m.search(
+        "test query",
+        user_id="alice",
+        rerank=False
+    )
+```
+
+## Custom Models
+
+### Using Private Models
+
+```python
+# Use a private model from Hugging Face
+config = {
+    "reranker": {
+        "provider": "huggingface",
+        "config": {
+            "model": "your-org/custom-reranker",
+            "device": "cuda",
+            "use_auth_token": "your-hf-token"
+        }
+    }
+}
+```
+
+### Local Model Path
+
+```python
+# Use a locally downloaded model
+config = {
+    "reranker": {
+        "provider": "huggingface",
+        "config": {
+            "model": "/path/to/local/model",
+            "device": "cuda"
+        }
+    }
+}
+```
+
+## Best Practices
+
+1. **Choose the Right Model**: Balance quality vs speed based on your needs
+2. **Use GPU**: Significantly faster than CPU for larger models
+3. **Optimize Batch Size**: Tune based on your hardware capabilities
+4. **Monitor Memory**: Watch GPU/CPU memory usage with large models
+5. **Cache Models**: Download once and reuse to avoid repeated downloads
+
+## Troubleshooting
+
+### Common Issues
+
+**Out of Memory Error**
+```python
+# Reduce batch size and sequence length
+config = {
+    "reranker": {
+        "provider": "huggingface",
+        "config": {
+            "model": "BAAI/bge-reranker-base",
+            "batch_size": 4,
+            "max_length": 256
+        }
+    }
+}
+```
+
+**Model Download Issues**
+```python
+# Set cache directory
+import os
+os.environ["TRANSFORMERS_CACHE"] = "/path/to/cache"
+
+# Or use offline mode
+config = {
+    "reranker": {
+        "provider": "huggingface",
+        "config": {
+            "model": "BAAI/bge-reranker-base",
+            "local_files_only": True
+        }
+    }
+}
+```
+
+**CUDA Not Available**
+```python
+import torch
+
+config = {
+    "reranker": {
+        "provider": "huggingface",
+        "config": {
+            "model": "BAAI/bge-reranker-base",
+            "device": "cuda" if torch.cuda.is_available() else "cpu"
+        }
+    }
+}
+```
+
+## Next Steps
+
+<CardGroup cols={2}>
+  <Card title="Reranker Overview" icon="sort" href="/components/rerankers/overview">
+    Learn about reranking concepts
+  </Card>
+  <Card title="Configuration Guide" icon="gear" href="/components/rerankers/config">
+    Detailed configuration options
+  </Card>
+</CardGroup>

docs/components/rerankers/models/llm.mdx

@@ -1,6 +1,6 @@
 ---
-title: LLM-based
-description: 'Flexible reranking using any Large Language Model'
+title: LLM as Reranker
+description: 'Flexible reranking using LLMs'
 icon: "robot"
 iconType: "solid"
 ---
@@ -118,6 +118,16 @@ for result in results['results']:
     print()
 ```
 
+```text Output
+Memory: I'm learning Python programming
+Vector Score: 0.856
+Rerank Score: 0.920
+
+Memory: I find object-oriented programming challenging
+Vector Score: 0.782
+Rerank Score: 0.850
+```
+
 ## Domain-Specific Scoring
 
 Create specialized scoring for your domain:

docs/components/rerankers/models/llm_reranker.mdx

@@ -0,0 +1,491 @@
+---
+title: LLM Reranker
+description: 'Use any language model as a reranker with custom prompts'
+icon: "robot"
+iconType: "solid"
+---
+
+## Overview
+
+The LLM reranker allows you to use any supported language model as a reranker. This approach uses prompts to instruct the LLM to score and rank memories based on their relevance to the query. While slower than specialized rerankers, it offers maximum flexibility and can be fine-tuned with custom prompts.
+
+## Configuration
+
+### Basic Setup
+
+```python
+from mem0 import Memory
+
+config = {
+    "reranker": {
+        "provider": "llm_reranker",
+        "config": {
+            "llm": {
+                "provider": "openai",
+                "config": {
+                    "model": "gpt-4",
+                    "api_key": "your-openai-api-key"
+                }
+            }
+        }
+    }
+}
+
+m = Memory.from_config(config)
+```
+
+### Configuration Parameters
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `llm` | dict | Required | LLM configuration object |
+| `top_k` | int | 10 | Number of results to rerank |
+| `temperature` | float | 0.0 | LLM temperature for consistency |
+| `custom_prompt` | str | None | Custom reranking prompt |
+| `score_range` | tuple | (0, 10) | Score range for relevance |
+
+### Advanced Configuration
+
+```python
+config = {
+    "reranker": {
+        "provider": "llm_reranker",
+        "config": {
+            "llm": {
+                "provider": "anthropic",
+                "config": {
+                    "model": "claude-3-sonnet-20240229",
+                    "api_key": "your-anthropic-api-key"
+                }
+            },
+            "top_k": 15,
+            "temperature": 0.0,
+            "score_range": (1, 5),
+            "custom_prompt": """
+            Rate the relevance of each memory to the query on a scale of 1-5.
+            Consider semantic similarity, context, and practical utility.
+            Only provide the numeric score.
+            """
+        }
+    }
+}
+```
+
+## Supported LLM Providers
+
+### OpenAI
+
+```python
+config = {
+    "reranker": {
+        "provider": "llm_reranker",
+        "config": {
+            "llm": {
+                "provider": "openai",
+                "config": {
+                    "model": "gpt-4",
+                    "api_key": "your-openai-api-key",
+                    "temperature": 0.0
+                }
+            }
+        }
+    }
+}
+```
+
+### Anthropic
+
+```python
+config = {
+    "reranker": {
+        "provider": "llm_reranker",
+        "config": {
+            "llm": {
+                "provider": "anthropic",
+                "config": {
+                    "model": "claude-3-sonnet-20240229",
+                    "api_key": "your-anthropic-api-key"
+                }
+            }
+        }
+    }
+}
+```
+
+### Ollama (Local)
+
+```python
+config = {
+    "reranker": {
+        "provider": "llm_reranker",
+        "config": {
+            "llm": {
+                "provider": "ollama",
+                "config": {
+                    "model": "llama2",
+                    "ollama_base_url": "http://localhost:11434"
+                }
+            }
+        }
+    }
+}
+```
+
+### Azure OpenAI
+
+```python
+config = {
+    "reranker": {
+        "provider": "llm_reranker",
+        "config": {
+            "llm": {
+                "provider": "azure_openai",
+                "config": {
+                    "model": "gpt-4",
+                    "api_key": "your-azure-api-key",
+                    "azure_endpoint": "https://your-resource.openai.azure.com/",
+                    "azure_deployment": "gpt-4-deployment"
+                }
+            }
+        }
+    }
+}
+```
+
+## Custom Prompts
+
+### Default Prompt Behavior
+
+The default prompt asks the LLM to score relevance on a 0-10 scale:
+
+```
+Given a query and a memory, rate how relevant the memory is to answering the query.
+Score from 0 (completely irrelevant) to 10 (perfectly relevant).
+Only provide the numeric score.
+
+Query: {query}
+Memory: {memory}
+Score:
+```
+
+### Custom Prompt Examples
+
+#### Domain-Specific Scoring
+
+```python
+custom_prompt = """
+You are a medical information specialist. Rate how relevant each memory is for answering the medical query.
+Consider clinical accuracy, specificity, and practical applicability.
+Rate from 1-10 where:
+- 1-3: Irrelevant or potentially harmful
+- 4-6: Somewhat relevant but incomplete
+- 7-8: Relevant and helpful
+- 9-10: Highly relevant and clinically useful
+
+Query: {query}
+Memory: {memory}
+Score:
+"""
+
+config = {
+    "reranker": {
+        "provider": "llm_reranker",
+        "config": {
+            "llm": {
+                "provider": "openai",
+                "config": {
+                    "model": "gpt-4",
+                    "api_key": "your-api-key"
+                }
+            },
+            "custom_prompt": custom_prompt
+        }
+    }
+}
+```
+
+#### Contextual Relevance
+
+```python
+contextual_prompt = """
+Rate how well this memory answers the specific question asked.
+Consider:
+- Direct relevance to the question
+- Completeness of information
+- Recency and accuracy
+- Practical usefulness
+
+Rate 1-5:
+1 = Not relevant
+2 = Slightly relevant
+3 = Moderately relevant
+4 = Very relevant
+5 = Perfectly answers the question
+
+Query: {query}
+Memory: {memory}
+Score:
+"""
+```
+
+#### Conversational Context
+
+```python
+conversation_prompt = """
+You are helping evaluate which memories are most useful for a conversational AI assistant.
+Rate how helpful this memory would be for generating a relevant response.
+
+Consider:
+- Direct relevance to user's intent
+- Emotional appropriateness
+- Factual accuracy
+- Conversation flow
+
+Rate 0-10:
+Query: {query}
+Memory: {memory}
+Score:
+"""
+```
+
+## Usage Examples
+
+### Basic Usage
+
+```python
+from mem0 import Memory
+
+m = Memory.from_config(config)
+
+# Add memories
+m.add("I'm allergic to peanuts", user_id="alice")
+m.add("I love Italian food", user_id="alice")
+m.add("I'm vegetarian", user_id="alice")
+
+# Search with LLM reranking
+results = m.search(
+    "What foods should I avoid?",
+    user_id="alice",
+    rerank=True
+)
+
+for result in results["results"]:
+    print(f"Memory: {result['memory']}")
+    print(f"LLM Score: {result['score']:.2f}")
+```
+
+### Batch Processing with Error Handling
+
+```python
+def safe_llm_rerank_search(query, user_id, max_retries=3):
+    for attempt in range(max_retries):
+        try:
+            return m.search(query, user_id=user_id, rerank=True)
+        except Exception as e:
+            print(f"Attempt {attempt + 1} failed: {e}")
+            if attempt == max_retries - 1:
+                # Fall back to vector search
+                return m.search(query, user_id=user_id, rerank=False)
+
+# Use the safe function
+results = safe_llm_rerank_search("What are my preferences?", "alice")
+```
+
+## Performance Considerations
+
+### Speed vs Quality Trade-offs
+
+| Model Type | Speed | Quality | Cost | Best For |
+|------------|-------|---------|------|----------|
+| GPT-3.5 Turbo | Fast | Good | Low | High-volume applications |
+| GPT-4 | Medium | Excellent | Medium | Quality-critical applications |
+| Claude 3 Sonnet | Medium | Excellent | Medium | Balanced performance |
+| Ollama Local | Variable | Good | Free | Privacy-sensitive applications |
+
+### Optimization Strategies
+
+```python
+# Fast configuration for high-volume use
+fast_config = {
+    "reranker": {
+        "provider": "llm_reranker",
+        "config": {
+            "llm": {
+                "provider": "openai",
+                "config": {
+                    "model": "gpt-3.5-turbo",
+                    "api_key": "your-api-key"
+                }
+            },
+            "top_k": 5,  # Limit candidates
+            "temperature": 0.0
+        }
+    }
+}
+
+# High-quality configuration
+quality_config = {
+    "reranker": {
+        "provider": "llm_reranker",
+        "config": {
+            "llm": {
+                "provider": "openai",
+                "config": {
+                    "model": "gpt-4",
+                    "api_key": "your-api-key"
+                }
+            },
+            "top_k": 15,
+            "temperature": 0.0
+        }
+    }
+}
+```
+
+## Advanced Use Cases
+
+### Multi-Step Reasoning
+
+```python
+reasoning_prompt = """
+Evaluate this memory's relevance using multi-step reasoning:
+
+1. What is the main intent of the query?
+2. What key information does the memory contain?
+3. How directly does the memory address the query?
+4. What additional context might be needed?
+
+Based on this analysis, rate relevance 1-10:
+
+Query: {query}
+Memory: {memory}
+
+Analysis:
+Step 1 (Intent):
+Step 2 (Information):
+Step 3 (Directness):
+Step 4 (Context):
+Final Score:
+"""
+```
+
+### Comparative Ranking
+
+```python
+comparative_prompt = """
+You will see a query and multiple memories. Rank them in order of relevance.
+Consider which memories best answer the question and would be most helpful.
+
+Query: {query}
+
+Memories to rank:
+{memories}
+
+Provide scores 1-10 for each memory, considering their relative usefulness.
+"""
+```
+
+### Emotional Intelligence
+
+```python
+emotional_prompt = """
+Consider both factual relevance and emotional appropriateness.
+Rate how suitable this memory is for responding to the user's query.
+
+Factors to consider:
+- Factual accuracy and relevance
+- Emotional tone and sensitivity
+- User's likely emotional state
+- Appropriateness of response
+
+Query: {query}
+Memory: {memory}
+Emotional Context: {context}
+Score (1-10):
+"""
+```
+
+## Error Handling and Fallbacks
+
+```python
+class RobustLLMReranker:
+    def __init__(self, primary_config, fallback_config=None):
+        self.primary = Memory.from_config(primary_config)
+        self.fallback = Memory.from_config(fallback_config) if fallback_config else None
+
+    def search(self, query, user_id, max_retries=2):
+        # Try primary LLM reranker
+        for attempt in range(max_retries):
+            try:
+                return self.primary.search(query, user_id=user_id, rerank=True)
+            except Exception as e:
+                print(f"Primary reranker attempt {attempt + 1} failed: {e}")
+
+        # Try fallback reranker
+        if self.fallback:
+            try:
+                return self.fallback.search(query, user_id=user_id, rerank=True)
+            except Exception as e:
+                print(f"Fallback reranker failed: {e}")
+
+        # Final fallback: vector search only
+        return self.primary.search(query, user_id=user_id, rerank=False)
+
+# Usage
+primary_config = {
+    "reranker": {
+        "provider": "llm_reranker",
+        "config": {"llm": {"provider": "openai", "config": {"model": "gpt-4"}}}
+    }
+}
+
+fallback_config = {
+    "reranker": {
+        "provider": "llm_reranker",
+        "config": {"llm": {"provider": "openai", "config": {"model": "gpt-3.5-turbo"}}}
+    }
+}
+
+reranker = RobustLLMReranker(primary_config, fallback_config)
+results = reranker.search("What are my preferences?", "alice")
+```
+
+## Best Practices
+
+1. **Use Specific Prompts**: Tailor prompts to your domain and use case
+2. **Set Temperature to 0**: Ensure consistent scoring across runs
+3. **Limit Top-K**: Don't rerank too many candidates to control costs
+4. **Implement Fallbacks**: Always have a backup plan for API failures
+5. **Monitor Costs**: Track API usage, especially with expensive models
+6. **Cache Results**: Consider caching reranking results for repeated queries
+7. **Test Prompts**: Experiment with different prompts to find what works best
+
+## Troubleshooting
+
+### Common Issues
+
+**Inconsistent Scores**
+- Set temperature to 0.0
+- Use more specific prompts
+- Consider using multiple calls and averaging
+
+**API Rate Limits**
+- Implement exponential backoff
+- Use cheaper models for high-volume scenarios
+- Add retry logic with delays
+
+**Poor Ranking Quality**
+- Refine your custom prompt
+- Try different LLM models
+- Add examples to your prompt
+
+## Next Steps
+
+<CardGroup cols={2}>
+  <Card title="Custom Prompts Guide" icon="pencil" href="/components/rerankers/custom-prompts">
+    Learn to craft effective reranking prompts
+  </Card>
+  <Card title="Performance Optimization" icon="bolt" href="/components/rerankers/optimization">
+    Optimize LLM reranker performance
+  </Card>
+</CardGroup>

docs/components/rerankers/models/sentence_transformer.mdx

@@ -67,7 +67,7 @@ config = {
         "config": {
             "model": "cross-encoder/ms-marco-MiniLM-L-6-v2",
             "device": "cuda",  # Use GPU
-            "batch_size": 64   # Larger batch size for GPU
+            "batch_size": 64   # high batch size for high memory GPUs
         }
     }
 }

docs/components/rerankers/models/zero_entropy.mdx

@@ -1,11 +1,11 @@
 ---
 title: Zero Entropy
-description: 'State-of-the-art neural reranking with Zero Entropy'
+description: 'Neural reranking with Zero Entropy'
 icon: "sparkles"
 iconType: "solid"
 ---
 
-[Zero Entropy](https://www.zeroentropy.dev) provides state-of-the-art neural reranking models that significantly improve search relevance with fast performance.
+[Zero Entropy](https://www.zeroentropy.dev) provides neural reranking models that significantly improve search relevance with fast performance.
 
 ## Models
 

docs/components/rerankers/optimization.mdx

@@ -0,0 +1,312 @@
+---
+title: Performance Optimization
+icon: "bolt"
+iconType: "solid"
+---
+
+Optimizing reranker performance is crucial for maintaining fast search response times while improving result quality. This guide covers best practices for different reranker types.
+
+## General Optimization Principles
+
+### Candidate Set Size
+The number of candidates sent to the reranker significantly impacts performance:
+
+```python
+# Optimal candidate sizes for different rerankers
+config_map = {
+    "cohere": {"initial_candidates": 100, "top_n": 10},
+    "sentence_transformer": {"initial_candidates": 50, "top_n": 10},
+    "huggingface": {"initial_candidates": 30, "top_n": 5},
+    "llm_reranker": {"initial_candidates": 20, "top_n": 5}
+}
+```
+
+### Batching Strategy
+Process multiple queries efficiently:
+
+```python
+# Configure for batch processing
+config = {
+    "reranker": {
+        "provider": "sentence_transformer",
+        "config": {
+            "model": "cross-encoder/ms-marco-MiniLM-L-6-v2",
+            "batch_size": 16,  # Process multiple candidates at once
+            "top_n": 10
+        }
+    }
+}
+```
+
+## Provider-Specific Optimizations
+
+### Cohere Optimization
+
+```python
+# Optimized Cohere configuration
+config = {
+    "reranker": {
+        "provider": "cohere",
+        "config": {
+            "model": "rerank-english-v3.0",
+            "top_n": 10,
+            "max_chunks_per_doc": 10,  # Limit chunk processing
+            "return_documents": False   # Reduce response size
+        }
+    }
+}
+```
+
+**Best Practices:**
+- Use v3.0 models for better speed/accuracy balance
+- Limit candidates to 100 or fewer
+- Cache API responses when possible
+- Monitor API rate limits
+
+### Sentence Transformer Optimization
+
+```python
+# Performance-optimized configuration
+config = {
+    "reranker": {
+        "provider": "sentence_transformer",
+        "config": {
+            "model": "cross-encoder/ms-marco-MiniLM-L-6-v2",
+            "device": "cuda",  # Use GPU when available
+            "batch_size": 32,
+            "top_n": 10,
+            "max_length": 512  # Limit input length
+        }
+    }
+}
+```
+
+**Device Optimization:**
+```python
+import torch
+
+# Auto-detect best device
+device = "cuda" if torch.cuda.is_available() else "mps" if torch.backends.mps.is_available() else "cpu"
+
+config = {
+    "reranker": {
+        "provider": "sentence_transformer",
+        "config": {
+            "device": device,
+            "model": "cross-encoder/ms-marco-MiniLM-L-6-v2"
+        }
+    }
+}
+```
+
+### Hugging Face Optimization
+
+```python
+# Optimized for Hugging Face models
+config = {
+    "reranker": {
+        "provider": "huggingface",
+        "config": {
+            "model": "BAAI/bge-reranker-base",
+            "use_fp16": True,  # Half precision for speed
+            "max_length": 512,
+            "batch_size": 8,
+            "top_n": 10
+        }
+    }
+}
+```
+
+### LLM Reranker Optimization
+
+```python
+# Optimized LLM reranker configuration
+config = {
+    "reranker": {
+        "provider": "llm_reranker",
+        "config": {
+            "llm": {
+                "provider": "openai",
+                "config": {
+                    "model": "gpt-3.5-turbo",  # Faster than gpt-4
+                    "temperature": 0,  # Deterministic results
+                    "max_tokens": 500  # Limit response length
+                }
+            },
+            "batch_ranking": True,  # Rank multiple at once
+            "top_n": 5,  # Fewer results for faster processing
+            "timeout": 10  # Request timeout
+        }
+    }
+}
+```
+
+## Performance Monitoring
+
+### Latency Tracking
+```python
+import time
+from mem0 import Memory
+
+def measure_reranker_performance(config, queries, user_id):
+    memory = Memory.from_config(config)
+
+    latencies = []
+    for query in queries:
+        start_time = time.time()
+        results = memory.search(query, user_id=user_id)
+        latency = time.time() - start_time
+        latencies.append(latency)
+
+    return {
+        "avg_latency": sum(latencies) / len(latencies),
+        "max_latency": max(latencies),
+        "min_latency": min(latencies)
+    }
+```
+
+### Memory Usage Monitoring
+```python
+import psutil
+import os
+
+def monitor_memory_usage():
+    process = psutil.Process(os.getpid())
+    return {
+        "memory_mb": process.memory_info().rss / 1024 / 1024,
+        "memory_percent": process.memory_percent()
+    }
+```
+
+## Caching Strategies
+
+### Result Caching
+```python
+from functools import lru_cache
+import hashlib
+
+class CachedReranker:
+    def __init__(self, config):
+        self.memory = Memory.from_config(config)
+        self.cache_size = 1000
+
+    @lru_cache(maxsize=1000)
+    def search_cached(self, query_hash, user_id):
+        return self.memory.search(query, user_id=user_id)
+
+    def search(self, query, user_id):
+        query_hash = hashlib.md5(f"{query}_{user_id}".encode()).hexdigest()
+        return self.search_cached(query_hash, user_id)
+```
+
+### Model Caching
+```python
+# Pre-load models to avoid initialization overhead
+config = {
+    "reranker": {
+        "provider": "sentence_transformer",
+        "config": {
+            "model": "cross-encoder/ms-marco-MiniLM-L-6-v2",
+            "cache_folder": "/path/to/model/cache",
+            "device": "cuda"
+        }
+    }
+}
+```
+
+## Parallel Processing
+
+### Async Configuration
+```python
+import asyncio
+from mem0 import Memory
+
+async def parallel_search(config, queries, user_id):
+    memory = Memory.from_config(config)
+
+    # Process multiple queries concurrently
+    tasks = [
+        memory.search_async(query, user_id=user_id)
+        for query in queries
+    ]
+
+    results = await asyncio.gather(*tasks)
+    return results
+```
+
+## Hardware Optimization
+
+### GPU Configuration
+```python
+# Optimize for GPU usage
+import torch
+
+if torch.cuda.is_available():
+    torch.cuda.set_per_process_memory_fraction(0.8)  # Reserve GPU memory
+
+config = {
+    "reranker": {
+        "provider": "sentence_transformer",
+        "config": {
+            "device": "cuda",
+            "model": "cross-encoder/ms-marco-electra-base",
+            "batch_size": 64,  # Larger batch for GPU
+            "fp16": True  # Half precision
+        }
+    }
+}
+```
+
+### CPU Optimization
+```python
+import torch
+
+# Optimize CPU threading
+torch.set_num_threads(4)  # Adjust based on your CPU
+
+config = {
+    "reranker": {
+        "provider": "sentence_transformer",
+        "config": {
+            "device": "cpu",
+            "model": "cross-encoder/ms-marco-MiniLM-L-6-v2",
+            "num_workers": 4  # Parallel processing
+        }
+    }
+}
+```
+
+## Benchmarking Different Configurations
+
+```python
+def benchmark_rerankers():
+    configs = [
+        {"provider": "cohere", "model": "rerank-english-v3.0"},
+        {"provider": "sentence_transformer", "model": "cross-encoder/ms-marco-MiniLM-L-6-v2"},
+        {"provider": "huggingface", "model": "BAAI/bge-reranker-base"}
+    ]
+
+    test_queries = ["sample query 1", "sample query 2", "sample query 3"]
+
+    results = {}
+    for config in configs:
+        provider = config["provider"]
+        performance = measure_reranker_performance(
+            {"reranker": {"provider": provider, "config": config}},
+            test_queries,
+            "test_user"
+        )
+        results[provider] = performance
+
+    return results
+```
+
+## Production Best Practices
+
+1. **Model Selection**: Choose the right balance of speed vs. accuracy
+2. **Resource Allocation**: Monitor CPU/GPU usage and memory consumption
+3. **Error Handling**: Implement fallbacks for reranker failures
+4. **Load Balancing**: Distribute reranking load across multiple instances
+5. **Monitoring**: Track latency, throughput, and error rates
+6. **Caching**: Cache frequent queries and model predictions
+7. **Batch Processing**: Group similar queries for efficient processing

docs/components/rerankers/overview.mdx

@@ -8,14 +8,34 @@ Mem0 includes built-in support for various reranking providers to improve the re
 
 ## Usage
 
-To use a reranker, you must provide a `rerank` configuration section in your memory config. If no reranker is configured, search results will rely on vector similarity scoring alone.
+To use a reranker:
+
+1. **Configure**: Add a `rerank` configuration section in your memory config
+2. **Search**: Reranking is automatically enabled for all searches (default: `rerank=True`)
+
+If no reranker is configured, search results will rely on vector similarity scoring alone.
 
 For comprehensive configuration parameters for each reranker, please refer to [Config](./config).
 
+### Controlling Reranking Per Search
+
+Once configured, reranking is enabled by default. You can control it per-search:
+
+```python
+# Reranking enabled (default)
+results = memory.search("query", user_id="user1")
+
+# Explicitly enable reranking
+results = memory.search("query", user_id="user1", rerank=True)
+
+# Disable reranking for this specific search
+results = memory.search("query", user_id="user1", rerank=False)
+```
+
 ## How Reranking Works
 
 1. **Initial Search**: Vector similarity search retrieves candidate memories
-2. **Reranking**: Selected reranker re-scores candidates using advanced models
+2. **Reranking** (if enabled): Selected reranker re-scores candidates using advanced models
 3. **Final Results**: Re-ordered results with both vector and rerank scores
 
 <Note>
@@ -30,7 +50,9 @@ See the list of supported rerankers below.
   <Card title="Zero Entropy" href="/components/rerankers/models/zero_entropy" />
   <Card title="Cohere" href="/components/rerankers/models/cohere" />
   <Card title="Sentence Transformer" href="/components/rerankers/models/sentence_transformer" />
+  <Card title="Hugging Face" href="/components/rerankers/models/huggingface" />
   <Card title="LLM-based" href="/components/rerankers/models/llm" />
+  <Card title="LLM Reranker" href="/components/rerankers/models/llm_reranker" />
 </CardGroup>
 
 ## When to Use Reranking
@@ -42,6 +64,7 @@ See the list of supported rerankers below.
 
 Choose the reranker that best fits your use case:
 - **Zero Entropy**: Best balance of speed and quality for general use
-- **Cohere**: Enterprise-grade with excellent multilingual support  
+- **Cohere**: Enterprise-grade with excellent multilingual support
 - **Sentence Transformer**: Local deployment for privacy-sensitive applications
-- **LLM-based**: Maximum customization with custom prompts and logic
+- **Hugging Face**: Wide variety of pre-trained models for specialized use cases
+- **LLM-based**: Maximum customization with custom prompts and logic

docs/components/vectordbs/dbs/azure.mdx

@@ -27,7 +27,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]
@@ -107,13 +107,13 @@ To enable Role-Based Access Control (RBAC) for Azure AI Search, follow these ste
     - Click **Add** > **Add role assignment**.
 6. **Choose Role:**
     - Mem0 requires the **Search Index Data Contributor** and **Search Service Contributor** role.
-7. **Choose Member** 
-    - To assign to a User, Group, Service Principle or Managed Identity:
+7. **Choose Member**
+    - To assign to a User, Group, Service Principal or Managed Identity:
         - For production it is recommended to use a service principal or managed identity.
             - For a service principal: select **User, group, or service principal** and search for the service principal.
             - For a managed identity: select **Managed identity** and choose the managed identity.
         - For development, you can assign the role to a user account.
-            - For development: select ***User, group, or service principal** and pick a Azure Entra ID account (the same used with `az login`).
+            - For development: select **User, group, or service principal** and pick an Azure Entra ID account (the same used with `az login`).
 8. **Complete the Assignment:**
     - Click **Review + Assign**.
 
@@ -133,7 +133,7 @@ config = {
 }
 ```
 
-### Environment Variables to set to use Azure Identity Credential:
+### Environment Variables to Use Azure Identity Credential
 * For an Environment Credential, you will need to setup a Service Principal and set the following environment variables:
   - `AZURE_TENANT_ID`: Your Azure Active Directory tenant ID.
   - `AZURE_CLIENT_ID`: The client ID of your service principal or managed identity.
@@ -142,7 +142,7 @@ config = {
   - `AZURE_CLIENT_ID`: The client ID of the user-assigned managed identity.
 * For a System-Assigned Managed Identity, no additional environment variables are needed.
 
-### Developer logins to use for a Azure Identity Credential:
+### Developer Logins for Azure Identity Credential
 * For an Azure CLI Credential, you need to have the Azure CLI installed and logged in with `az login`.
 * For an Azure PowerShell Credential, you need to have the Azure PowerShell module installed and logged in with `Connect-AzAccount`.
 * For an Azure Developer CLI Credential, you need to have the Azure Developer CLI installed and logged in with `azd auth login`.

docs/components/vectordbs/dbs/azure_mysql.mdx

@@ -0,0 +1,128 @@
+---
+title: Azure MySQL
+---
+
+[Azure Database for MySQL](https://azure.microsoft.com/products/mysql) is a fully managed relational database service that provides enterprise-grade reliability and security. It supports JSON-based vector storage for semantic search capabilities in AI applications.
+
+### Usage
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "sk-xx"
+
+config = {
+    "vector_store": {
+        "provider": "azure_mysql",
+        "config": {
+            "host": "your-server.mysql.database.azure.com",
+            "port": 3306,
+            "user": "your_username",
+            "password": "your_password",
+            "database": "mem0_db",
+            "collection_name": "memories",
+        }
+    }
+}
+
+m = Memory.from_config(config)
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
+```
+
+#### Using Azure Managed Identity
+
+For production deployments, use Azure Managed Identity instead of passwords:
+
+```python
+config = {
+    "vector_store": {
+        "provider": "azure_mysql",
+        "config": {
+            "host": "your-server.mysql.database.azure.com",
+            "user": "your_username",
+            "database": "mem0_db",
+            "collection_name": "memories",
+            "use_azure_credential": True,  # Uses DefaultAzureCredential
+            "ssl_disabled": False
+        }
+    }
+}
+```
+
+<Note>
+When `use_azure_credential` is enabled, the password is obtained via Azure DefaultAzureCredential (supports Managed Identity, Azure CLI, etc.)
+</Note>
+
+### Config
+
+Here are the parameters available for configuring Azure MySQL:
+
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `host` | MySQL server hostname | Required |
+| `port` | MySQL server port | `3306` |
+| `user` | Database user | Required |
+| `password` | Database password (optional with Azure credential) | `None` |
+| `database` | Database name | Required |
+| `collection_name` | Table name for storing vectors | `"mem0"` |
+| `embedding_model_dims` | Dimensions of embedding vectors | `1536` |
+| `use_azure_credential` | Use Azure DefaultAzureCredential | `False` |
+| `ssl_ca` | Path to SSL CA certificate | `None` |
+| `ssl_disabled` | Disable SSL (not recommended) | `False` |
+| `minconn` | Minimum connections in pool | `1` |
+| `maxconn` | Maximum connections in pool | `5` |
+
+### Setup
+
+#### Create MySQL Flexible Server using Azure CLI:
+
+```bash
+# Create resource group
+az group create --name mem0-rg --location eastus
+
+# Create MySQL Flexible Server
+az mysql flexible-server create \
+    --resource-group mem0-rg \
+    --name mem0-mysql-server \
+    --location eastus \
+    --admin-user myadmin \
+    --admin-password <YourPassword> \
+    --version 8.0.21
+
+# Create database
+az mysql flexible-server db create \
+    --resource-group mem0-rg \
+    --server-name mem0-mysql-server \
+    --database-name mem0_db
+
+# Configure firewall
+az mysql flexible-server firewall-rule create \
+    --resource-group mem0-rg \
+    --name mem0-mysql-server \
+    --rule-name AllowMyIP \
+    --start-ip-address <YourIP> \
+    --end-ip-address <YourIP>
+```
+
+#### Enable Azure AD Authentication:
+
+1. In Azure Portal, navigate to your MySQL Flexible Server
+2. Go to **Security** > **Authentication** and enable Azure AD
+3. Add your application's managed identity as a MySQL user:
+
+```sql
+CREATE AADUSER 'your-app-identity' IDENTIFIED BY 'your-client-id';
+GRANT ALL PRIVILEGES ON mem0_db.* TO 'your-app-identity'@'%';
+FLUSH PRIVILEGES;
+```
+
+<Tip>
+For production, use [Managed Identity](https://learn.microsoft.com/azure/active-directory/managed-identities-azure-resources/) to eliminate password management.
+</Tip>

docs/components/vectordbs/dbs/baidu.mdx

@@ -37,7 +37,7 @@ m.add(messages, user_id="alice", metadata={"category": "movies"})
 
 ### Config
 
-Here are the available parameters for the `mochow` config:
+Here are the parameters available for configuring Baidu VectorDB:
 
 | Parameter | Description | Default Value |
 | --- | --- | --- |

docs/components/vectordbs/dbs/chroma.mdx

@@ -26,7 +26,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]

docs/components/vectordbs/dbs/elasticsearch.mdx

@@ -31,7 +31,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]
@@ -40,7 +40,7 @@ m.add(messages, user_id="alice", metadata={"category": "movies"})
 
 ### Config
 
-Let's see the available parameters for the `elasticsearch` config:
+Here are the parameters available for configuring Elasticsearch:
 
 | Parameter              | Description                                        | Default Value |
 | ---------------------- | -------------------------------------------------- | ------------- |

docs/components/vectordbs/dbs/faiss.mdx

@@ -22,7 +22,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]

docs/components/vectordbs/dbs/langchain.mdx

@@ -38,7 +38,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]
@@ -64,12 +64,12 @@ const memory = new Memory(config);
 
 const messages = [
     { role: "user", content: "I'm planning to watch a movie tonight. Any recommendations?" },
-    { role: "assistant", content: "How about a thriller movies? They can be quite engaging." },
+    { role: "assistant", content: "How about thriller movies? They can be quite engaging." },
     { role: "user", content: "I'm not a big fan of thriller movies but I love sci-fi movies." },
     { role: "assistant", content: "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future." }
 ]
 
-memory.add(messages, user_id="alice", metadata={"category": "movies"})
+await memory.add(messages, { userId: "alice", metadata: { category: "movies" } });
 ```
 </CodeGroup>
 

docs/components/vectordbs/dbs/milvus.mdx

@@ -1,4 +1,4 @@
-[Milvus](https://milvus.io/) Milvus is an open-source vector database that suits AI applications of every size from running a demo chatbot in Jupyter notebook to building web-scale search that serves billions of users.
+[Milvus](https://milvus.io/) is an open-source vector database that suits AI applications of every size, from running a demo chatbot in a Jupyter notebook to building web-scale search that serves billions of users.
 
 ### Usage
 
@@ -11,7 +11,7 @@ config = {
         "provider": "milvus",
         "config": {
             "collection_name": "test",
-            "embedding_model_dims": "123",
+            "embedding_model_dims": 1536,
             "url": "127.0.0.1",
             "token": "8e4b8ca8cf2c67",
             "db_name": "my_database",
@@ -22,7 +22,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]
@@ -31,7 +31,7 @@ m.add(messages, user_id="alice", metadata={"category": "movies"})
 
 ### Config
 
-Here's the parameters available for configuring Milvus Database:
+Here are the parameters available for configuring Milvus:
 
 | Parameter | Description | Default Value |
 | --- | --- | --- |

docs/components/vectordbs/dbs/mongodb.mdx

@@ -24,7 +24,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]
@@ -40,6 +40,6 @@ Here are the parameters available for configuring MongoDB:
 | db_name | Name of the MongoDB database | `"mem0_db"` |
 | collection_name | Name of the MongoDB collection | `"mem0_collection"` |
 | embedding_model_dims | Dimensions of the embedding vectors | `1536` |
-| mongo_uri | The mongo URI connection string | mongodb://username:password@localhost:27017 |
+| mongo_uri | The MongoDB URI connection string | `mongodb://username:password@localhost:27017` |
 
-> **Note**: If Mongo_uri is not provided it will default to mongodb://username:password@localhost:27017.
+> **Note**: If `mongo_uri` is not provided, it will default to `mongodb://username:password@localhost:27017`.

docs/components/vectordbs/dbs/opensearch.mdx

@@ -58,7 +58,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]
@@ -74,8 +74,8 @@ results = m.search("What kind of movies does Alice like?", user_id="alice")
 ### Features
 
 - Fast and Efficient Vector Search
-- Can be deployed on-premises, in containers, or on cloud platforms like AWS OpenSearch Service.
-- Multiple Authentication and Security Methods (Basic Authentication, API Keys, LDAP, SAML, and OpenID Connect)
+- Can be deployed on-premises, in containers, or on cloud platforms like AWS OpenSearch Service
+- Multiple authentication and security methods (Basic Authentication, API Keys, LDAP, SAML, and OpenID Connect)
 - Automatic index creation with optimized mappings for vector search
-- Memory Optimization through Disk-Based Vector Search and Quantization
-- Real-Time Analytics and Observability
+- Memory optimization through disk-based vector search and quantization
+- Real-time analytics and observability

docs/components/vectordbs/dbs/pgvector.mdx

@@ -1,4 +1,4 @@
-[pgvector](https://github.com/pgvector/pgvector) is open-source vector similarity search for Postgres. After connecting with postgres run `CREATE EXTENSION IF NOT EXISTS vector;` to create the vector extension.
+[pgvector](https://github.com/pgvector/pgvector) is an open-source vector similarity search extension for Postgres. After connecting to Postgres, run `CREATE EXTENSION IF NOT EXISTS vector;` to create the vector extension.
 
 ### Usage
 
@@ -24,7 +24,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]
@@ -54,7 +54,7 @@ const config = {
 const memory = new Memory(config);
 const messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]
@@ -64,7 +64,7 @@ await memory.add(messages, { userId: "alice", metadata: { category: "movies" } }
 
 ### Config
 
-Here's the parameters available for configuring pgvector:
+Here are the parameters available for configuring pgvector:
 
 | Parameter | Description | Default Value |
 | --- | --- | --- |

docs/components/vectordbs/dbs/pinecone.mdx

@@ -33,7 +33,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]

docs/components/vectordbs/dbs/qdrant.mdx

@@ -23,7 +23,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]
@@ -48,7 +48,7 @@ const config = {
 const memory = new Memory(config);
 const messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]

docs/components/vectordbs/dbs/redis.mdx

@@ -34,7 +34,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]
@@ -60,7 +60,7 @@ const config = {
 const memory = new Memory(config);
 const messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]

docs/components/vectordbs/dbs/s3_vectors.mdx

@@ -28,7 +28,7 @@ config = {
         "provider": "s3_vectors",
         "config": {
             "vector_bucket_name": "my-mem0-vector-bucket",
-            "index_name": "my-memories-index",
+            "collection_name": "my-memories-index",
             "embedding_model_dims": 1536,
             "distance_metric": "cosine",
             "region_name": "us-east-1"
@@ -48,15 +48,15 @@ m.add(messages, user_id="alice", metadata={"category": "movies"})
 
 ### Config
 
-Here are the available parameters for the `s3_vectors` config:
+Here are the parameters available for configuring Amazon S3 Vectors:
 
-| Parameter              | Description                                                          | Default Value |
-| ---------------------- | -------------------------------------------------------------------- | ------------- |
-| `vector_bucket_name`   | The name of the S3 Vector bucket to use. It will be created if it doesn't exist. | Required      |
-| `index_name`           | The name of the vector index within the bucket.                        | `mem0`        |
-| `embedding_model_dims` | Dimensions of the embedding model. Must match your embedder.         | `1536`        |
-| `distance_metric`      | Distance metric for similarity search. Options: `cosine`, `euclidean`. | `cosine`      |
-| `region_name`          | The AWS region where the bucket and index reside.                    | `None` (uses default from AWS config) |
+| Parameter              | Description                                                                      | Default Value                         |
+| ---------------------- | -------------------------------------------------------------------------------- | ------------------------------------- |
+| `vector_bucket_name`   | The name of the S3 Vector bucket to use. It will be created if it doesn't exist. | Required                              |
+| `collection_name`      | The name of the vector index within the bucket.                                  | `mem0`                                |
+| `embedding_model_dims` | Dimensions of the embedding model. Must match your embedder.                     | `1536`                                |
+| `distance_metric`      | Distance metric for similarity search. Options: `cosine`, `euclidean`.           | `cosine`                              |
+| `region_name`          | The AWS region where the bucket and index reside.                                | `None` (uses default from AWS config) |
 
 ### IAM Permissions
 
@@ -64,15 +64,15 @@ Your AWS identity (user or role) needs permissions to perform actions on S3 Vect
 
 ```json
 {
-    "Version": "2012-10-17",
-    "Statement": [
-        {
-            "Effect": "Allow",
-            "Action": "s3vectors:*",
-            "Resource": "*"
-        }
-    ]
+  "Version": "2012-10-17",
+  "Statement": [
+    {
+      "Effect": "Allow",
+      "Action": "s3vectors:*",
+      "Resource": "*"
+    }
+  ]
 }
 ```
 
-For production, it is recommended to scope down the resource ARN to your specific buckets and indexes.
+For production, it is recommended to scope down the resource ARN to your specific buckets and indexes.

docs/components/vectordbs/dbs/supabase.mdx

@@ -26,7 +26,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]
@@ -53,7 +53,7 @@ const memory = new Memory(config);
 
 const messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]
@@ -109,7 +109,7 @@ end;
 $$;
 ```
 
-Goto [Supabase](https://supabase.com/dashboard/projects) and run the above SQL migrations inside the SQL Editor.
+Go to [Supabase](https://supabase.com/dashboard/projects) and run the above SQL migrations in the SQL Editor.
 
 ### Config
 

docs/components/vectordbs/dbs/valkey.mdx

@@ -26,7 +26,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]
@@ -35,7 +35,7 @@ m.add(messages, user_id="alice", metadata={"category": "movies"})
 
 ## Parameters
 
-Let's see the available parameters for the `valkey` config:
+Here are the parameters available for configuring Valkey:
 
 | Parameter | Description | Default Value |
 | --- | --- | --- |

docs/components/vectordbs/dbs/vectorize.mdx

@@ -31,7 +31,7 @@ await memory.add(messages, { userId: "bob", metadata: { interest: "books" } });
 
 ### Config
 
-Let's see the available parameters for the `vectorize` config:
+Here are the parameters available for configuring Vectorize:
 
 <Tabs>
 <Tab title="TypeScript">

docs/components/vectordbs/dbs/weaviate.mdx

@@ -37,7 +37,7 @@ m.add(messages, user_id="alice", metadata={"category": "movies"})
 
 ### Config
 
-Let's see the available parameters for the `weaviate` config:
+Here are the parameters available for configuring Weaviate:
 
 | Parameter | Description | Default Value |
 | --- | --- | --- |

docs/components/vectordbs/overview.mdx

@@ -17,7 +17,7 @@ See the list of supported vector databases below.
 <CardGroup cols={3}>
   <Card title="Qdrant" href="/components/vectordbs/dbs/qdrant"></Card>
   <Card title="Chroma" href="/components/vectordbs/dbs/chroma"></Card>
-  <Card title="Pgvector" href="/components/vectordbs/dbs/pgvector"></Card>
+  <Card title="PGVector" href="/components/vectordbs/dbs/pgvector"></Card>
   <Card title="Upstash Vector" href="/components/vectordbs/dbs/upstash-vector"></Card>
   <Card title="Milvus" href="/components/vectordbs/dbs/milvus"></Card>
   <Card title="Pinecone" href="/components/vectordbs/dbs/pinecone"></Card>
@@ -44,12 +44,11 @@ For a comprehensive list of available parameters for vector database configurati
 
 ## Common issues
 
-### Using model with different dimensions
+### Using Model with Different Dimensions
 
-If you are using customized model, which is having different dimensions other than 1536
-for example 768, you may encounter below error:
+If you are using a customized model with different dimensions other than 1536 (for example, 768), you may encounter the following error:
 
 `ValueError: shapes (0,1536) and (768,) not aligned: 1536 (dim 1) != 768 (dim 0)`
 
-you could add `"embedding_model_dims": 768,` to the config of the vector_store to overcome this issue.
+You can add `"embedding_model_dims": 768,` to the config of the vector_store to resolve this issue.
 

docs/contributing/development.mdx

@@ -19,25 +19,25 @@ To contribute, follow these steps:
 4. **Code Quality Checks**:
    - Run **linting** to catch style issues
    - Ensure **all tests pass**
-5. **Submit a Pull Request** 🚀
+5. **Submit a Pull Request**
 
 For detailed guidance on pull requests, refer to [GitHub's documentation](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-a-pull-request).
 
 ---
 
-## 📦 Dependency Management
+## Dependency Management
 
 We use `hatch` as our package manager. Install it by following the [official instructions](https://hatch.pypa.io/latest/install/).
 
-⚠️ **Do NOT use `pip` or `conda` for dependency management.** Instead, follow these steps in order:
+**Do NOT use `pip` or `conda` for dependency management.** Instead, follow these steps in order:
 
 ```bash
 # 1. Install base dependencies
 make install
 
-# 2. Activate virtual environment (this will install deps.)
-hatch shell (for default env)
-hatch -e dev_py_3_11 shell (for dev_py_3_11) (differences are mentioned in pyproject.toml)
+# 2. Activate virtual environment (this will install dependencies)
+hatch shell  # For default environment
+hatch -e dev_py_3_11 shell  # For dev_py_3_11 (differences are mentioned in pyproject.toml)
 
 # 3. Install all optional dependencies
 make install_all
@@ -45,9 +45,9 @@ make install_all
 
 ---
 
-## 🛠️ Development Standards
+## Development Standards
 
-### ✅ Pre-commit Hooks
+### Pre-commit Hooks
 
 Ensure `pre-commit` is installed before contributing:
 
@@ -55,7 +55,7 @@ Ensure `pre-commit` is installed before contributing:
 pre-commit install
 ```
 
-### 🔍 Linting with `ruff`
+### Linting with `ruff`
 
 Run the linter and fix any reported issues before submitting your PR:
 
@@ -63,7 +63,7 @@ Run the linter and fix any reported issues before submitting your PR:
 make lint
 ```
 
-### 🎨 Code Formatting
+### Code Formatting
 
 To maintain a consistent code style, format your code:
 
@@ -71,7 +71,7 @@ To maintain a consistent code style, format your code:
 make format
 ```
 
-### 🧪 Testing with `pytest`
+### Testing with `pytest`
 
 Run tests to verify functionality before submitting your PR:
 
@@ -79,14 +79,14 @@ Run tests to verify functionality before submitting your PR:
 make test
 ```
 
-💡 **Note:** Some dependencies have been removed from the main dependencies to reduce package size. Run `make install_all` to install necessary dependencies before running tests.
+**Note:** Some dependencies have been removed from the main dependencies to reduce package size. Run `make install_all` to install necessary dependencies before running tests.
 
 ---
 
-## 🚀 Release Process
+## Release Process
 
 Currently, releases are handled manually. We aim for frequent releases, typically when new features or bug fixes are introduced.
 
 ---
 
-Thank you for contributing to Mem0! 🎉
+Thank you for contributing to Mem0!

docs/contributing/documentation.mdx

@@ -5,13 +5,13 @@ icon: "book"
 
 # Documentation Contributions
 
-## 📌 Prerequisites
+## Prerequisites
 
 Before getting started, ensure you have **Node.js (version 23.6.0 or higher)** installed on your system.
 
 ---
 
-## 🚀 Setting Up Mintlify
+## Setting Up Mintlify
 
 ### Step 1: Install Mintlify
 
@@ -41,7 +41,7 @@ The documentation website will be available at: [http://localhost:3000](http://l
 
 ---
 
-## 🔧 Custom Ports
+## Custom Ports
 
 By default, Mintlify runs on **port 3000**. To use a different port, add the `--port` flag:
 
@@ -51,5 +51,5 @@ mintlify dev --port 3333
 
 ---
 
-By following these steps, you can efficiently contribute to **Mem0's documentation**. Happy documenting! ✍️
+By following these steps, you can efficiently contribute to Mem0's documentation.
 

docs/core-concepts/memory-operations/add.mdx

@@ -8,7 +8,7 @@ iconType: "solid"
 
 ## Overview
 
-The `add` operation is how you store memory into Mem0. Whether you're working with a chatbot, a voice assistant, or a multi-agent system, this is the entry point to create long-term memory.
+The `add` operation stores memory into Mem0. Whether you're working with a chatbot, a voice assistant, or a multi-agent system, this is the entry point to create long-term memory.
 
 Memories typically come from a **user-assistant interaction** and Mem0 handles the extraction, transformation, and storage for you.
 
@@ -17,7 +17,7 @@ Mem0 offers two implementation flows:
 - **Mem0 Platform** (Managed, scalable, with dashboard + API)
 - **Mem0 Open Source** (Lightweight, fully local, flexible SDKs)
 
-Each supports the same core memory operations, but with slightly different setup. Below, we walk through examples for both.
+Each supports the same core memory operations, but with slightly different setup.
 
 
 ## Architecture
@@ -37,7 +37,7 @@ When you call `add`, Mem0 performs the following steps under the hood:
 3. **Memory Storage**
    The result is stored in a vector database (for semantic search) and optionally in a graph structure (for relationship mapping).
 
-You don’t need to handle any of this manually, Mem0 takes care of it with a single API call or SDK method.
+You don't need to handle any of this manually - Mem0 takes care of it with a single API call or SDK method.
 
 ---
 
@@ -57,7 +57,7 @@ messages = [
 client.add(
     messages=messages,
     user_id="alice",
-    version="v2"
+    
 )
 ```
 
@@ -94,7 +94,7 @@ m = Memory()
 
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]

docs/core-concepts/memory-operations/delete.mdx

@@ -13,7 +13,7 @@ Memories can become outdated, irrelevant, or need to be removed for privacy or c
 2. **Batch Delete**: Delete multiple known memory IDs (up to 1000)
 3. **Filtered Delete**: Delete memories matching a filter (e.g., `user_id`, `metadata`, `run_id`)
 
-This page walks through code example for each method.
+This page walks through code examples for each method.
 
 
 ## Use Cases
@@ -109,6 +109,7 @@ client.deleteAll({ user_id: "alice" })
 </CodeGroup>
 
 You can also filter by other parameters such as:
+
 - `agent_id`
 - `run_id`
 - `metadata` (as JSON string)
@@ -133,8 +134,6 @@ For request/response schema and additional filtering options, see:
 
 You’ve now seen how to add, search, update, and delete memories in Mem0.
 
----
-
 ## Need help?
 If you have any questions, please feel free to reach out to us using one of the following methods:
 

docs/core-concepts/memory-operations/search.mdx

@@ -26,7 +26,7 @@ This applies to both:
   <img src="../../images/search_architecture.png" />
 </Frame>
 
-The search flow follows these steps:
+When you call `search`, Mem0 performs the following steps:
 
 1. **Query Processing**
    An LLM refines and optimizes your natural language query.
@@ -58,7 +58,7 @@ filters = {
    ]
 }
 
-results = client.search(query, version="v2", filters=filters)
+results = client.search(query, filters=filters)
 ```
 
 ```javascript JavaScript
@@ -74,7 +74,6 @@ const filters = {
 };
 
 const results = await client.search(query, {
-  version: "v2",
   filters
 });
 ```
@@ -89,26 +88,78 @@ const results = await client.search(query, {
 from mem0 import Memory
 
 m = Memory()
+
+# Simple search
 related_memories = m.search("Should I drink coffee or tea?", user_id="alice")
+
+# Search with filters
+memories = m.search(
+    "food preferences",
+    user_id="alice",
+    filters={"categories": {"contains": "diet"}}
+)
 ```
 
 ```javascript JavaScript
 import { Memory } from 'mem0ai/oss';
 
 const memory = new Memory();
+
+// Simple search
 const relatedMemories = memory.search("Should I drink coffee or tea?", { userId: "alice" });
+
+// Search with filters (if supported)
+const memories = memory.search("food preferences", {
+    userId: "alice",
+    filters: { categories: { contains: "diet" } }
+});
 ```
 </CodeGroup>
 
 ---
 
+## Using Filters
+
+Filters help narrow down search results. Common use cases:
+
+**Filter by Session Context:**
+```python
+# Get memories from a specific agent session
+m.search("query", user_id="alice", agent_id="chatbot", run_id="session-123")
+```
+
+**Filter by Date Range:**
+```python
+# Platform only - date filtering
+client.search("recent memories", filters={
+    "AND": [
+        {"user_id": "alice"},
+        {"created_at": {"gte": "2024-07-01"}}
+    ]
+})
+```
+
+**Filter by Categories:**
+```python
+# Platform only - category filtering
+client.search("preferences", filters={
+    "AND": [
+        {"user_id": "alice"},
+        {"categories": {"contains": "food"}}
+    ]
+})
+```
+
+---
+
 ## Tips for Better Search
 
-- Use descriptive natural queries (Mem0 can interpret intent)
-- Apply filters for scoped, faster lookup
-- Use `version: "v2"` for enhanced results
-- Consider wildcard filters (e.g., `run_id: "*"`) for broader matches
-- Tune with `top_k`, `threshold`, or `rerank` if needed
+- **Use natural language**: Mem0 understands intent, so describe what you're looking for naturally
+- **Scope with session IDs**: Always provide at least `user_id` to scope search to relevant memories
+- **Combine filters**: Use AND/OR logic to create precise queries (Platform)
+- **Consider wildcard filters**: Use wildcard filters (e.g., `run_id: "*"`) for broader matches
+- **Tune parameters**: Adjust `top_k` for result count, `threshold` for relevance cutoff
+- **Enable reranking**: Use `rerank=True` (default) when you have a reranker configured
 
 
 ### More Details
@@ -116,8 +167,6 @@ const relatedMemories = memory.search("Should I drink coffee or tea?", { userId:
 For the full list of filter logic, comparison operators, and optional search parameters, see the
 [Search Memory API Reference](/api-reference/memory/v2-search-memories).
 
----
-
 ## Need help?
 If you have any questions, please feel free to reach out to us using one of the following methods:
 

docs/core-concepts/memory-operations/update.mdx

@@ -7,21 +7,21 @@ iconType: "solid"
 
 ## Overview
 
-User preferences, interests, and behaviors often evolve over time. The `update` operation lets you revise a stored memory, whether it's updating facts and memories, rephrasing a message, or enriching metadata.
+User preferences, interests, and behaviors often evolve over time. The `update` operation lets you revise a stored memory, whether it's updating facts, rephrasing a message, or enriching metadata.
 
 Mem0 supports both:
 - **Single Memory Update** for one specific memory using its ID
 - **Batch Update** for updating many memories at once (up to 1000)
 
-This guide includes usage for both single update and batch update of memories through **Mem0 Platform**
+This guide includes usage for both single update and batch update of memories through **Mem0 Platform**.
 
 
 ## Use Cases
 
 - Refine a vague or incorrect memory after a correction
 - Add or edit memory with new metadata (e.g., categories, tags)
-- Evolve factual knowledge as the user’s profile changes
-- A user profile evolves: “I love spicy food” → later says “Actually, I can’t handle spicy food.”
+- Evolve factual knowledge as the user's profile changes
+- Handle profile evolution: "I love spicy food" → later says "Actually, I can't handle spicy food"
 
 Updating memory ensures your agents remain accurate, adaptive, and personalized.
 
@@ -99,18 +99,16 @@ client.batchUpdate(updateMemories)
 
 ## Tips
 
-- You can update both `text` and `metadata` in the same call.
-- Use `batchUpdate` when you're applying similar corrections at scale.
-- If memory is marked `immutable`, it must first be deleted and re-added.
-- Combine this with feedback mechanisms (e.g., user thumbs-up/down) to self-improve memory.
+- You can update both `text` and `metadata` in the same call
+- Use `batchUpdate` when you're applying similar corrections at scale
+- If memory is marked `immutable`, it must first be deleted and re-added
+- Combine this with feedback mechanisms (e.g., user thumbs-up/down) to self-improve memory
 
 
 ### More Details
 
 Refer to the full [Update Memory API Reference](/api-reference/memory/update-memory) and [Batch Update Reference](/api-reference/memory/batch-update) for schema and advanced fields.
 
----
-
 ## Need help?
 If you have any questions, please feel free to reach out to us using one of the following methods:
 

docs/core-concepts/memory-types.mdx

@@ -42,6 +42,7 @@ Each memory type has distinct characteristics:
 | Long-Term | Persistent | Fast | User preferences and history |
 
 ## How Mem0 Implements Long-Term Memory
+
 Mem0's long-term memory system builds on these foundations by:
 
 1. Using vector embeddings to store and retrieve semantic information

docs/examples.mdx

@@ -18,71 +18,99 @@ Here are some examples of how Mem0 can be integrated into various applications:
 Explore how **Mem0** can power real-world applications and bring personalized, intelligent experiences to life:
 
 <CardGroup cols={2}>
+  <Card title="Mem0 Demo" icon="rocket" href="/examples/mem0-demo">
+    Get started with **Mem0** with this simple demo showcasing basic memory operations.
+  </Card>
+
   <Card title="AI Companion in Node.js" icon="node" href="/examples/ai_companion_js">
-    Build a personalized AI Companion in **Node.js** that remembers conversations and adapts over time using Mem0.
+    Build a personalized AI Companion in **Node.js** that remembers conversations and adapts over time.
   </Card>
 
   <Card title="Mem0 with Ollama" icon="server" href="/examples/mem0-with-ollama">
-    Run **Mem0 locally** with **Ollama** to create private, stateful AI experiences without relying on cloud APIs.
+    Run **Mem0 locally** with **Ollama** to create private, stateful AI experiences without cloud APIs.
   </Card>
 
   <Card title="Personal AI Tutor" icon="graduation-cap" href="/examples/personal-ai-tutor">
-    Create an **AI Tutor** that adapts to student progress, learning style, and history — for a truly customized learning experience.
-  </Card>
-
-  <Card title="Personal Travel Assistant" icon="plane" href="/examples/personal-travel-assistant">
-    Develop a **Personal Travel Assistant** that remembers your preferences, past trips, and helps plan future adventures.
+    Create an **AI Tutor** that adapts to student progress, learning style, and history.
   </Card>
 
   <Card title="Customer Support Agent" icon="headset" href="/examples/customer-support-agent">
-    Build a **Customer Support AI** that recalls user preferences, past chats, and provides context-aware, efficient help.
+    Build a **Customer Support AI** that recalls user preferences and past chats.
   </Card>
 
-  <Card title="LlamaIndex + Mem0" icon="book-open" href="/examples/llama-index-mem0">
-    Combine **LlamaIndex** and Mem0 to create a powerful **ReAct Agent** with persistent memory for smarter interactions.
-  </Card>
-
-  <Card title="LlamaIndex + Mem0 Learning System" icon="book-open" href="/examples/llama-index-mem0">
-    Multi-agent learning system powered by memory.
+  <Card title="Personal Travel Assistant" icon="plane" href="/examples/personal-travel-assistant">
+    Develop a **Personal Travel Assistant** that remembers your preferences and past trips.
   </Card>
 
   <Card title="Chrome Extension" icon="puzzle-piece" href="/examples/chrome-extension">
-    Add **long-term memory** to ChatGPT, Claude, or Perplexity via the **Mem0 Chrome Extension** — personalize your AI chats anywhere.
+    Add **long-term memory** to ChatGPT, Claude, or Perplexity via the **Mem0 Chrome Extension**.
   </Card>
 
-  <Card title="YouTube Assistant" icon="puzzle-piece" href="/examples/youtube-assistant">
-    Integrate **Mem0** into **YouTube's** native UI, providing personalized responses with video context. 
-  </Card> 
+  <Card title="YouTube Assistant" icon="video" href="/examples/youtube-assistant">
+    Integrate **Mem0** into **YouTube's** native UI with personalized responses.
+  </Card>
 
-  <Card title="Document Writing Assistant" icon="pen" href="/examples/document-writing">
-    Create a **Writing Assistant** that understands and adapts to your unique style, improving consistency and productivity.
+  <Card title="Memory-Guided Content Writing" icon="pen" href="/examples/memory-guided-content-writing">
+    Create a **Writing Assistant** that understands and adapts to your unique style.
   </Card>
 
   <Card title="Multimodal AI Demo" icon="image" href="/examples/multimodal-demo">
-    Supercharge AI with **Mem0's multimodal memory** — blend text, images, and more for richer, context-aware interactions.
-  </Card>
-
-  <Card title="Personalized Research Agent" icon="magnifying-glass" href="/examples/personalized-deep-research">
-    Build a **Deep Research AI** that remembers your research goals and compiles insights from vast information sources.
-  </Card>
-
-  <Card title="Mem0 as an Agentic Tool" icon="robot" href="/examples/mem0-agentic-tool">
-    Integrate Mem0's memory capabilities with OpenAI's Agents SDK to create AI agents with persistent memory.
-  </Card>
-
-  <Card title="OpenAI Inbuilt Tools" icon="robot" href="/examples/openai-inbuilt-tools">
-    Use Mem0's memory capabilities with OpenAI's Inbuilt Tools to create AI agents with persistent memory.
-  </Card>
-
-  <Card title="Mem0 OpenAI Voice Demo" icon="microphone" href="/examples/mem0-openai-voice-demo">
-    Use Mem0's memory capabilities with OpenAI's Inbuilt Tools to create AI agents with persistent memory.
-  </Card>
-
-  <Card title="Healthcare Assistant Google ADK" icon="microphone" href="/examples/mem0-google-adk-healthcare-assistant">
-    Build a personalized healthcare assistant with persistent memory using Google's ADK and Mem0.
+    Supercharge AI with **Mem0's multimodal memory** — blend text, images, and more.
   </Card>
 
   <Card title="Email Processing" icon="envelope" href="/examples/email_processing">
-    Use Mem0's memory capabilities to process emails and create AI agents with persistent memory.
+    Use Mem0's memory capabilities to process emails with persistent memory.
+  </Card>
+
+  <Card title="Personalized Research Agent" icon="magnifying-glass" href="/examples/personalized-deep-research">
+    Build a **Deep Research AI** that remembers your research goals.
+  </Card>
+
+  <Card title="Multi-User Collaboration" icon="users" href="/examples/collaborative-task-agent">
+    Build collaborative agents with shared memory across multiple users.
+  </Card>
+
+  <Card title="LlamaIndex ReAct Agent" icon="book-open" href="/examples/llama-index-mem0">
+    Combine **LlamaIndex** and Mem0 to create a **ReAct Agent** with persistent memory.
+  </Card>
+
+  <Card title="LlamaIndex Multi-Agent System" icon="book-open" href="/examples/llamaindex-multiagent-learning-system">
+    Multi-agent learning system powered by memory.
+  </Card>
+
+  <Card title="Personalized Search with Tavily" icon="search" href="/examples/personalized-search-tavily-mem0">
+    Build a personalized search experience using Mem0 and Tavily.
+  </Card>
+
+  <Card title="Mem0 as an Agentic Tool" icon="robot" href="/examples/mem0-agentic-tool">
+    Integrate Mem0's memory capabilities with OpenAI's Agents SDK.
+  </Card>
+
+  <Card title="OpenAI Inbuilt Tools" icon="wrench" href="/examples/openai-inbuilt-tools">
+    Use Mem0 with OpenAI's Inbuilt Tools to create AI agents with persistent memory.
+  </Card>
+
+  <Card title="OpenAI Voice Demo" icon="microphone" href="/examples/mem0-openai-voice-demo">
+    Voice-enabled AI agents with persistent memory using OpenAI.
+  </Card>
+
+  <Card title="Healthcare Assistant with Google ADK" icon="heart-pulse" href="/examples/mem0-google-adk-healthcare-assistant">
+    Build a personalized healthcare assistant with persistent memory using Google ADK.
+  </Card>
+
+  <Card title="Mem0 with Mastra" icon="wand-magic-sparkles" href="/examples/mem0-mastra">
+    Integrate Mem0 with Mastra for powerful agentic workflows.
+  </Card>
+
+  <Card title="Eliza OS Character" icon="comment" href="/examples/eliza_os">
+    Build conversational AI characters with persistent memory using Eliza OS.
+  </Card>
+
+  <Card title="AWS Bedrock Example" icon="aws" href="/examples/aws_example">
+    Use Mem0 with **AWS Bedrock**, **OpenSearch**, and **Neptune Analytics**.
+  </Card>
+
+  <Card title="AWS Neptune Analytics" icon="aws" href="/examples/aws_neptune_analytics_hybrid_store">
+    Hybrid memory store with **AWS Neptune Analytics** and Bedrock.
   </Card>
 </CardGroup>

docs/examples/ai_companion_js.mdx

@@ -2,7 +2,7 @@
 title: AI Companion in Node.js
 ---
 
-You can create a personalised AI Companion using Mem0. This guide will walk you through the necessary steps and provide the complete code to get you started.
+You can create a personalized AI Companion using Mem0. This guide will walk you through the necessary steps and provide the complete code to get you started.
 
 ## Overview
 
@@ -45,7 +45,7 @@ ${memoriesStr}`;
   ];
   
   const response = await openaiClient.chat.completions.create({
-    model: "gpt-4o-mini",
+    model: "gpt-4.1-nano-2025-04-14",
     messages: messages
   });
   

docs/examples/aws_example.mdx

@@ -1,5 +1,5 @@
 ---
-title: "Amazon Stack: AWS Bedrock, AOSS, and Neptune Analytics"
+title: "AWS Bedrock Example"
 ---
 
 This example demonstrates how to configure and use the `mem0ai` SDK with **AWS Bedrock**, **OpenSearch Service (AOSS)**, and **AWS Neptune Analytics** for persistent memory capabilities in Python.
@@ -36,7 +36,7 @@ This sets up Mem0 with:
 - [AWS Bedrock for LLM](https://docs.mem0.ai/components/llms/models/aws_bedrock)
 - [AWS Bedrock for embeddings](https://docs.mem0.ai/components/embedders/models/aws_bedrock#aws-bedrock)
 - [OpenSearch as the vector store](https://docs.mem0.ai/components/vectordbs/dbs/opensearch)
-- [Neptune Analytics as your graph store](https://docs.mem0.ai/open-source/graph_memory/overview#initialize-neptune-analytics).
+- [Neptune Analytics as your graph store](https://docs.mem0.ai/open-source/graph_memory/overview#initialize-neptune-analytics)
 
 ```python
 import boto3
@@ -93,12 +93,12 @@ m = Memory.from_config(config)
 
 Reference [Notebook example](https://github.com/mem0ai/mem0/blob/main/examples/graph-db-demo/neptune-example.ipynb)
 
-#### Add a memory:
+### Add a memory
 
 ```python
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
     {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]
@@ -107,24 +107,24 @@ messages = [
 result = m.add(messages, user_id="alice", metadata={"category": "movie_recommendations"})
 ```
 
-#### Search a memory:
+### Search a memory
+
 ```python
 relevant_memories = m.search(query, user_id="alice")
 ```
 
-#### Get all memories:
+### Get all memories
+
 ```python
 all_memories = m.get_all(user_id="alice")
 ```
 
-#### Get a specific memory:
+### Get a specific memory
+
 ```python
 memory = m.get(memory_id)
 ```
 
-
----
-
 ## Conclusion
 
 With Mem0 and AWS services like Bedrock, OpenSearch, and Neptune Analytics, you can build intelligent AI companions that remember, adapt, and personalize their responses over time. This makes them ideal for long-term assistants, tutors, or support bots with persistent memory and natural conversation abilities.

docs/examples/aws_neptune_analytics_hybrid_store.mdx

@@ -1,5 +1,5 @@
 ---
-title: "Amazon Stack - Neptune Analytics Hybrid Store: AWS Bedrock and Neptune Analytics"
+title: "AWS Neptune Analytics"
 ---
 
 This example demonstrates how to configure and use the `mem0ai` SDK with **AWS Bedrock** and **AWS Neptune Analytics** for persistent memory capabilities in Python.

docs/examples/chrome-extension.mdx

@@ -1,9 +1,9 @@
 # Mem0 Chrome Extension
 
-Enhance your AI interactions with **Mem0**, a Chrome extension that introduces a universal memory layer across platforms like `ChatGPT`, `Claude`, and `Perplexity`. Mem0 ensures seamless context sharing, making your AI experiences more personalized and efficient.
+Enhance your AI interactions with Mem0, a Chrome extension that introduces a universal memory layer across platforms like ChatGPT, Claude, and Perplexity. Mem0 ensures seamless context sharing, making your AI experiences more personalized and efficient.
 
 <Note>
-  🎉 We now support Grok! The Mem0 Chrome Extension has been updated to work with Grok, bringing the same powerful memory capabilities to your Grok conversations.
+  We now support Grok! The Mem0 Chrome Extension has been updated to work with Grok, bringing the same powerful memory capabilities to your Grok conversations.
 </Note>
 
 
@@ -44,7 +44,7 @@ You can install the Mem0 Chrome Extension using one of the following methods:
 ## Configuration
 
 - **API Key**: Obtain your API key from the Mem0 Dashboard to connect the extension to the Mem0 API.
-- **User ID**: This is your unique identifier in the Mem0 system. If not provided, it defaults to 'chrome-extension-user'.
+- **User ID**: This is your unique identifier in the Mem0 system. If not provided, it defaults to `chrome-extension-user`.
 
 ## Demo Video
 

docs/examples/collaborative-task-agent.mdx

@@ -51,7 +51,7 @@ class CollaborativeAgent:
             {"role": "user", "content": f"Prompt: {prompt}\nContext:\n{context}"}
         ]
         reply = client.chat.completions.create(
-            model="gpt-4o-mini",
+            model="gpt-4.1-nano-2025-04-14",
             messages=messages
         ).choices[0].message.content.strip()
         self.add_message("assistant", "assistant", reply)

docs/examples/eliza_os.mdx

@@ -2,13 +2,14 @@
 title: Eliza OS Character
 ---
 
-You can create a personalised Eliza OS Character using Mem0. This guide will walk you through the necessary steps and provide the complete code to get you started.
+You can create a personalized Eliza OS Character using Mem0. This guide will walk you through the necessary steps and provide the complete code to get you started.
 
 ## Overview
 
-ElizaOS is a powerful AI agent framework for autonomy & personality. It is a collection of tools that help you create a personalised AI agent.
+ElizaOS is a powerful AI agent framework for autonomy and personality. It is a collection of tools that help you create a personalized AI agent.
 
 ## Setup
+
 You can start by cloning the eliza-os repository:
 
 ```bash
@@ -35,22 +36,22 @@ pnpm build
 
 ## Setup ENVs
 
-Create a `.env` file in the root of the project and add the following ( You can use the `.env.example` file as a reference):
+Create a `.env` file in the root of the project and add the following (you can use the `.env.example` file as a reference):
 
 ```bash
 # Mem0 Configuration
-MEM0_API_KEY= # Mem0 API Key ( Get from https://app.mem0.ai/dashboard/api-keys )
+MEM0_API_KEY= # Mem0 API Key (get from https://app.mem0.ai/dashboard/api-keys)
 MEM0_USER_ID= # Default: eliza-os-user
 MEM0_PROVIDER= # Default: openai
-MEM0_PROVIDER_API_KEY= # API Key for the provider (openai, anthropic, etc.)
-SMALL_MEM0_MODEL= # Default: gpt-4o-mini
+MEM0_PROVIDER_API_KEY= # API Key for the provider (OpenAI, Anthropic, etc.)
+SMALL_MEM0_MODEL= # Default: gpt-4.1-nano
 MEDIUM_MEM0_MODEL= # Default: gpt-4o
 LARGE_MEM0_MODEL= # Default: gpt-4o
 ```
 
 ## Make the default character use Mem0
 
-By default, there is a character called `eliza` that uses the `ollama` model. You can make this character use Mem0 by changing the config in the `agent/src/defaultCharacter.ts` file.
+By default, there is a character called `eliza` that uses the Ollama model. You can make this character use Mem0 by changing the config in the `agent/src/defaultCharacter.ts` file.
 
 ```ts
 modelProvider: ModelProviderName.MEM0,
@@ -66,8 +67,6 @@ pnpm start
 
 ## Conclusion
 
-You have now created a personalised Eliza OS Character using Mem0. You can now start interacting with the character by running the project and talking to the character.
-
-This is a simple example of how to use Mem0 to create a personalised AI agent. You can use this as a starting point to create your own AI agent.
-
+You have now created a personalized Eliza OS Character using Mem0. You can now start interacting with the character by running the project and talking to the character.
 
+This is a simple example of how to use Mem0 to create a personalized AI agent. You can use this as a starting point to create your own AI agent.

docs/examples/email_processing.mdx

@@ -84,7 +84,7 @@ class EmailProcessor:
             user_id=user_id,
             metadata=metadata,
             categories=["email", "correspondence"],
-            version="v2"
+            
         )
         
         return response
@@ -99,47 +99,57 @@ class EmailProcessor:
         else:
             return email.get_payload(decode=True).decode()
     
-    def search_emails(self, query, user_id):
+    def search_emails(self, query, user_id, sender=None):
         """
         Search through stored emails
-        
+
         Args:
             query (str): Search query
             user_id (str): User identifier
+            sender (str, optional): Filter by sender email address
         """
-        # Search Mem0 for relevant emails
-        results = self.client.search(
-            query=query,
-            user_id=user_id,
-            categories=["email"],
-            output_format="v1.1",
-            version="v2"
-        )
-        
+        # For Platform API, all filters including user_id go in filters object
+        if not sender:
+            # Simple filter - just user_id and category
+            filters = {
+                "AND": [
+                    {"user_id": user_id},
+                    {"categories": {"contains": "email"}}
+                ]
+            }
+            results = self.client.search(query=query, filters=filters)
+        else:
+            # Advanced filter - add sender condition
+            filters = {
+                "AND": [
+                    {"user_id": user_id},
+                    {"categories": {"contains": "email"}},
+                    {"sender": sender}
+                ]
+            }
+            results = self.client.search(query=query, filters=filters)
+
         return results
         
     def get_email_thread(self, subject, user_id):
         """
         Retrieve all emails in a thread based on subject
-        
+
         Args:
             subject (str): Email subject to match
             user_id (str): User identifier
         """
+        # For Platform API, user_id goes in the filters object
         filters = {
             "AND": [
                 {"user_id": user_id},
                 {"categories": {"contains": "email"}},
-                {"metadata": {"subject": {"contains": subject}}}
+                {"subject": {"icontains": subject}}
             ]
         }
-        
-        thread = self.client.get_all(
-            version="v2",
-            filters=filters,
-            output_format="v1.1"
-        )
-        
+
+        thread = self.client.get_all(filters=filters)
+
         return thread
 
 # Initialize the processor

docs/examples/llama-index-mem0.mdx

@@ -4,10 +4,12 @@ title: LlamaIndex ReAct Agent
 
 Create a ReAct Agent with LlamaIndex which uses Mem0 as the memory store.
 
-### Overview
+## Overview
+
 A ReAct agent combines reasoning and action capabilities, making it versatile for tasks requiring both thought processes (reasoning) and interaction with tools or APIs (acting). Mem0 as memory enhances these capabilities by allowing the agent to store and retrieve contextual information from past interactions.
 
-### Setup
+## Setup
+
 ```bash
 pip install llama-index-core llama-index-memory-mem0
 ```
@@ -18,7 +20,7 @@ import os
 from llama_index.llms.openai import OpenAI
 
 os.environ["OPENAI_API_KEY"] = "<your-openai-api-key>"
-llm = OpenAI(model="gpt-4o")
+llm = OpenAI(model="gpt-4.1-nano-2025-04-14")
 ```
 
 Initialize the Mem0 client. You can find your API key [here](https://app.mem0.ai/dashboard/api-keys). Read about Mem0 [Open Source](https://docs.mem0.ai/open-source/overview).
@@ -67,6 +69,7 @@ order_food_tool = FunctionTool.from_defaults(fn=order_food)
 ```
 
 Initialize the agent with tools and memory.
+
 ```python
 from llama_index.core.agent import FunctionCallingAgent
 
@@ -79,14 +82,16 @@ agent = FunctionCallingAgent.from_tools(
 ```
 
 Start the chat.
-<Note> The agent will use the Mem0 to store the relevant memories from the chat. </Note>
 
-Input
+<Note>The agent will use Mem0 to store the relevant memories from the chat.</Note>
+
+**Input**
 ```python
 response = agent.chat("Hi, My name is David")
 print(response)
 ```
-Output
+
+**Output**
 ```text
 > Running step bf44a75a-a920-4cf3-944e-b6e6b5695043. Step input: Hi, My name is David
 Added user message to memory: Hi, My name is David
@@ -94,24 +99,27 @@ Added user message to memory: Hi, My name is David
 Hello, David! How can I assist you today?
 ```
 
-Input
+**Input**
 ```python
 response = agent.chat("I love to eat pizza on weekends")
 print(response)
 ```
-Output
+
+**Output**
 ```text
 > Running step 845783b0-b85b-487c-baee-8460ebe8b38d. Step input: I love to eat pizza on weekends
 Added user message to memory: I love to eat pizza on weekends
 === LLM Response ===
 Pizza is a great choice for the weekend! If you'd like, I can help you order some. Just let me know what kind of pizza you prefer!
 ```
-Input
+
+**Input**
 ```python
 response = agent.chat("My preferred way of communication is email")
 print(response)
 ```
-Output
+
+**Output**
 ```text
 > Running step 345842f0-f8a0-42ea-a1b7-612265d72a92. Step input: My preferred way of communication is email
 Added user message to memory: My preferred way of communication is email
@@ -119,8 +127,9 @@ Added user message to memory: My preferred way of communication is email
 Got it! If you need any assistance or have any requests, feel free to let me know, and I can communicate with you via email.
 ```
 
-### Using the agent WITHOUT memory
-Input
+## Using the Agent Without Memory
+
+**Input**
 ```python
 agent = FunctionCallingAgent.from_tools(
     [call_tool, email_tool, order_food_tool],
@@ -131,17 +140,20 @@ agent = FunctionCallingAgent.from_tools(
 response = agent.chat("I am feeling hungry, order me something and send me the bill")
 print(response)
 ```
-Output
+
+**Output**
 ```text
 > Running step e89eb75d-75e1-4dea-a8c8-5c3d4b77882d. Step input: I am feeling hungry, order me something and send me the bill
 Added user message to memory: I am feeling hungry, order me something and send me the bill
 === LLM Response ===
 Please let me know your name and the dish you'd like to order, and I'll take care of it for you!
 ```
-<Note> The agent is not able to remember the past preferences that user shared in previous chats. </Note>
 
-### Using the agent WITH memory
-Input
+<Note>The agent is not able to remember the past preferences the user shared in previous chats.</Note>
+
+## Using the Agent With Memory
+
+**Input**
 ```python
 agent = FunctionCallingAgent.from_tools(
     [call_tool, email_tool, order_food_tool],
@@ -170,4 +182,5 @@ Emailing... David
 === LLM Response ===
 I've ordered a pizza for you, and the bill has been sent to your email. Enjoy your meal! If there's anything else you need, feel free to let me know.
 ```
-<Note> The agent is able to remember the past preferences that user shared and use them to perform actions. </Note>
+
+<Note>The agent is able to remember the past preferences the user shared and use them to perform actions.</Note>

docs/examples/llamaindex-multiagent-learning-system.mdx

@@ -11,7 +11,7 @@ Build an intelligent multi-agent learning system that uses Mem0 to maintain pers
 This example showcases a **Multi-Agent Personal Learning System** that combines:
 - **LlamaIndex AgentWorkflow** for multi-agent orchestration
 - **Mem0** for persistent, shared memory across agents
-- **Multi-agents** that collaborate on teaching tasks
+- **Multiple agents** that collaborate on teaching tasks
 
 The system consists of two agents:
 - **TutorAgent**: Primary instructor for explanations and concept teaching
@@ -81,7 +81,7 @@ class MultiAgentLearningSystem:
 
     def __init__(self, student_id: str):
         self.student_id = student_id
-        self.llm = OpenAI(model="gpt-4o", temperature=0.2)
+        self.llm = OpenAI(model="gpt-4.1-nano-2025-04-14", temperature=0.2)
 
         # Memory context for this student
         self.memory_context = {"user_id": student_id, "app": "learning_assistant"}
@@ -350,7 +350,7 @@ Based on our previous session, I remember we covered Vision Language Models and
 1. **Clear Agent Roles**: Define specific responsibilities for each agent
 2. **Memory Context**: Use descriptive context for memory isolation
 3. **Handoff Strategy**: Design clear handoff criteria between agents
-5. **Memory Hygiene**: Regularly review and clean memory for optimal performance
+4. **Memory Hygiene**: Regularly review and clean memory for optimal performance
 
 ## Help & Resources
 

docs/examples/mem0-agentic-tool.mdx

@@ -3,8 +3,7 @@ title: Mem0 as an Agentic Tool
 ---
 
 
-Integrate Mem0's memory capabilities with OpenAI's Agents SDK to create AI agents with persistent memory.
-You can create agents that remember past conversations and use that context to provide better responses.
+Integrate Mem0's memory capabilities with OpenAI's Agents SDK to create AI agents with persistent memory. You can create agents that remember past conversations and use that context to provide better responses.
 
 ## Installation
 
@@ -112,7 +111,7 @@ async def search_memory(
         query: The search query.
     """
     user_id = context.context.user_id or "default_user"
-    memories = await client.search(query, user_id=user_id, output_format="v1.1")
+    memories = await client.search(query, user_id=user_id)
     results = '\n'.join([result["memory"] for result in memories["results"]])
     return str(results)
 ```
@@ -126,7 +125,7 @@ async def get_all_memory(
 ) -> str:
     """Retrieve all memories from Mem0"""
     user_id = context.context.user_id or "default_user"
-    memories = await client.get_all(user_id=user_id, output_format="v1.1")
+    memories = await client.get_all(user_id=user_id)
     results = '\n'.join([result["memory"] for result in memories["results"]])
     return str(results)
 ```

docs/examples/mem0-demo.mdx

@@ -53,9 +53,9 @@ Before you begin, follow these steps to set up the demo application:
 ## Enhancing the Next.js Application
 
 Once the demo is running, you can customize and enhance the Next.js application by modifying the components in the `mem0-demo` folder. Consider:
-- Adding new memory features to improve contextual retention.
-- Customizing the UI to better suit your application needs.
-- Integrating additional APIs or third-party services to extend functionality.
+- Adding new memory features to improve contextual retention
+- Customizing the UI to better suit your application needs
+- Integrating additional APIs or third-party services to extend functionality
 
 ## Full Code
 

docs/examples/mem0-google-adk-healthcare-assistant.mdx

@@ -4,7 +4,7 @@ description: 'Build a personalized healthcare agent that remembers patient infor
 ---
 
 
-# Healthcare Assistant with Memory
+## Healthcare Assistant with Memory
 
 This example demonstrates how to build a healthcare assistant that remembers patient information across conversations using Google ADK and Mem0.
 
@@ -80,8 +80,7 @@ def retrieve_patient_info(query: str) -> dict:
         query,
         user_id=USER_ID,
         limit=5,
-        threshold=0.7,  # Higher threshold for more relevant results
-        output_format="v1.1"
+        threshold=0.7  # Higher threshold for more relevant results
     )
 
     # Format and return the results
@@ -258,7 +257,7 @@ This healthcare assistant demonstrates several key capabilities:
 
 ## Key Implementation Details
 
-### User ID Management
+## User ID Management
 
 Instead of passing the user ID as a parameter to the memory tools (which would require modifying the ADK's tool calling system), we attach it directly to the function object:
 
@@ -277,7 +276,7 @@ user_id = getattr(save_patient_info, 'user_id', 'default_user')
 
 This approach allows our tools to maintain user context without complicating their parameter signatures.
 
-### Mem0 Integration
+## Mem0 Integration
 
 The integration with Mem0 happens through two primary functions:
 

docs/examples/mem0-mastra.mdx

@@ -2,8 +2,7 @@
 title: Mem0 with Mastra
 ---
 
-In this example you'll learn how to use the Mem0 to add long-term memory capabilities to [Mastra's agent](https://mastra.ai/) via tool-use.
-This memory integration can work alongside Mastra's [agent memory features](https://mastra.ai/docs/agents/01-agent-memory).
+In this example you'll learn how to use Mem0 to add long-term memory capabilities to [Mastra's agent](https://mastra.ai/) via tool-use. This memory integration can work alongside Mastra's [agent memory features](https://mastra.ai/docs/agents/01-agent-memory).
 
 You can find the complete example code in the [Mastra repository](https://github.com/mastra-ai/mastra/tree/main/examples/memory-with-mem0).
 
@@ -11,9 +10,9 @@ You can find the complete example code in the [Mastra repository](https://github
 
 This guide will show you how to integrate Mem0 with Mastra to add long-term memory capabilities to your agents. We'll create tools that allow agents to save and retrieve memories using Mem0's API.
 
-### Installation
+## Installation
 
-1. **Install the Integration Package**
+**Install the Integration Package**
 
 To install the Mem0 integration, run:
 
@@ -21,7 +20,7 @@ To install the Mem0 integration, run:
 npm install @mastra/mem0
 ```
 
-2. **Add the Integration to Your Project**
+**Add the Integration to Your Project**
 
 Create a new file for your integrations and import the integration:
 
@@ -36,7 +35,7 @@ export const mem0 = new Mem0Integration({
 });
 ```
 
-3. **Use the Integration in Tools or Workflows**
+**Use the Integration in Tools or Workflows**
 
 You can now use the integration when defining tools for your agents or in workflows.
 
@@ -86,7 +85,7 @@ export const mem0MemorizeTool = createTool({
 });
 ```
 
-4. **Create a new agent**
+**Create a New Agent**
 
 ```typescript agents/index.ts
 import { openai } from '@ai-sdk/openai';
@@ -98,12 +97,12 @@ export const mem0Agent = new Agent({
   instructions: `
     You are a helpful assistant that has the ability to memorize and remember facts using Mem0.
   `,
-  model: openai('gpt-4o'),
+  model: openai('gpt-4.1-nano'),
   tools: { mem0RememberTool, mem0MemorizeTool },
 });
 ```
 
-5. **Run the agent**
+**Run the Agent**
 
 ```typescript index.ts
 import { Mastra } from '@mastra/core/mastra';
@@ -121,6 +120,6 @@ export const mastra = new Mastra({
 ```
 
 In the example above:
-- We import the `@mastra/mem0` integration.
-- We define two tools that uses the Mem0 API client to create new memories and recall previously saved memories.
-- The tool accepts `question` as an input and returns the memory as a string.
+- We import the `@mastra/mem0` integration
+- We define two tools that use the Mem0 API client to create new memories and recall previously saved memories
+- The tool accepts `question` as an input and returns the memory as a string

docs/examples/mem0-openai-voice-demo.mdx

@@ -3,7 +3,7 @@ title: 'Mem0 with OpenAI Agents SDK for Voice'
 description: 'Integrate memory capabilities into your voice agents using Mem0 and OpenAI Agents SDK'
 ---
 
-# Building Voice Agents with Memory using Mem0 and OpenAI Agents SDK
+## Building Voice Agents with Memory using Mem0 and OpenAI Agents SDK
 
 This guide demonstrates how to combine OpenAI's Agents SDK for voice applications with Mem0's memory capabilities to create a voice assistant that remembers user preferences and past interactions.
 
@@ -130,7 +130,7 @@ async def search_memories(
         user_id=USER_ID,
         limit=5,
         threshold=0.7,  # Higher threshold for more relevant results
-        output_format="v1.1"
+        
     )
     
     # Format and return the results
@@ -162,7 +162,7 @@ def create_memory_voice_agent():
             Use the search_memories tool when you need context from past conversations or user asks you to recall something.
             """,
         ),
-        model="gpt-4o",
+        model="gpt-4.1-nano-2025-04-14",
         tools=[save_memories, search_memories],
     )
     
@@ -171,7 +171,7 @@ def create_memory_voice_agent():
 
 This function:
 - Creates an OpenAI Agent with specific instructions
-- Configures it to use gpt-4o (you can use other models)
+- Configures it to use gpt-4.1-nano (you can use other models)
 - Registers the memory-related tools with the agent
 - Uses `prompt_with_handoff_instructions` to include standard voice agent behaviors
 
@@ -346,7 +346,7 @@ async def search_memories(
         user_id=USER_ID,
         limit=5,
         threshold=0.7,  # Higher threshold for more relevant results
-        output_format="v1.1"
+        
     )
     
     # Format and return the results
@@ -369,7 +369,7 @@ def create_memory_voice_agent():
             Use the search_memories tool when you need context from past conversations or user asks you to recall something.
             """,
         ),
-        model="gpt-4o",
+        model="gpt-4.1-nano-2025-04-14",
         tools=[save_memories, search_memories],
     )
     

docs/examples/mem0-with-ollama.mdx

@@ -6,15 +6,15 @@ title: Mem0 with Ollama
 
 Mem0 can be utilized entirely locally by leveraging Ollama for both the embedding model and the language model (LLM). This guide will walk you through the necessary steps and provide the complete code to get you started.
 
-### Overview
+## Overview
 
 By using Ollama, you can run Mem0 locally, which allows for greater control over your data and models. This setup uses Ollama for both the embedding model and the language model, providing a fully local solution.
 
-### Setup
+## Setup
 
 Before you begin, ensure you have Mem0 and Ollama installed and properly configured on your local machine.
 
-### Full Code Example
+## Full Code Example
 
 Below is the complete code to set up and use Mem0 locally with Ollama:
 
@@ -60,13 +60,13 @@ m.add("I'm visiting Paris", user_id="john")
 memories = m.get_all(user_id="john")
 ```
 
-### Key Points
+## Key Points
 
-- **Configuration**: The setup involves configuring the vector store, language model, and embedding model to use local resources.
-- **Vector Store**: Qdrant is used as the vector store, running on localhost.
-- **Language Model**: Ollama is used as the LLM provider, with the "llama3.1:latest" model.
-- **Embedding Model**: Ollama is also used for embeddings, with the "nomic-embed-text:latest" model.
+- **Configuration**: The setup involves configuring the vector store, language model, and embedding model to use local resources
+- **Vector Store**: Qdrant is used as the vector store, running on localhost
+- **Language Model**: Ollama is used as the LLM provider, with the `llama3.1:latest` model
+- **Embedding Model**: Ollama is also used for embeddings, with the `nomic-embed-text:latest` model
 
-### Conclusion
+## Conclusion
 
 This local setup of Mem0 using Ollama provides a fully self-contained solution for memory management and AI interactions. It allows for greater control over your data and models while still leveraging the powerful capabilities of Mem0.

docs/examples/memory-guided-content-writing.mdx

@@ -31,7 +31,7 @@ USER_ID = "content_writer"
 RUN_ID = "smart_editing_session"
 ```
 
-## **Storing Your Writing Preferences in Mem0**
+## Storing Your Writing Preferences in Mem0
 
 ```python
 def store_writing_preferences():
@@ -60,7 +60,7 @@ def store_writing_preferences():
     return response
 ```
 
-## **Editing Content Using Stored Preferences**
+## Editing Content Using Stored Preferences
 
 ```python
 def apply_writing_style(original_content):
@@ -68,17 +68,12 @@ def apply_writing_style(original_content):
 
     results = client.search(
         query="What are my writing style preferences?",
-        version="v2",
         filters={
             "AND": [
-                {
-                    "user_id": USER_ID
-                },
-                {
-                    "run_id": RUN_ID
-                }
+                {"user_id": USER_ID},
+                {"run_id": RUN_ID}
             ]
-        },
+        }
     )
 
     if not results:
@@ -103,7 +98,7 @@ Preferences:
     ]
 
     response = openai.chat.completions.create(
-        model="gpt-4o-mini",
+        model="gpt-4.1-nano-2025-04-14",
         messages=messages
     )
     clean_response = response.choices[0].message.content.strip()
@@ -111,7 +106,7 @@ Preferences:
     return clean_response
 ```
 
-## **Complete Workflow: Content Editing**
+## Complete Workflow: Content Editing
 
 ```python
 def content_writing_workflow(content):
@@ -136,7 +131,7 @@ def content_writing_workflow(content):
     return edited_content
 ```
 
-## **Example Usage**
+## Example Usage
 
 ```python
 # Define your document
@@ -156,11 +151,11 @@ We plan to launch the campaign in July and continue through September.
 result = content_writing_workflow(original_content)
 ```
 
-## **Expected Output**
+## Expected Output
 
 Your document will be transformed into a structured, well-formatted version based on your preferences.
 
-### **Original Document**
+### Original Document
 ```
 Project Proposal
     
@@ -174,37 +169,38 @@ Expand our social media following
 We plan to launch the campaign in July and continue through September.
 ```
 
-### **Edited Document**
-```
-# **Project Proposal**
+### Edited Document
 
-## **Q3 Marketing Campaign Strategy**
+```
+# Project Proposal
+
+## Q3 Marketing Campaign Strategy
 
 This proposal outlines our strategy for the Q3 marketing campaign. We aim to significantly increase our market share with this approach.
 
-### **Objectives**
+### Objectives
 
 - **Increase Brand Awareness**: Implement targeted advertising and community engagement to enhance visibility.
 - **Boost Sales by 15%**: Increase sales by 15% compared to Q2 figures.
 - **Expand Social Media Following**: Grow our social media audience by 20%.
 
-### **Timeline**
+### Timeline
 
 - **Launch Date**: July
 - **Duration**: July – September
 
-### **Key Actions**
+### Key Actions
 
 - **Targeted Advertising**: Utilize platforms like Google Ads and Facebook to reach specific demographics.
 - **Community Engagement**: Host webinars and live Q&A sessions.
 - **Content Creation**: Produce engaging videos and infographics.
 
-### **Supporting Data**
+### Supporting Data
 
 - **Previous Campaign Success**: Our Q2 campaign increased sales by 12%. We will refine similar strategies for Q3.
 - **Social Media Growth**: Last year, our Instagram followers grew by 25% during a similar campaign.
 
-### **Conclusion**
+### Conclusion
 
 We believe this strategy will effectively increase our market share. To achieve these goals, we need your support and collaboration. Let’s work together to make this campaign a success. Please review the proposal and provide your feedback by the end of the week.
 ```

docs/examples/multimodal-demo.mdx

@@ -2,24 +2,24 @@
 title: Multimodal Demo with Mem0
 ---
 
-Enhance your AI interactions with **Mem0**'s multimodal capabilities. Mem0 now supports image understanding, allowing for richer context and more natural interactions across supported AI platforms.
+Enhance your AI interactions with Mem0's multimodal capabilities. Mem0 now supports image understanding, allowing for richer context and more natural interactions across supported AI platforms.
 
 > Experience the power of multimodal AI! Test out Mem0's image understanding capabilities at [multimodal-demo.mem0.ai](https://multimodal-demo.mem0.ai)
 
 ## Features
 
-- **Image Understanding**: Share and discuss images with AI assistants while maintaining context.
-- **Smart Visual Context**: Automatically capture and reference visual elements in conversations.
-- **Cross-Modal Memory**: Link visual and textual information seamlessly in your memory layer.
-- **Cross-Session Recall**: Reference previously discussed visual content across different conversations.
-- **Seamless Integration**: Works naturally with existing chat interfaces for a smooth experience.
+- **Image Understanding**: Share and discuss images with AI assistants while maintaining context
+- **Smart Visual Context**: Automatically capture and reference visual elements in conversations
+- **Cross-Modal Memory**: Link visual and textual information seamlessly in your memory layer
+- **Cross-Session Recall**: Reference previously discussed visual content across different conversations
+- **Seamless Integration**: Works naturally with existing chat interfaces for a smooth experience
 
 ## How It Works
 
-1. **Upload Visual Content**: Simply drag and drop or paste images into your conversations.
-2. **Natural Interaction**: Discuss the visual content naturally with AI assistants.
-3. **Memory Integration**: Visual context is automatically stored and linked with your conversation history.
-4. **Persistent Recall**: Retrieve and reference past visual content effortlessly.
+1. **Upload Visual Content**: Simply drag and drop or paste images into your conversations
+2. **Natural Interaction**: Discuss the visual content naturally with AI assistants
+3. **Memory Integration**: Visual context is automatically stored and linked with your conversation history
+4. **Persistent Recall**: Retrieve and reference past visual content effortlessly
 
 ## Demo Video
 

docs/examples/openai-inbuilt-tools.mdx

@@ -35,7 +35,7 @@ const openAIClient = new OpenAI();
 const mem0Client = new MemoryClient(mem0Config);
 ```
 
-### Adding Memories
+## Adding Memories
 
 Store user preferences, past interactions, or any relevant information:
 <CodeGroup>
@@ -84,7 +84,7 @@ await addUserPreferences();
 ]
 ```
 </CodeGroup>
-### Retrieving Memories
+## Retrieving Memories
 
 Search for relevant memories based on the current user input:
 
@@ -92,7 +92,7 @@ Search for relevant memories based on the current user input:
 const relevantMemories = await mem0Client.search(userInput, mem0Config);
 ```
 
-### Structured Responses with Zod
+## Structured Responses with Zod
 
 Define structured response schemas to get consistent output formats:
 
@@ -119,19 +119,19 @@ const carRecommendationTool = zodResponsesFunction({
 
 // Use the tool in your OpenAI request
 const response = await openAIClient.responses.create({
-    model: "gpt-4o",
+    model: "gpt-4.1-nano-2025-04-14",
     tools: [{ type: "web_search_preview" }, carRecommendationTool],
     input: `${getMemoryString(relevantMemories)}\n${userInput}`,
 });
 ```
 
-### Using Web Search
+## Using Web Search
 
 Combine memory with web search for up-to-date recommendations:
 
 ```javascript
 const response = await openAIClient.responses.create({
-    model: "gpt-4o",
+    model: "gpt-4.1-nano-2025-04-14",
     tools: [{ type: "web_search_preview" }, carRecommendationTool],
     input: `${getMemoryString(relevantMemories)}\n${userInput}`,
 });
@@ -139,7 +139,7 @@ const response = await openAIClient.responses.create({
 
 ## Examples
 
-### Complete Car Recommendation System
+## Complete Car Recommendation System
 
 ```javascript
 import MemoryClient from "mem0ai";
@@ -202,7 +202,7 @@ async function main(memory = false) {
   }
 
   const response = await openAIClient.responses.create({
-    model: "gpt-4o",
+    model: "gpt-4.1-nano-2025-04-14",
     tools: [{ type: "web_search_preview" }, tool],
     input: `${getMemoryString(relevantMemories)}\n${input}`,
   });
@@ -230,7 +230,7 @@ const getMemoryString = (memories) => {
 run().catch(console.error);
 ```
 
-### Responses
+## Responses
 
 <CodeGroup>
     ```json Without Memories