bump version -> 0.1.73 (#2412)

Co-authored-by: Dev Khant <devkhant24@gmail.com>

.github/workflows/cd.yml

@@ -25,22 +25,23 @@ jobs:
 
       - name: Install dependencies
         run: |
-          cd embedchain
+          cd mem0
           poetry install
 
       - name: Build a binary wheel and a source tarball
         run: |
-          cd embedchain
+          cd mem0
           poetry build
 
-      - name: Publish distribution 📦 to Test PyPI
-        uses: pypa/gh-action-pypi-publish@release/v1
-        with:
-          repository_url: https://test.pypi.org/legacy/
-          packages_dir: embedchain/dist/
+      # TODO: Needs to setup mem0 repo on Test PyPI
+      # - name: Publish distribution 📦 to Test PyPI
+      #   uses: pypa/gh-action-pypi-publish@release/v1
+      #   with:
+      #     repository_url: https://test.pypi.org/legacy/
+      #     packages_dir: dist/
 
       - name: Publish distribution 📦 to PyPI
         if: startsWith(github.ref, 'refs/tags')
         uses: pypa/gh-action-pypi-publish@release/v1
         with:
-          packages_dir: embedchain/dist/
+          packages_dir: dist/

Makefile

@@ -12,8 +12,8 @@ install:
 
 install_all:
 	poetry install
-	poetry run pip install groq together boto3 litellm ollama chromadb sentence_transformers vertexai \
-	                        google-generativeai elasticsearch opensearch-py vecs
+	poetry run pip install groq together boto3 litellm ollama chromadb weaviate weaviate-client sentence_transformers vertexai \
+	                        google-generativeai elasticsearch opensearch-py vecs pinecone pinecone-text
 
 # Format code with ruff
 format:

README.md

@@ -16,6 +16,8 @@
     <a href="https://mem0.ai">Learn more</a>
     ·
     <a href="https://mem0.dev/DiG">Join Discord</a>
+    ·
+    <a href="https://mem0.dev/demo">Demo</a>
   </p>
 </p>
 
@@ -79,7 +81,7 @@ npm install mem0ai
 
 ### Basic Usage
 
-Mem0 requires an LLM to function, with `gpt-4o` from OpenAI as the default. However, it supports a variety of LLMs; for details, refer to our [Supported LLMs documentation](https://docs.mem0.ai/llms).
+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/llms).
 
 First step is to instantiate the memory:
 
@@ -93,7 +95,7 @@ memory = Memory()
 def chat_with_memories(message: str, user_id: str = "default_user") -> str:
     # Retrieve relevant memories
     relevant_memories = memory.search(query=message, user_id=user_id, limit=3)
-    memories_str = "\n".join(f"- {entry['memory']}" for entry in relevant_memories)
+    memories_str = "\n".join(f"- {entry['memory']}" for entry in relevant_memories["results"])
     
     # Generate Assistant response
     system_prompt = f"You are a helpful AI. Answer the question based on query and memories.\nUser Memories:\n{memories_str}"
@@ -129,15 +131,17 @@ For more advanced usage and API documentation, visit our [documentation](https:/
 
 ## Demos
 
-- AI Companion: Experience personalized conversations with an AI that remembers your preferences and past interactions
+- Mem0 - ChatGPT with Memory: A personalized AI chat app powered by Mem0 that remembers your preferences, facts, and memories.
 
-[AI Companion Demo](https://github.com/user-attachments/assets/3fc72023-a72c-4593-8be0-3cee3ba744da)
+[Mem0 - ChatGPT with Memory](https://github.com/user-attachments/assets/cebc4f8e-bdb9-4837-868d-13c5ab7bb433)
+
+Try live [demo](https://mem0.dev/demo/)
 
 <br/><br/>
 
-- Mem0 Demo: A personalized AI chat app powered by Mem0 that remembers your preferences, facts, and memories.
+- AI Companion: Experience personalized conversations with an AI that remembers your preferences and past interactions
 
-[Mem0 Demo](https://github.com/user-attachments/assets/cebc4f8e-bdb9-4837-868d-13c5ab7bb433)
+[AI Companion Demo](https://github.com/user-attachments/assets/3fc72023-a72c-4593-8be0-3cee3ba744da)
 
 <br/><br/>
 

docs/components/vectordbs/config.mdx

@@ -8,8 +8,9 @@ iconType: "solid"
 
 The `config` is defined as an object with two main keys:
 - `vector_store`: Specifies the vector database provider and its configuration
-  - `provider`: The name of the vector database (e.g., "chroma", "pgvector", "qdrant", "milvus", "azure_ai_search")
-  - `config`: A nested object containing provider-specific settings
+  - `provider`: The name of the vector database (e.g., "chroma", "pgvector", "qdrant", "milvus","azure_ai_search", "vertex_ai_vector_search")
+  - `config`: A nested dictionary containing provider-specific settings
+
 
 ## How to Use Config
 
@@ -86,6 +87,12 @@ Here's a comprehensive list of all parameters that can be used across different
 | `url` | Full URL for the server |
 | `api_key` | API key for the server |
 | `on_disk` | Enable persistent storage |
+| `endpoint_id` | Endpoint ID (vertex_ai_vector_search) |
+| `index_id` | Index ID (vertex_ai_vector_search) |
+| `deployment_index_id` | Deployment index ID (vertex_ai_vector_search) |
+| `project_id` | Project ID (vertex_ai_vector_search) |
+| `project_number` | Project number (vertex_ai_vector_search) |
+| `vector_search_api_endpoint` | Vector search API endpoint (vertex_ai_vector_search) |
 | `connection_string` | PostgreSQL connection string (for Supabase/PGVector) |
 | `index_method` | Vector index method (for Supabase) |
 | `index_measure` | Distance measure for similarity search (for Supabase) |

docs/components/vectordbs/dbs/azure_ai_search.mdx

@@ -1,12 +1,14 @@
-[Azure AI Search](https://learn.microsoft.com/en-us/azure/search/search-what-is-azure-search/) (formerly known as "Azure Cognitive Search") provides secure information retrieval at scale over user-owned content in traditional and generative AI search applications.
+# Azure AI Search
 
-### Usage
+[Azure AI Search](https://learn.microsoft.com/azure/search/search-what-is-azure-search/) (formerly known as "Azure Cognitive Search") provides secure information retrieval at scale over user-owned content in traditional and generative AI search applications.
+
+## Usage
 
 ```python
 import os
 from mem0 import Memory
 
-os.environ["OPENAI_API_KEY"] = "sk-xx"   #this key is used for embedding purpose
+os.environ["OPENAI_API_KEY"] = "sk-xx"   # This key is used for embedding purpose
 
 config = {
     "vector_store": {
@@ -15,8 +17,7 @@ config = {
             "service_name": "ai-search-test",
             "api_key": "*****",
             "collection_name": "mem0", 
-            "embedding_model_dims": 1536 ,
-            "use_compression": False
+            "embedding_model_dims": 1536
         }
     }
 }
@@ -25,20 +26,48 @@ m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
     {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
-    {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]
 m.add(messages, user_id="alice", metadata={"category": "movies"})
 ```
 
-### Config
+## Using binary compression for large vector collections
 
-Let's see the available parameters for the `qdrant` config:
-service_name (str): Azure Cognitive Search service name.  
-| Parameter | Description | Default Value |
-| --- | --- | --- |
-| `service_name` | Azure AI Search service name | `None` |
-| `api_key` | API key of the Azure AI Search service | `None` |
-| `collection_name` | The name of the collection/index to store the vectors, it will be created automatically if not exist | `mem0` |
-| `embedding_model_dims` | Dimensions of the embedding model | `1536` |
-| `use_compression` | Use scalar quantization vector compression | False |
+```python
+config = {
+    "vector_store": {
+        "provider": "azure_ai_search",
+        "config": {
+            "service_name": "ai-search-test",
+            "api_key": "*****",
+            "collection_name": "mem0", 
+            "embedding_model_dims": 1536,
+            "compression_type": "binary",
+            "use_float16": True  # Use half precision for storage efficiency
+        }
+    }
+}
+```
+
+## Configuration Parameters
+
+| Parameter | Description | Default Value | Options |
+| --- | --- | --- | --- |
+| `service_name` | Azure AI Search service name | Required | - |
+| `api_key` | API key of the Azure AI Search service | Required | - |
+| `collection_name` | The name of the collection/index to store vectors | `mem0` | Any valid index name |
+| `embedding_model_dims` | Dimensions of the embedding model | `1536` | Any integer value |
+| `compression_type` | Type of vector compression to use | `none` | `none`, `scalar`, `binary` |
+| `use_float16` | Store vectors in half precision (Edm.Half) | `False` | `True`, `False` |
+
+## Notes on Configuration Options
+
+- **compression_type**: 
+  - `none`: No compression, uses full vector precision
+  - `scalar`: Scalar quantization with reasonable balance of speed and accuracy
+  - `binary`: Binary quantization for maximum compression with some accuracy trade-off
+
+- **use_float16**: Using half precision (float16) reduces storage requirements but may slightly impact accuracy. Useful for very large vector collections.
+
+- **Filterable Fields**: The implementation automatically extracts `user_id`, `run_id`, and `agent_id` fields from payloads for filtering.

docs/components/vectordbs/dbs/elasticsearch.mdx

@@ -54,6 +54,7 @@ Let's see the available parameters for the `elasticsearch` config:
 | `password`             | Password for basic authentication                  | `None`        |
 | `verify_certs`         | Whether to verify SSL certificates                 | `True`        |
 | `auto_create_index`    | Whether to automatically create the index          | `True`        |
+| `custom_search_query`  | Function returning a custom search query            | `None`        |
 
 ### Features
 
@@ -62,3 +63,46 @@ Let's see the available parameters for the `elasticsearch` config:
 - Multiple authentication methods (Basic Auth, API Key)
 - Automatic index creation with optimized mappings for vector search
 - Memory isolation through payload filtering
+- Custom search query function to customize the search query
+
+### Custom Search Query
+
+The `custom_search_query` parameter allows you to customize the search query when `Memory.search` is called.  
+  
+__Example__  
+```python
+import os
+from typing import List, Optional, Dict
+from mem0 import Memory
+
+def custom_search_query(query: List[float], limit: int, filters: Optional[Dict]) -> Dict:
+    return {
+        "knn": {
+            "field": "vector", 
+            "query_vector": query, 
+            "k": limit, 
+            "num_candidates": limit * 2
+        }
+    }
+
+os.environ["OPENAI_API_KEY"] = "sk-xx"
+
+config = {
+    "vector_store": {
+        "provider": "elasticsearch",
+        "config": {
+            "collection_name": "mem0",
+            "host": "localhost",
+            "port": 9200,
+            "embedding_model_dims": 1536,
+            "custom_search_query": custom_search_query
+        }
+    }
+}
+```
+It should be a function that takes the following parameters:
+- `query`: a query vector used in `Memory.search`
+- `limit`: a number of results used in `Memory.search`
+- `filters`: a dictionary of key-value pairs used in `Memory.search`. You can add custom pairs for the custom search query.  
+  
+The function should return a query body for the Elasticsearch search API.

docs/components/vectordbs/dbs/pinecone.mdx

@@ -0,0 +1,88 @@
+# Pinecone
+
+[Pinecone](https://www.pinecone.io/) is a fully managed vector database designed for machine learning applications, offering high performance vector search with low latency at scale. It's particularly well-suited for semantic search, recommendation systems, and other AI-powered applications.
+
+### Usage
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "sk-xx"
+os.environ["PINECONE_API_KEY"] = "your-api-key"
+
+config = {
+    "vector_store": {
+        "provider": "pinecone",
+        "config": {
+            "collection_name": "memory_index",
+            "embedding_model_dims": 1536,
+            "environment": "us-west1-gcp",
+            "metric": "cosine"
+        }
+    }
+}
+
+m = Memory.from_config(config)
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
+```
+
+### Config
+
+Here are the parameters available for configuring Pinecone:
+
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `collection_name` | Name of the index/collection | Required |
+| `embedding_model_dims` | Dimensions of the embedding model | Required |
+| `client` | Existing Pinecone client instance | `None` |
+| `api_key` | API key for Pinecone | Environment variable: `PINECONE_API_KEY` |
+| `environment` | Pinecone environment | `None` |
+| `serverless_config` | Configuration for serverless deployment | `None` |
+| `pod_config` | Configuration for pod-based deployment | `None` |
+| `hybrid_search` | Whether to enable hybrid search | `False` |
+| `metric` | Distance metric for vector similarity | `"cosine"` |
+| `batch_size` | Batch size for operations | `100` |
+
+#### Serverless Config Example
+
+```python
+config = {
+    "vector_store": {
+        "provider": "pinecone",
+        "config": {
+            "collection_name": "memory_index",
+            "embedding_model_dims": 1536,
+            "serverless_config": {
+                "cloud": "aws",
+                "region": "us-west-2"
+            }
+        }
+    }
+}
+```
+
+#### Pod Config Example
+
+```python
+config = {
+    "vector_store": {
+        "provider": "pinecone",
+        "config": {
+            "collection_name": "memory_index",
+            "embedding_model_dims": 1536,
+            "pod_config": {
+                "environment": "gcp-starter",
+                "replicas": 1,
+                "pod_type": "starter"
+            }
+        }
+    }
+}
+```

docs/components/vectordbs/dbs/vertex_ai_vector_search.mdx

@@ -0,0 +1,46 @@
+## Google Cloud Vertex AI Vector Search
+
+
+### Usage
+
+To use Google Cloud Vertex AI Vector Search with `mem0`, you need to configure the `vector_store` in your `mem0` config:
+
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["GEMINI_API_KEY"] = = "sk-xx"
+
+config = {
+    "vector_store": {
+        "provider": "vertex_ai_vector_search",
+        "config": {
+            "endpoint_id": "YOUR_ENDPOINT_ID",            # Required: Vector Search endpoint ID
+            "index_id": "YOUR_INDEX_ID",                  # Required: Vector Search index ID 
+            "deployment_index_id": "YOUR_DEPLOYMENT_INDEX_ID",  # Required: Deployment-specific ID
+            "project_id": "YOUR_PROJECT_ID",              # Required: Google Cloud project ID
+            "project_number": "YOUR_PROJECT_NUMBER",      # Required: Google Cloud project number
+            "region": "YOUR_REGION",                      # Optional: Defaults to GOOGLE_CLOUD_REGION
+            "credentials_path": "path/to/credentials.json", # Optional: Defaults to GOOGLE_APPLICATION_CREDENTIALS
+            "vector_search_api_endpoint": "YOUR_API_ENDPOINT" # Required for get operations
+        }
+    }
+}
+m = Memory.from_config(config)
+m.add("Your text here", user_id="user", metadata={"category": "example"})
+```
+
+
+### Required Parameters
+
+| Parameter | Description | Required |
+|-----------|-------------|----------|
+| `endpoint_id` | Vector Search endpoint ID | Yes |
+| `index_id` | Vector Search index ID | Yes |
+| `deployment_index_id` | Deployment-specific index ID | Yes |
+| `project_id` | Google Cloud project ID | Yes |
+| `project_number` | Google Cloud project number | Yes |
+| `vector_search_api_endpoint` | Vector search API endpoint | Yes (for get operations) |
+| `region` | Google Cloud region | No (defaults to GOOGLE_CLOUD_REGION) |
+| `credentials_path` | Path to service account credentials | No (defaults to GOOGLE_APPLICATION_CREDENTIALS) |

docs/components/vectordbs/dbs/weaviate.mdx

@@ -0,0 +1,47 @@
+[Weaviate](https://weaviate.io/) is an open-source vector search engine. It allows efficient storage and retrieval of high-dimensional vector embeddings, enabling powerful search and retrieval capabilities.
+
+
+### Installation
+```bash
+pip install weaviate weaviate-client
+```
+
+### Usage
+
+```python Python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "sk-xx"
+
+config = {
+    "vector_store": {
+        "provider": "weaviate",
+        "config": {
+            "collection_name": "test",
+            "cluster_url": "http://localhost:8080",
+            "auth_client_secret": None,
+        }
+    }
+}
+
+m = Memory.from_config(config)
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movie? They can be quite engaging."},
+    {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
+```
+
+### Config
+
+Let's see the available parameters for the `weaviate` config:
+
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `collection_name` | The name of the collection to store the vectors | `mem0` |
+| `embedding_model_dims` | Dimensions of the embedding model | `1536` |
+| `cluster_url` | URL for the Weaviate server | `None` |
+| `auth_client_secret` | API key for Weaviate authentication | `None` |

docs/components/vectordbs/overview.mdx

@@ -19,11 +19,14 @@ See the list of supported vector databases below.
   <Card title="Chroma" href="/components/vectordbs/dbs/chroma"></Card>
   <Card title="Pgvector" href="/components/vectordbs/dbs/pgvector"></Card>
   <Card title="Milvus" href="/components/vectordbs/dbs/milvus"></Card>
+  <Card title="Pinecone" href="/components/vectordbs/dbs/pinecone"></Card>
   <Card title="Azure AI Search" href="/components/vectordbs/dbs/azure_ai_search"></Card>
   <Card title="Redis" href="/components/vectordbs/dbs/redis"></Card>
   <Card title="Elasticsearch" href="/components/vectordbs/dbs/elasticsearch"></Card>
   <Card title="OpenSearch" href="/components/vectordbs/dbs/opensearch"></Card>
   <Card title="Supabase" href="/components/vectordbs/dbs/supabase"></Card>
+  <Card title="Vertex AI Vector Search" href="/components/vectordbs/dbs/vertex_ai_vector_search"></Card>
+  <Card title="Weaviate" href="/components/vectordbs/dbs/weaviate"></Card>
 </CardGroup>
 
 ## Usage

docs/docs.json

@@ -47,6 +47,7 @@
                     "pages": [
                       "features/platform-overview",
                       "features/advanced-retrieval",
+                      "features/contextual-add",
                       "features/multimodal-support",
                       "features/selective-memory",
                       "features/custom-categories",
@@ -54,7 +55,9 @@
                       "features/direct-import",
                       "features/async-client",
                       "features/memory-export",
-                      "features/webhooks"
+                      "features/webhooks",
+                      "features/graph-memory",
+                      "features/feedback-mechanism"
                     ]
                   }
                 ]
@@ -71,7 +74,8 @@
                     "icon": "wrench",
                     "pages": [
                       "features/openai_compatibility",
-                      "features/custom-prompts",
+                      "features/custom-fact-extraction-prompt",
+                      "features/custom-update-memory-prompt",
                       "open-source/multimodal-support",
                       "open-source/features/rest-api"
                     ]
@@ -125,11 +129,14 @@
                           "components/vectordbs/dbs/chroma",
                           "components/vectordbs/dbs/pgvector",
                           "components/vectordbs/dbs/milvus",
+                          "components/vectordbs/dbs/pinecone",
                           "components/vectordbs/dbs/azure_ai_search",
                           "components/vectordbs/dbs/redis",
                           "components/vectordbs/dbs/elasticsearch",
                           "components/vectordbs/dbs/opensearch",
-                          "components/vectordbs/dbs/supabase"
+                          "components/vectordbs/dbs/supabase",
+                          "components/vectordbs/dbs/vertex_ai_vector_search",
+                          "components/vectordbs/dbs/weaviate"
                         ]
                       }
                     ]
@@ -180,7 +187,13 @@
                   "examples/personal-ai-tutor",
                   "examples/customer-support-agent",
                   "examples/personal-travel-assistant",
-                  "examples/llama-index-mem0"
+                  "examples/llama-index-mem0",
+                  "examples/chrome-extension",
+                  "examples/document-writing",
+                  "examples/multimodal-demo",
+                  "examples/personalized-deep-research",
+                  "examples/mem0-agentic-tool",
+                  "examples/openai-inbuilt-tools"
                 ]
               }
             ]
@@ -200,7 +213,8 @@
                   "integrations/langgraph",
                   "integrations/llama-index",
                   "integrations/langchain-tools",
-                  "integrations/dify"
+                  "integrations/dify",
+                  "integrations/mcp-server"
                 ]
               }
             ]
@@ -277,7 +291,7 @@
       },
       {
         "anchor": "Demo",
-        "href": "https://demo.mem0.ai",
+        "href": "https://mem0.dev/demo",
         "icon": "play"
       },
       {
@@ -327,6 +341,9 @@
     "posthog": {
       "apiKey": "phc_hgJkUVJFYtmaJqrvf6CYN67TIQ8yhXAkWzUn9AMU4yX",
       "apiHost": "https://mango.mem0.ai"
+    },
+    "intercom": {
+      "appId": "jjv2r0tt"
     }
   }
 }

docs/examples/chrome-extension.mdx

@@ -0,0 +1,55 @@
+# 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.
+
+<Note>
+  🎉 We now support Grok! The Mem0 Chrome Extension has been updated to work with Grok, bringing the same powerful memory capabilities to your Grok conversations.
+</Note>
+
+
+## Features
+
+- **Universal Memory Layer**: Share context seamlessly across ChatGPT, Claude, Perplexity, and Grok.
+- **Smart Context Detection**: Automatically captures relevant information from your conversations.
+- **Intelligent Memory Retrieval**: Surfaces pertinent memories at the right time.
+- **One-Click Sync**: Easily synchronize with existing ChatGPT memories.
+- **Memory Dashboard**: Manage all your memories in one centralized location.
+
+## Installation
+
+You can install the Mem0 Chrome Extension using one of the following methods:
+
+### Method 1: Chrome Web Store Installation
+
+1. **Download the Extension**: Open Google Chrome and navigate to the [Mem0 Chrome Extension page](https://chromewebstore.google.com/detail/mem0/onihkkbipkfeijkadecaafbgagkhglop?hl=en).
+2. **Add to Chrome**: Click on the "Add to Chrome" button.
+3. **Confirm Installation**: In the pop-up dialog, click "Add extension" to confirm. The Mem0 icon should now appear in your Chrome toolbar.
+
+### Method 2: Manual Installation
+
+1. **Download the Extension**: Clone or download the extension files from the [Mem0 Chrome Extension GitHub repository](https://github.com/mem0ai/mem0-chrome-extension).
+2. **Access Chrome Extensions**: Open Google Chrome and navigate to `chrome://extensions`.
+3. **Enable Developer Mode**: Toggle the "Developer mode" switch in the top right corner.
+4. **Load Unpacked Extension**: Click "Load unpacked" and select the directory containing the extension files.
+5. **Confirm Installation**: The Mem0 Chrome Extension should now appear in your Chrome toolbar.
+
+## Usage
+
+1. **Locate the Mem0 Icon**: After installation, find the Mem0 icon in your Chrome toolbar.
+2. **Sign In**: Click the icon and sign in with your Google account.
+3. **Interact with AI Assistants**:
+   - **ChatGPT and Perplexity**: Continue your conversations as usual; Mem0 operates seamlessly in the background.
+   - **Claude**: Click the Mem0 button or use the shortcut `Ctrl + M` to activate memory functions.
+
+## Configuration
+
+- **API Key**: Obtain your API key from the Mem0 Dashboard to connect the extension to the Mem0 API.
+- **User ID**: This is your unique identifier in the Mem0 system. If not provided, it defaults to 'chrome-extension-user'.
+
+## Demo Video
+
+<iframe width="700" height="400" src="https://www.youtube.com/embed/dqenCMMlfwQ?si=zhGVrkq6IS_0Jwyj" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>
+
+## Privacy and Data Security
+
+Your messages are sent to the Mem0 API for extracting and retrieving memories. Mem0 is committed to ensuring your data's privacy and security.

docs/examples/customer-support-agent.mdx

@@ -94,8 +94,8 @@ You can fetch all the memories at any point in time using the following code:
 
 ```python
 memories = support_agent.get_memories(user_id=customer_id)
-for m in memories:
-    print(m['text'])
+for m in memories['results']:
+    print(m['memory'])
 ```
 
 ### Key Points

docs/examples/document-writing.mdx

@@ -0,0 +1,184 @@
+---
+title: Document Editing with Mem0
+---
+
+This guide demonstrates how to leverage **Mem0** to edit documents efficiently, ensuring they align with your unique writing style and preferences.
+
+## **Why Use Mem0?**
+
+By integrating Mem0 into your workflow, you can streamline your document editing process with:
+
+1. **Persistent Writing Preferences**: Mem0 stores and recalls your style preferences, ensuring consistency across all documents.
+2. **Automated Enhancements**: Your stored preferences guide document refinements, making edits seamless and efficient.
+3. **Scalability & Reusability**: Your writing style can be applied to multiple documents, saving time and effort.
+
+---
+## **Setup**
+
+```python
+import os
+from mem0 import MemoryClient
+
+# Set up Mem0 client
+os.environ["MEM0_API_KEY"] = "your-mem0-api-key"
+client = MemoryClient()
+
+# Define constants
+USER_ID = "content_writer"
+RUN_ID = "smart_editing_session"
+```
+
+---
+## **Storing Your Writing Preferences in Mem0**
+
+```python
+def store_writing_preferences():
+    """Store your writing preferences in Mem0."""
+    
+    # Define writing preferences
+    preferences = """My writing preferences:
+1. Use headings and sub-headings for structure.
+2. Keep paragraphs concise (8-10 sentences max).
+3. Incorporate specific numbers and statistics.
+4. Provide concrete examples.
+5. Use bullet points for clarity.
+6. Avoid jargon and buzzwords."""
+
+    # Store preferences in Mem0
+    preference_message = [
+        {"role": "user", "content": "Here are my writing style preferences"},
+        {"role": "assistant", "content": preferences}
+    ]
+    
+    response = client.add(preference_message, user_id=USER_ID, run_id=RUN_ID, metadata={"type": "preferences", "category": "writing_style"})
+    
+    print("Writing preferences stored successfully.")
+    return response
+```
+
+---
+## **Editing Documents with Mem0**
+
+```python
+def edit_document_based_on_preferences(original_content):
+    """Edit a document using Mem0-based stored preferences."""
+    
+    # Retrieve stored preferences
+    query = "What are my writing style preferences?"
+    preferences_results = client.search(query, user_id=USER_ID, run_id=RUN_ID)
+    
+    if not preferences_results:
+        print("No writing preferences found.")
+        return None
+    
+    # Extract preferences
+    preferences = ' '.join(memory["memory"] for memory in preferences_results)
+    
+    # Apply stored preferences to refine the document
+    edited_content = f"Applying stored preferences:\n{preferences}\n\nEdited Document:\n{original_content}"
+    
+    return edited_content
+```
+
+---
+## **Complete Workflow: Document Editing**
+
+```python
+def document_editing_workflow(content):
+    """Automated workflow for editing a document based on writing preferences."""
+    
+    # Step 1: Store writing preferences (if not already stored)
+    store_writing_preferences()
+    
+    # Step 2: Edit the document with Mem0 preferences
+    edited_content = edit_document_based_on_preferences(content)
+    
+    if not edited_content:
+        return "Failed to edit document."
+    
+    # Step 3: Display results
+    print("\n=== ORIGINAL DOCUMENT ===\n")
+    print(content)
+    
+    print("\n=== EDITED DOCUMENT ===\n")
+    print(edited_content)
+    
+    return edited_content
+```
+
+---
+## **Example Usage**
+
+```python
+# Define your document
+original_content = """Project Proposal
+    
+The following proposal outlines our strategy for the Q3 marketing campaign. 
+We believe this approach will significantly increase our market share.
+
+Increase brand awareness
+Boost sales by 15%
+Expand our social media following
+
+We plan to launch the campaign in July and continue through September.
+"""
+
+# Run the workflow
+result = document_editing_workflow(original_content)
+```
+
+---
+## **Expected Output**
+
+Your document will be transformed into a structured, well-formatted version based on your preferences.
+
+### **Original Document**
+```
+Project Proposal
+    
+The following proposal outlines our strategy for the Q3 marketing campaign. 
+We believe this approach will significantly increase our market share.
+
+Increase brand awareness
+Boost sales by 15%
+Expand our social media following
+
+We plan to launch the campaign in July and continue through September.
+```
+
+### **Edited Document**
+```
+# **Project Proposal**
+
+## **Q3 Marketing Campaign Strategy**
+
+This proposal outlines our strategy for the Q3 marketing campaign. We aim to significantly increase our market share with this approach.
+
+### **Objectives**
+
+- **Increase Brand Awareness**: Implement targeted advertising and community engagement to enhance visibility.
+- **Boost Sales by 15%**: Increase sales by 15% compared to Q2 figures.
+- **Expand Social Media Following**: Grow our social media audience by 20%.
+
+### **Timeline**
+
+- **Launch Date**: July
+- **Duration**: July – September
+
+### **Key Actions**
+
+- **Targeted Advertising**: Utilize platforms like Google Ads and Facebook to reach specific demographics.
+- **Community Engagement**: Host webinars and live Q&A sessions.
+- **Content Creation**: Produce engaging videos and infographics.
+
+### **Supporting Data**
+
+- **Previous Campaign Success**: Our Q2 campaign increased sales by 12%. We will refine similar strategies for Q3.
+- **Social Media Growth**: Last year, our Instagram followers grew by 25% during a similar campaign.
+
+### **Conclusion**
+
+We believe this strategy will effectively increase our market share. To achieve these goals, we need your support and collaboration. Let’s work together to make this campaign a success. Please review the proposal and provide your feedback by the end of the week.
+```
+
+Mem0 creates a seamless, intelligent document editing experience—perfect for content creators, technical writers, and businesses alike!

docs/examples/mem0-agentic-tool.mdx

@@ -0,0 +1,226 @@
+---
+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.
+
+## Installation
+
+First, install the required packages:
+```bash
+pip install mem0ai pydantic openai-agents
+```
+
+You'll also need a custom agents framework for this implementation.
+
+## Setting Up Environment Variables
+
+Store your Mem0 API key as an environment variable:
+
+```bash
+export MEM0_API_KEY="your_mem0_api_key"
+```
+
+Or in your Python script:
+
+```python
+import os
+os.environ["MEM0_API_KEY"] = "your_mem0_api_key"
+```
+
+## Code Structure
+
+The integration consists of three main components:
+
+1. **Context Manager**: Defines user context for memory operations
+2. **Memory Tools**: Functions to add, search, and retrieve memories
+3. **Memory Agent**: An agent configured to use these memory tools
+
+## Step-by-Step Implementation
+
+### 1. Import Dependencies
+
+```python
+from __future__ import annotations
+import os
+import asyncio
+from pydantic import BaseModel
+try:
+    from mem0 import AsyncMemoryClient
+except ImportError:
+    raise ImportError("mem0 is not installed. Please install it using 'pip install mem0ai'.")
+from agents import (
+    Agent,
+    ItemHelpers,
+    MessageOutputItem,
+    RunContextWrapper,
+    Runner,
+    ToolCallItem,
+    ToolCallOutputItem,
+    TResponseInputItem,
+    function_tool,
+)
+```
+
+### 2. Define Memory Context
+
+```python
+class Mem0Context(BaseModel):
+    user_id: str | None = None
+```
+
+### 3. Initialize the Mem0 Client
+
+```python
+client = AsyncMemoryClient(api_key=os.getenv("MEM0_API_KEY"))
+```
+
+### 4. Create Memory Tools
+
+#### Add to Memory
+
+```python
+@function_tool
+async def add_to_memory(
+    context: RunContextWrapper[Mem0Context],
+    content: str,
+) -> str:
+    """
+    Add a message to Mem0
+    Args:
+        content: The content to store in memory.
+    """
+    messages = [{"role": "user", "content": content}]
+    user_id = context.context.user_id or "default_user"
+    await client.add(messages, user_id=user_id)
+    return f"Stored message: {content}"
+```
+
+#### Search Memory
+
+```python
+@function_tool
+async def search_memory(
+    context: RunContextWrapper[Mem0Context],
+    query: str,
+) -> str:
+    """
+    Search for memories in Mem0
+    Args:
+        query: The search query.
+    """
+    user_id = context.context.user_id or "default_user"
+    memories = await client.search(query, user_id=user_id, output_format="v1.1")
+    results = '\n'.join([result["memory"] for result in memories["results"]])
+    return str(results)
+```
+
+#### Get All Memories
+
+```python
+@function_tool
+async def get_all_memory(
+    context: RunContextWrapper[Mem0Context],
+) -> str:
+    """Retrieve all memories from Mem0"""
+    user_id = context.context.user_id or "default_user"
+    memories = await client.get_all(user_id=user_id, output_format="v1.1")
+    results = '\n'.join([result["memory"] for result in memories["results"]])
+    return str(results)
+```
+
+### 5. Configure the Memory Agent
+
+```python
+memory_agent = Agent[Mem0Context](
+    name="Memory Assistant",
+    instructions="""You are a helpful assistant with memory capabilities. You can:
+    1. Store new information using add_to_memory
+    2. Search existing information using search_memory
+    3. Retrieve all stored information using get_all_memory
+    When users ask questions:
+    - If they want to store information, use add_to_memory
+    - If they're searching for specific information, use search_memory
+    - If they want to see everything stored, use get_all_memory""",
+    tools=[add_to_memory, search_memory, get_all_memory],
+)
+```
+
+### 6. Implement the Main Runtime Loop
+
+```python
+async def main():
+    current_agent: Agent[Mem0Context] = memory_agent
+    input_items: list[TResponseInputItem] = []
+    context = Mem0Context()
+    while True:
+        user_input = input("Enter your message (or 'quit' to exit): ")
+        if user_input.lower() == 'quit':
+            break
+        input_items.append({"content": user_input, "role": "user"})
+        result = await Runner.run(current_agent, input_items, context=context)
+        for new_item in result.new_items:
+            agent_name = new_item.agent.name
+            if isinstance(new_item, MessageOutputItem):
+                print(f"{agent_name}: {ItemHelpers.text_message_output(new_item)}")
+            elif isinstance(new_item, ToolCallItem):
+                print(f"{agent_name}: Calling a tool")
+            elif isinstance(new_item, ToolCallOutputItem):
+                print(f"{agent_name}: Tool call output: {new_item.output}")
+            else:
+                print(f"{agent_name}: Skipping item: {new_item.__class__.__name__}")
+        input_items = result.to_input_list()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## Usage Examples
+
+### Storing Information
+
+```
+User: Remember that my favorite color is blue
+Agent: Calling a tool
+Agent: Tool call output: Stored message: my favorite color is blue
+Agent: I've stored that your favorite color is blue in my memory. I'll remember that for future conversations.
+```
+
+### Searching Memory
+
+```
+User: What's my favorite color?
+Agent: Calling a tool
+Agent: Tool call output: my favorite color is blue
+Agent: Your favorite color is blue, based on what you've told me earlier.
+```
+
+### Retrieving All Memories
+
+```
+User: What do you know about me?
+Agent: Calling a tool
+Agent: Tool call output: favorite color is blue
+my birthday is on March 15
+Agent: Based on our previous conversations, I know that:
+1. Your favorite color is blue
+2. Your birthday is on March 15
+```
+
+## Advanced Configuration
+
+### Custom User IDs
+
+You can specify different user IDs to maintain separate memory stores for multiple users:
+
+```python
+context = Mem0Context(user_id="user123")
+```
+
+
+## Resources
+
+- [Mem0 Documentation](https://docs.mem0.ai)
+- [Mem0 Dashboard](https://app.mem0.ai/dashboard)
+- [API Reference](https://docs.mem0.ai/api-reference)

docs/examples/mem0-demo.mdx

@@ -13,6 +13,8 @@ You can create a personalized AI Companion using Mem0. This guide will walk you
   src="https://github.com/user-attachments/assets/cebc4f8e-bdb9-4837-868d-13c5ab7bb433"
 ></video>
 
+You can try the [Mem0 Demo](https://mem0.dev/demo) live here.
+
 ## Overview
 
 The Personalized AI Companion leverages Mem0 to retain information across interactions, enabling a tailored learning experience. It creates memories for each user interaction and integrates with OpenAI's GPT models to provide detailed and context-aware responses to user queries.

docs/examples/multimodal-demo.mdx

@@ -0,0 +1,31 @@
+---
+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.
+
+> 🎉 Experience the power of multimodal AI! Test out Mem0's image understanding capabilities at [multimodal-demo.mem0.ai](https://multimodal-demo.mem0.ai)
+
+## 🚀 Features
+
+- **🖼️ Image Understanding**: Share and discuss images with AI assistants while maintaining context.
+- **🔍 Smart Visual Context**: Automatically capture and reference visual elements in conversations.
+- **🔗 Cross-Modal Memory**: Link visual and textual information seamlessly in your memory layer.
+- **📌 Cross-Session Recall**: Reference previously discussed visual content across different conversations.
+- **⚡ Seamless Integration**: Works naturally with existing chat interfaces for a smooth experience.
+
+## 📖 How It Works
+
+1. **📂 Upload Visual Content**: Simply drag and drop or paste images into your conversations.
+2. **💬 Natural Interaction**: Discuss the visual content naturally with AI assistants.
+3. **📚 Memory Integration**: Visual context is automatically stored and linked with your conversation history.
+4. **🔄 Persistent Recall**: Retrieve and reference past visual content effortlessly.
+
+## Demo Video
+
+<iframe width="700" height="400" src="https://www.youtube.com/embed/2Md5AEFVpmg?si=rXXupn6CiDUPJsi3" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>
+
+## 🔥 Try It Out
+
+Visit [multimodal-demo.mem0.ai](https://multimodal-demo.mem0.ai) to experience Mem0's multimodal capabilities firsthand. Upload images and see how Mem0 understands and remembers visual context across your conversations.
+

docs/examples/openai-inbuilt-tools.mdx

@@ -0,0 +1,312 @@
+---
+title: OpenAI Inbuilt Tools
+---
+
+Integrate Mem0’s memory capabilities with OpenAI’s Inbuilt Tools to create AI agents with persistent memory.
+
+## Getting Started
+
+### Installation
+
+```bash
+npm install mem0ai openai zod
+```
+
+## Environment Setup
+
+Save your Mem0 and OpenAI API keys in a `.env` file:
+
+```
+MEM0_API_KEY=your_mem0_api_key
+OPENAI_API_KEY=your_openai_api_key
+```
+
+Get your Mem0 API key from the [Mem0 Dashboard](https://app.mem0.ai/dashboard/api-keys).
+
+### Configuration
+
+```javascript
+const mem0Config = {
+    apiKey: process.env.MEM0_API_KEY,
+    user_id: "sample-user",
+};
+
+const openAIClient = new OpenAI();
+const mem0Client = new MemoryClient(mem0Config);
+```
+
+### Adding Memories
+
+Store user preferences, past interactions, or any relevant information:
+<CodeGroup>
+```javascript JavaScript
+async function addUserPreferences() {
+    const mem0Client = new MemoryClient(mem0Config);
+    
+    const userPreferences = "I Love BMW, Audi and Porsche. I Hate Mercedes. I love Red cars and Maroon cars. I have a budget of 120K to 150K USD. I like Audi the most.";
+    
+    await mem0Client.add([{
+        role: "user",
+        content: userPreferences,
+    }], mem0Config);
+}
+
+await addUserPreferences();
+```
+
+```json Output (Memories)
+ [
+  {
+    "id": "ff9f3367-9e83-415d-b9c5-dc8befd9a4b4",
+    "data": { "memory": "Loves BMW, Audi, and Porsche" },
+    "event": "ADD"
+  },
+  {
+    "id": "04172ce6-3d7b-45a3-b4a1-ee9798593cb4",
+    "data": { "memory": "Hates Mercedes" },
+    "event": "ADD"
+  },
+  {
+    "id": "db363a5d-d258-4953-9e4c-777c120de34d",
+    "data": { "memory": "Loves red cars and maroon cars" },
+    "event": "ADD"
+  },
+  {
+    "id": "5519aaad-a2ac-4c0d-81d7-0d55c6ecdba8",
+    "data": { "memory": "Has a budget of 120K to 150K USD" },
+    "event": "ADD"
+  },
+  {
+    "id": "523b7693-7344-4563-922f-5db08edc8634",
+    "data": { "memory": "Likes Audi the most" },
+    "event": "ADD"
+  }
+]
+```
+</CodeGroup>
+### Retrieving Memories
+
+Search for relevant memories based on the current user input:
+
+```javascript
+const relevantMemories = await mem0Client.search(userInput, mem0Config);
+```
+
+### Structured Responses with Zod
+
+Define structured response schemas to get consistent output formats:
+
+```javascript
+// Define the schema for a car recommendation
+const CarSchema = z.object({
+  car_name: z.string(),
+  car_price: z.string(),
+  car_url: z.string(),
+  car_image: z.string(),
+  car_description: z.string(),
+});
+
+// Schema for a list of car recommendations
+const Cars = z.object({
+  cars: z.array(CarSchema),
+});
+
+// Create a function tool based on the schema
+const carRecommendationTool = zodResponsesFunction({ 
+    name: "carRecommendations", 
+    parameters: Cars 
+});
+
+// Use the tool in your OpenAI request
+const response = await openAIClient.responses.create({
+    model: "gpt-4o",
+    tools: [{ type: "web_search_preview" }, carRecommendationTool],
+    input: `${getMemoryString(relevantMemories)}\n${userInput}`,
+});
+```
+
+### Using Web Search
+
+Combine memory with web search for up-to-date recommendations:
+
+```javascript
+const response = await openAIClient.responses.create({
+    model: "gpt-4o",
+    tools: [{ type: "web_search_preview" }, carRecommendationTool],
+    input: `${getMemoryString(relevantMemories)}\n${userInput}`,
+});
+```
+
+## Examples
+
+### Complete Car Recommendation System
+
+```javascript
+import MemoryClient from "mem0ai";
+import { OpenAI } from "openai";
+import { zodResponsesFunction } from "openai/helpers/zod";
+import { z } from "zod";
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+const mem0Config = {
+    apiKey: process.env.MEM0_API_KEY,
+    user_id: "sample-user",
+};
+
+async function run() {
+    // Responses without memories
+    console.log("\n\nRESPONSES WITHOUT MEMORIES\n\n");
+    await main();
+
+    // Adding sample memories
+    await addSampleMemories();
+
+    // Responses with memories
+    console.log("\n\nRESPONSES WITH MEMORIES\n\n");
+    await main(true);
+}
+
+// OpenAI Response Schema
+const CarSchema = z.object({
+  car_name: z.string(),
+  car_price: z.string(),
+  car_url: z.string(),
+  car_image: z.string(),
+  car_description: z.string(),
+});
+
+const Cars = z.object({
+  cars: z.array(CarSchema),
+});
+
+async function main(memory = false) {
+  const openAIClient = new OpenAI();
+  const mem0Client = new MemoryClient(mem0Config);
+
+  const input = "Suggest me some cars that I can buy today.";
+
+  const tool = zodResponsesFunction({ name: "carRecommendations", parameters: Cars });
+
+  // Store the user input as a memory
+  await mem0Client.add([{
+    role: "user",
+    content: input,
+  }], mem0Config);
+
+  // Search for relevant memories
+  let relevantMemories = []
+  if (memory) {
+    relevantMemories = await mem0Client.search(input, mem0Config);
+  }
+
+  const response = await openAIClient.responses.create({
+    model: "gpt-4o",
+    tools: [{ type: "web_search_preview" }, tool],
+    input: `${getMemoryString(relevantMemories)}\n${input}`,
+  });
+
+  console.log(response.output);
+}
+
+async function addSampleMemories() {
+  const mem0Client = new MemoryClient(mem0Config);
+
+  const myInterests = "I Love BMW, Audi and Porsche. I Hate Mercedes. I love Red cars and Maroon cars. I have a budget of 120K to 150K USD. I like Audi the most.";
+  
+  await mem0Client.add([{
+    role: "user",
+    content: myInterests,
+  }], mem0Config);
+}
+
+const getMemoryString = (memories) => {
+    const MEMORY_STRING_PREFIX = "These are the memories I have stored. Give more weightage to the question by users and try to answer that first. You have to modify your answer based on the memories I have provided. If the memories are irrelevant you can ignore them. Also don't reply to this section of the prompt, or the memories, they are only for your reference. The MEMORIES of the USER are: \n\n";
+    const memoryString = memories.map((mem) => `${mem.memory}`).join("\n") ?? "";
+    return memoryString.length > 0 ? `${MEMORY_STRING_PREFIX}${memoryString}` : "";
+};
+
+run().catch(console.error);
+```
+
+### Responses
+
+<CodeGroup>
+    ```json Without Memories
+    {
+      "cars": [
+        {
+          "car_name": "Toyota Camry",
+          "car_price": "$25,000",
+          "car_url": "https://www.toyota.com/camry/",
+          "car_image": "https://link-to-toyota-camry-image.com",
+          "car_description": "Reliable mid-size sedan with great fuel efficiency."
+        },
+        {
+          "car_name": "Honda Accord",
+          "car_price": "$26,000",
+          "car_url": "https://www.honda.com/accord/",
+          "car_image": "https://link-to-honda-accord-image.com",
+          "car_description": "Comfortable and spacious with advanced safety features."
+        },
+        {
+          "car_name": "Ford Mustang",
+          "car_price": "$28,000",
+          "car_url": "https://www.ford.com/mustang/",
+          "car_image": "https://link-to-ford-mustang-image.com",
+          "car_description": "Iconic sports car with powerful engine options."
+        },
+        {
+          "car_name": "Tesla Model 3",
+          "car_price": "$38,000",
+          "car_url": "https://www.tesla.com/model3",
+          "car_image": "https://link-to-tesla-model3-image.com",
+          "car_description": "Electric vehicle with advanced technology and long range."
+        },
+        {
+          "car_name": "Chevrolet Equinox",
+          "car_price": "$24,000",
+          "car_url": "https://www.chevrolet.com/equinox/",
+          "car_image": "https://link-to-chevron-equinox-image.com",
+          "car_description": "Compact SUV with a spacious interior and user-friendly technology."
+        }
+      ]
+    }
+    ```
+  
+    ```json With Memories
+    {
+      "cars": [
+        {
+          "car_name": "Audi RS7",
+          "car_price": "$118,500",
+          "car_url": "https://www.audiusa.com/us/web/en/models/rs7/2023/overview.html",
+          "car_image": "https://www.audiusa.com/content/dam/nemo/us/models/rs7/my23/gallery/1920x1080_AOZ_A717_191004.jpg",
+          "car_description": "The Audi RS7 is a high-performance hatchback with a sleek design, powerful 591-hp twin-turbo V8, and luxurious interior. It's available in various colors including red."
+        },
+        {
+          "car_name": "Porsche Panamera GTS",
+          "car_price": "$129,300",
+          "car_url": "https://www.porsche.com/usa/models/panamera/panamera-models/panamera-gts/",
+          "car_image": "https://files.porsche.com/filestore/image/multimedia/noneporsche-panamera-gts-sample-m02-high/normal/8a6327c3-6c7f-4c6f-a9a8-fb9f58b21795;sP;twebp/porsche-normal.webp",
+          "car_description": "The Porsche Panamera GTS is a luxury sports sedan with a 473-hp V8 engine, exquisite handling, and available in stunning red. Balances sportiness and comfort."
+        },
+        {
+          "car_name": "BMW M5",
+          "car_price": "$105,500",
+          "car_url": "https://www.bmwusa.com/vehicles/m-models/m5/sedan/overview.html",
+          "car_image": "https://www.bmwusa.com/content/dam/bmwusa/M/m5/2023/bmw-my23-m5-sapphire-black-twilight-purple-exterior-02.jpg",
+          "car_description": "The BMW M5 is a powerhouse sedan with a 600-hp V8 engine, known for its great handling and luxury. It comes in several distinctive colors including maroon."
+        }
+      ]
+    }
+    ```
+</CodeGroup>
+
+## Resources
+
+- [Mem0 Documentation](https://docs.mem0.ai)
+- [Mem0 Dashboard](https://app.mem0.ai/dashboard)
+- [API Reference](https://docs.mem0.ai/api-reference)
+- [OpenAI Documentation](https://platform.openai.com/docs)

docs/examples/overview.mdx

@@ -16,23 +16,54 @@ Here are some examples of how Mem0 can be integrated into various applications:
 
 ## Examples
 
-<CardGroup cols={2}>
-  <Card title="AI Companion in Node.js" icon="square-6" href="/examples/ai_companion_js">
-    Create a Personalized AI Companion using Mem0 in Node.js.
-  </Card>
-  <Card title="Mem0 with Ollama" icon="square-1" href="/examples/mem0-with-ollama">
-    Run Mem0 locally with Ollama.
-  </Card>
-  <Card title="Personal AI Tutor" icon="square-2" href="/examples/personal-ai-tutor">
-    Create a Personalized AI Tutor that adapts to student progress and learning preferences.
-  </Card>
-  <Card title="Personal Travel Assistant" icon="square-3" href="/examples/personal-travel-assistant">
-    Build a Personalized AI Travel Assistant that understands your travel preferences and past itineraries.
-  </Card>
-  <Card title="Customer Support Agent" icon="square-4" href="/examples/customer-support-agent">
-    Develop a Personal AI Assistant that remembers user preferences, past interactions, and context to provide personalized and efficient assistance.
-  </Card>
-  <Card title="LlamaIndex Mem0" icon="square-5" href="/examples/llama-index-mem0">
-    Create a ReAct Agent with LlamaIndex which uses Mem0 as the memory store.
-  </Card>
+Explore how **Mem0** can power real-world applications and bring personalized, intelligent experiences to life:
+
+<CardGroup cols={2}>  
+  <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.  
+  </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.  
+  </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.  
+  </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.  
+  </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="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.  
+  </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>  
+
+  <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="robot" 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>  
 </CardGroup>

docs/examples/personal-ai-tutor.mdx

@@ -96,8 +96,8 @@ You can fetch all the memories at any point in time using the following code:
 
 ```python
 memories = ai_tutor.get_memories(user_id=user_id)
-for m in memories:
-    print(m['text'])
+for m in memories['results']:
+    print(m['memory'])
 ```
 
 ### Key Points

docs/examples/personal-travel-assistant.mdx

@@ -82,11 +82,11 @@ class PersonalTravelAssistant:
 
     def get_memories(self, user_id):
         memories = self.memory.get_all(user_id=user_id)
-        return [m['memory'] for m in memories['memories']]
+        return [m['memory'] for m in memories['results']]
 
     def search_memories(self, query, user_id):
         memories = self.memory.search(query, user_id=user_id)
-        return [m['memory'] for m in memories['memories']]
+        return [m['memory'] for m in memories['results']]
 
 # Usage example
 user_id = "traveler_123"

docs/examples/personalized-deep-research.mdx

@@ -0,0 +1,70 @@
+---
+title: Personalized Deep Research
+---
+
+Deep Research is an intelligent agent that synthesizes large amounts of online data and completes complex research tasks, customized to your unique preferences and insights. Built on Mem0's technology, it enhances AI-driven online exploration with personalized memories.
+
+## Overview
+
+Deep Research leverages Mem0's memory capabilities to:
+- Synthesize large amounts of online data
+- Complete complex research tasks
+- Customize results to your preferences
+- Store and utilize personal insights
+- Maintain context across research sessions
+
+## Demo
+
+Watch Deep Research in action:
+
+<iframe 
+  width="700" 
+  height="400" 
+  src="https://www.youtube.com/embed/8vQlCtXzF60?si=b8iTOgummAVzR7ia" 
+  title="YouTube video player" 
+  frameborder="0" 
+  allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" 
+  referrerpolicy="strict-origin-when-cross-origin" 
+  allowfullscreen
+></iframe>
+
+## Getting Started
+
+1. Visit [deep-research.mem0.ai](https://deep-research.mem0.ai/)
+2. Upload your resume (PDF or text) or manually enter information about yourself
+3. Enter your research topic
+4. Click "Start Research" to begin
+
+## Features
+
+### 1. Personalized Research
+- Analyzes your background and expertise
+- Tailors research depth and complexity to your level
+- Incorporates your previous research context
+
+### 2. Comprehensive Data Synthesis
+- Processes multiple online sources
+- Extracts relevant information
+- Provides coherent summaries
+
+### 3. Memory Integration
+- Stores research findings for future reference
+- Maintains context across sessions
+- Links related research topics
+
+### 4. Interactive Exploration
+- Allows real-time query refinement
+- Supports follow-up questions
+- Enables deep-diving into specific areas
+
+## Use Cases
+
+- **Academic Research**: Literature reviews, thesis research, paper writing
+- **Market Research**: Industry analysis, competitor research, trend identification
+- **Technical Research**: Technology evaluation, solution comparison
+- **Business Research**: Strategic planning, opportunity analysis
+
+
+## Try It Out
+
+Experience AI-powered research personalization at [deep-research.mem0.ai](https://deep-research.mem0.ai/)

docs/faqs.mdx

@@ -84,9 +84,48 @@ iconType: "solid"
         - Include specific examples or cases rather than general definitions
     </Accordion>
 
+    <Accordion title="How do I configure Mem0 for AWS Lambda?">
+        When deploying Mem0 on AWS Lambda, you'll need to modify the storage directory configuration due to Lambda's file system restrictions. By default, Lambda only allows writing to the `/tmp` directory.
+
+        To configure Mem0 for AWS Lambda, set the `MEM0_DIR` environment variable to point to a writable directory in `/tmp`:
+
+        ```bash
+        MEM0_DIR=/tmp/.mem0
+        ```
+
+        If you're not using environment variables, you'll need to modify the storage path in your code:
+
+        ```python
+        # Change from
+        home_dir = os.path.expanduser("~")
+        mem0_dir = os.environ.get("MEM0_DIR") or os.path.join(home_dir, ".mem0")
+
+        # To
+        mem0_dir = os.environ.get("MEM0_DIR", "/tmp/.mem0")
+        ```
+
+        Note that the `/tmp` directory in Lambda has a size limit of 512MB and its contents are not persistent between function invocations.
+    </Accordion>
+
+    <Accordion title="How can I use metadata with Mem0?">
+        Metadata is the recommended approach for incorporating additional information with Mem0. You can store any type of structured data as metadata during the `add` method, such as location, timestamp, weather conditions, user state, or application context. This enriches your memories with valuable contextual information that can be used for more precise retrieval and filtering.
+
+        During retrieval, you have two main approaches for using metadata:
+
+        1. **Pre-filtering**: Include metadata parameters in your initial search query to narrow down the memory pool
+        2. **Post-processing**: Retrieve a broader set of memories based on query, then apply metadata filters to refine the results
+
+        Examples of useful metadata you might store:
+
+        - **Contextual information**: Location, time, device type, application state
+        - **User attributes**: Preferences, skill levels, demographic information
+        - **Interaction details**: Conversation topics, sentiment, urgency levels
+        - **Custom tags**: Any domain-specific categorization relevant to your application
+
+        This flexibility allows you to create highly contextually aware AI applications that can adapt to specific user needs and situations. Metadata provides an additional dimension for memory retrieval, enabling more precise and relevant responses.
+    </Accordion>
+
 </AccordionGroup>
 
 
 
-
-

docs/features/advanced-retrieval.mdx

@@ -14,23 +14,77 @@ Mem0's **Advanced Retrieval** feature delivers superior search results by levera
    client.search(query, keyword_search=True, user_id='alex')
    ```
 
+   **Example:**
+   ```python
+   # Search for memories about food preferences with keyword search enabled
+   query = "What are my food preferences?"
+   results = client.search(query, keyword_search=True, user_id='alex')
+
+   # Output might include:
+   # - "Vegetarian. Allergic to nuts." (highly relevant)
+   # - "Prefers spicy food and enjoys Thai cuisine" (relevant)
+   # - "Mentioned disliking sea food during restaurant discussion" (keyword match)
+
+   # Without keyword_search=True, only the most relevant memories would be returned:
+   # - "Vegetarian. Allergic to nuts." (highly relevant)
+   # - "Prefers spicy food and enjoys Thai cuisine" (relevant)
+   # The keyword-based match about "sea food" would be excluded
+   ```
+
 2. **Reranking**
 
-   Reranking allows you to reorder the memories returned by the default search based on relevance. This parameter is set to `false` by default. When enabled, it reorders the memories based on the relevance score.
+   Normal retrieval gives you memories sorted in order of their relevancy, but the order may not be perfect. Reranking uses a deep neural network to correct this order, ensuring the most relevant memories appear first. If you are concerned about the order of memories, or want that the best results always comes at top then use reranking. This parameter is set to `false` by default. When enabled, it reorders the memories based on a more accurate relevance score.
 
    ```python
    client.search(query, rerank=True, user_id='alex')
    ```
 
+   **Example:**
+   ```python
+   # Search for travel plans with reranking enabled
+   query = "What are my travel plans?"
+   results = client.search(query, rerank=True, user_id='alex')
+
+   # Without reranking, results might be ordered like:
+   # 1. "Traveled to France last year" (less relevant to current plans)
+   # 2. "Planning a trip to Japan next month" (more relevant to current plans)
+   # 3. "Interested in visiting Tokyo restaurants" (relevant to current plans)
+
+   # With reranking enabled, results would be reordered:
+   # 1. "Planning a trip to Japan next month" (most relevant to current plans)
+   # 2. "Interested in visiting Tokyo restaurants" (highly relevant to current plans)
+   # 3. "Traveled to France last year" (less relevant to current plans)
+   ```
+
 3. **Filtering**
 
-   Filtering enables you to narrow down the search results by applying specific criteria. This parameter is set to `false` by default. Activating it enhances search precision, potentially reducing recall by a small margin.
+   Filtering allows you to narrow down search results by applying specific criterias. This parameter is set to `false` by default. When activated, it significantly enhances search precision by removing irrelevant memories, though it may slightly reduce recall. Filtering is particularly useful when you need highly specific information.
 
    ```python
    client.search(query, filter_memories=True, user_id='alex')
    ```
 
-**Note:** You can enable or disable these search modes by passing the respective parameters to the `search` method. There is no required sequence for these modes, and any combination can be used based on your needs.
+   **Example:**
+   ```python
+   # Search for dietary restrictions with filtering enabled
+   query = "What are my dietary restrictions?"
+   results = client.search(query, filter_memories=True, user_id='alex')
+
+   # Without filtering, results might include:
+   # - "Vegetarian. Allergic to nuts." (directly relevant)
+   # - "I enjoy cooking Italian food on weekends" (somewhat related to food)
+   # - "Mentioned disliking seafood during restaurant discussion" (food-related)
+   # - "Prefers to eat dinner at 7pm" (tangentially food-related)
+
+   # With filtering enabled, results would be focused:
+   # - "Vegetarian. Allergic to nuts." (directly relevant)
+   # - "Mentioned disliking seafood during restaurant discussion" (relevant restriction)
+   #
+   # The filtering process removes memories that are about food preferences
+   # but not specifically about dietary restrictions
+   ```
+
+<Note> You can enable or disable these search modes by passing the respective parameters to the `search` method. There is no required sequence for these modes, and any combination can be used based on your needs. </Note>
 
 
 ### Latency Numbers

docs/features/contextual-add.mdx

@@ -0,0 +1,205 @@
+---
+title: Contextual Add (ADD v2)
+icon: "square-plus"
+iconType: "solid"
+---
+
+Mem0 now supports an contextual add version (v2). To use it, set `version="v2"` during the add call. The default version is v1, which is deprecated now. We recommend migrating to `v2` for new applications.
+
+## Key Differences Between v1 and v2
+
+### Version 1 (Legacy)
+In v1 (default), users needed to pass either the entire conversation history or past k messages with each new message to generate properly contextualized memories. This approach required:
+
+- Manually tracking and sending previous messages using a sliding window approach
+- Increased payload sizes as conversations grew longer, requiring careful window size management
+
+<CodeGroup>
+
+```python Python
+# First interaction
+messages1 = [
+    {"role": "user", "content": "Hi, I'm Alex and I live in San Francisco."},
+    {"role": "assistant", "content": "Hello Alex! Nice to meet you. San Francisco is a beautiful city."}
+]
+client.add(messages1, user_id="alex")
+
+# Second interaction - must include previous messages for context
+messages2 = [
+    {"role": "user", "content": "Hi, I'm Alex and I live in San Francisco."},
+    {"role": "assistant", "content": "Hello Alex! Nice to meet you. San Francisco is a beautiful city."},
+    {"role": "user", "content": "I like to eat sushi, and yesterday I went to Sunnyvale to eat sushi with my friends."},
+    {"role": "assistant", "content": "Sushi is really a tasty choice. What did you do this weekend?"}
+]
+client.add(messages2, user_id="alex")
+```
+
+```javascript JavaScript
+// First interaction
+const messages1 = [
+    {"role": "user", "content": "Hi, I'm Alex and I live in San Francisco."},
+    {"role": "assistant", "content": "Hello Alex! Nice to meet you. San Francisco is a beautiful city."}
+];
+client.add(messages1, { user_id: "alex" })
+    .then(response => console.log(response))
+    .catch(error => console.error(error));
+
+// Second interaction - must include previous messages for context
+const messages2 = [
+    {"role": "user", "content": "Hi, I'm Alex and I live in San Francisco."},
+    {"role": "assistant", "content": "Hello Alex! Nice to meet you. San Francisco is a beautiful city."},
+    {"role": "user", "content": "I like to eat sushi, and yesterday I went to Sunnyvale to eat sushi with my friends."},
+    {"role": "assistant", "content": "Sushi is really a tasty choice. What did you do this weekend?"}
+];
+client.add(messages2, { user_id: "alex" })
+    .then(response => console.log(response))
+    .catch(error => console.error(error));
+```
+
+</CodeGroup>
+
+### Version 2 (Recommended)
+In v2, Mem0 automatically manages conversation context. Users only need to send new messages, and the system will:
+
+- Automatically retrieve relevant conversation history
+- Generate properly contextualized memories
+- Reduce payload sizes and simplify integration
+
+<CodeGroup>
+
+```python Python
+# First interaction
+messages1 = [
+    {"role": "user", "content": "Hi, I'm Alex and I live in San Francisco."},
+    {"role": "assistant", "content": "Hello Alex! Nice to meet you. San Francisco is a beautiful city."}
+]
+client.add(messages1, user_id="alex", version="v2")
+
+# Second interaction - only need to send new messages
+messages2 = [
+    {"role": "user", "content": "I like to eat sushi, and yesterday I went to Sunnyvale to eat sushi with my friends."},
+    {"role": "assistant", "content": "Sushi is really a tasty choice. What did you do this weekend?"}
+]
+client.add(messages2, user_id="alex", version="v2")
+```
+
+```javascript JavaScript
+// First interaction
+const messages1 = [
+    {"role": "user", "content": "Hi, I'm Alex and I live in San Francisco."},
+    {"role": "assistant", "content": "Hello Alex! Nice to meet you. San Francisco is a beautiful city."}
+];
+client.add(messages1, { user_id: "alex", version: "v2" })
+    .then(response => console.log(response))
+    .catch(error => console.error(error));
+
+// Second interaction - only need to send new messages
+const messages2 = [
+    {"role": "user", "content": "I like to eat sushi, and yesterday I went to Sunnyvale to eat sushi with my friends."},
+    {"role": "assistant", "content": "Sushi is really a tasty choice. What did you do this weekend?"}
+];
+client.add(messages2, { user_id: "alex", version: "v2" })
+    .then(response => console.log(response))
+    .catch(error => console.error(error));
+```
+
+</CodeGroup>
+
+## Benefits of Using v2
+
+1. **Simplified Integration**: No need to track and manage conversation history
+2. **Reduced Payload Size**: Only send new messages, not the entire conversation
+3. **Improved Memory Quality**: Automatic context retrieval ensures better memory generation
+
+## Understanding ID Parameters in v2
+
+When using contextual add v2, you have different options for how to organize and retrieve memories:
+
+### Using Only `user_id`
+
+When you provide only a `user_id`:
+
+- Memories are associated with this user's long-term memory store
+- The system will automatically retrieve relevant context from all of the user's previous conversations
+- These memories persist indefinitely across all of the user's sessions
+- Ideal for maintaining persistent user information (preferences, personal details, etc.)
+
+<CodeGroup>
+
+```python Python
+# Adding to long-term user memory
+messages = [
+    {"role": "user", "content": "I'm allergic to peanuts and shellfish."},
+    {"role": "assistant", "content": "I've noted your allergies to peanuts and shellfish."}
+]
+client.add(messages, user_id="alex", version="v2")
+```
+
+```javascript JavaScript
+// Adding to long-term user memory
+const messages = [
+    {"role": "user", "content": "I'm allergic to peanuts and shellfish."},
+    {"role": "assistant", "content": "I've noted your allergies to peanuts and shellfish."}
+];
+client.add(messages, { user_id: "alex", version: "v2" })
+    .then(response => console.log(response))
+    .catch(error => console.error(error));
+```
+
+</CodeGroup>
+
+### Using `user_id` with `run_id`
+
+When you provide both `user_id` and `run_id`:
+
+- Memories are associated with a specific conversation session or interaction
+- The system will retrieve context primarily from this specific session
+- These memories are still tied to the user but are organized by the specific session
+- Ideal for maintaining context within a specific conversation flow or task
+- Helps prevent context from different conversations from interfering with each other
+
+<CodeGroup>
+
+```python Python
+# Adding to a specific conversation session
+messages = [
+    {"role": "user", "content": "For this trip to Paris, I want to focus on art museums."},
+    {"role": "assistant", "content": "Great! I'll help you plan your Paris trip with a focus on art museums."}
+]
+client.add(messages, user_id="alex", run_id="paris-trip-2024", version="v2")
+
+# Later in the same conversation session
+messages2 = [
+    {"role": "user", "content": "I'd like to visit the Louvre on Monday."},
+    {"role": "assistant", "content": "The Louvre is a great choice for Monday. Would you like information about opening hours?"}
+]
+client.add(messages2, user_id="alex", run_id="paris-trip-2024", version="v2")
+```
+
+```javascript JavaScript
+// Adding to a specific conversation session
+const messages = [
+    {"role": "user", "content": "For this trip to Paris, I want to focus on art museums."},
+    {"role": "assistant", "content": "Great! I'll help you plan your Paris trip with a focus on art museums."}
+];
+client.add(messages, { user_id: "alex", run_id: "paris-trip-2024", version: "v2" })
+    .then(response => console.log(response))
+    .catch(error => console.error(error));
+
+// Later in the same conversation session
+const messages2 = [
+    {"role": "user", "content": "I'd like to visit the Louvre on Monday."},
+    {"role": "assistant", "content": "The Louvre is a great choice for Monday. Would you like information about opening hours?"}
+];
+client.add(messages2, { user_id: "alex", run_id: "paris-trip-2024", version: "v2" })
+    .then(response => console.log(response))
+    .catch(error => console.error(error));
+```
+
+</CodeGroup>
+
+Using `run_id` helps you organize memories into logical sessions or tasks, making it easier to maintain context for specific interactions while still associating everything with the user's overall profile.
+
+If you have any questions, please feel free to reach out to us using one of the following methods:
+
+<Snippet file="get-help.mdx" />

docs/features/custom-fact-extraction-prompt.mdx

@@ -1,25 +1,25 @@
 ---
-title: Custom Prompts
-description: 'Enhance your product experience by adding custom prompts tailored to your needs'
+title: Custom Fact Extraction Prompt
+description: 'Enhance your product experience by adding custom fact extraction prompt tailored to your needs'
 icon: "pencil"
 iconType: "solid"
 ---
 
-## Introduction to Custom Prompts
+## Introduction to Custom Fact Extraction Prompt
 
-Custom prompts allow you to tailor the behavior of your Mem0 instance to specific use cases or domains. 
-By defining a custom prompt, you can control how information is extracted, processed, and stored in your memory system.
+Custom fact extraction prompt allow you to tailor the behavior of your Mem0 instance to specific use cases or domains. 
+By defining it, you can control how information is extracted from the user's message.
 
-To create an effective custom prompt:
+To create an effective custom fact extraction prompt:
 1. Be specific about the information to extract.
 2. Provide few-shot examples to guide the LLM.
 3. Ensure examples follow the format shown below.
 
-Example of a custom prompt:
+Example of a custom fact extraction prompt:
 
 <CodeGroup>
 ```python Python
-custom_prompt = """
+custom_fact_extraction_prompt = """
 Please only extract entities containing customer support information, order details, and user information. 
 Here are some few shot examples:
 
@@ -67,7 +67,7 @@ Return the facts and customer information in a json format as shown above.
 ```
 </CodeGroup>
 
-Here we initialize the custom prompt in the config:
+Here we initialize the custom fact extraction prompt in the config:
 
 <CodeGroup>
 ```python Python
@@ -82,7 +82,7 @@ config = {
             "max_tokens": 2000,
         }
     },
-    "custom_prompt": custom_prompt,
+    "custom_fact_extraction_prompt": custom_fact_extraction_prompt,
     "version": "v1.1"
 }
 
@@ -166,4 +166,4 @@ await memory.add('I like going to hikes', { userId: "user123" });
 ```
 </CodeGroup>
 
-The custom prompt will process both the user and assistant messages to extract relevant information according to the defined format.
+The custom fact extraction prompt will process both the user and assistant messages to extract relevant information according to the defined format.

docs/features/custom-update-memory-prompt.mdx

@@ -0,0 +1,239 @@
+---
+title: Custom Update Memory Prompt
+icon: "pencil"
+iconType: "solid"
+---
+Update memory prompt is a prompt used to determine the action to be performed on the memory. 
+By customizing this prompt, you can control how the memory is updated.  
+  
+
+## Introduction  
+Mem0 memory system compares the newly retrieved facts with the existing memory and determines the action to be performed on the memory.  
+The kinds of actions are:
+- Add
+    - Add the newly retrieved facts to the memory.
+- Update
+    - Update the existing memory with the newly retrieved facts.
+- Delete
+    - Delete the existing memory.
+- No Change
+    - Do not make any changes to the memory.
+  
+### Example
+Example of a custom update memory prompt:
+
+<CodeGroup>
+```python Python
+UPDATE_MEMORY_PROMPT = """You are a smart memory manager which controls the memory of a system.
+You can perform four operations: (1) add into the memory, (2) update the memory, (3) delete from the memory, and (4) no change.
+
+Based on the above four operations, the memory will change.
+
+Compare newly retrieved facts with the existing memory. For each new fact, decide whether to:
+- ADD: Add it to the memory as a new element
+- UPDATE: Update an existing memory element
+- DELETE: Delete an existing memory element
+- NONE: Make no change (if the fact is already present or irrelevant)
+
+There are specific guidelines to select which operation to perform:
+
+1. **Add**: If the retrieved facts contain new information not present in the memory, then you have to add it by generating a new ID in the id field.
+- **Example**:
+    - Old Memory:
+        [
+            {
+                "id" : "0",
+                "text" : "User is a software engineer"
+            }
+        ]
+    - Retrieved facts: ["Name is John"]
+    - New Memory:
+        {
+            "memory" : [
+                {
+                    "id" : "0",
+                    "text" : "User is a software engineer",
+                    "event" : "NONE"
+                },
+                {
+                    "id" : "1",
+                    "text" : "Name is John",
+                    "event" : "ADD"
+                }
+            ]
+
+        }
+
+2. **Update**: If the retrieved facts contain information that is already present in the memory but the information is totally different, then you have to update it. 
+If the retrieved fact contains information that conveys the same thing as the elements present in the memory, then you have to keep the fact which has the most information. 
+Example (a) -- if the memory contains "User likes to play cricket" and the retrieved fact is "Loves to play cricket with friends", then update the memory with the retrieved facts.
+Example (b) -- if the memory contains "Likes cheese pizza" and the retrieved fact is "Loves cheese pizza", then you do not need to update it because they convey the same information.
+If the direction is to update the memory, then you have to update it.
+Please keep in mind while updating you have to keep the same ID.
+Please note to return the IDs in the output from the input IDs only and do not generate any new ID.
+- **Example**:
+    - Old Memory:
+        [
+            {
+                "id" : "0",
+                "text" : "I really like cheese pizza"
+            },
+            {
+                "id" : "1",
+                "text" : "User is a software engineer"
+            },
+            {
+                "id" : "2",
+                "text" : "User likes to play cricket"
+            }
+        ]
+    - Retrieved facts: ["Loves chicken pizza", "Loves to play cricket with friends"]
+    - New Memory:
+        {
+        "memory" : [
+                {
+                    "id" : "0",
+                    "text" : "Loves cheese and chicken pizza",
+                    "event" : "UPDATE",
+                    "old_memory" : "I really like cheese pizza"
+                },
+                {
+                    "id" : "1",
+                    "text" : "User is a software engineer",
+                    "event" : "NONE"
+                },
+                {
+                    "id" : "2",
+                    "text" : "Loves to play cricket with friends",
+                    "event" : "UPDATE",
+                    "old_memory" : "User likes to play cricket"
+                }
+            ]
+        }
+
+
+3. **Delete**: If the retrieved facts contain information that contradicts the information present in the memory, then you have to delete it. Or if the direction is to delete the memory, then you have to delete it.
+Please note to return the IDs in the output from the input IDs only and do not generate any new ID.
+- **Example**:
+    - Old Memory:
+        [
+            {
+                "id" : "0",
+                "text" : "Name is John"
+            },
+            {
+                "id" : "1",
+                "text" : "Loves cheese pizza"
+            }
+        ]
+    - Retrieved facts: ["Dislikes cheese pizza"]
+    - New Memory:
+        {
+        "memory" : [
+                {
+                    "id" : "0",
+                    "text" : "Name is John",
+                    "event" : "NONE"
+                },
+                {
+                    "id" : "1",
+                    "text" : "Loves cheese pizza",
+                    "event" : "DELETE"
+                }
+        ]
+        }
+
+4. **No Change**: If the retrieved facts contain information that is already present in the memory, then you do not need to make any changes.
+- **Example**:
+    - Old Memory:
+        [
+            {
+                "id" : "0",
+                "text" : "Name is John"
+            },
+            {
+                "id" : "1",
+                "text" : "Loves cheese pizza"
+            }
+        ]
+    - Retrieved facts: ["Name is John"]
+    - New Memory:
+        {
+        "memory" : [
+                {
+                    "id" : "0",
+                    "text" : "Name is John",
+                    "event" : "NONE"
+                },
+                {
+                    "id" : "1",
+                    "text" : "Loves cheese pizza",
+                    "event" : "NONE"
+                }
+            ]
+        }
+"""
+```
+</CodeGroup>  
+
+## Output format
+The prompt needs to guide the output to follow the structure as shown below:
+<CodeGroup>
+```json Add
+{
+    "memory": [
+        {
+            "id" : "0",
+            "text" : "This information is new",
+            "event" : "ADD"
+        }
+    ]
+}
+```
+
+```json Update
+{
+    "memory": [
+        {
+            "id" : "0",
+            "text" : "This information replaces the old information",
+            "event" : "UPDATE",
+            "old_memory" : "Old information"
+        }
+    ]
+}
+```
+
+```json Delete
+{
+    "memory": [
+        {
+            "id" : "0",
+            "text" : "This information will be deleted",
+            "event" : "DELETE"
+        }
+    ]
+}
+```
+
+```json No Change
+{
+    "memory": [
+        {
+            "id" : "0",
+            "text" : "No changes for this information",
+            "event" : "NONE"
+        }
+    ]
+}
+```
+</CodeGroup>
+  
+  
+## custom update memory prompt vs custom prompt
+
+| Feature | `custom_update_memory_prompt` | `custom_prompt` |
+|---------|-------------------------------|-----------------|
+| Use case | Determine the action to be performed on the memory | Extract the facts from messages |
+| Reference | Retrieved facts from messages and old memory | Messages |
+| Output | Action to be performed on the memory | Extracted facts |

docs/features/feedback-mechanism.mdx

@@ -0,0 +1,62 @@
+---
+title: Feedback Mechanism
+icon: "thumbs-up"
+iconType: "solid"
+---
+
+Mem0's **Feedback Mechanism** allows you to provide feedback on the memories generated by your application. This feedback is used to improve the accuracy of the memories and the search results.
+
+## How it works
+
+The feedback mechanism is a simple API that allows you to provide feedback on the memories generated by your application. The feedback is stored in the database and is used to improve the accuracy of the memories and the search results. Over time, Mem0 continuously learns from this feedback, refining its memory generation and search capabilities for better performance.
+
+## Give Feedback
+
+You can give feedback on a memory by calling the `feedback` method on the Mem0 client.
+
+<CodeGroup>
+
+```python Python
+from mem0 import Mem0
+
+client = Mem0(api_key="your_api_key")
+
+client.feedback(memory_id="your-memory-id", feedback="NEGATIVE", feedback_reason="I don't like this memory because it is not relevant.")
+```
+
+```javascript JavaScript
+import MemoryClient from 'mem0ai';
+
+const client = new MemoryClient({ apiKey: 'your-api-key'});
+
+client.feedback({
+    memory_id: "your-memory-id", 
+    feedback: "NEGATIVE", 
+    feedback_reason: "I don't like this memory because it is not relevant."
+})
+```
+
+</CodeGroup>
+
+## Feedback Types
+
+The `feedback` parameter can be one of the following values:
+
+- `POSITIVE`: The memory is useful.
+- `NEGATIVE`: The memory is not useful.
+- `VERY_NEGATIVE`: The memory is not useful at all.
+
+## Parameters
+
+The `feedback` method takes the following parameters:
+
+- `memory_id`: The ID of the memory to give feedback on.
+- `feedback`: The feedback to give on the memory. (Optional)
+- `feedback_reason`: The reason for the feedback. (Optional)
+
+The `feedback_reason` parameter is optional and can be used to provide a reason for the feedback.
+
+<Note>
+You can pass `None` or `null` to the `feedback` and `feedback_reason` parameters to remove the feedback for a memory.
+</Note>
+

docs/features/graph-memory.mdx

@@ -0,0 +1,295 @@
+---
+title: Graph Memory
+icon: "circle-nodes"
+iconType: "solid"
+description: "Enable graph-based memory retrieval for more contextually relevant results"
+---
+
+## Overview
+
+Graph Memory enhances memory pipeline by creating relationships between entities in your data. It builds a network of interconnected information for more contextually relevant search results.
+
+This feature allows your AI applications to understand connections between entities, providing richer context for responses. It's ideal for applications needing relationship tracking and nuanced information retrieval across related memories.
+
+## How Graph Memory Works
+
+The Graph Memory feature analyzes how each entity connects and relates to each other. When enabled:
+
+1. Mem0 automatically builds a graph representation of entities
+2. Retrieval considers graph relationships between entities
+3. Results include entities that may be contextually important even if they're not direct semantic matches
+
+## Using Graph Memory
+
+To use Graph Memory, you need to enable it in your API calls by setting the `enable_graph=True` parameter. You'll also need to specify `output_format="v1.1"` to receive the enriched response format.
+
+### Adding Memories with Graph Memory
+
+When adding new memories, enable Graph Memory to automatically build relationships with existing memories:
+
+<CodeGroup>
+
+```python Python
+from mem0 import MemoryClient
+
+client = MemoryClient(
+    api_key="your-api-key",
+    org_id="your-org-id",
+    project_id="your-project-id"
+)
+
+messages = [
+    {"role": "user", "content": "My name is Joseph"},
+    {"role": "assistant", "content": "Hello Joseph, it's nice to meet you!"},
+    {"role": "user", "content": "I'm from Seattle and I work as a software engineer"}
+]
+
+# Enable graph memory when adding
+client.add(
+    messages, 
+    user_id="joseph", 
+    version="v1", 
+    enable_graph=True, 
+    output_format="v1.1"
+)
+```
+
+```javascript JavaScript
+import { MemoryClient } from "mem0";
+
+const client = new MemoryClient({
+  apiKey: "your-api-key",
+  orgId: "your-org-id",
+  projectId: "your-project-id"
+});
+
+const messages = [
+  { role: "user", content: "My name is Joseph" },
+  { role: "assistant", content: "Hello Joseph, it's nice to meet you!" },
+  { role: "user", content: "I'm from Seattle and I work as a software engineer" }
+];
+
+// Enable graph memory when adding
+await client.add({
+  messages,
+  userId: "joseph",
+  version: "v1",
+  enableGraph: true,
+  outputFormat: "v1.1"
+});
+```
+
+```json Output
+{
+  "results": [
+    {
+      "memory": "Name is Joseph",
+      "event": "ADD",
+      "id": "4a5a417a-fa10-43b5-8c53-a77c45e80438"
+    },
+    {
+      "memory": "Is from Seattle",
+      "event": "ADD",
+      "id": "8d268d0f-5452-4714-b27d-ae46f676a49d"
+    },
+    {
+      "memory": "Is a software engineer",
+      "event": "ADD",
+      "id": "5f0a184e-ddea-4fe6-9b92-692d6a901df8"
+    }
+  ]
+}
+```
+</CodeGroup>
+
+The graph memory would look like this:
+
+<Frame>
+  <img src="/images/graph-platform.png" alt="Graph Memory Visualization showing relationships between entities" />
+</Frame>
+
+<Caption>Graph Memory creates a network of relationships between entities, enabling more contextual retrieval</Caption>
+
+
+<Note>
+Response for the graph memory's `add` operation will not be available directly in the response. 
+As adding graph memories is an asynchronous operation due to heavy processing, 
+you can use the `get_all()` endpoint to retrieve the memory with the graph metadata.
+</Note>
+
+
+### Searching with Graph Memory
+
+When searching memories, Graph Memory helps retrieve entities that are contextually important even if they're not direct semantic matches.
+
+<CodeGroup>
+
+```python Python
+# Search with graph memory enabled
+results = client.search(
+    "what is my name?", 
+    user_id="joseph", 
+    enable_graph=True, 
+    output_format="v1.1"
+)
+
+print(results)
+```
+
+```javascript JavaScript
+// Search with graph memory enabled
+const results = await client.search({
+  query: "what is my name?",
+  userId: "joseph",
+  enableGraph: true,
+  outputFormat: "v1.1"
+});
+
+console.log(results);
+```
+
+```json Output
+{
+  "results": [
+    {
+      "id": "4a5a417a-fa10-43b5-8c53-a77c45e80438",
+      "memory": "Name is Joseph",
+      "user_id": "joseph",
+      "metadata": null,
+      "categories": ["personal_details"],
+      "immutable": false,
+      "created_at": "2025-03-19T09:09:00.146390-07:00",
+      "updated_at": "2025-03-19T09:09:00.146404-07:00",
+      "score": 0.3621795393335552
+    },
+    {
+      "id": "8d268d0f-5452-4714-b27d-ae46f676a49d",
+      "memory": "Is from Seattle",
+      "user_id": "joseph",
+      "metadata": null,
+      "categories": ["personal_details"],
+      "immutable": false,
+      "created_at": "2025-03-19T09:09:00.170680-07:00",
+      "updated_at": "2025-03-19T09:09:00.170692-07:00",
+      "score": 0.31212713194651254
+    }
+  ],
+  "relations": [
+    {
+      "source": "joseph",
+      "source_type": "person",
+      "relationship": "name",
+      "target": "joseph",
+      "target_type": "person",
+      "score": 0.39
+    }
+  ]
+}
+```
+
+</CodeGroup>
+
+### Retrieving All Memories with Graph Memory
+
+When retrieving all memories, Graph Memory provides additional relationship context:
+
+<CodeGroup>
+
+```python Python
+# Get all memories with graph context
+memories = client.get_all(
+    user_id="joseph", 
+    enable_graph=True, 
+    output_format="v1.1"
+)
+
+print(memories)
+```
+
+```javascript JavaScript
+// Get all memories with graph context
+const memories = await client.getAll({
+  userId: "joseph",
+  enableGraph: true,
+  outputFormat: "v1.1"
+});
+
+console.log(memories);
+```
+
+```json Output
+{
+  "results": [
+    {
+      "id": "5f0a184e-ddea-4fe6-9b92-692d6a901df8",
+      "memory": "Is a software engineer",
+      "user_id": "joseph",
+      "metadata": null,
+      "categories": ["professional_details"],
+      "immutable": false,
+      "created_at": "2025-03-19T09:09:00.194116-07:00",
+      "updated_at": "2025-03-19T09:09:00.194128-07:00",
+    },
+    {
+      "id": "8d268d0f-5452-4714-b27d-ae46f676a49d",
+      "memory": "Is from Seattle",
+      "user_id": "joseph",
+      "metadata": null,
+      "categories": ["personal_details"],
+      "immutable": false,
+      "created_at": "2025-03-19T09:09:00.170680-07:00",
+      "updated_at": "2025-03-19T09:09:00.170692-07:00",
+    },
+    {
+      "id": "4a5a417a-fa10-43b5-8c53-a77c45e80438",
+      "memory": "Name is Joseph",
+      "user_id": "joseph",
+      "metadata": null,
+      "categories": ["personal_details"],
+      "immutable": false,
+      "created_at": "2025-03-19T09:09:00.146390-07:00",
+      "updated_at": "2025-03-19T09:09:00.146404-07:00",
+    }
+  ],
+  "relations": [
+    {
+      "source": "joseph",
+      "source_type": "person",
+      "relationship": "name",
+      "target": "joseph",
+      "target_type": "person"
+    },
+    {
+      "source": "joseph",
+      "source_type": "person",
+      "relationship": "city",
+      "target": "seattle",
+      "target_type": "city"
+    },
+    {
+      "source": "joseph",
+      "source_type": "person",
+      "relationship": "job",
+      "target": "software engineer",
+      "target_type": "job"
+    }
+  ]
+}
+```
+
+</CodeGroup>
+
+## Best Practices
+
+- Enable Graph Memory for applications where understanding context and relationships between memories is important
+- Graph Memory works best with a rich history of related conversations
+- Consider Graph Memory for long-running assistants that need to track evolving information
+
+## Performance Considerations
+
+Graph Memory requires additional processing and may increase response times slightly for very large memory stores. However, for most use cases, the improved retrieval quality outweighs the minimal performance impact.
+
+If you have any questions, please feel free to reach out to us using one of the following methods:
+
+<Snippet file="get-help.mdx" />
+

docs/features/memory-export.mdx

@@ -71,13 +71,32 @@ Here's an example schema for extracting professional profile information:
 
 ### Submit Export Job
 
+You can optionally provide additional instructions to guide how memories are processed and structured during export using the `export_instructions` parameter.
+
 <CodeGroup>
 
 ```python Python
+# Basic export request
 response = client.create_memory_export(
     schema=json_schema,
-    user_id="user123"
+    user_id="alice"
 )
+
+# Export with custom instructions
+export_instructions = """
+1. Create a comprehensive profile with detailed information in each category
+2. Only mark fields as "None" when absolutely no relevant information exists
+3. Base all information directly on the user's memories
+4. When contradictions exist, prioritize the most recent information
+5. Clearly distinguish between factual statements and inferences
+"""
+
+response = client.create_memory_export(
+    schema=json_schema,
+    user_id="alice",
+    export_instructions=export_instructions
+)
+
 print(response)
 ```
 
@@ -87,7 +106,8 @@ curl -X POST "https://api.mem0.ai/v1/memories/export/" \
      -H "Content-Type: application/json" \
      -d '{
          "schema": {json_schema},
-         "user_id": "user123"
+         "user_id": "alice",
+         "export_instructions": "1. Create a comprehensive profile with detailed information\n2. Only mark fields as \"None\" when absolutely no relevant information exists"
      }'
 ```
 
@@ -107,12 +127,12 @@ Once the export job is complete, you can retrieve the structured data:
 <CodeGroup>
 
 ```python Python
-response = client.get_memory_export(user_id="user123")
+response = client.get_memory_export(user_id="alice")
 print(response)
 ```
 
 ```bash cURL
-curl -X GET "https://api.mem0.ai/v1/memories/export/?user_id=user123" \
+curl -X GET "https://api.mem0.ai/v1/memories/export/?user_id=alice" \
      -H "Authorization: Token your-api-key"
 ```
 

docs/features/multimodal-support.mdx

@@ -12,7 +12,7 @@ Mem0 extends its capabilities beyond text by supporting multimodal data, includi
 When a user submits an image, Mem0 processes it to extract textual information and other pertinent details. These details are then added to the user's memory, enhancing the system's ability to understand and recall visual inputs.
 
 <CodeGroup>
-```python Code
+```python Python
 import os
 from mem0 import MemoryClient
 
@@ -44,6 +44,34 @@ messages = [
 client.add(messages, user_id="alice")
 ```
 
+```typescript TypeScript
+import MemoryClient from "mem0ai";
+
+const client = new MemoryClient();
+
+const messages = [
+    {
+        role: "user",
+        content: "Hi, my name is Alice."
+    },
+    {
+        role: "assistant",
+        content: "Nice to meet you, Alice! What do you like to eat?"
+    },
+    {
+        role: "user",
+        content: {
+            type: "image_url",
+            image_url: {
+                url: "https://www.superhealthykids.com/wp-content/uploads/2021/10/best-veggie-pizza-featured-image-square-2.jpg"
+            }
+        }
+    },
+]
+
+await client.add(messages, { user_id: "alice" })
+```
+
 ```json Output
 {
   "results": [
@@ -90,7 +118,9 @@ client.add([image_message], user_id="alice")
 ## 2. Using Base64 Image Encoding for Local Files
 
 For local images—or when embedding the image directly is preferable—you can use a Base64-encoded string.
-```python
+
+<CodeGroup>
+```python Python
 import base64
 
 # Path to the image file
@@ -113,6 +143,27 @@ image_message = {
 client.add([image_message], user_id="alice")
 ```
 
+```typescript TypeScript
+import MemoryClient from "mem0ai";
+import fs from 'fs';
+
+const imagePath = 'path/to/your/image.jpg';
+
+const base64Image = fs.readFileSync(imagePath, { encoding: 'base64' });
+
+const imageMessage = {
+    role: "user",
+    content: {
+        type: "image_url",
+        image_url: {
+            url: `data:image/jpeg;base64,${base64Image}`
+        }
+    }
+};
+
+await client.add([imageMessage], { user_id: "alice" })
+```
+</CodeGroup>
 Using these methods, you can seamlessly incorporate images into your interactions, further enhancing Mem0's multimodal capabilities.
 
 If you have any questions, please feel free to reach out to us using one of the following methods:

docs/features/platform-overview.mdx

@@ -12,6 +12,9 @@ Learn about the key features and capabilities that make Mem0 a powerful platform
   <Card title="Advanced Retrieval" icon="magnifying-glass" href="/features/advanced-retrieval">
     Superior search results using state-of-the-art algorithms, including keyword search, reranking, and filtering capabilities.
   </Card>
+  <Card title="Contextual Add" icon="square-plus" href="/features/contextual-add">
+    Only send your latest conversation history - we automatically retrieve the rest and generate properly contextualized memories.
+  </Card>
   <Card title="Multimodal Support" icon="photo-film" href="/features/multimodal-support">
     Process and analyze various types of content including images.
   </Card>
@@ -33,6 +36,9 @@ Learn about the key features and capabilities that make Mem0 a powerful platform
   <Card title="Memory Export" icon="file-export" href="/features/memory-export">
     Export memories in structured formats using customizable Pydantic schemas.
   </Card>
+  <Card title="Graph Memory" icon="graph" href="/features/graph-memory">
+    Add memories in the form of nodes and edges in a graph database and search for related memories.
+  </Card>
 </CardGroup>
 
 ## Getting Help

docs/integrations/langchain-tools.mdx

@@ -95,7 +95,7 @@ add_input = {
         {"role": "user", "content": "Hi, I'm Alex. I'm a vegetarian and I'm allergic to nuts."},
         {"role": "assistant", "content": "Hello Alex! I've noted that you're a vegetarian and have a nut allergy."}
     ],
-    "user_id": "alex123",
+    "user_id": "alex",
     "output_format": "v1.1",
     "metadata": {"food": "vegan"}
 }
@@ -173,7 +173,7 @@ search_input = {
     "filters": {
         "AND": [
             {"created_at": {"gte": "2024-07-20", "lte": "2024-12-10"}},
-            {"user_id": "alex123"}
+            {"user_id": "alex"}
         ]
     },
     "version": "v2"
@@ -186,7 +186,7 @@ result = search_tool.invoke(search_input)
   {
     "id": "1a75e827-7eca-45ea-8c5c-cfd43299f061",
     "memory": "Name is Alex",
-    "user_id": "alex123", 
+    "user_id": "alex", 
     "hash": "d0fccc8fa47f7a149ee95750c37bb0ca",
     "metadata": {
       "food": "vegan"
@@ -255,7 +255,7 @@ get_all_input = {
     "version": "v2",
     "filters": {
         "AND": [
-            {"user_id": "alex123"},
+            {"user_id": "alex"},
             {"created_at": {"gte": "2024-07-01", "lte": "2024-12-31"}}
         ]
     },
@@ -274,7 +274,7 @@ get_all_result = get_all_tool.invoke(get_all_input)
     {
       "id": "1a75e827-7eca-45ea-8c5c-cfd43299f061",
       "memory": "Name is Alex",
-      "user_id": "alex123", 
+      "user_id": "alex", 
       "hash": "d0fccc8fa47f7a149ee95750c37bb0ca",
       "metadata": {
         "food": "vegan"
@@ -288,7 +288,7 @@ get_all_result = get_all_tool.invoke(get_all_input)
     {
       "id": "91509588-0b39-408a-8df3-84b3bce8c521",
       "memory": "Is a vegetarian",
-      "user_id": "alex123",
+      "user_id": "alex",
       "hash": "ce6b1c84586772ab9995a9477032df99", 
       "metadata": {
         "food": "vegan"
@@ -303,7 +303,7 @@ get_all_result = get_all_tool.invoke(get_all_input)
     {
       "id": "8d74f7a0-6107-4589-bd6f-210f6bf4fbbb",
       "memory": "Is allergic to nuts",
-      "user_id": "alex123",
+      "user_id": "alex",
       "hash": "7873cd0e5a29c513253d9fad038e758b",
       "metadata": {
         "food": "vegan"

docs/integrations/mcp-server.mdx

@@ -0,0 +1,60 @@
+---
+title: MCP Server
+---
+
+## Integrating mem0 as an MCP Server in Cursor
+[mem0](https://github.com/mem0ai/mem0-mcp) is a powerful tool designed to enhance AI-driven workflows, particularly in code generation and contextual memory. In this guide, we'll walk through integrating mem0 as an **MCP (Model Context Protocol) server** within [Cursor](https://cursor.sh/), an AI-powered coding editor.
+
+## Prerequisites
+Before proceeding, ensure you have the following installed:
+- Cursor IDE
+- Python (>=3.8)
+- Git
+- [mem0-mcp](https://github.com/mem0ai/mem0-mcp) (Clone the repository and set up as per the instructions in the README)
+
+
+## Configuring Cursor to use mem0 as an MCP Server
+
+1. **Open Cursor.**
+2. **Navigate to `Settings` > `Cursor Settings` > `Features` > `MCP Servers`.**
+3. **Add a new provider using the MCP server:**
+   - Click on **`Add new MCP server`**
+   - Provide a name for the server, e.g. `mem0` and select type as `sse`
+   - Enter the **SSE Endpoint**: `http://0.0.0.0:8080/sse`
+4. **Save and Restart Cursor** to apply changes.
+
+## Demo
+<iframe width="560" height="315" src="https://www.youtube.com/embed/fWa6KX7cpG8?si=cmJDz2sQevGnItSI" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>
+
+## Using mem0 in Cursor
+Once integrated, mem0 can assist with contextual memory and AI-driven coding enhancements. Some key functionalities include:
+
+### 1. Storing Coding Preferences
+Mem0 can store and manage coding preferences, including:
+- Complete code snippets with dependencies
+- Language/framework versions
+- Documentation and comments
+- Best practices and example usage
+
+### 2. Retrieving Stored Preferences
+Access all stored coding references to:
+- Review implementations
+- Maintain consistency in coding practices
+
+### 3. Semantic Search for Preferences
+Use natural language queries to find:
+- Code snippets
+- Technical documentation
+- Best practices
+- Setup guides
+
+## Benefits of Using mem0 in Cursor
+- **Persistent Context Storage**: Retain and reuse coding insights across sessions.
+- **Seamless Integration**: Works directly within Cursor as an MCP server.
+- **Efficient Search**: Retrieve relevant coding insights using semantic search.
+
+## Conclusion
+By integrating mem0 as an MCP server within Cursor, you enhance your development workflow with AI-powered memory and context-aware assistance. Follow the steps above to set up and start leveraging mem0 in your coding environment.
+
+For more details on MCP integration, refer to Cursor's [Model Context Protocol documentation](https://docs.cursor.com/context/model-context-protocol).
+

docs/integrations/overview.mdx

@@ -198,4 +198,26 @@ Here are the available integrations for Mem0:
   >
     Build AI applications with persistent memory using Dify and Mem0.
   </Card>
+  <Card
+    title="MCP Server"
+    icon={
+      <svg
+        viewBox="0 0 180 180"
+        xmlns="http://www.w3.org/2000/svg"
+        width="24"
+        height="24"
+      >
+        <path
+          d="M45 45 L135 45 M45 90 L135 90 M45 135 L135 135"
+          stroke="currentColor"
+          strokeWidth="12"
+          strokeLinecap="round"
+          fill="none"
+        />
+      </svg>
+    }
+    href="/integrations/mcp-server"
+  >
+    Integrate Mem0 as an MCP Server in Cursor.
+  </Card>
 </CardGroup>

docs/open-source/graph_memory/features.mdx

@@ -16,23 +16,43 @@ Users can add a customized prompt that will be used to extract specific entities
 This allows for more targeted and relevant information extraction based on the user's needs. 
 Here's an example of how to add a customized prompt:
 
-```python
-from mem0 import Memory
+<CodeGroup>
+    ```python Python
+    from mem0 import Memory
 
-config = {
-    "graph_store": {
-        "provider": "neo4j",
-        "config": {
-            "url": "neo4j+s://xxx",
-            "username": "neo4j",
-            "password": "xxx"
-        },
-        "custom_prompt": "Please only extract entities containing sports related relationships and nothing else.",
+    config = {
+        "graph_store": {
+            "provider": "neo4j",
+            "config": {
+                "url": "neo4j+s://xxx",
+                "username": "neo4j",
+                "password": "xxx"
+            },
+            "custom_prompt": "Please only extract entities containing sports related relationships and nothing else.",
+        }
     }
-}
 
-m = Memory.from_config(config_dict=config)
-```
+    m = Memory.from_config(config_dict=config)
+    ```
+
+    ```typescript TypeScript
+    import { Memory } from "mem0ai/oss";
+
+    const config = {
+        graphStore: {
+            provider: "neo4j",
+            config: {
+                url: "neo4j+s://xxx",
+                username: "neo4j",
+                password: "xxx",
+            },
+            customPrompt: "Please only extract entities containing sports related relationships and nothing else.",
+        }
+    }
+
+    const memory = new Memory(config);
+    ```
+</CodeGroup>
 
 If you want to use a managed version of Mem0, please check out [Mem0](https://mem0.dev/pd). If you have any questions, please feel free to reach out to us using one of the following methods:
 

docs/open-source/graph_memory/overview.mdx

@@ -9,14 +9,24 @@ Mem0 now supports **Graph Memory**.
 With Graph Memory, users can now create and utilize complex relationships between pieces of information, allowing for more nuanced and context-aware responses. 
 This integration enables users to leverage the strengths of both vector-based and graph-based approaches, resulting in more accurate and comprehensive information retrieval and generation.
 
+<Note>
+NodeSDK now supports Graph Memory. 🎉
+</Note>
+
 ## Installation
 
 To use Mem0 with Graph Memory support, install it using pip:
 
-```bash
+<CodeGroup>
+```bash Python
 pip install "mem0ai[graph]"
 ```
 
+```bash TypeScript
+npm install mem0ai
+```
+</CodeGroup>
+
 This command installs Mem0 along with the necessary dependencies for graph functionality.
 
 Try Graph Memory on Google Colab.
@@ -42,7 +52,6 @@ Currently, we support Neo4j as a graph store provider. You can setup [Neo4j](htt
 
 <Note>If you are using Neo4j locally, then you need to install [APOC plugins](https://neo4j.com/labs/apoc/4.1/installation/).</Note>
 
-
 User can also customize the LLM for Graph Memory from the [Supported LLM list](https://docs.mem0.ai/components/llms/overview) with three levels of configuration:
 
 1. **Main Configuration**: If `llm` is set in the main config, it will be used for all graph operations.
@@ -53,7 +62,7 @@ Here's how you can do it:
 
 
 <CodeGroup>
-```python Basic
+```python Python
 from mem0 import Memory
 
 config = {
@@ -70,9 +79,25 @@ config = {
 m = Memory.from_config(config_dict=config)
 ```
 
-```python Advanced (Custom LLM)
-from mem0 import Memory
+```typescript TypeScript
+import { Memory } from "mem0ai/oss";
 
+const config = {
+    enableGraph: true,
+    graphStore: {
+        provider: "neo4j",
+        config: {
+            url: "neo4j+s://xxx",
+            username: "neo4j",
+            password: "xxx",
+        }
+    }
+}
+
+const memory = new Memory(config);
+```
+
+```python Python (Advanced)
 config = {
     "llm": {
         "provider": "openai",
@@ -101,22 +126,61 @@ config = {
 
 m = Memory.from_config(config_dict=config)
 ```
+
+```typescript TypeScript (Advanced)
+const config = {
+    llm: {
+        provider: "openai",
+        config: {
+            model: "gpt-4o",
+            temperature: 0.2,
+            max_tokens: 2000,
+        }
+    },
+    enableGraph: true,
+    graphStore: {
+        provider: "neo4j",
+        config: {
+            url: "neo4j+s://xxx",
+            username: "neo4j",
+            password: "xxx",
+        },
+        llm: {
+            provider: "openai",
+            config: {
+                model: "gpt-4o-mini",
+                temperature: 0.0,
+            }
+        }
+    }
+}
+
+const memory = new Memory(config);
+```
 </CodeGroup>
 
+<Note>
+If you are using NodeSDK, you need to pass `enableGraph` as `true` in the `config` object.
+</Note>
+
 ## Graph Operations
 The Mem0's graph supports the following operations:
 
 ### Add Memories
 
 <Note>
-If you are using Mem0 with Graph Memory, it is recommended to pass `user_id`. The default value of `user_id` (in case of graph memory) is `user`.
+If you are using Mem0 with Graph Memory, it is recommended to pass `user_id`. Use `userId` in NodeSDK.
 </Note>
 
 <CodeGroup>
-```python Code
+```python Python
 m.add("I like pizza", user_id="alice")
 ```
 
+```typescript TypeScript
+memory.add("I like pizza", { userId: "alice" });
+```
+
 ```json Output
 {'message': 'ok'}
 ```
@@ -126,10 +190,14 @@ m.add("I like pizza", user_id="alice")
 ### Get all memories
 
 <CodeGroup>
-```python Code
+```python Python
 m.get_all(user_id="alice")
 ```
 
+```typescript TypeScript
+memory.getAll({ userId: "alice" });
+```
+
 ```json Output
 {
     'memories': [
@@ -157,10 +225,14 @@ m.get_all(user_id="alice")
 ### Search Memories
 
 <CodeGroup>
-```python Code
+```python Python
 m.search("tell me my name.", user_id="alice")
 ```
 
+```typescript TypeScript
+memory.search("tell me my name.", { userId: "alice" });
+```
+
 ```json Output
 {
     'memories': [
@@ -187,10 +259,16 @@ m.search("tell me my name.", user_id="alice")
 
 
 ### Delete all Memories
-```python
+
+<CodeGroup>
+```python Python
 m.delete_all(user_id="alice")
 ```
 
+```typescript TypeScript
+memory.deleteAll({ userId: "alice" });
+```
+</CodeGroup>
 
 # Example Usage
 Here's an example of how to use Mem0's graph operations:
@@ -206,64 +284,110 @@ Below are the steps to add memories and visualize the graph:
 <Steps>
   <Step title="Add memory 'I like going to hikes'">
 
-```python
+<CodeGroup>
+```python Python
 m.add("I like going to hikes", user_id="alice123")
 ```
+
+```typescript TypeScript
+memory.add("I like going to hikes", { userId: "alice123" });
+```
+</CodeGroup>
 ![Graph Memory Visualization](/images/graph_memory/graph_example1.png)
 
 </Step>
 <Step title="Add memory 'I love to play badminton'">
 
-
-```python
+<CodeGroup>
+```python Python
 m.add("I love to play badminton", user_id="alice123")
 ```
+
+```typescript TypeScript
+memory.add("I love to play badminton", { userId: "alice123" });
+```
+</CodeGroup>
+
 ![Graph Memory Visualization](/images/graph_memory/graph_example2.png)
 
 </Step>
 
 <Step title="Add memory 'I hate playing badminton'">
 
-```python
+<CodeGroup>
+```python Python
 m.add("I hate playing badminton", user_id="alice123")
 ```
+
+```typescript TypeScript
+memory.add("I hate playing badminton", { userId: "alice123" });
+```
+</CodeGroup>
+
 ![Graph Memory Visualization](/images/graph_memory/graph_example3.png)
 
 </Step>
 
 <Step title="Add memory 'My friend name is john and john has a dog named tommy'">
 
-```python
+<CodeGroup>
+```python Python
 m.add("My friend name is john and john has a dog named tommy", user_id="alice123")
 ```
+
+```typescript TypeScript
+memory.add("My friend name is john and john has a dog named tommy", { userId: "alice123" });
+```
+</CodeGroup>
+
 ![Graph Memory Visualization](/images/graph_memory/graph_example4.png)
 
 </Step>
 
 <Step title="Add memory 'My name is Alice'">
 
-```python
+<CodeGroup>
+```python Python
 m.add("My name is Alice", user_id="alice123")
 ```
+
+```typescript TypeScript
+memory.add("My name is Alice", { userId: "alice123" });
+```
+</CodeGroup>
+
 ![Graph Memory Visualization](/images/graph_memory/graph_example5.png)
 
 </Step>
 
 <Step title="Add memory 'John loves to hike and Harry loves to hike as well'">
 
-```python
+<CodeGroup>
+```python Python
 m.add("John loves to hike and Harry loves to hike as well", user_id="alice123")
 ```
+
+```typescript TypeScript
+memory.add("John loves to hike and Harry loves to hike as well", { userId: "alice123" });
+```
+</CodeGroup>
+
 ![Graph Memory Visualization](/images/graph_memory/graph_example6.png)
 
 </Step>
 
 <Step title="Add memory 'My friend peter is the spiderman'">
 
-```python
+<CodeGroup>
+```python Python
 m.add("My friend peter is the spiderman", user_id="alice123")
 ```
 
+```typescript TypeScript
+memory.add("My friend peter is the spiderman", { userId: "alice123" });
+```
+</CodeGroup>
+
 ![Graph Memory Visualization](/images/graph_memory/graph_example7.png)
 
 </Step>
@@ -274,10 +398,14 @@ m.add("My friend peter is the spiderman", user_id="alice123")
 ### Search Memories
 
 <CodeGroup>
-```python Code
+```python Python
 m.search("What is my name?", user_id="alice123")
 ```
 
+```typescript TypeScript
+memory.search("What is my name?", { userId: "alice123" });
+```
+
 ```json Output
 {
     'memories': [...],
@@ -297,10 +425,14 @@ Below graph visualization shows what nodes and relationships are fetched from th
 ![Graph Memory Visualization](/images/graph_memory/graph_example8.png)
 
 <CodeGroup>
-```python Code
+```python Python
 m.search("Who is spiderman?", user_id="alice123")
 ```
 
+```typescript TypeScript
+memory.search("Who is spiderman?", { userId: "alice123" });
+```
+
 ```json Output
 {
     'memories': [...],

docs/open-source/multimodal-support.mdx

@@ -10,11 +10,25 @@ Mem0 extends its capabilities beyond text by supporting multimodal data, includi
 
 When a user provides an image, Mem0 processes the image to extract textual information and relevant details, which are then added to the user's memory. This feature enhances the system's ability to understand and remember details based on visual inputs.
 
+<Note>
+To enable multimodal support, you must set `enable_vision = True` in your configuration. The `vision_details` parameter can be set to "auto" (default), "low", or "high" to control the level of detail in image processing.
+</Note>
+
 <CodeGroup>
 ```python Code
 from mem0 import Memory
 
-client = Memory()
+config = {
+    "llm": {
+        "provider": "openai",
+        "config": {
+            "enable_vision": True,
+            "vision_details": "high"
+        }
+    }
+}
+
+client = Memory.from_config(config=config)
 
 messages = [
     {
@@ -40,6 +54,34 @@ messages = [
 client.add(messages, user_id="alice")
 ```
 
+```typescript TypeScript
+import { Memory, Message } from "mem0ai/oss";
+
+const client = new Memory();
+
+const messages: Message[] = [
+    {
+        role: "user",
+        content: "Hi, my name is Alice."
+    },
+    {
+        role: "assistant",
+        content: "Nice to meet you, Alice! What do you like to eat?"
+    },
+    {
+        role: "user",
+        content: {
+            type: "image_url",
+            image_url: {
+                url: "https://www.superhealthykids.com/wp-content/uploads/2021/10/best-veggie-pizza-featured-image-square-2.jpg"
+            }
+        }
+    },
+]
+
+await client.add(messages, { userId: "alice" })
+```
+
 ```json Output
 {
   "results": [
@@ -66,6 +108,7 @@ Mem0 allows you to add images to user interactions through two primary methods:
 
 You can include an image by passing its direct URL. This method is simple and efficient for online images.
 
+<CodeGroup>
 ```python
 # Define the image URL
 image_url = "https://www.superhealthykids.com/wp-content/uploads/2021/10/best-veggie-pizza-featured-image-square-2.jpg"
@@ -82,11 +125,33 @@ image_message = {
 }
 ```
 
+```typescript TypeScript
+import { Memory, Message } from "mem0ai/oss";
+
+const client = new Memory();
+
+const imageUrl = "https://www.superhealthykids.com/wp-content/uploads/2021/10/best-veggie-pizza-featured-image-square-2.jpg";
+
+const imageMessage: Message = {
+    role: "user",
+    content: {
+        type: "image_url",
+        image_url: {
+            url: imageUrl
+        }
+    }
+}
+
+await client.add([imageMessage], { userId: "alice" })
+```
+</CodeGroup>
+
 ## 2. Using Base64 Image Encoding for Local Files
 
 For local images or scenarios where embedding the image directly is preferable, you can use a Base64-encoded string.
 
-```python
+<CodeGroup>
+```python Python
 import base64
 
 # Path to the image file
@@ -108,11 +173,95 @@ image_message = {
 }
 ```
 
-By utilizing these methods, you can effectively incorporate images into user interactions, enhancing the multimodal capabilities of your Mem0 instance.
+```typescript TypeScript
+import { Memory, Message } from "mem0ai/oss";
 
-<Note>
-Currently, we support only OpenAI models for image description.
-</Note>
+const client = new Memory();
+
+const imagePath = "path/to/your/image.jpg";
+
+const base64Image = fs.readFileSync(imagePath, { encoding: 'base64' });
+
+const imageMessage: Message = {
+    role: "user",
+    content: {
+        type: "image_url",
+        image_url: {
+            url: `data:image/jpeg;base64,${base64Image}`
+        }
+    }
+}
+
+await client.add([imageMessage], { userId: "alice" })
+```
+</CodeGroup>
+
+## 3. OpenAI-Compatible Message Format
+
+You can also use the OpenAI-compatible format to combine text and images in a single message:
+
+<CodeGroup>
+```python Python
+import base64
+
+# Path to the image file
+image_path = "path/to/your/image.jpg"
+
+# Encode the image in Base64
+with open(image_path, "rb") as image_file:
+    base64_image = base64.b64encode(image_file.read()).decode("utf-8")
+
+# Create the message using OpenAI-compatible format
+message = {
+    "role": "user",
+    "content": [
+        {
+            "type": "text",
+            "text": "What is in this image?",
+        },
+        {
+            "type": "image_url",
+            "image_url": {"url": f"data:image/jpeg;base64,{base64_image}"},
+        },
+    ],
+}
+
+# Add the message to memory
+client.add([message], user_id="alice")
+```
+
+```typescript TypeScript
+import { Memory, Message } from "mem0ai/oss";
+
+const client = new Memory();
+
+const imagePath = "path/to/your/image.jpg";
+
+const base64Image = fs.readFileSync(imagePath, { encoding: 'base64' });
+
+const message: Message = {
+    role: "user",
+    content: [
+        {
+            type: "text",
+            text: "What is in this image?",
+        },
+        {
+            type: "image_url",
+            image_url: {
+                url: `data:image/jpeg;base64,${base64Image}`
+            }
+        },
+    ],
+}
+
+await client.add([message], { userId: "alice" })
+```
+</CodeGroup>
+
+This format allows you to combine text and images in a single message, making it easier to provide context along with visual content.
+
+By utilizing these methods, you can effectively incorporate images into user interactions, enhancing the multimodal capabilities of your Mem0 instance.
 
 If you have any questions, please feel free to reach out to us using one of the following methods:
 

docs/open-source/node-quickstart.mdx

@@ -74,14 +74,14 @@ const messages = [
     {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]
 
-await memory.add(messages, { userId: "user123", metadata: { category: "movie_recommendations" } });
+await memory.add(messages, { userId: "alice", metadata: { category: "movie_recommendations" } });
 ```
 
 ```json Output
 {
   "results": [
     {
-      "id": "c03c9045-df76-4949-bbc5-d5dc1932aa5c",
+      "id": "892db2ae-06d9-49e5-8b3e-585ef9b85b8e",
       "memory": "User is planning to watch a movie tonight.",
       "metadata": {
         "category": "movie_recommendations"
@@ -111,7 +111,7 @@ await memory.add(messages, { userId: "user123", metadata: { category: "movie_rec
 <CodeGroup>
 ```typescript Code
 // Get all memories
-const allMemories = await memory.getAll({ userId: "user123" });
+const allMemories = await memory.getAll({ userId: "alice" });
 console.log(allMemories)
 ```
 
@@ -127,7 +127,7 @@ console.log(allMemories)
       "metadata": {
         "category": "movie_recommendations"
       },
-      "userId": "user123"
+      "userId": "alice"
     },
     {
       "id": "475bde34-21e6-42ab-8bef-0ab84474f156",
@@ -138,7 +138,7 @@ console.log(allMemories)
       "metadata": {
         "category": "movie_recommendations"
       },
-      "userId": "user123"
+      "userId": "alice"
     },
     {
       "id": "cbb1fe73-0bf1-4067-8c1f-63aa53e7b1a4",
@@ -149,7 +149,7 @@ console.log(allMemories)
       "metadata": {
         "category": "movie_recommendations"
       },
-      "userId": "user123"
+      "userId": "alice"
     }
   ]
 }
@@ -176,7 +176,7 @@ console.log(singleMemory);
   "metadata": {
     "category": "movie_recommendations"
   },
-  "userId": "user123"
+  "userId": "alice"
 }
 ```
 </CodeGroup>
@@ -185,7 +185,7 @@ console.log(singleMemory);
 
 <CodeGroup>
 ```typescript Code
-const result = await memory.search('What do you know about me?', { userId: "user123" });
+const result = await memory.search('What do you know about me?', { userId: "alice" });
 console.log(result);
 ```
 
@@ -202,7 +202,7 @@ console.log(result);
       "metadata": {
         "category": "movie_recommendations"
       },
-      "userId": "user123"
+      "userId": "alice"
     },
     {
       "id": "475bde34-21e6-42ab-8bef-0ab84474f156",
@@ -214,7 +214,7 @@ console.log(result);
       "metadata": {
         "category": "movie_recommendations"
       },
-      "userId": "user123"
+      "userId": "alice"
     },
     {
       "id": "cbb1fe73-0bf1-4067-8c1f-63aa53e7b1a4",
@@ -226,7 +226,7 @@ console.log(result);
       "metadata": {
         "category": "movie_recommendations"
       },
-      "userId": "user123"
+      "userId": "alice"
     }
   ]
 }
@@ -263,23 +263,23 @@ console.log(history);
 [
   {
     "id": 39,
-    "memory_id": "892db2ae-06d9-49e5-8b3e-585ef9b85b8e",
-    "previous_value": "User is planning to watch a movie tonight.",
-    "new_value": "I love India, it is my favorite country.",
+    "memoryId": "892db2ae-06d9-49e5-8b3e-585ef9b85b8e",
+    "previousValue": "User is planning to watch a movie tonight.",
+    "newValue": "I love India, it is my favorite country.",
     "action": "UPDATE",
-    "created_at": "2025-02-27T16:33:20.557Z",
-    "updated_at": "2025-02-27T16:33:27.051Z",
-    "is_deleted": 0
+    "createdAt": "2025-02-27T16:33:20.557Z",
+    "updatedAt": "2025-02-27T16:33:27.051Z",
+    "isDeleted": 0
   },
   {
     "id": 37,
-    "memory_id": "892db2ae-06d9-49e5-8b3e-585ef9b85b8e",
-    "previous_value": null,
-    "new_value": "User is planning to watch a movie tonight.",
+    "memoryId": "892db2ae-06d9-49e5-8b3e-585ef9b85b8e",
+    "previousValue": null,
+    "newValue": "User is planning to watch a movie tonight.",
     "action": "ADD",
-    "created_at": "2025-02-27T16:33:20.557Z",
-    "updated_at": null,
-    "is_deleted": 0
+    "createdAt": "2025-02-27T16:33:20.557Z",
+    "updatedAt": null,
+    "isDeleted": 0
   }
 ]
 ```
@@ -292,7 +292,7 @@ console.log(history);
 await memory.delete('892db2ae-06d9-49e5-8b3e-585ef9b85b8e');
 
 // Delete all memories for a user
-await memory.deleteAll({ userId: "user123" });
+await memory.deleteAll({ userId: "alice" });
 ```
 
 ### Reset Memory
@@ -327,6 +327,15 @@ Mem0 offers extensive configuration options to customize its behavior according
 | `openaiBaseUrl`     | Base URL for OpenAI API                      | OpenAI           |
 </Accordion>
 
+<Accordion title="Graph Store Configuration">
+| Parameter    | Description                     | Default     |
+|-------------|---------------------------------|-------------|
+| `provider`   | Graph store provider (e.g., "neo4j") | "neo4j"    |
+| `url`        | Connection URL                  | env.NEO4J_URL        |
+| `username`   | Authentication username         | env.NEO4J_USERNAME        |
+| `password`   | Authentication password         | env.NEO4J_PASSWORD        |
+</Accordion>
+
 <Accordion title="Embedder Configuration">
 | Parameter    | Description                     | Default                      |
 |-------------|---------------------------------|------------------------------|

docs/open-source/python-quickstart.mdx

@@ -22,7 +22,11 @@ pip install mem0ai
 <Tabs>
   <Tab title="Basic">
 ```python
+import os
 from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "your-api-key"
+
 m = Memory()
 ```
   </Tab>
@@ -42,8 +46,11 @@ docker run -p 6333:6333 -p 6334:6334 \
 Then, instantiate memory with qdrant server:
 
 ```python
+import os
 from mem0 import Memory
 
+os.environ["OPENAI_API_KEY"] = "your-api-key"
+
 config = {
     "vector_store": {
         "provider": "qdrant",
@@ -61,8 +68,11 @@ m = Memory.from_config(config)
 <Tab title="Advanced (Graph Memory)">
 
 ```python
+import os
 from mem0 import Memory
 
+os.environ["OPENAI_API_KEY"] = "your-api-key"
+
 config = {
     "graph_store": {
         "provider": "neo4j",
@@ -85,20 +95,47 @@ m = Memory.from_config(config_dict=config)
 
 <CodeGroup>
 ```python Code
-# For a user
-result = m.add("Likes to play cricket on weekends", user_id="alice", metadata={"category": "hobbies"})
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
 
-# messages = [
-#    {"role": "user", "content": "Hi, I'm Alex. I like to play cricket on weekends."},
-#    {"role": "assistant", "content": "Hello Alex! It's great to know that you enjoy playing cricket on weekends. I'll remember that for future reference."}
-# ]
-# client.add(messages, user_id="alice")
+# Store inferred memories (default behavior)
+result = m.add(messages, user_id="alice", metadata={"category": "movie_recommendations"})
+
+# Store raw messages without inference
+# result = m.add(messages, user_id="alice", metadata={"category": "movie_recommendations"}, infer=False)
 ```
 
 ```json Output
 {
     "results": [
-        {"id": "bf4d4092-cf91-4181-bfeb-b6fa2ed3061b", "memory": "Likes to play cricket on weekends", "event": "ADD"}
+        {
+            "id": "892db2ae-06d9-49e5-8b3e-585ef9b85b8e",
+            "memory": "User is planning to watch a movie tonight.",
+            "metadata": {
+                "category": "movie_recommendations"
+            },
+            "event": "ADD"
+        },
+        {
+            "id": "cbb1fe73-0bf1-4067-8c1f-63aa53e7b1a4",
+            "memory": "User is not a big fan of thriller movies.",
+            "metadata": {
+                "category": "movie_recommendations"
+            },
+            "event": "ADD"
+        },
+        {
+            "id": "475bde34-21e6-42ab-8bef-0ab84474f156",
+            "memory": "User loves sci-fi movies.",
+            "metadata": {
+                "category": "movie_recommendations"
+            },
+            "event": "ADD"
+        }
     ]
 }
 ```
@@ -115,14 +152,38 @@ all_memories = m.get_all(user_id="alice")
 ```json Output
 {
     "results": [
+            {
+        "id": "892db2ae-06d9-49e5-8b3e-585ef9b85b8e",
+        "memory": "User is planning to watch a movie tonight.",
+        "hash": "1a271c007316c94377175ee80e746a19",
+        "created_at": "2025-02-27T16:33:20.557Z",
+        "updated_at": "2025-02-27T16:33:27.051Z",
+        "metadata": {
+            "category": "movie_recommendations"
+        },
+        "user_id": "alice"
+        },
         {
-            "id": "bf4d4092-cf91-4181-bfeb-b6fa2ed3061b", 
-            "memory": "Likes to play cricket on weekends", 
-            "hash": "285d07801ae42054732314853e9eadd7", 
-            "metadata": {"category": "hobbies"}, 
-            "created_at": "2024-10-28T12:32:07.744891-07:00", 
-            "updated_at": None, 
-            "user_id": "alice"
+        "id": "475bde34-21e6-42ab-8bef-0ab84474f156",
+        "memory": "User loves sci-fi movies.",
+        "hash": "285d07801ae42054732314853e9eadd7",
+        "created_at": "2025-02-27T16:33:20.560Z",
+        "updated_at": None,
+        "metadata": {
+            "category": "movie_recommendations"
+        },
+        "user_id": "alice"
+        },
+        {
+        "id": "cbb1fe73-0bf1-4067-8c1f-63aa53e7b1a4",
+        "memory": "User is not a big fan of thriller movies.",
+        "hash": "285d07801ae42054732314853e9eadd7",
+        "created_at": "2025-02-27T16:33:20.560Z",
+        "updated_at": None,
+        "metadata": {
+            "category": "movie_recommendations"
+        },
+        "user_id": "alice"
         }
     ]
 }
@@ -135,18 +196,20 @@ all_memories = m.get_all(user_id="alice")
 <CodeGroup>
 ```python Code
 # Get a single memory by ID
-specific_memory = m.get("bf4d4092-cf91-4181-bfeb-b6fa2ed3061b")
+specific_memory = m.get("892db2ae-06d9-49e5-8b3e-585ef9b85b8e")
 ```
 
 ```json Output
 {
-    "id": "bf4d4092-cf91-4181-bfeb-b6fa2ed3061b", 
-    "memory": "Likes to play cricket on weekends", 
-    "hash": "285d07801ae42054732314853e9eadd7", 
-    "metadata": {"category": "hobbies"}, 
-    "created_at": "2024-10-28T12:32:07.744891-07:00", 
-    "updated_at": None, 
-    "user_id": "alice"
+  "id": "892db2ae-06d9-49e5-8b3e-585ef9b85b8e",
+  "memory": "User is planning to watch a movie tonight.",
+  "hash": "1a271c007316c94377175ee80e746a19",
+  "created_at": "2025-02-27T16:33:20.557Z",
+  "updated_at": None,
+  "metadata": {
+    "category": "movie_recommendations"
+  },
+  "user_id": "alice"
 }
 ```
 </CodeGroup>
@@ -155,23 +218,49 @@ specific_memory = m.get("bf4d4092-cf91-4181-bfeb-b6fa2ed3061b")
 
 <CodeGroup>
 ```python Code
-related_memories = m.search(query="What are Alice's hobbies?", user_id="alice")
+related_memories = m.search(query="What do you know about me?", user_id="alice")
 ```
 
 ```json Output
 {
-    "results": [
-        {
-            "id": "bf4d4092-cf91-4181-bfeb-b6fa2ed3061b", 
-            "memory": "Likes to play cricket on weekends", 
-            "hash": "285d07801ae42054732314853e9eadd7", 
-            "metadata": {"category": "hobbies"}, 
-            "score": 0.30808347, 
-            "created_at": "2024-10-28T12:32:07.744891-07:00", 
-            "updated_at": None, 
-            "user_id": "alice"
-        }
-    ]
+  "results": [
+    {
+      "id": "892db2ae-06d9-49e5-8b3e-585ef9b85b8e",
+      "memory": "User is planning to watch a movie tonight.",
+      "hash": "1a271c007316c94377175ee80e746a19",
+      "created_at": "2025-02-27T16:33:20.557Z",
+      "updated_at": None,
+      "score": 0.38920719231944799,
+      "metadata": {
+        "category": "movie_recommendations"
+      },
+      "user_id": "alice"
+    },
+    {
+      "id": "475bde34-21e6-42ab-8bef-0ab84474f156",
+      "memory": "User loves sci-fi movies.",
+      "hash": "285d07801ae42054732314853e9eadd7",
+      "created_at": "2025-02-27T16:33:20.560Z",
+      "updated_at": None,
+      "score": 0.36869761478135689,
+      "metadata": {
+        "category": "movie_recommendations"
+      },
+      "user_id": "alice"
+    },
+    {
+      "id": "cbb1fe73-0bf1-4067-8c1f-63aa53e7b1a4",
+      "memory": "User is not a big fan of thriller movies.",
+      "hash": "285d07801ae42054732314853e9eadd7",
+      "created_at": "2025-02-27T16:33:20.560Z",
+      "updated_at": None,
+      "score": 0.33855272141248272,
+      "metadata": {
+        "category": "movie_recommendations"
+      },
+      "user_id": "alice"
+    }
+  ]
 }
 ```
 </CodeGroup>
@@ -180,7 +269,7 @@ related_memories = m.search(query="What are Alice's hobbies?", user_id="alice")
 
 <CodeGroup>
 ```python Code
-result = m.update(memory_id="bf4d4092-cf91-4181-bfeb-b6fa2ed3061b", data="Likes to play tennis on weekends")
+result = m.update(memory_id="892db2ae-06d9-49e5-8b3e-585ef9b85b8e", data="I love India, it is my favorite country.")
 ```
 
 ```json Output
@@ -192,29 +281,31 @@ result = m.update(memory_id="bf4d4092-cf91-4181-bfeb-b6fa2ed3061b", data="Likes
 
 <CodeGroup>
 ```python Code
-history = m.history(memory_id="bf4d4092-cf91-4181-bfeb-b6fa2ed3061b")
+history = m.history(memory_id="892db2ae-06d9-49e5-8b3e-585ef9b85b8e")
 ```
 
 ```json Output
 [
-    {
-        "id": "96d2821d-e551-4089-aa57-9398c421d450", 
-        "memory_id": "bf4d4092-cf91-4181-bfeb-b6fa2ed3061b", 
-        "old_memory": None, 
-        "new_memory": "Likes to play cricket on weekends", 
-        "event": "ADD", 
-        "created_at": "2024-10-28T12:32:07.744891-07:00", 
-        "updated_at": None
-    }, 
-    {
-        "id": "3db4cb58-c0f1-4dd0-b62a-8123068ebfe7", 
-        "memory_id": "bf4d4092-cf91-4181-bfeb-b6fa2ed3061b", 
-        "old_memory": "Likes to play cricket on weekends", 
-        "new_memory": "Likes to play tennis on weekends", 
-        "event": "UPDATE", 
-        "created_at": "2024-10-28T12:32:07.744891-07:00", 
-        "updated_at": "2024-10-28T13:05:46.987978-07:00"
-    }
+  {
+    "id": 39,
+    "memory_id": "892db2ae-06d9-49e5-8b3e-585ef9b85b8e",
+    "previous_value": "User is planning to watch a movie tonight.",
+    "new_value": "I love India, it is my favorite country.",
+    "action": "UPDATE",
+    "created_at": "2025-02-27T16:33:20.557Z",
+    "updated_at": "2025-02-27T16:33:27.051Z",
+    "is_deleted": 0
+  },
+  {
+    "id": 37,
+    "memory_id": "892db2ae-06d9-49e5-8b3e-585ef9b85b8e",
+    "previous_value": null,
+    "new_value": "User is planning to watch a movie tonight.",
+    "action": "ADD",
+    "created_at": "2025-02-27T16:33:20.557Z",
+    "updated_at": null,
+    "is_deleted": 0
+  }
 ]
 ```
 </CodeGroup>
@@ -223,7 +314,7 @@ history = m.history(memory_id="bf4d4092-cf91-4181-bfeb-b6fa2ed3061b")
 
 ```python
 # Delete a memory by id
-m.delete(memory_id="bf4d4092-cf91-4181-bfeb-b6fa2ed3061b")
+m.delete(memory_id="892db2ae-06d9-49e5-8b3e-585ef9b85b8e")
 # Delete all memories for a user
 m.delete_all(user_id="alice")
 ```
@@ -291,7 +382,8 @@ Mem0 offers extensive configuration options to customize its behavior according
 |------------------|--------------------------------------|----------------------------|
 | `history_db_path` | Path to the history database         | "{mem0_dir}/history.db"    |
 | `version`         | API version                          | "v1.1"                     |
-| `custom_prompt`   | Custom prompt for memory processing  | None                       |
+| `custom_fact_extraction_prompt`   | Custom prompt for memory processing  | None                       |
+| `custom_update_memory_prompt` | Custom prompt for update memory | None                |
 </Accordion>
 
 <Accordion title="Complete Configuration Example">
@@ -328,7 +420,8 @@ config = {
     },
     "history_db_path": "/path/to/history.db",
     "version": "v1.1",
-    "custom_prompt": "Optional custom prompt for memory processing"
+    "custom_fact_extraction_prompt": "Optional custom prompt for fact extraction for memory",
+    "custom_update_memory_prompt": "Optional custom prompt for update memory"
 }
 ```
 </Accordion>

docs/openapi.json

@@ -932,27 +932,27 @@
 				"x-code-samples": [
 				{
 				"lang": "Python",
-				"source": "# To use the Python SDK, install the package:\n# pip install mem0ai\n\nfrom mem0 import MemoryClient\n\nclient = MemoryClient(api_key=\"your_api_key\", org_id=\"your_org_id\", project_id=\"your_project_id\")\n\nmessages = [\n    {\"role\": \"user\", \"content\": \"<user-message>\"},\n    {\"role\": \"assistant\", \"content\": \"<assistant-response>\"}\n]\n\nclient.add(messages, user_id=\"<user-id>\")"
+				"source": "# To use the Python SDK, install the package:\n# pip install mem0ai\n\nfrom mem0 import MemoryClient\n\nclient = MemoryClient(api_key=\"your_api_key\", org_id=\"your_org_id\", project_id=\"your_project_id\")\n\nmessages = [\n    {\"role\": \"user\", \"content\": \"<user-message>\"},\n    {\"role\": \"assistant\", \"content\": \"<assistant-response>\"}\n]\n\nclient.add(messages, user_id=\"<user-id>\", version=\"v2\")"
 				},
 				{
 				"lang": "JavaScript",
-				"source": "// To use the JavaScript SDK, install the package:\n// npm i mem0ai\n\nimport MemoryClient from 'mem0ai';\nconst client = new MemoryClient({ apiKey: \"your-api-key\" });\n\nconst messages = [\n  { role: \"user\", content: \"Hi, I'm Alex. I'm a vegetarian and I'm allergic to nuts.\" },\n  { role: \"assistant\", content: \"Hello Alex! I've noted that you're a vegetarian and have a nut allergy. I'll keep this in mind for any food-related recommendations or discussions.\" }\n];\n\nclient.add(messages, { user_id: \"<user_id>\" })\n  .then(result => console.log(result))\n  .catch(error => console.error(error));"
+				"source": "// To use the JavaScript SDK, install the package:\n// npm i mem0ai\n\nimport MemoryClient from 'mem0ai';\nconst client = new MemoryClient({ apiKey: \"your-api-key\" });\n\nconst messages = [\n  { role: \"user\", content: \"Hi, I'm Alex. I'm a vegetarian and I'm allergic to nuts.\" },\n  { role: \"assistant\", content: \"Hello Alex! I've noted that you're a vegetarian and have a nut allergy. I'll keep this in mind for any food-related recommendations or discussions.\" }\n];\n\nclient.add(messages, { user_id: \"<user_id>\", version: \"v2\" })\n  .then(result => console.log(result))\n  .catch(error => console.error(error));"
 				},				  
 				{
 				"lang": "cURL",
-				"source": "curl --request POST \\\n  --url https://api.mem0.ai/v1/memories/ \\\n  --header 'Authorization: Token <api-key>' \\\n  --header 'Content-Type: application/json' \\\n  --data '{\n  \"messages\": [\n    {}\n  ],\n  \"agent_id\": \"<string>\",\n  \"user_id\": \"<string>\",\n  \"app_id\": \"<string>\",\n  \"run_id\": \"<string>\",\n  \"metadata\": {},\n  \"includes\": \"<string>\",\n  \"excludes\": \"<string>\",\n  \"infer\": true,\n  \"custom_categories\": {}, \n  \"org_id\": \"<string>\",\n  \"project_id\": \"<string>\"\n}'"
+				"source": "curl --request POST \\\n  --url https://api.mem0.ai/v1/memories/ \\\n  --header 'Authorization: Token <api-key>' \\\n  --header 'Content-Type: application/json' \\\n  --data '{\n  \"messages\": [\n    {}\n  ],\n  \"agent_id\": \"<string>\",\n  \"user_id\": \"<string>\",\n  \"app_id\": \"<string>\",\n  \"run_id\": \"<string>\",\n  \"metadata\": {},\n  \"includes\": \"<string>\",\n  \"excludes\": \"<string>\",\n  \"infer\": true,\n  \"custom_categories\": {}, \n  \"org_id\": \"<string>\",\n  \"project_id\": \"<string>\",\n  \"version\": \"v2\"\n}'"
 				},
 				{
 				"lang": "Go",
-				"source": "package main\n\nimport (\n\t\"fmt\"\n\t\"strings\"\n\t\"net/http\"\n\t\"io/ioutil\"\n)\n\nfunc main() {\n\n\turl := \"https://api.mem0.ai/v1/memories/\"\n\n\tpayload := strings.NewReader(\"{\n  \\\"messages\\\": [\n    {}\n  ],\n  \\\"agent_id\\\": \\\"<string>\\\",\n  \\\"user_id\\\": \\\"<string>\\\",\n  \\\"app_id\\\": \\\"<string>\\\",\n  \\\"run_id\\\": \\\"<string>\\\",\n  \\\"metadata\\\": {},\n  \\\"includes\\\": \\\"<string>\\\",\n  \\\"excludes\\\": \\\"<string>\\\",\n  \\\"infer\\\": true,\n  \\\"custom_categories\\\": {},\n  \\\"org_id\\\": \\\"<string>\\\",\n  \\\"project_id\\\": \\\"<string>\"\n}\")\n\n\treq, _ := http.NewRequest(\"POST\", url, payload)\n\n\treq.Header.Add(\"Authorization\", \"Token <api-key>\")\n\treq.Header.Add(\"Content-Type\", \"application/json\")\n\n\tres, _ := http.DefaultClient.Do(req)\n\n\tdefer res.Body.Close()\n\tbody, _ := ioutil.ReadAll(res.Body)\n\n\tfmt.Println(res)\n\tfmt.Println(string(body))\n\n}"
+				"source": "package main\n\nimport (\n\t\"fmt\"\n\t\"strings\"\n\t\"net/http\"\n\t\"io/ioutil\"\n)\n\nfunc main() {\n\n\turl := \"https://api.mem0.ai/v1/memories/\"\n\n\tpayload := strings.NewReader(\"{\n  \\\"messages\\\": [\n    {}\n  ],\n  \\\"agent_id\\\": \\\"<string>\\\",\n  \\\"user_id\\\": \\\"<string>\\\",\n  \\\"app_id\\\": \\\"<string>\\\",\n  \\\"run_id\\\": \\\"<string>\\\",\n  \\\"metadata\\\": {},\n  \\\"includes\\\": \\\"<string>\\\",\n  \\\"excludes\\\": \\\"<string>\\\",\n  \\\"infer\\\": true,\n  \\\"custom_categories\\\": {},\n  \\\"org_id\\\": \\\"<string>\\\",\n  \\\"project_id\\\": \\\"<string>\",\n  \\\"version\\\": \"v2\"\n}\")\n\n\treq, _ := http.NewRequest(\"POST\", url, payload)\n\n\treq.Header.Add(\"Authorization\", \"Token <api-key>\")\n\treq.Header.Add(\"Content-Type\", \"application/json\")\n\n\tres, _ := http.DefaultClient.Do(req)\n\n\tdefer res.Body.Close()\n\tbody, _ := ioutil.ReadAll(res.Body)\n\n\tfmt.Println(res)\n\tfmt.Println(string(body))\n\n}"
 				},
 				{
 				"lang": "PHP",
-				"source": "<?php\n\n$curl = curl_init();\n\ncurl_setopt_array($curl, [\n  CURLOPT_URL => \"https://api.mem0.ai/v1/memories/\",\n  CURLOPT_RETURNTRANSFER => true,\n  CURLOPT_ENCODING => \"\",\n  CURLOPT_MAXREDIRS => 10,\n  CURLOPT_TIMEOUT => 30,\n  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,\n  CURLOPT_CUSTOMREQUEST => \"POST\",\n  CURLOPT_POSTFIELDS => \"{\n  \\\"messages\\\": [\n    {}\n  ],\n  \\\"agent_id\\\": \\\"<string>\\\",\n  \\\"user_id\\\": \\\"<string>\\\",\n  \\\"app_id\\\": \\\"<string>\\\",\n  \\\"run_id\\\": \\\"<string>\\\",\n  \\\"metadata\\\": {},\n  \\\"includes\\\": \\\"<string>\\\",\n  \\\"excludes\\\": \\\"<string>\\\",\n  \\\"infer\\\": true,\n  \\\"custom_categories\\\": {}, \n  \\\"org_id\\\": \\\"<string>\\\",\n  \\\"project_id\\\": \\\"<string>\"\n}\",\n  CURLOPT_HTTPHEADER => [\n    \"Authorization: Token <api-key>\",\n    \"Content-Type: application/json\"\n  ],\n]);\n\n$response = curl_exec($curl);\n$err = curl_error($curl);\n\ncurl_close($curl);\n\nif ($err) {\n  echo \"cURL Error #:\" . $err;\n} else {\n  echo $response;\n}"
+				"source": "<?php\n\n$curl = curl_init();\n\ncurl_setopt_array($curl, [\n  CURLOPT_URL => \"https://api.mem0.ai/v1/memories/\",\n  CURLOPT_RETURNTRANSFER => true,\n  CURLOPT_ENCODING => \"\",\n  CURLOPT_MAXREDIRS => 10,\n  CURLOPT_TIMEOUT => 30,\n  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,\n  CURLOPT_CUSTOMREQUEST => \"POST\",\n  CURLOPT_POSTFIELDS => \"{\n  \\\"messages\\\": [\n    {}\n  ],\n  \\\"agent_id\\\": \\\"<string>\\\",\n  \\\"user_id\\\": \\\"<string>\\\",\n  \\\"app_id\\\": \\\"<string>\\\",\n  \\\"run_id\\\": \\\"<string>\\\",\n  \\\"metadata\\\": {},\n  \\\"includes\\\": \\\"<string>\\\",\n  \\\"excludes\\\": \\\"<string>\\\",\n  \\\"infer\\\": true,\n  \\\"custom_categories\\\": {}, \n  \\\"org_id\\\": \\\"<string>\\\",\n  \\\"project_id\\\": \\\"<string>\",\n  \\\"version\\\": \"v2\"\n}\",\n  CURLOPT_HTTPHEADER => [\n    \"Authorization: Token <api-key>\",\n    \"Content-Type: application/json\"\n  ],\n]);\n\n$response = curl_exec($curl);\n$err = curl_error($curl);\n\ncurl_close($curl);\n\nif ($err) {\n  echo \"cURL Error #:\" . $err;\n} else {\n  echo $response;\n}"
 				},
 				{
 				"lang": "Java",
-				"source": "HttpResponse<String> response = Unirest.post(\"https://api.mem0.ai/v1/memories/\")\n  .header(\"Authorization\", \"Token <api-key>\")\n  .header(\"Content-Type\", \"application/json\")\n  .body(\"{\n  \\\"messages\\\": [\n    {}\n  ],\n  \\\"agent_id\\\": \\\"<string>\\\",\n  \\\"user_id\\\": \\\"<string>\\\",\n  \\\"app_id\\\": \\\"<string>\\\",\n  \\\"run_id\\\": \\\"<string>\\\",\n  \\\"metadata\\\": {},\n  \\\"includes\\\": \\\"<string>\\\",\n  \\\"excludes\\\": \\\"<string>\\\",\n  \\\"infer\\\": true,\n  \\\"custom_categories\\\": {}, \n  \\\"org_id\\\": \\\"<string>\\\",\n  \\\"project_id\\\": \\\"<string>\"\n}\")\n  .asString();"
+				"source": "HttpResponse<String> response = Unirest.post(\"https://api.mem0.ai/v1/memories/\")\n  .header(\"Authorization\", \"Token <api-key>\")\n  .header(\"Content-Type\", \"application/json\")\n  .body(\"{\n  \\\"messages\\\": [\n    {}\n  ],\n  \\\"agent_id\\\": \\\"<string>\\\",\n  \\\"user_id\\\": \\\"<string>\\\",\n  \\\"app_id\\\": \\\"<string>\\\",\n  \\\"run_id\\\": \\\"<string>\\\",\n  \\\"metadata\\\": {},\n  \\\"includes\\\": \\\"<string>\\\",\n  \\\"excludes\\\": \\\"<string>\\\",\n  \\\"infer\\\": true,\n  \\\"custom_categories\\\": {}, \n  \\\"org_id\\\": \\\"<string>\\\",\n  \\\"project_id\\\": \\\"<string>\",\n  \\\"version\\\": \"v2\"\n}\")\n  .asString();"
 					}
 				],
 				"x-codegen-request-body-name": "data"
@@ -4743,7 +4743,7 @@
 						"nullable": true
 					},
 					"metadata": {
-						"description": "Additional metadata associated with the memory, which can be used to store any additional information or context about the memory.",
+						"description": "Additional metadata associated with the memory, which can be used to store any additional information or context about the memory. Best practice for incorporating additional information is through metadata (e.g. location, time, ids, etc.). During retrieval, you can either use these metadata alongside the query to fetch relevant memories or retrieve memories based on the query first and then refine the results using metadata during post-processing.",
 						"title": "Metadata",
 						"type": "object",
 						"properties": {
@@ -4809,6 +4809,12 @@
 						"title": "Project id",
 						"type": "string",
 						"nullable": true
+					},
+					"version": {
+						"description": "The version of the memory to use. The default version is v1, which is deprecated. We recommend using v2 for new applications.",
+						"title": "Version", 
+						"type": "string",
+						"nullable": true
 					}
 				}
 			},

docs/platform/quickstart.mdx

@@ -87,10 +87,10 @@ messages = [
 ]
 
 # The default output_format is v1.0
-client.add(messages, user_id="alex", output_format="v1.0")
+client.add(messages, user_id="alex", output_format="v1.0", version="v2")
 
 # To use the latest output_format, set the output_format parameter to "v1.1"
-client.add(messages, user_id="alex", output_format="v1.1", metadata={"food": "vegan"})
+client.add(messages, user_id="alex", output_format="v1.1", metadata={"food": "vegan"}, version="v2")
 ```
 
 ```javascript JavaScript
@@ -98,7 +98,7 @@ const messages = [
     {"role": "user", "content": "Hi, I'm Alex. I'm a vegetarian and I'm allergic to nuts."},
     {"role": "assistant", "content": "Hello Alex! I've noted that you're a vegetarian and have a nut allergy. I'll keep this in mind for any food-related recommendations or discussions."}
 ];
-client.add(messages, { user_id: "alex", output_format: "v1.1", metadata: { food: "vegan" } })
+client.add(messages, { user_id: "alex", output_format: "v1.1", metadata: { food: "vegan" }, version: "v2" })
     .then(response => console.log(response))
     .catch(error => console.error(error));
 ```
@@ -116,7 +116,8 @@ curl -X POST "https://api.mem0.ai/v1/memories/" \
          "output_format": "v1.1",
          "metadata": {
              "food": "vegan"
-         }
+         },
+         "version": "v2"
      }'
 ```
 
@@ -173,6 +174,8 @@ curl -X POST "https://api.mem0.ai/v1/memories/" \
     Messages passed along with `user_id`, `run_id`, or `app_id` are stored as user memories, while messages from the assistant are excluded from memory. To store messages for the assistant, use `agent_id` exclusively and avoid including other IDs, such as user_id, alongside it. This ensures the memory is properly attributed to the assistant.
 </Note>
 
+<Note>Metadata allows you to store structured information (location, timestamp, user state) with memories. Add it during creation to enable precise filtering and retrieval during searches.</Note>
+
 
 #### Short-term memory for a user session
 
@@ -189,10 +192,10 @@ messages = [
 ]
 
 # The default output_format is v1.0
-client.add(messages, user_id="alex123", run_id="trip-planning-2024", output_format="v1.0")
+client.add(messages, user_id="alex", run_id="trip-planning-2024", output_format="v1.0", version="v2")
 
 # To use the latest output_format, set the output_format parameter to "v1.1"
-client.add(messages, user_id="alex123", run_id="trip-planning-2024", output_format="v1.1")
+client.add(messages, user_id="alex", run_id="trip-planning-2024", output_format="v1.1", version="v2")
 ```
 
 ```javascript JavaScript
@@ -202,7 +205,7 @@ const messages = [
     {"role": "user", "content": "Yes, please! Especially in Tokyo."},
     {"role": "assistant", "content": "Great! I'll remember that you're interested in vegetarian restaurants in Tokyo for your upcoming trip. I'll prepare a list for you in our next interaction."}
 ];
-client.add(messages, { user_id: "alex123", run_id: "trip-planning-2024", output_format: "v1.1" })
+client.add(messages, { user_id: "alex", run_id: "trip-planning-2024", output_format: "v1.1", version: "v2" })
     .then(response => console.log(response))
     .catch(error => console.error(error));
 ```
@@ -218,9 +221,10 @@ curl -X POST "https://api.mem0.ai/v1/memories/" \
              {"role": "user", "content": "Yes, please! Especially in Tokyo."},
              {"role": "assistant", "content": "Great! I'll remember that you're interested in vegetarian restaurants in Tokyo for your upcoming trip. I'll prepare a list for you in our next interaction."}
          ],
-         "user_id": "alex123",
+         "user_id": "alex",
          "run_id": "trip-planning-2024",
-         "output_format": "v1.1"
+         "output_format": "v1.1",
+         "version": "v2"
      }'
 ```
 
@@ -272,10 +276,10 @@ messages = [
 ]
 
 # The default output_format is v1.0
-client.add(messages, agent_id="ai-tutor", output_format="v1.0")
+client.add(messages, agent_id="ai-tutor", output_format="v1.0", version="v2")
 
 # To use the latest output_format, set the output_format parameter to "v1.1"
-client.add(messages, agent_id="ai-tutor", output_format="v1.1")
+client.add(messages, agent_id="ai-tutor", output_format="v1.1", version="v2")
 ```
 
 ```javascript JavaScript
@@ -283,7 +287,7 @@ const messages = [
     {"role": "system", "content": "You are an AI tutor with a personality. Give yourself a name for the user."},
     {"role": "assistant", "content": "Understood. I'm an AI tutor with a personality. My name is Alice."}
 ];
-client.add(messages, { agent_id: "ai-tutor", output_format: "v1.1" })
+client.add(messages, { agent_id: "ai-tutor", output_format: "v1.1", version: "v2" })
     .then(response => console.log(response))
     .catch(error => console.error(error));
 ```
@@ -298,7 +302,8 @@ curl -X POST "https://api.mem0.ai/v1/memories/" \
              {"role": "assistant", "content": "Understood. I'm an AI tutor with a personality. My name is Alice."}
          ],
          "agent_id": "ai-tutor",
-         "output_format": "v1.1"
+         "output_format": "v1.1",
+         "version": "v2"
      }'
 ```
 
@@ -352,6 +357,65 @@ curl -X POST "https://api.mem0.ai/v1/memories/" \
     The `agent_id` retains memories exclusively based on messages generated by the assistant or those explicitly provided as input to the assistant. Messages outside these criteria are not stored as memory.
 </Note>
 
+#### Long-term memory for both users and agents
+When you provide both `user_id` and `agent_id`, Mem0 will store memories with both identifiers attached:
+- Each memory will be tagged with both the specified `user_id` and `agent_id`
+- During retrieval, you'll need to provide both IDs to access the memories
+- This enables tracking the full context of conversations between specific users and agents
+
+<CodeGroup>
+
+```python Python
+messages = [
+    {"role": "user", "content": "I'm travelling to San Francisco"},
+    {"role": "assistant", "content": "That's great! I'm going to Dubai next month."},
+]
+
+client.add(messages=messages, user_id="user1", agent_id="agent1", version="v2")
+```
+
+```javascript JavaScript
+const messages = [
+    {"role": "user", "content": "I'm travelling to San Francisco"},
+    {"role": "assistant", "content": "That's great! I'm going to Dubai next month."},
+]
+
+client.add(messages, { user_id: "user1", agent_id: "agent1", version: "v2" })
+    .then(response => console.log(response))
+    .catch(error => console.error(error));
+```
+
+```bash cURL
+curl -X POST "https://api.mem0.ai/v1/memories/" \
+     -H "Authorization: Token your-api-key" \
+     -H "Content-Type: application/json" \
+     -d '{
+         "messages": [
+             {"role": "user", "content": "I'm travelling to San Francisco"},
+             {"role": "assistant", "content": "That's great! I'm going to Dubai next month."},
+         ],
+         "user_id": "user1",
+         "agent_id": "agent1",
+         "version": "v2"
+     }'
+```
+
+```json Output
+[
+    {
+        'id': 'c57abfa2-f0ac-48af-896a-21728dbcecee0',
+        'data': {'memory': 'Travelling to San Francisco'},
+        'event': 'ADD'
+    },
+    {   'id': '0e8c003f-7db7-426a-9fdc-a46f9331a0c2',
+        'data': {'memory': 'Going to Dubai next month'},
+        'event': 'ADD'
+    }
+]
+```
+
+</CodeGroup>
+
 
 #### Monitor Memories
 
@@ -431,6 +495,7 @@ curl -X POST "https://api.mem0.ai/v1/memories/search/" \
 </CodeGroup>
 
 Use category and metadata filters:
+
 <CodeGroup>
 
 ```python Python
@@ -943,17 +1008,17 @@ curl -X GET "https://api.mem0.ai/v1/memories/?agent_id=ai-tutor&page=1&page_size
 <CodeGroup>
 
 ```python Python
-short_term_memories = client.get_all(user_id="alex123", run_id="trip-planning-2024", page=1, page_size=50)
+short_term_memories = client.get_all(user_id="alex", run_id="trip-planning-2024", page=1, page_size=50)
 ```
 
 ```javascript JavaScript
-client.getAll({ user_id: "alex123", run_id: "trip-planning-2024", page: 1, page_size: 50 })
+client.getAll({ user_id: "alex", run_id: "trip-planning-2024", page: 1, page_size: 50 })
     .then(memories => console.log(memories))
     .catch(error => console.error(error));
 ```
 
 ```bash cURL
-curl -X GET "https://api.mem0.ai/v1/memories/?user_id=alex123&run_id=trip-planning-2024&page=1&page_size=50" \
+curl -X GET "https://api.mem0.ai/v1/memories/?user_id=alex&run_id=trip-planning-2024&page=1&page_size=50" \
      -H "Authorization: Token your-api-key"
 ```
 
@@ -966,7 +1031,7 @@ curl -X GET "https://api.mem0.ai/v1/memories/?user_id=alex123&run_id=trip-planni
         {
             "id":"06d8df63-7bd2-4fad-9acb-60871bcecee0",
             "memory":"Planning a trip to Japan next month. Interested in vegetarian restaurants in Tokyo.",
-            "user_id":"alex123",
+            "user_id":"alex",
             "hash":"d2088c936e259f2f5d2d75543d31401c",
             "metadata":None,
             "immutable": false,
@@ -977,7 +1042,7 @@ curl -X GET "https://api.mem0.ai/v1/memories/?user_id=alex123&run_id=trip-planni
         {
             "id":"b4229775-d860-4ccb-983f-0f628ca112f5",
             "memory":"Planning a trip to Japan next month. Interested in vegetarian restaurants in Tokyo.",
-            "user_id":"alex123",
+            "user_id":"alex",
             "hash":"d2088c936e259f2f5d2d75543d31401c",
             "metadata":None,
             "immutable": false,
@@ -988,7 +1053,7 @@ curl -X GET "https://api.mem0.ai/v1/memories/?user_id=alex123&run_id=trip-planni
         {
             "id":"df1aca24-76cf-4b92-9f58-d03857efcb64",
             "memory":"Planning a trip to Japan next month. Interested in vegetarian restaurants in Tokyo.",
-            "user_id":"alex123",
+            "user_id":"alex",
             "hash":"d2088c936e259f2f5d2d75543d31401c",
             "metadata":None,
             "immutable": false,
@@ -1011,7 +1076,7 @@ curl -X GET "https://api.mem0.ai/v1/memories/?user_id=alex123&run_id=trip-planni
             {
                 "id": "06d8df63-7bd2-4fad-9acb-60871bcecee0",
                 "memory": "Planning a trip to Japan next month. Interested in vegetarian restaurants in Tokyo.",
-                "user_id": "alex123",
+                "user_id": "alex",
                 "hash": "d2088c936e259f2f5d2d75543d31401c",
                 "metadata":None,
                 "immutable": false,
@@ -1022,7 +1087,7 @@ curl -X GET "https://api.mem0.ai/v1/memories/?user_id=alex123&run_id=trip-planni
             {
                 "id": "b4229775-d860-4ccb-983f-0f628ca112f5",
                 "memory": "Planning a trip to Japan next month. Interested in vegetarian restaurants in Tokyo.",
-                "user_id": "alex123",
+                "user_id": "alex",
                 "hash": "d2088c936e259f2f5d2d75543d31401c",
                 "metadata":None,
                 "immutable": false,
@@ -1033,7 +1098,7 @@ curl -X GET "https://api.mem0.ai/v1/memories/?user_id=alex123&run_id=trip-planni
             {
                 "id": "df1aca24-76cf-4b92-9f58-d03857efcb64",
                 "memory": "Planning a trip to Japan next month. Interested in vegetarian restaurants in Tokyo.",
-                "user_id": "alex123",
+                "user_id": "alex",
                 "hash": "d2088c936e259f2f5d2d75543d31401c",
                 "metadata":None,
                 "immutable": false,
@@ -1072,7 +1137,7 @@ curl -X GET "https://api.mem0.ai/v1/memories/582bbe6d-506b-48c6-a4c6-5df3b1e6342
 {
    "id":"06d8df63-7bd2-4fad-9acb-60871bcecee0",
    "memory":"Planning a trip to Japan next month. Interested in vegetarian restaurants in Tokyo.",
-   "user_id":"alex123",
+   "user_id":"alex",
    "hash":"d2088c936e259f2f5d2d75543d31401c",
    "metadata":"None",
    "immutable": false,
@@ -1091,55 +1156,55 @@ You can filter memories by their categories when using get_all:
 
 ```python Python
 # Get memories with specific categories
-memories = client.get_all(user_id="alex123", categories=["likes"])
+memories = client.get_all(user_id="alex", categories=["likes"])
 
 # Get memories with multiple categories
-memories = client.get_all(user_id="alex123", categories=["likes", "food_preferences"])
+memories = client.get_all(user_id="alex", categories=["likes", "food_preferences"])
 
 # Custom pagination with categories
-memories = client.get_all(user_id="alex123", categories=["likes"], page=1, page_size=50)
+memories = client.get_all(user_id="alex", categories=["likes"], page=1, page_size=50)
 
 # Get memories with specific keywords
-memories = client.get_all(user_id="alex123", keywords="to play", page=1, page_size=50)
+memories = client.get_all(user_id="alex", keywords="to play", page=1, page_size=50)
 ```
 
 ```javascript JavaScript
 // Get memories with specific categories
-client.getAll({ user_id: "alex123", categories: ["likes"] })
+client.getAll({ user_id: "alex", categories: ["likes"] })
     .then(memories => console.log(memories))
     .catch(error => console.error(error));
 
 // Get memories with multiple categories
-client.getAll({ user_id: "alex123", categories: ["likes", "food_preferences"] })
+client.getAll({ user_id: "alex", categories: ["likes", "food_preferences"] })
     .then(memories => console.log(memories))
     .catch(error => console.error(error));
 
 // Custom pagination with categories
-client.getAll({ user_id: "alex123", categories: ["likes"], page: 1, page_size: 50 })
+client.getAll({ user_id: "alex", categories: ["likes"], page: 1, page_size: 50 })
     .then(memories => console.log(memories))
     .catch(error => console.error(error));
 
 // Get memories with specific keywords
-client.getAll({ user_id: "alex123", keywords: "to play", page: 1, page_size: 50 })
+client.getAll({ user_id: "alex", keywords: "to play", page: 1, page_size: 50 })
     .then(memories => console.log(memories))
     .catch(error => console.error(error));
 ```
 
 ```bash cURL
 # Get memories with specific categories
-curl -X GET "https://api.mem0.ai/v1/memories/?user_id=alex123&categories=likes" \
+curl -X GET "https://api.mem0.ai/v1/memories/?user_id=alex&categories=likes" \
      -H "Authorization: Token your-api-key"
 
 # Get memories with multiple categories
-curl -X GET "https://api.mem0.ai/v1/memories/?user_id=alex123&categories=likes,food_preferences" \
+curl -X GET "https://api.mem0.ai/v1/memories/?user_id=alex&categories=likes,food_preferences" \
      -H "Authorization: Token your-api-key"
 
 # Custom pagination with categories
-curl -X GET "https://api.mem0.ai/v1/memories/?user_id=alex123&categories=likes&page=1&page_size=50" \
+curl -X GET "https://api.mem0.ai/v1/memories/?user_id=alex&categories=likes&page=1&page_size=50" \
      -H "Authorization: Token your-api-key"
 
 # Get memories with specific keywords
-curl -X GET "https://api.mem0.ai/v1/memories/?user_id=alex123&keywords=to play&page=1&page_size=50" \
+curl -X GET "https://api.mem0.ai/v1/memories/?user_id=alex&keywords=to play&page=1&page_size=50" \
      -H "Authorization: Token your-api-key"
 ```
 
@@ -1152,7 +1217,7 @@ curl -X GET "https://api.mem0.ai/v1/memories/?user_id=alex123&keywords=to play&p
         {
             "id": "06d8df63-7bd2-4fad-9acb-60871bcecee0",
             "memory": "Likes pizza and pasta",
-            "user_id": "alex123",
+            "user_id": "alex",
             "hash": "d2088c936e259f2f5d2d75543d31401c",
             "metadata": null,
             "immutable": false,
@@ -1163,7 +1228,7 @@ curl -X GET "https://api.mem0.ai/v1/memories/?user_id=alex123&keywords=to play&p
         {
             "id": "b4229775-d860-4ccb-983f-0f628ca112f5",
             "memory": "Likes to travel to beach destinations",
-            "user_id": "alex123",
+            "user_id": "alex",
             "hash": "d2088c936e259f2f5d2d75543d31401c",
             "metadata": null,
             "immutable": false,
@@ -1230,11 +1295,6 @@ const filters = {
          "categories":{
             "contains": "food_preferences"
          }
-      },
-      {
-         "keywords":{
-            "contains": "to play"
-         }
       }
    ]
 };
@@ -1258,20 +1318,14 @@ curl -X GET "https://api.mem0.ai/v1/memories/?version=v2" \
      -d '{
          "filters": {
              "AND": [
-                 {
-                     "user_id": "alex"
-                 },
-                 {
-                     "created_at": {
-                         "gte": "2024-07-01",
-                         "lte": "2024-07-31"
-                     }
-                 },
-                 {
-                    "categories":{
-                        "contains": "food_preferences"
-                    }
-                }
+                {"user_id":"alex"},
+                {"created_at":{
+                    "gte":"2024-07-01",
+                    "lte":"2024-07-31"
+                }},
+                {"categories":{
+                    "contains": "food_preferences"
+                }}
              ]
          }
      }'
@@ -1283,15 +1337,14 @@ curl -X GET "https://api.mem0.ai/v1/memories/?version=v2&page=1&page_size=50" \
      -d '{
          "filters": {
              "AND": [
-                 {
-                     "user_id": "alex"
-                 },
-                 {
-                     "created_at": {
-                         "gte": "2024-07-01",
-                         "lte": "2024-07-31"
-                     }
-                 }
+                {"user_id":"alex"},
+                {"created_at":{
+                    "gte":"2024-07-01",
+                    "lte":"2024-07-31"
+                }},
+                {"categories":{
+                    "contains": "food_preferences"
+                }}
              ]
          }
      }'
@@ -1392,8 +1445,8 @@ curl -X GET "https://api.mem0.ai/v1/memories/?version=v2" \
                     "categories": {
                         "contains": "food_preferences"
                     }
-                }
-            ]
+                }}
+             ]
          }
      }'
 
@@ -1409,7 +1462,7 @@ curl -X GET "https://api.mem0.ai/v1/memories/?version=v2&page=1&page_size=50" \
                     "categories": {
                         "contains": "food_preferences"
                     }
-                }
+                }}
             ]
          }
      }'
@@ -1536,7 +1589,7 @@ curl -X GET "https://api.mem0.ai/v1/memories/<memory-id-here>/history/" \
       ],
       "old_memory":"None",
       "new_memory":"Turned vegetarian.",
-      "user_id":"alex123456",
+      "user_id":"alex",
       "event":"ADD",
       "metadata":"None",
       "created_at":"2024-07-26T01:02:41.737310-07:00",
@@ -1767,12 +1820,10 @@ print(response)
 ```
 ```javascript JavaScript
 const updateMemories = [
-    {
-        memoryId: "285ed74b-6e05-4043-b16b-3abd5b533496",
+    {"memory_id": "285ed74b-6e05-4043-b16b-3abd5b533496",
         text: "Watches football"
     },
-    {
-        memoryId: "2c9bd859-d1b7-4d33-a6b8-94e0147c4f07",
+    {"memory_id": "2c9bd859-d1b7-4d33-a6b8-94e0147c4f07",
         text: "Loves to travel"
     }
 ];
@@ -1817,8 +1868,7 @@ response = client.batch_delete(delete_memories)
 print(response)
 ```
 ```javascript JavaScript
-const deleteMemories = [
-    {"memory_id": "285ed74b-6e05-4043-b16b-3abd5b533496"},
+const deleteMemories = [{"memory_id": "285ed74b-6e05-4043-b16b-3abd5b533496"},
     {"memory_id": "2c9bd859-d1b7-4d33-a6b8-94e0147c4f07"}
 ];
 

examples/mem0-demo/app/assistant.tsx

@@ -6,7 +6,7 @@ import { Thread } from "@/components/assistant-ui/thread";
 import { ThreadList } from "@/components/assistant-ui/thread-list";
 import { useEffect, useState } from "react";
 import { v4 as uuidv4 } from "uuid";
-import { Sun, Moon, MessageSquare } from "lucide-react";
+import { Sun, Moon, AlignJustify } from "lucide-react";
 import { Button } from "@/components/ui/button";
 import ThemeAwareLogo from "@/components/mem0/theme-aware-logo";
 import Link from "next/link";
@@ -45,7 +45,7 @@ const useUserId = () => {
 export const Assistant = () => {
   const { userId, resetUserId } = useUserId();
   const runtime = useChatRuntime({
-    api: "/api/chat",
+    api: "https://demo.mem0.ai/api/chat",
     body: { userId },
   });
 
@@ -63,7 +63,7 @@ export const Assistant = () => {
 
   return (
     <AssistantRuntimeProvider runtime={runtime}>
-      <div className={`h-dvh bg-[#f8fafc] dark:bg-zinc-900 text-[#1e293b] ${isDarkMode ? "dark" : ""}`}>
+      <div className={`bg-[#f8fafc] dark:bg-zinc-900 text-[#1e293b] ${isDarkMode ? "dark" : ""}`}>
         <header className="h-16 border-b border-[#e2e8f0] flex items-center justify-between px-4 sm:px-6 bg-white dark:bg-zinc-900 dark:border-zinc-800 dark:text-white">
           <div className="flex items-center">
           <Link href="/" className="flex items-center">
@@ -71,29 +71,34 @@ export const Assistant = () => {
           </Link>
           </div>
 
-          <div className="flex items-center">
-            <Button 
+          <Button 
               variant="ghost" 
               size="sm" 
               onClick={() => setSidebarOpen(true)}
               className="text-[#475569] dark:text-zinc-300 md:hidden"
             >
-              <MessageSquare className="w-10 h-10" />
-            </Button>
+              <AlignJustify size={24} className="md:hidden" />
+          </Button>
+
+
+          <div className="md:flex items-center hidden">
             <button
               className="p-2 rounded-full hover:bg-[#eef2ff] dark:hover:bg-zinc-800 text-[#475569] dark:text-zinc-300"
               onClick={toggleDarkMode}
               aria-label="Toggle theme"
             >
-              {isDarkMode ? <Sun className="w-5 h-5" /> : <Moon className="w-5 h-5" />}
+              {isDarkMode ? <Sun className="w-6 h-6" /> : <Moon className="w-6 h-6" />}
             </button>
             <GithubButton url="https://github.com/mem0ai/mem0/tree/main/examples" />
+
+            <Link href={"https://app.mem0.ai/"} target="_blank" className="py-2 ml-2 px-4 font-semibold dark:bg-zinc-100 dark:hover:bg-zinc-200 bg-zinc-800 text-white rounded-full hover:bg-zinc-900 dark:text-[#475569]">
+              Save Memories
+            </Link>
           </div>
         </header>
-
-        <div className="grid grid-cols-1 md:grid-cols-[260px_1fr] gap-x-0 h-[calc(100vh-8rem)] md:h-[calc(100vh-4rem)]">
-          <ThreadList onResetUserId={resetUserId} />
-          <Thread sidebarOpen={sidebarOpen} setSidebarOpen={setSidebarOpen} onResetUserId={resetUserId} />
+        <div className="grid grid-cols-1 md:grid-cols-[260px_1fr] gap-x-0 h-[calc(100dvh-4rem)]">
+          <ThreadList onResetUserId={resetUserId} isDarkMode={isDarkMode} />
+          <Thread sidebarOpen={sidebarOpen} setSidebarOpen={setSidebarOpen} onResetUserId={resetUserId} isDarkMode={isDarkMode} toggleDarkMode={toggleDarkMode} />
         </div>
       </div>
     </AssistantRuntimeProvider>

examples/mem0-demo/app/layout.tsx

@@ -13,8 +13,8 @@ const geistMono = Geist_Mono({
 });
 
 export const metadata: Metadata = {
-  title: "Mem0-Demo",
-  description: "Mem0-Demo: By Mem0",
+  title: "Mem0 - ChatGPT with Memory",
+  description: "Mem0 - ChatGPT with Memory is a personalized AI chat app powered by Mem0 that remembers your preferences, facts, and memories.",
 };
 
 export default function RootLayout({

examples/mem0-demo/components/assistant-ui/theme-aware-logo.tsx

@@ -1,5 +1,6 @@
 "use client";
-
+import darkAssistantUi from "@/images/assistant-ui-dark.svg";
+import assistantUi from "@/images/assistant-ui.svg";
 import React from "react";
 import Image from "next/image";
 
@@ -27,7 +28,7 @@ export default function ThemeAwareLogo({
   }
   
   // For default variant, use the full logo image
-  const logoSrc = isDarkMode ? "/images/assistant-ui-dark.svg" : "/images/assistant-ui.svg";
+  const logoSrc = isDarkMode ? darkAssistantUi : assistantUi;
   
   return (
     <Image

examples/mem0-demo/components/assistant-ui/thread-list.tsx

@@ -19,9 +19,11 @@ import {
   AlertDialogTitle,
   AlertDialogTrigger,
 } from "@/components/ui/alert-dialog";
-
+// import ThemeAwareLogo from "@/components/assistant-ui/theme-aware-logo";
+// import Link from "next/link";
 interface ThreadListProps {
   onResetUserId?: () => void;
+  isDarkMode: boolean;
 }
 
 export const ThreadList: FC<ThreadListProps> = ({ onResetUserId }) => {
@@ -29,45 +31,55 @@ export const ThreadList: FC<ThreadListProps> = ({ onResetUserId }) => {
   
   return (
     <div className="flex-col h-full border-r border-[#e2e8f0] bg-white dark:bg-zinc-900 dark:border-zinc-800 p-3 overflow-y-auto hidden md:flex">
-      <ThreadListPrimitive.Root className="flex flex-col items-stretch gap-1.5">
-        <ThreadListNew />
-        <div className="mt-4 mb-2 flex justify-between items-center px-2.5">
-          <h2 className="text-sm font-medium text-[#475569] dark:text-zinc-300">Recent Chats</h2>
-          {onResetUserId && (
-            <AlertDialog open={open} onOpenChange={setOpen}>
-              <AlertDialogTrigger asChild>
-                <TooltipIconButton
-                  tooltip="Reset Memory"
-                  className="hover:text-[#4f46e5] text-[#475569] dark:text-zinc-300 dark:hover:text-[#6366f1] size-4 p-0"
-                  variant="ghost"
-                >
-                  <RefreshCwIcon className="w-4 h-4" />
-                </TooltipIconButton>
-              </AlertDialogTrigger>
-              <AlertDialogContent className="bg-white dark:bg-zinc-900 border-[#e2e8f0] dark:border-zinc-800">
-                <AlertDialogHeader>
-                  <AlertDialogTitle className="text-[#1e293b] dark:text-white">Reset Memory</AlertDialogTitle>
-                  <AlertDialogDescription className="text-[#475569] dark:text-zinc-300">
-                    This will permanently delete all your chat history and memories. This action cannot be undone.
-                  </AlertDialogDescription>
-                </AlertDialogHeader>
-                <AlertDialogFooter>
-                  <AlertDialogCancel className="text-[#475569] dark:text-zinc-300 hover:bg-[#eef2ff] dark:hover:bg-zinc-800">Cancel</AlertDialogCancel>
-                  <AlertDialogAction
-                    onClick={() => {
-                      onResetUserId();
-                      setOpen(false);
-                    }}
-                    className="bg-[#4f46e5] hover:bg-[#4338ca] dark:bg-[#6366f1] dark:hover:bg-[#4f46e5] text-white"
+      <ThreadListPrimitive.Root className="flex flex-col justify-between h-full items-stretch gap-1.5">
+        <div className="flex flex-col h-full items-stretch gap-1.5">
+          <ThreadListNew />
+          <div className="mt-4 mb-2 flex justify-between items-center px-2.5">
+            <h2 className="text-sm font-medium text-[#475569] dark:text-zinc-300">
+              Recent Chats
+            </h2>
+            {onResetUserId && (
+              <AlertDialog open={open} onOpenChange={setOpen}>
+                <AlertDialogTrigger asChild>
+                  <TooltipIconButton
+                    tooltip="Reset Memory"
+                    className="hover:text-[#4f46e5] text-[#475569] dark:text-zinc-300 dark:hover:text-[#6366f1] size-4 p-0"
+                    variant="ghost"
                   >
-                    Reset
-                  </AlertDialogAction>
-                </AlertDialogFooter>
-              </AlertDialogContent>
-            </AlertDialog>
-          )}
+                    <RefreshCwIcon className="w-4 h-4" />
+                  </TooltipIconButton>
+                </AlertDialogTrigger>
+                <AlertDialogContent className="bg-white dark:bg-zinc-900 border-[#e2e8f0] dark:border-zinc-800">
+                  <AlertDialogHeader>
+                    <AlertDialogTitle className="text-[#1e293b] dark:text-white">
+                      Reset Memory
+                    </AlertDialogTitle>
+                    <AlertDialogDescription className="text-[#475569] dark:text-zinc-300">
+                      This will permanently delete all your chat history and
+                      memories. This action cannot be undone.
+                    </AlertDialogDescription>
+                  </AlertDialogHeader>
+                  <AlertDialogFooter>
+                    <AlertDialogCancel className="text-[#475569] dark:text-zinc-300 hover:bg-[#eef2ff] dark:hover:bg-zinc-800">
+                      Cancel
+                    </AlertDialogCancel>
+                    <AlertDialogAction
+                      onClick={() => {
+                        onResetUserId();
+                        setOpen(false);
+                      }}
+                      className="bg-[#4f46e5] hover:bg-[#4338ca] dark:bg-[#6366f1] dark:hover:bg-[#4f46e5] text-white"
+                    >
+                      Reset
+                    </AlertDialogAction>
+                  </AlertDialogFooter>
+                </AlertDialogContent>
+              </AlertDialog>
+            )}
+          </div>
+          <ThreadListItems />
         </div>
-        <ThreadListItems />
+
       </ThreadListPrimitive.Root>
     </div>
   );

examples/mem0-demo/components/assistant-ui/thread.tsx

@@ -1,4 +1,4 @@
-"use client"
+"use client";
 
 import {
   ActionBarPrimitive,
@@ -22,9 +22,12 @@ import {
   SendHorizontalIcon,
   ArchiveIcon,
   PlusIcon,
+  Sun,
+  Moon,
+  SaveIcon,
 } from "lucide-react";
 import { cn } from "@/lib/utils";
-import { Dispatch, SetStateAction, useState } from "react";
+import { Dispatch, SetStateAction, useState, useRef } from "react";
 import { Button } from "@/components/ui/button";
 import { ScrollArea } from "../ui/scroll-area";
 import { TooltipIconButton } from "@/components/assistant-ui/tooltip-icon-button";
@@ -42,42 +45,57 @@ import {
   AlertDialogTitle,
   AlertDialogTrigger,
 } from "@/components/ui/alert-dialog";
-
+import GithubButton from "../mem0/github-button";
+import Link from "next/link";
 interface ThreadProps {
   sidebarOpen: boolean;
   setSidebarOpen: Dispatch<SetStateAction<boolean>>;
   onResetUserId?: () => void;
+  isDarkMode: boolean;
+  toggleDarkMode: () => void;
 }
 
-export const Thread: FC<ThreadProps> = ({ sidebarOpen, setSidebarOpen, onResetUserId }) => {
+export const Thread: FC<ThreadProps> = ({
+  sidebarOpen,
+  setSidebarOpen,
+  onResetUserId,
+  isDarkMode,
+  toggleDarkMode
+}) => {
   const [resetDialogOpen, setResetDialogOpen] = useState(false);
+  const composerInputRef = useRef<HTMLTextAreaElement>(null);
 
   return (
     <ThreadPrimitive.Root
-      className="bg-[#f8fafc] dark:bg-zinc-900 box-border h-full flex flex-col overflow-hidden relative"
+      className="bg-[#f8fafc] dark:bg-zinc-900 box-border flex flex-col overflow-hidden relative h-[calc(100dvh-4rem)] pb-4 md:h-full"
       style={{
         ["--thread-max-width" as string]: "42rem",
       }}
     >
       {/* Mobile sidebar overlay */}
       {sidebarOpen && (
-        <div 
+        <div
           className="fixed inset-0 bg-black/40 z-30 md:hidden"
           onClick={() => setSidebarOpen(false)}
         ></div>
       )}
 
       {/* Mobile sidebar drawer */}
-      <div className={cn(
-        "fixed inset-y-0 left-0 z-40 w-[85%] bg-white dark:bg-zinc-900 transform transition-transform duration-300 ease-in-out md:hidden",
-        sidebarOpen ? "translate-x-0" : "-translate-x-full"
-      )}>
+      <div
+        className={cn(
+          "fixed inset-y-0 left-0 z-40 w-[75%] bg-white shadow-lg rounded-r-lg dark:bg-zinc-900 transform transition-transform duration-300 ease-in-out md:hidden",
+          sidebarOpen ? "translate-x-0" : "-translate-x-full"
+        )}
+      >
         <div className="h-full flex flex-col">
           <div className="flex items-center justify-between border-b dark:text-white border-[#e2e8f0] dark:border-zinc-800 p-4">
-            <h2 className="font-medium">Recent Chats</h2>
+            <h2 className="font-medium">Settings</h2>
             <div className="flex items-center gap-2">
               {onResetUserId && (
-                <AlertDialog open={resetDialogOpen} onOpenChange={setResetDialogOpen}>
+                <AlertDialog
+                  open={resetDialogOpen}
+                  onOpenChange={setResetDialogOpen}
+                >
                   <AlertDialogTrigger asChild>
                     <TooltipIconButton
                       tooltip="Reset Memory"
@@ -89,13 +107,18 @@ export const Thread: FC<ThreadProps> = ({ sidebarOpen, setSidebarOpen, onResetUs
                   </AlertDialogTrigger>
                   <AlertDialogContent className="bg-white dark:bg-zinc-900 border-[#e2e8f0] dark:border-zinc-800">
                     <AlertDialogHeader>
-                      <AlertDialogTitle className="text-[#1e293b] dark:text-white">Reset Memory</AlertDialogTitle>
+                      <AlertDialogTitle className="text-[#1e293b] dark:text-white">
+                        Reset Memory
+                      </AlertDialogTitle>
                       <AlertDialogDescription className="text-[#475569] dark:text-zinc-300">
-                        This will permanently delete all your chat history and memories. This action cannot be undone.
+                        This will permanently delete all your chat history and
+                        memories. This action cannot be undone.
                       </AlertDialogDescription>
                     </AlertDialogHeader>
                     <AlertDialogFooter>
-                      <AlertDialogCancel className="text-[#475569] dark:text-zinc-300 hover:bg-[#eef2ff] dark:hover:bg-zinc-800">Cancel</AlertDialogCancel>
+                      <AlertDialogCancel className="text-[#475569] dark:text-zinc-300 hover:bg-[#eef2ff] dark:hover:bg-zinc-800">
+                        Cancel
+                      </AlertDialogCancel>
                       <AlertDialogAction
                         onClick={() => {
                           onResetUserId();
@@ -109,9 +132,9 @@ export const Thread: FC<ThreadProps> = ({ sidebarOpen, setSidebarOpen, onResetUs
                   </AlertDialogContent>
                 </AlertDialog>
               )}
-              <Button 
-                variant="ghost" 
-                size="sm" 
+              <Button
+                variant="ghost"
+                size="sm"
                 onClick={() => setSidebarOpen(false)}
                 className="text-[#475569] dark:text-zinc-300 hover:bg-[#eef2ff] dark:hover:bg-zinc-800 h-8 w-8 p-0"
               >
@@ -120,28 +143,67 @@ export const Thread: FC<ThreadProps> = ({ sidebarOpen, setSidebarOpen, onResetUs
             </div>
           </div>
           <div className="flex-1 overflow-y-auto p-3">
-            <ThreadListPrimitive.Root className="flex flex-col items-stretch gap-1.5 h-full dark:text-white">
-              <ThreadListPrimitive.New asChild>
-                <Button
-                  className="hover:bg-[#eef2ff] dark:hover:bg-zinc-800 dark:data-[active]:bg-zinc-800 flex items-center justify-start gap-1 rounded-lg px-2.5 py-2 text-start bg-[#4f46e5] text-white dark:bg-[#6366f1]"
-                  variant="default"
-                >
-                  <PlusIcon className="w-4 h-4" />
-                  New Thread
-                </Button>
-              </ThreadListPrimitive.New>
-              <div className="mt-4 mb-2">
-                <h2 className="text-sm font-medium text-[#475569] dark:text-zinc-300 px-2.5">Recent Chats</h2>
-              </div>
-              <ThreadListPrimitive.Items components={{ ThreadListItem }} />
-            </ThreadListPrimitive.Root>
+            <div className="flex flex-col justify-between items-stretch gap-1.5 h-full dark:text-white">
+              <ThreadListPrimitive.Root className="flex flex-col items-stretch gap-1.5 h-full dark:text-white">
+                <ThreadListPrimitive.New asChild>
+                  <div className="flex items-center flex-col gap-2 w-full">
+                  <Button
+                    className="hover:bg-zinc-600 w-full dark:hover:bg-zinc-800 dark:data-[active]:bg-zinc-800 flex items-center justify-start gap-1 rounded-lg px-2.5 py-2 text-start bg-[#4f46e5] text-white dark:bg-[#6366f1]"
+                    variant="default"
+                  >
+                    <PlusIcon className="w-4 h-4" />
+                    New Thread
+                  </Button>
+                    <Button
+                      className="hover:bg-zinc-600 w-full dark:hover:bg-zinc-700 dark:data-[active]:bg-zinc-800 flex items-center justify-start gap-1 rounded-lg px-2.5 py-2 text-start bg-zinc-800 text-white"
+                      onClick={toggleDarkMode}
+                      aria-label="Toggle theme"
+                    >
+                      {isDarkMode ? (
+                        <div className="flex items-center gap-2">
+                          <Sun className="w-6 h-6" /> 
+                          <span>Toggle Light Mode</span>
+                        </div>
+                      ) : (
+                        <div className="flex items-center gap-2">
+                          <Moon className="w-6 h-6" />
+                          <span>Toggle Dark Mode</span>
+                        </div>
+                      )}
+                    </Button>
+                    <GithubButton url="https://github.com/mem0ai/mem0/tree/main/examples" className="w-full rounded-lg h-9 pl-2 text-sm font-semibold bg-zinc-800 dark:border-zinc-800 dark:text-white text-white hover:bg-zinc-900" text="View on Github" />
+
+                    <Link
+                      href={"https://app.mem0.ai/"}
+                      target="_blank"
+                      className="py-2 px-4 w-full rounded-lg h-9 pl-3 text-sm font-semibold dark:bg-zinc-800 dark:hover:bg-zinc-700 bg-zinc-800 text-white hover:bg-zinc-900 dark:text-white"
+                    >
+                      <span className="flex items-center gap-2">
+                        <SaveIcon className="w-4 h-4" />
+                        Save Memories
+                      </span>
+                    </Link>
+                  </div>
+                </ThreadListPrimitive.New>
+                <div className="mt-4 mb-2">
+                  <h2 className="text-sm font-medium text-[#475569] dark:text-zinc-300 px-2.5">
+                    Recent Chats
+                  </h2>
+                </div>
+                <ThreadListPrimitive.Items components={{ ThreadListItem }} />
+              </ThreadListPrimitive.Root>
+            </div>
           </div>
         </div>
       </div>
 
-      <ScrollArea className="flex-1">
-        <div className="flex h-full flex-col items-center px-4 pt-8 justify-end">
-          <ThreadWelcome />
+      <ScrollArea className="flex-1 w-full">
+        <div className="flex h-full flex-col w-full items-center px-4 pt-8 justify-end">
+          <ThreadWelcome
+            composerInputRef={
+              composerInputRef as React.RefObject<HTMLTextAreaElement>
+            }
+          />
 
           <ThreadPrimitive.Messages
             components={{
@@ -157,9 +219,13 @@ export const Thread: FC<ThreadProps> = ({ sidebarOpen, setSidebarOpen, onResetUs
         </div>
       </ScrollArea>
 
-      <div className="sticky bottom-0 mt-3 flex w-full max-w-[var(--thread-max-width)] flex-col items-center justify-end rounded-t-lg bg-inherit px-4 pb-4 mx-auto">
+      <div className="sticky bottom-0 flex w-full max-w-[var(--thread-max-width)] flex-col items-center justify-end rounded-t-lg bg-inherit px-4 md:pb-4 mx-auto">
         <ThreadScrollToBottom />
-        <Composer />
+        <Composer
+          composerInputRef={
+            composerInputRef as React.RefObject<HTMLTextAreaElement>
+          }
+        />
       </div>
     </ThreadPrimitive.Root>
   );
@@ -179,60 +245,88 @@ const ThreadScrollToBottom: FC = () => {
   );
 };
 
-const ThreadWelcome: FC = () => {
+interface ThreadWelcomeProps {
+  composerInputRef: React.RefObject<HTMLTextAreaElement>;
+}
+
+const ThreadWelcome: FC<ThreadWelcomeProps> = ({ composerInputRef }) => {
   return (
     <ThreadPrimitive.Empty>
-      <div className="flex w-full max-w-[var(--thread-max-width)] flex-grow flex-col">
-        <div className="flex w-full flex-grow flex-col items-center justify-start h-[calc(100vh-23rem)] md:h-[calc(100vh-18rem)]">
+      <div className="flex w-full flex-grow flex-col mt-8 md:h-[calc(100vh-15rem)]">
+        <div className="flex w-full flex-grow flex-col items-center justify-start">
           <div className="flex flex-col items-center justify-center h-full">
-            <div className="text-5xl font-bold text-[#1e293b] dark:text-white mb-2">
-              Mem0 Demo
+            <div className="text-[2rem] leading-[1] tracking-[-0.02em] md:text-4xl font-bold text-[#1e293b] dark:text-white mb-2 text-center md:w-full w-5/6">
+              Mem0 - ChatGPT with memory
             </div>
-            <p className="text-center text-sm text-[#1e293b] dark:text-white mb-2 w-3/4">
-            A personalized AI chat app powered by Mem0 that remembers your preferences, facts, and memories.
+            <p className="text-center text-md text-[#1e293b] dark:text-white mb-2 md:w-3/4 w-5/6">
+              A personalized AI chat app powered by Mem0 that remembers your
+              preferences, facts, and memories.
             </p>
           </div>
         </div>
-        <div className="flex flex-col items-center justify-center">
-        <p className="mt-4 font-medium text-[#1e293b] dark:text-white">
+        <div className="flex flex-col items-center justify-center mt-16">
+          <p className="mt-4 font-medium text-[#1e293b] dark:text-white">
             How can I help you today?
           </p>
-        <ThreadWelcomeSuggestions />
+          <ThreadWelcomeSuggestions composerInputRef={composerInputRef} />
         </div>
       </div>
     </ThreadPrimitive.Empty>
   );
 };
 
-const ThreadWelcomeSuggestions: FC = () => {
+interface ThreadWelcomeSuggestionsProps {
+  composerInputRef: React.RefObject<HTMLTextAreaElement>;
+}
+
+const ThreadWelcomeSuggestions: FC<ThreadWelcomeSuggestionsProps> = ({ composerInputRef }) => {
   return (
-    <div className="mt-3 flex w-full items-stretch justify-center gap-4 dark:text-white">
+    <div className="mt-3 flex flex-col md:flex-row w-full md:items-stretch justify-center gap-4 dark:text-white items-center">
       <ThreadPrimitive.Suggestion
-        className="hover:bg-[#eef2ff] dark:hover:bg-zinc-800 flex max-w-sm grow basis-0 flex-col items-center justify-center rounded-[2rem] border border-[#e2e8f0] dark:border-zinc-700 p-3 transition-colors ease-in"
+        className="hover:bg-[#eef2ff] w-full dark:hover:bg-zinc-800 flex max-w-sm grow basis-0 flex-col items-center justify-center rounded-[2rem] border border-[#e2e8f0] dark:border-zinc-700 p-3 transition-colors ease-in"
         prompt="I like to travel to "
         method="replace"
+        onClick={() => {
+          composerInputRef.current?.focus();
+        }}
       >
-        <span className="line-clamp-2 text-ellipsis text-sm font-semibold">Travel</span>
+        <span className="line-clamp-2 text-ellipsis text-sm font-semibold">
+          Travel
+        </span>
       </ThreadPrimitive.Suggestion>
       <ThreadPrimitive.Suggestion
-        className="hover:bg-[#eef2ff] dark:hover:bg-zinc-800 flex max-w-sm grow basis-0 flex-col items-center justify-center rounded-[2rem] border border-[#e2e8f0] dark:border-zinc-700 p-3 transition-colors ease-in"
+        className="hover:bg-[#eef2ff] w-full dark:hover:bg-zinc-800 flex max-w-sm grow basis-0 flex-col items-center justify-center rounded-[2rem] border border-[#e2e8f0] dark:border-zinc-700 p-3 transition-colors ease-in"
         prompt="I like to eat "
         method="replace"
+        onClick={() => {
+          composerInputRef.current?.focus();
+        }}
       >
-        <span className="line-clamp-2 text-ellipsis text-sm font-semibold">Food</span>
+        <span className="line-clamp-2 text-ellipsis text-sm font-semibold">
+          Food
+        </span>
       </ThreadPrimitive.Suggestion>
       <ThreadPrimitive.Suggestion
-        className="hover:bg-[#eef2ff] dark:hover:bg-zinc-800 flex max-w-sm grow basis-0 flex-col items-center justify-center rounded-[2rem] border border-[#e2e8f0] dark:border-zinc-700 p-3 transition-colors ease-in"
+        className="hover:bg-[#eef2ff] w-full dark:hover:bg-zinc-800 flex max-w-sm grow basis-0 flex-col items-center justify-center rounded-[2rem] border border-[#e2e8f0] dark:border-zinc-700 p-3 transition-colors ease-in"
         prompt="I am working on "
         method="replace"
+        onClick={() => {
+          composerInputRef.current?.focus();
+        }}
       >
-        <span className="line-clamp-2 text-ellipsis text-sm font-semibold">Project details</span>
+        <span className="line-clamp-2 text-ellipsis text-sm font-semibold">
+          Project details
+        </span>
       </ThreadPrimitive.Suggestion>
     </div>
   );
 };
 
-const Composer: FC = () => {
+interface ComposerProps {
+  composerInputRef: React.RefObject<HTMLTextAreaElement>;
+}
+
+const Composer: FC<ComposerProps> = ({ composerInputRef }) => {
   return (
     <ComposerPrimitive.Root className="focus-within:border-[#4f46e5]/20 dark:focus-within:border-[#6366f1]/20 flex w-full flex-wrap items-end rounded-full border border-[#e2e8f0] dark:border-zinc-700 bg-white dark:bg-zinc-800 px-2.5 shadow-sm transition-colors ease-in">
       <ComposerPrimitive.Input
@@ -240,6 +334,7 @@ const Composer: FC = () => {
         autoFocus
         placeholder="Message to Mem0..."
         className="placeholder:text-zinc-400 dark:placeholder:text-zinc-500 max-h-40 flex-grow resize-none border-none bg-transparent px-2 py-4 text-sm outline-none focus:ring-0 disabled:cursor-not-allowed text-[#1e293b] dark:text-zinc-200"
+        ref={composerInputRef}
       />
       <ComposerAction />
     </ComposerPrimitive.Root>
@@ -335,22 +430,22 @@ const EditComposer: FC = () => {
 const AssistantMessage: FC = () => {
   const content = useMessage((m) => m.content);
   const markdownText = React.useMemo(() => {
-    if (!content) return '';
-    if (typeof content === 'string') return content;
-    if (Array.isArray(content) && content.length > 0 && 'text' in content[0]) {
-      return content[0].text || '';
+    if (!content) return "";
+    if (typeof content === "string") return content;
+    if (Array.isArray(content) && content.length > 0 && "text" in content[0]) {
+      return content[0].text || "";
     }
-    return '';
+    return "";
   }, [content]);
 
   return (
     <MessagePrimitive.Root className="grid grid-cols-[auto_auto_1fr] grid-rows-[auto_1fr] relative w-full max-w-[var(--thread-max-width)] py-4">
       <div className="text-[#1e293b] dark:text-zinc-200 max-w-[calc(var(--thread-max-width)*0.8)] break-words leading-7 col-span-2 col-start-2 row-start-1 my-1.5 bg-white dark:bg-zinc-800 rounded-3xl px-5 py-2.5 border border-[#e2e8f0] dark:border-zinc-700 shadow-sm">
         <MemoryUI />
-        <MarkdownRenderer 
+        <MarkdownRenderer
           markdownText={markdownText}
           showCopyButton={true}
-          isDarkMode={document.documentElement.classList.contains('dark')}
+          isDarkMode={document.documentElement.classList.contains("dark")}
         />
       </div>
 
@@ -400,7 +495,10 @@ const BranchPicker: FC<BranchPickerPrimitive.Root.Props> = ({
   return (
     <BranchPickerPrimitive.Root
       hideWhenSingleBranch
-      className={cn("text-[#475569] dark:text-zinc-300 inline-flex items-center text-xs", className)}
+      className={cn(
+        "text-[#475569] dark:text-zinc-300 inline-flex items-center text-xs",
+        className
+      )}
       {...rest}
     >
       <BranchPickerPrimitive.Previous asChild>
@@ -428,7 +526,13 @@ const BranchPicker: FC<BranchPickerPrimitive.Root.Props> = ({
 
 const CircleStopIcon = () => {
   return (
-    <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16" fill="currentColor" width="16" height="16">
+    <svg
+      xmlns="http://www.w3.org/2000/svg"
+      viewBox="0 0 16 16"
+      fill="currentColor"
+      width="16"
+      height="16"
+    >
       <rect width="10" height="10" x="3" y="3" rx="2" />
     </svg>
   );

examples/mem0-demo/components/mem0/github-button.tsx

@@ -1,18 +1,18 @@
+import { cn } from "@/lib/utils";
 
-
-const GithubButton = ({ url }: { url: string }) => {
+const GithubButton = ({ url, className, text }: { url: string, className?: string, text?: string }) => {
   return (
     <a
       href={url}
       target="_blank"
       rel="noopener noreferrer"
-      className="flex items-center bg-black text-white rounded-full shadow-lg hover:bg-gray-800 transition border border-gray-700"
+      className={cn("flex items-center bg-black text-white rounded-full shadow-lg hover:bg-gray-800 transition border border-gray-700", className)}
     >
       <svg
         xmlns="http://www.w3.org/2000/svg"
         viewBox="0 0 24 24"
         fill="white"
-        className="w-6 h-6"
+        className="w-5 h-5 md:w-6 md:h-6"
       >
         <path
           fillRule="evenodd"
@@ -20,6 +20,7 @@ const GithubButton = ({ url }: { url: string }) => {
           clipRule="evenodd"
         />
       </svg>
+      {text && <span className="ml-2">{text}</span>}
     </a>
   );
 };

examples/mem0-demo/components/mem0/theme-aware-logo.tsx

@@ -1,5 +1,7 @@
 "use client";
 
+import darkLogo from "@/images/dark.svg";
+import lightLogo from "@/images/light.svg";
 import React from "react";
 import Image from "next/image";
 
@@ -27,7 +29,7 @@ export default function ThemeAwareLogo({
   }
   
   // For default variant, use the full logo image
-  const logoSrc = isDarkMode ? "/images/dark.svg" : "/images/light.svg";
+  const logoSrc = isDarkMode ? darkLogo : lightLogo;
   
   return (
     <Image

examples/mem0-demo/images/assistant-ui-dark.svg

@@ -0,0 +1,6 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="white" stroke-width="3" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-messages-square">
+	<path d="M14 9a2 2 0 0 1-2 2H6l-4 4V4c0-1.1.9-2 2-2h8a2 2 0 0 1 2 2z">
+	</path>
+	<path d="M18 9h2a2 2 0 0 1 2 2v11l-4-4h-6a2 2 0 0 1-2-2v-1">
+	</path>
+</svg>

examples/mem0-demo/images/assistant-ui.svg

@@ -0,0 +1,6 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="3" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-messages-square">
+	<path d="M14 9a2 2 0 0 1-2 2H6l-4 4V4c0-1.1.9-2 2-2h8a2 2 0 0 1 2 2z">
+	</path>
+	<path d="M18 9h2a2 2 0 0 1 2 2v11l-4-4h-6a2 2 0 0 1-2-2v-1">
+	</path>
+</svg>

examples/mem0-demo/next.config.ts

@@ -2,6 +2,24 @@ import type { NextConfig } from "next";
 
 const nextConfig: NextConfig = {
   /* config options here */
+  assetPrefix: "https://demo.mem0.ai",
+  images: {
+    path: "https://demo.mem0.ai",
+  },
+  async headers() {
+    return [
+        {
+            // matching all API routes
+            source: "/api/:path*",
+            headers: [
+                { key: "Access-Control-Allow-Credentials", value: "true" },
+                { key: "Access-Control-Allow-Origin", value: "*" },
+                { key: "Access-Control-Allow-Methods", value: "GET,DELETE,PATCH,POST,PUT" },
+                { key: "Access-Control-Allow-Headers", value: "X-CSRF-Token, X-Requested-With, Accept, Accept-Version, Content-Length, Content-MD5, Content-Type, Date, X-Api-Version" },
+            ]
+        }
+    ]
+}
 };
 
 export default nextConfig;

examples/multimodal-demo/.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

examples/multimodal-demo/.gitignore

@@ -0,0 +1,29 @@
+**/.env
+**/node_modules
+**/dist
+**/.DS_Store
+
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?

examples/multimodal-demo/components.json

@@ -0,0 +1,20 @@
+{
+  "$schema": "https://ui.shadcn.com/schema.json",
+  "style": "new-york",
+  "rsc": false,
+  "tsx": true,
+  "tailwind": {
+    "config": "tailwind.config.js",
+    "css": "src/index.css",
+    "baseColor": "zinc",
+    "cssVariables": true,
+    "prefix": ""
+  },
+  "aliases": {
+    "components": "@/components",
+    "utils": "@/libs/utils",
+    "ui": "@/components/ui",
+    "lib": "@/libs",
+    "hooks": "@/hooks"
+  }
+}

examples/multimodal-demo/eslint.config.js

@@ -0,0 +1,28 @@
+import js from '@eslint/js'
+import globals from 'globals'
+import reactHooks from 'eslint-plugin-react-hooks'
+import reactRefresh from 'eslint-plugin-react-refresh'
+import tseslint from 'typescript-eslint'
+
+export default tseslint.config(
+  { ignores: ['dist'] },
+  {
+    extends: [js.configs.recommended, ...tseslint.configs.recommended],
+    files: ['**/*.{ts,tsx}'],
+    languageOptions: {
+      ecmaVersion: 2020,
+      globals: globals.browser,
+    },
+    plugins: {
+      'react-hooks': reactHooks,
+      'react-refresh': reactRefresh,
+    },
+    rules: {
+      ...reactHooks.configs.recommended.rules,
+      'react-refresh/only-export-components': [
+        'warn',
+        { allowConstantExport: true },
+      ],
+    },
+  },
+)

examples/multimodal-demo/index.html

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/mem0_logo.jpeg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>JustChat | Chat with AI</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

examples/multimodal-demo/package.json

@@ -24,9 +24,11 @@
     "clsx": "^2.1.1",
     "framer-motion": "^11.11.11",
     "lucide-react": "^0.454.0",
+    "openai": "^4.86.2",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
     "react-markdown": "^9.0.1",
+    "mem0ai": "2.1.2",
     "tailwind-merge": "^2.5.4",
     "tailwindcss-animate": "^1.0.7",
     "zod": "^3.23.8"
@@ -46,6 +48,7 @@
     "tailwindcss": "^3.4.14",
     "typescript": "~5.6.2",
     "typescript-eslint": "^8.11.0",
-    "vite": "^5.4.10"
-  }
-}
+    "vite": "^6.2.1"
+  },
+  "packageManager": "pnpm@10.5.2+sha512.da9dc28cd3ff40d0592188235ab25d3202add8a207afbedc682220e4a0029ffbff4562102b9e6e46b4e3f9e8bd53e6d05de48544b0c57d4b0179e22c76d1199b"
+}

examples/multimodal-demo/postcss.config.js

@@ -0,0 +1,6 @@
+export default {
+  plugins: {
+    tailwindcss: {},
+    autoprefixer: {},
+  },
+}

examples/multimodal-demo/src/App.tsx

@@ -0,0 +1,13 @@
+import Home from "./page"
+
+
+function App() {
+
+  return (
+    <>
+      <Home />
+    </>
+  )
+}
+
+export default App

examples/multimodal-demo/src/assets/react.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="35.93" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 228"><path fill="#00D8FF" d="M210.483 73.824a171.49 171.49 0 0 0-8.24-2.597c.465-1.9.893-3.777 1.273-5.621c6.238-30.281 2.16-54.676-11.769-62.708c-13.355-7.7-35.196.329-57.254 19.526a171.23 171.23 0 0 0-6.375 5.848a155.866 155.866 0 0 0-4.241-3.917C100.759 3.829 77.587-4.822 63.673 3.233C50.33 10.957 46.379 33.89 51.995 62.588a170.974 170.974 0 0 0 1.892 8.48c-3.28.932-6.445 1.924-9.474 2.98C17.309 83.498 0 98.307 0 113.668c0 15.865 18.582 31.778 46.812 41.427a145.52 145.52 0 0 0 6.921 2.165a167.467 167.467 0 0 0-2.01 9.138c-5.354 28.2-1.173 50.591 12.134 58.266c13.744 7.926 36.812-.22 59.273-19.855a145.567 145.567 0 0 0 5.342-4.923a168.064 168.064 0 0 0 6.92 6.314c21.758 18.722 43.246 26.282 56.54 18.586c13.731-7.949 18.194-32.003 12.4-61.268a145.016 145.016 0 0 0-1.535-6.842c1.62-.48 3.21-.974 4.76-1.488c29.348-9.723 48.443-25.443 48.443-41.52c0-15.417-17.868-30.326-45.517-39.844Zm-6.365 70.984c-1.4.463-2.836.91-4.3 1.345c-3.24-10.257-7.612-21.163-12.963-32.432c5.106-11 9.31-21.767 12.459-31.957c2.619.758 5.16 1.557 7.61 2.4c23.69 8.156 38.14 20.213 38.14 29.504c0 9.896-15.606 22.743-40.946 31.14Zm-10.514 20.834c2.562 12.94 2.927 24.64 1.23 33.787c-1.524 8.219-4.59 13.698-8.382 15.893c-8.067 4.67-25.32-1.4-43.927-17.412a156.726 156.726 0 0 1-6.437-5.87c7.214-7.889 14.423-17.06 21.459-27.246c12.376-1.098 24.068-2.894 34.671-5.345a134.17 134.17 0 0 1 1.386 6.193ZM87.276 214.515c-7.882 2.783-14.16 2.863-17.955.675c-8.075-4.657-11.432-22.636-6.853-46.752a156.923 156.923 0 0 1 1.869-8.499c10.486 2.32 22.093 3.988 34.498 4.994c7.084 9.967 14.501 19.128 21.976 27.15a134.668 134.668 0 0 1-4.877 4.492c-9.933 8.682-19.886 14.842-28.658 17.94ZM50.35 144.747c-12.483-4.267-22.792-9.812-29.858-15.863c-6.35-5.437-9.555-10.836-9.555-15.216c0-9.322 13.897-21.212 37.076-29.293c2.813-.98 5.757-1.905 8.812-2.773c3.204 10.42 7.406 21.315 12.477 32.332c-5.137 11.18-9.399 22.249-12.634 32.792a134.718 134.718 0 0 1-6.318-1.979Zm12.378-84.26c-4.811-24.587-1.616-43.134 6.425-47.789c8.564-4.958 27.502 2.111 47.463 19.835a144.318 144.318 0 0 1 3.841 3.545c-7.438 7.987-14.787 17.08-21.808 26.988c-12.04 1.116-23.565 2.908-34.161 5.309a160.342 160.342 0 0 1-1.76-7.887Zm110.427 27.268a347.8 347.8 0 0 0-7.785-12.803c8.168 1.033 15.994 2.404 23.343 4.08c-2.206 7.072-4.956 14.465-8.193 22.045a381.151 381.151 0 0 0-7.365-13.322Zm-45.032-43.861c5.044 5.465 10.096 11.566 15.065 18.186a322.04 322.04 0 0 0-30.257-.006c4.974-6.559 10.069-12.652 15.192-18.18ZM82.802 87.83a323.167 323.167 0 0 0-7.227 13.238c-3.184-7.553-5.909-14.98-8.134-22.152c7.304-1.634 15.093-2.97 23.209-3.984a321.524 321.524 0 0 0-7.848 12.897Zm8.081 65.352c-8.385-.936-16.291-2.203-23.593-3.793c2.26-7.3 5.045-14.885 8.298-22.6a321.187 321.187 0 0 0 7.257 13.246c2.594 4.48 5.28 8.868 8.038 13.147Zm37.542 31.03c-5.184-5.592-10.354-11.779-15.403-18.433c4.902.192 9.899.29 14.978.29c5.218 0 10.376-.117 15.453-.343c-4.985 6.774-10.018 12.97-15.028 18.486Zm52.198-57.817c3.422 7.8 6.306 15.345 8.596 22.52c-7.422 1.694-15.436 3.058-23.88 4.071a382.417 382.417 0 0 0 7.859-13.026a347.403 347.403 0 0 0 7.425-13.565Zm-16.898 8.101a358.557 358.557 0 0 1-12.281 19.815a329.4 329.4 0 0 1-23.444.823c-7.967 0-15.716-.248-23.178-.732a310.202 310.202 0 0 1-12.513-19.846h.001a307.41 307.41 0 0 1-10.923-20.627a310.278 310.278 0 0 1 10.89-20.637l-.001.001a307.318 307.318 0 0 1 12.413-19.761c7.613-.576 15.42-.876 23.31-.876H128c7.926 0 15.743.303 23.354.883a329.357 329.357 0 0 1 12.335 19.695a358.489 358.489 0 0 1 11.036 20.54a329.472 329.472 0 0 1-11 20.722Zm22.56-122.124c8.572 4.944 11.906 24.881 6.52 51.026c-.344 1.668-.73 3.367-1.15 5.09c-10.622-2.452-22.155-4.275-34.23-5.408c-7.034-10.017-14.323-19.124-21.64-27.008a160.789 160.789 0 0 1 5.888-5.4c18.9-16.447 36.564-22.941 44.612-18.3ZM128 90.808c12.625 0 22.86 10.235 22.86 22.86s-10.235 22.86-22.86 22.86s-22.86-10.235-22.86-22.86s10.235-22.86 22.86-22.86Z"></path></svg>

examples/multimodal-demo/src/components/api-settings-popup.tsx

@@ -0,0 +1,91 @@
+import { Dispatch, SetStateAction, useContext, useEffect, useState } from 'react'
+import { Button } from "@/components/ui/button"
+import { Input } from "@/components/ui/input"
+import { Label } from "@/components/ui/label"
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select"
+import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogFooter } from "@/components/ui/dialog"
+import GlobalContext from '@/contexts/GlobalContext'
+import { Provider } from '@/constants/messages'
+export default function ApiSettingsPopup(props: { isOpen: boolean, setIsOpen: Dispatch<SetStateAction<boolean>> }) {
+  const {isOpen, setIsOpen} = props
+  const [mem0ApiKey, setMem0ApiKey] = useState('')
+  const [providerApiKey, setProviderApiKey] = useState('')
+  const [provider, setProvider] = useState('OpenAI')
+  const { selectorHandler, selectedOpenAIKey, selectedMem0Key, selectedProvider } = useContext(GlobalContext);
+
+  const handleSave = () => {
+    // Here you would typically save the settings to your backend or local storage
+    selectorHandler(mem0ApiKey, providerApiKey, provider as Provider);
+    setIsOpen(false)
+  }
+
+  useEffect(() => {
+    if (selectedOpenAIKey) {
+      setProviderApiKey(selectedOpenAIKey);
+    }
+    if (selectedMem0Key) {
+      setMem0ApiKey(selectedMem0Key);
+    }
+    if (selectedProvider) {
+      setProvider(selectedProvider);
+    }
+  }, [selectedOpenAIKey, selectedMem0Key, selectedProvider]);
+  
+
+
+  return (
+    <>
+      <Dialog open={isOpen} onOpenChange={setIsOpen}>
+        <DialogContent className="sm:max-w-[425px]">
+          <DialogHeader>
+            <DialogTitle>API Configuration Settings</DialogTitle>
+          </DialogHeader>
+          <div className="grid gap-4 py-4">
+            <div className="grid grid-cols-4 items-center gap-4">
+              <Label htmlFor="mem0-api-key" className="text-right">
+                Mem0 API Key
+              </Label>
+              <Input
+                id="mem0-api-key"
+                value={mem0ApiKey}
+                onChange={(e) => setMem0ApiKey(e.target.value)}
+                className="col-span-3 rounded-3xl"
+              />
+            </div>
+            <div className="grid grid-cols-4 items-center gap-4">
+              <Label htmlFor="provider-api-key" className="text-right">
+                Provider API Key
+              </Label>
+              <Input
+                id="provider-api-key"
+                value={providerApiKey}
+                onChange={(e) => setProviderApiKey(e.target.value)}
+                className="col-span-3 rounded-3xl"
+              />
+            </div>
+            <div className="grid grid-cols-4 items-center gap-4">
+              <Label htmlFor="provider" className="text-right">
+                Provider
+              </Label>
+              <Select value={provider} onValueChange={setProvider}>
+                <SelectTrigger className="col-span-3 rounded-3xl">
+                  <SelectValue placeholder="Select provider" />
+                </SelectTrigger>
+                <SelectContent className='rounded-3xl'>
+                  <SelectItem value="openai" className='rounded-3xl'>OpenAI</SelectItem>
+                  <SelectItem value="anthropic" className='rounded-3xl'>Anthropic</SelectItem>
+                  <SelectItem value="cohere" className='rounded-3xl'>Cohere</SelectItem>
+                  <SelectItem value="groq" className='rounded-3xl'>Groq</SelectItem>
+                </SelectContent>
+              </Select>
+            </div>
+          </div>
+          <DialogFooter>
+            <Button className='rounded-3xl' variant="outline" onClick={() => setIsOpen(false)}>Cancel</Button>
+            <Button className='rounded-3xl' onClick={handleSave}>Save</Button>
+          </DialogFooter>
+        </DialogContent>
+      </Dialog>
+    </>
+  )
+}

examples/multimodal-demo/src/components/chevron-toggle.tsx

@@ -0,0 +1,35 @@
+import { Button } from "@/components/ui/button";
+import { ChevronLeft, ChevronRight } from "lucide-react";
+import React from "react";
+
+const ChevronToggle = (props: {
+  isMemoriesExpanded: boolean;
+  setIsMemoriesExpanded: React.Dispatch<React.SetStateAction<boolean>>;
+}) => {
+  const { isMemoriesExpanded, setIsMemoriesExpanded } = props;
+  return (
+    <>
+      <div className="relaive">
+        <div className="flex items-center absolute top-1/2 z-10">
+          <Button
+            variant="ghost"
+            size="icon"
+            className="h-8 w-8 border-y border rounded-lg relative right-10"
+            onClick={() => setIsMemoriesExpanded(!isMemoriesExpanded)}
+            aria-label={
+              isMemoriesExpanded ? "Collapse memories" : "Expand memories"
+            }
+          >
+            {isMemoriesExpanded ? (
+              <ChevronRight className="h-4 w-4" />
+            ) : (
+              <ChevronLeft className="h-4 w-4" />
+            )}
+          </Button>
+        </div>
+      </div>
+    </>
+  );
+};
+
+export default ChevronToggle;

examples/multimodal-demo/src/components/header.tsx

@@ -0,0 +1,81 @@
+import { Button } from "@/components/ui/button";
+import { ChevronRight, X, RefreshCcw, Settings } from "lucide-react";
+import { Dispatch, SetStateAction, useContext, useEffect, useState } from "react";
+import GlobalContext from "../contexts/GlobalContext";
+import { Input } from "./ui/input";
+
+const Header = (props: {
+  setIsSettingsOpen: Dispatch<SetStateAction<boolean>>;
+}) => {
+  const { setIsSettingsOpen } = props;
+  const { selectUserHandler, clearUserHandler, selectedUser, clearConfiguration } = useContext(GlobalContext);
+  const [userId, setUserId] = useState<string>("");
+
+  const handleSelectUser = (e: React.ChangeEvent<HTMLInputElement>) => {
+    setUserId(e.target.value);
+  };
+
+  const handleClearUser = () => {
+    clearUserHandler();
+    setUserId("");
+  };
+
+  const handleSubmit = () => {
+    selectUserHandler(userId);
+  };
+
+  // New function to handle key down events
+  const handleKeyDown = (e: React.KeyboardEvent<HTMLInputElement>) => {
+    if (e.key === 'Enter') {
+      e.preventDefault(); // Prevent form submission if it's in a form
+      handleSubmit();
+    }
+  };
+
+  useEffect(() => {
+    if (selectedUser) {
+      setUserId(selectedUser);
+    }
+  }, [selectedUser]);
+
+  return (
+    <>
+      <header className="border-b p-4 flex items-center justify-between">
+        <div className="flex items-center space-x-2">
+          <span className="text-xl font-semibold">Mem0 Assistant</span>
+        </div>
+        <div className="flex items-center space-x-2 text-sm">
+          <div className="flex">
+            <Input 
+              placeholder="UserId" 
+              className="w-full rounded-3xl pr-6 pl-4" 
+              value={userId}
+              onChange={handleSelectUser} 
+              onKeyDown={handleKeyDown} // Attach the key down handler here
+            />
+            <Button variant="ghost" size="icon" onClick={handleClearUser} className="relative hover:bg-transparent hover:text-neutral-400 right-8">
+              <X className="h-4 w-4" />
+            </Button>
+            <Button variant="ghost" size="icon" onClick={handleSubmit} className="relative right-6">
+              <ChevronRight className="h-4 w-4" />
+            </Button>
+          </div>
+          <div className="flex items-center space-x-2">
+            <Button variant="ghost" size="icon" onClick={clearConfiguration}>
+              <RefreshCcw className="h-4 w-4" />
+            </Button>
+            <Button
+              variant="ghost"
+              size="icon"
+              onClick={() => setIsSettingsOpen(true)}
+            >
+              <Settings className="h-4 w-4" />
+            </Button>
+          </div>
+        </div>
+      </header>
+    </>
+  );
+};
+
+export default Header;

examples/multimodal-demo/src/components/input-area.tsx

@@ -0,0 +1,107 @@
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import GlobalContext from "@/contexts/GlobalContext";
+import { FileInfo } from "@/types";
+import { Images, Send, X } from "lucide-react";
+import { useContext, useRef, useState } from "react";
+
+const InputArea = () => {
+  const [inputValue, setInputValue] = useState("");
+  const { handleSend, selectedFile, setSelectedFile, setFile } = useContext(GlobalContext);
+  const [loading, setLoading] = useState(false);
+
+  const ref = useRef<HTMLInputElement>(null);
+  const fileInputRef = useRef<HTMLInputElement>(null)
+
+  const handleFileChange = (event: React.ChangeEvent<HTMLInputElement>) => {
+    const file = event.target.files?.[0]
+    if (file) {
+      setSelectedFile({
+        name: file.name,
+        type: file.type,
+        size: file.size
+      })
+      setFile(file)
+    }
+  }
+
+  const handleSendController = async () => {
+    setLoading(true);
+    setInputValue("");
+    await handleSend(inputValue);
+    setLoading(false);
+
+    // focus on input
+    setTimeout(() => {
+      ref.current?.focus();
+    }, 0);
+  };
+
+  const handleClosePopup = () => {
+    setSelectedFile(null)
+    if (fileInputRef.current) {
+      fileInputRef.current.value = ''
+    }
+  }
+
+  return (
+    <>
+      <div className="border-t p-4">
+        <div className="flex items-center space-x-2">
+          <div className="relative bottom-3 left-5">
+          <div className="absolute">
+          <Input
+            type="file"
+            accept="image/*"
+            onChange={handleFileChange}
+            ref={fileInputRef}
+            className="sr-only"
+            id="file-upload"
+          />
+          <label
+            htmlFor="file-upload"
+            className="flex items-center justify-center w-6 h-6 text-gray-500 hover:text-gray-700 dark:text-gray-400 dark:hover:text-gray-200 cursor-pointer"
+          >
+            <Images className="h-4 w-4" />
+          </label>
+          {selectedFile && <FileInfoPopup file={selectedFile} onClose={handleClosePopup} />}
+        </div>
+          </div>
+          <Input
+            value={inputValue}
+            onChange={(e) => setInputValue(e.target.value)}
+            onKeyDown={(e) => e.key === "Enter" && handleSendController()}
+            placeholder="Type a message..."
+            className="flex-1 pl-10 rounded-3xl"
+            disabled={loading}
+            ref={ref}
+          />
+          <div className="relative right-14 bottom-5 flex">
+          <Button className="absolute rounded-full w-10 h-10 bg-transparent hover:bg-transparent cursor-pointer z-20 text-primary" onClick={handleSendController} disabled={!inputValue.trim() || loading}>
+            <Send className="h-8 w-8" size={50} />
+          </Button>
+          </div>
+        </div>
+      </div>
+    </>
+  );
+};
+
+const FileInfoPopup = ({ file, onClose }: { file: FileInfo, onClose: () => void }) => {
+  return (
+   <div className="relative bottom-36">
+     <div className="absolute top-full left-0 mt-1 bg-white dark:bg-gray-800 p-2 rounded-md shadow-md border border-gray-200 dark:border-gray-700 z-10 w-48">
+      <div className="flex justify-between items-center">
+        <h3 className="font-semibold text-sm truncate">{file.name}</h3>
+        <Button variant="ghost" size="sm" onClick={onClose} className="h-5 w-5 p-0">
+          <X className="h-3 w-3" />
+        </Button>
+      </div>
+      <p className="text-xs text-gray-500 dark:text-gray-400 truncate">Type: {file.type}</p>
+      <p className="text-xs text-gray-500 dark:text-gray-400">Size: {(file.size / 1024).toFixed(2)} KB</p>
+    </div>
+   </div>
+  )
+}
+
+export default InputArea;

examples/multimodal-demo/src/components/memories.tsx

@@ -0,0 +1,84 @@
+import { Badge } from "@/components/ui/badge";
+import { Card } from "@/components/ui/card";
+import { ScrollArea } from "@radix-ui/react-scroll-area";
+import { Memory } from "../types";
+import GlobalContext from "@/contexts/GlobalContext";
+import { useContext } from "react";
+import {  motion } from "framer-motion";
+
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const MemoryItem = ({ memory }: { memory: Memory; index: number }) => {
+  return (
+    <motion.div
+      layout
+      initial={{ opacity: 0, y: 20 }}
+      animate={{ opacity: 1, y: 0 }}
+      exit={{ opacity: 0, y: -20 }}
+      transition={{ duration: 0.3 }}
+      key={memory.id}
+      className="space-y-2"
+    >
+      <div className="flex items-start justify-between">
+        <p className="text-sm font-medium">{memory.content}</p>
+      </div>
+      <div className="flex items-center space-x-2 text-xs text-muted-foreground">
+        <span>{new Date(memory.timestamp).toLocaleString()}</span>
+      </div>
+      <div className="flex flex-wrap gap-1">
+        {memory.tags.map((tag) => (
+          <Badge key={tag} variant="secondary" className="text-xs">
+            {tag}
+          </Badge>
+        ))}
+      </div>
+    </motion.div>
+  );
+};
+
+const Memories = (props: { isMemoriesExpanded: boolean }) => {
+  const { isMemoriesExpanded } = props;
+  const { memories } = useContext(GlobalContext);
+
+  return (
+    <Card
+      className={`border-l rounded-none flex flex-col transition-all duration-300 ${
+        isMemoriesExpanded ? "w-80" : "w-0 overflow-hidden"
+      }`}
+    >
+      <div className="px-4 py-[22px] border-b">
+        <span className="font-semibold">
+          Relevant Memories ({memories.length})
+        </span>
+      </div>
+      {memories.length === 0 && (
+        <motion.div 
+          initial={{ opacity: 0 }}
+          animate={{ opacity: 1 }}
+          className="p-4 text-center"
+        >
+          <span className="font-semibold">No relevant memories found.</span>
+          <br />
+          Only the relevant memories will be displayed here.
+        </motion.div>
+      )}
+      <ScrollArea className="flex-1 p-4">
+        <motion.div 
+          className="space-y-4"
+        >
+          {/* <AnimatePresence mode="popLayout"> */}
+            {memories.map((memory: Memory, index: number) => (
+              <MemoryItem 
+                key={memory.id} 
+                memory={memory} 
+                index={index}
+              />
+            ))}
+          {/* </AnimatePresence> */}
+        </motion.div>
+      </ScrollArea>
+    </Card>
+  );
+};
+
+export default Memories;

examples/multimodal-demo/src/components/messages.tsx

@@ -0,0 +1,102 @@
+import { Avatar, AvatarFallback, AvatarImage } from "@/components/ui/avatar";
+import { ScrollArea } from "@/components/ui/scroll-area";
+import { Message } from "../types";
+import { useContext, useEffect, useRef } from "react";
+import GlobalContext from "@/contexts/GlobalContext";
+import Markdown from "react-markdown";
+import Mem00Logo from "../assets/mem0_logo.jpeg";
+import UserLogo from "../assets/user.jpg";
+
+const Messages = () => {
+  const { messages, thinking } = useContext(GlobalContext);
+  const scrollAreaRef = useRef<HTMLDivElement>(null);
+
+  // scroll to bottom
+  useEffect(() => {
+    if (scrollAreaRef.current) {
+      scrollAreaRef.current.scrollTop += 40; // Scroll down by 40 pixels
+    }
+  }, [messages, thinking]);
+
+  return (
+    <>
+      <ScrollArea ref={scrollAreaRef} className="flex-1 p-4 pr-10">
+        <div className="space-y-4">
+          {messages.map((message: Message) => (
+            <div
+              key={message.id}
+              className={`flex ${
+                message.sender === "user" ? "justify-end" : "justify-start"
+              }`}
+            >
+              <div
+                className={`flex items-start space-x-2 max-w-[80%] ${
+                  message.sender === "user"
+                    ? "flex-row-reverse space-x-reverse"
+                    : "flex-row"
+                }`}
+              >
+                <div className="h-full flex flex-col items-center justify-end">
+                  <Avatar className="h-8 w-8">
+                    <AvatarImage
+                      src={
+                        message.sender === "assistant" ? Mem00Logo : UserLogo
+                      }
+                    />
+                    <AvatarFallback>
+                      {message.sender === "assistant" ? "AI" : "U"}
+                    </AvatarFallback>
+                  </Avatar>
+                </div>
+                <div
+                  className={`rounded-xl px-3 py-2 ${
+                    message.sender === "user"
+                      ? "bg-blue-500 text-white rounded-br-none"
+                      : "bg-muted text-muted-foreground rounded-bl-none"
+                  }`}
+                >
+                  {message.image && (
+                    <div className="w-44 flex items-center justify-center overflow-hidden rounded-lg">
+                      <img
+                        src={message.image}
+                        alt="Message attachment"
+                        className="my-2 rounded-lg max-w-full h-auto w-44 mx-auto"
+                      />
+                    </div>
+                  )}
+                  <Markdown>{message.content}</Markdown>
+                  <span className="text-xs opacity-50 mt-1 block text-end relative bottom-1 -mb-2">
+                    {message.timestamp}
+                  </span>
+                </div>
+              </div>
+            </div>
+          ))}
+          {thinking && (
+            <div className={`flex justify-start`}>
+              <div
+                className={`flex items-start space-x-2 max-w-[80%] flex-row`}
+              >
+                <Avatar className="h-8 w-8">
+                  <AvatarImage src={Mem00Logo} />
+                  <AvatarFallback>{"AI"}</AvatarFallback>
+                </Avatar>
+                <div
+                  className={`rounded-lg p-3 bg-muted text-muted-foreground`}
+                >
+                  <div className="loader">
+                    <div className="ball"></div>
+                    <div className="ball"></div>
+                    <div className="ball"></div>
+                  </div>
+                </div>
+              </div>
+            </div>
+          )}
+        </div>
+      </ScrollArea>
+    </>
+  );
+};
+
+export default Messages;

examples/multimodal-demo/src/components/ui/avatar.tsx

@@ -0,0 +1,50 @@
+"use client"
+
+import * as React from "react"
+import * as AvatarPrimitive from "@radix-ui/react-avatar"
+
+import { cn } from "@/libs/utils"
+
+const Avatar = React.forwardRef<
+  React.ElementRef<typeof AvatarPrimitive.Root>,
+  React.ComponentPropsWithoutRef<typeof AvatarPrimitive.Root>
+>(({ className, ...props }, ref) => (
+  <AvatarPrimitive.Root
+    ref={ref}
+    className={cn(
+      "relative flex h-10 w-10 shrink-0 overflow-hidden rounded-full",
+      className
+    )}
+    {...props}
+  />
+))
+Avatar.displayName = AvatarPrimitive.Root.displayName
+
+const AvatarImage = React.forwardRef<
+  React.ElementRef<typeof AvatarPrimitive.Image>,
+  React.ComponentPropsWithoutRef<typeof AvatarPrimitive.Image>
+>(({ className, ...props }, ref) => (
+  <AvatarPrimitive.Image
+    ref={ref}
+    className={cn("aspect-square h-full w-full", className)}
+    {...props}
+  />
+))
+AvatarImage.displayName = AvatarPrimitive.Image.displayName
+
+const AvatarFallback = React.forwardRef<
+  React.ElementRef<typeof AvatarPrimitive.Fallback>,
+  React.ComponentPropsWithoutRef<typeof AvatarPrimitive.Fallback>
+>(({ className, ...props }, ref) => (
+  <AvatarPrimitive.Fallback
+    ref={ref}
+    className={cn(
+      "flex h-full w-full items-center justify-center rounded-full bg-muted",
+      className
+    )}
+    {...props}
+  />
+))
+AvatarFallback.displayName = AvatarPrimitive.Fallback.displayName
+
+export { Avatar, AvatarImage, AvatarFallback }

examples/multimodal-demo/src/components/ui/badge.tsx

@@ -0,0 +1,36 @@
+import * as React from "react"
+import { cva, type VariantProps } from "class-variance-authority"
+
+import { cn } from "@/libs/utils"
+
+const badgeVariants = cva(
+  "inline-flex items-center rounded-md border px-2.5 py-0.5 text-xs font-semibold transition-colors focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2",
+  {
+    variants: {
+      variant: {
+        default:
+          "border-transparent bg-primary text-primary-foreground shadow hover:bg-primary/80",
+        secondary:
+          "border-transparent bg-secondary text-secondary-foreground hover:bg-secondary/80",
+        destructive:
+          "border-transparent bg-destructive text-destructive-foreground shadow hover:bg-destructive/80",
+        outline: "text-foreground",
+      },
+    },
+    defaultVariants: {
+      variant: "default",
+    },
+  }
+)
+
+export interface BadgeProps
+  extends React.HTMLAttributes<HTMLDivElement>,
+    VariantProps<typeof badgeVariants> {}
+
+function Badge({ className, variant, ...props }: BadgeProps) {
+  return (
+    <div className={cn(badgeVariants({ variant }), className)} {...props} />
+  )
+}
+
+export { Badge, badgeVariants }

examples/multimodal-demo/src/components/ui/button.tsx

@@ -0,0 +1,57 @@
+import * as React from "react"
+import { Slot } from "@radix-ui/react-slot"
+import { cva, type VariantProps } from "class-variance-authority"
+
+import { cn } from "@/libs/utils"
+
+const buttonVariants = cva(
+  "inline-flex items-center justify-center gap-2 whitespace-nowrap rounded-md text-sm font-medium transition-colors focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring disabled:pointer-events-none disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:size-4 [&_svg]:shrink-0",
+  {
+    variants: {
+      variant: {
+        default:
+          "bg-primary text-primary-foreground shadow hover:bg-primary/90",
+        destructive:
+          "bg-destructive text-destructive-foreground shadow-sm hover:bg-destructive/90",
+        outline:
+          "border border-input bg-background shadow-sm hover:bg-accent hover:text-accent-foreground",
+        secondary:
+          "bg-secondary text-secondary-foreground shadow-sm hover:bg-secondary/80",
+        ghost: "hover:bg-accent hover:text-accent-foreground",
+        link: "text-primary underline-offset-4 hover:underline",
+      },
+      size: {
+        default: "h-9 px-4 py-2",
+        sm: "h-8 rounded-md px-3 text-xs",
+        lg: "h-10 rounded-md px-8",
+        icon: "h-9 w-9",
+      },
+    },
+    defaultVariants: {
+      variant: "default",
+      size: "default",
+    },
+  }
+)
+
+export interface ButtonProps
+  extends React.ButtonHTMLAttributes<HTMLButtonElement>,
+    VariantProps<typeof buttonVariants> {
+  asChild?: boolean
+}
+
+const Button = React.forwardRef<HTMLButtonElement, ButtonProps>(
+  ({ className, variant, size, asChild = false, ...props }, ref) => {
+    const Comp = asChild ? Slot : "button"
+    return (
+      <Comp
+        className={cn(buttonVariants({ variant, size, className }))}
+        ref={ref}
+        {...props}
+      />
+    )
+  }
+)
+Button.displayName = "Button"
+
+export { Button, buttonVariants }

examples/multimodal-demo/src/components/ui/card.tsx

@@ -0,0 +1,76 @@
+import * as React from "react"
+
+import { cn } from "@/libs/utils"
+
+const Card = React.forwardRef<
+  HTMLDivElement,
+  React.HTMLAttributes<HTMLDivElement>
+>(({ className, ...props }, ref) => (
+  <div
+    ref={ref}
+    className={cn(
+      "rounded-xl border bg-card text-card-foreground shadow",
+      className
+    )}
+    {...props}
+  />
+))
+Card.displayName = "Card"
+
+const CardHeader = React.forwardRef<
+  HTMLDivElement,
+  React.HTMLAttributes<HTMLDivElement>
+>(({ className, ...props }, ref) => (
+  <div
+    ref={ref}
+    className={cn("flex flex-col space-y-1.5 p-6", className)}
+    {...props}
+  />
+))
+CardHeader.displayName = "CardHeader"
+
+const CardTitle = React.forwardRef<
+  HTMLParagraphElement,
+  React.HTMLAttributes<HTMLHeadingElement>
+>(({ className, ...props }, ref) => (
+  <h3
+    ref={ref}
+    className={cn("font-semibold leading-none tracking-tight", className)}
+    {...props}
+  />
+))
+CardTitle.displayName = "CardTitle"
+
+const CardDescription = React.forwardRef<
+  HTMLParagraphElement,
+  React.HTMLAttributes<HTMLParagraphElement>
+>(({ className, ...props }, ref) => (
+  <p
+    ref={ref}
+    className={cn("text-sm text-muted-foreground", className)}
+    {...props}
+  />
+))
+CardDescription.displayName = "CardDescription"
+
+const CardContent = React.forwardRef<
+  HTMLDivElement,
+  React.HTMLAttributes<HTMLDivElement>
+>(({ className, ...props }, ref) => (
+  <div ref={ref} className={cn("p-6 pt-0", className)} {...props} />
+))
+CardContent.displayName = "CardContent"
+
+const CardFooter = React.forwardRef<
+  HTMLDivElement,
+  React.HTMLAttributes<HTMLDivElement>
+>(({ className, ...props }, ref) => (
+  <div
+    ref={ref}
+    className={cn("flex items-center p-6 pt-0", className)}
+    {...props}
+  />
+))
+CardFooter.displayName = "CardFooter"
+
+export { Card, CardHeader, CardFooter, CardTitle, CardDescription, CardContent }

examples/multimodal-demo/src/components/ui/dialog.tsx

@@ -0,0 +1,120 @@
+import * as React from "react"
+import * as DialogPrimitive from "@radix-ui/react-dialog"
+import { Cross2Icon } from "@radix-ui/react-icons"
+
+import { cn } from "@/libs/utils"
+
+const Dialog = DialogPrimitive.Root
+
+const DialogTrigger = DialogPrimitive.Trigger
+
+const DialogPortal = DialogPrimitive.Portal
+
+const DialogClose = DialogPrimitive.Close
+
+const DialogOverlay = React.forwardRef<
+  React.ElementRef<typeof DialogPrimitive.Overlay>,
+  React.ComponentPropsWithoutRef<typeof DialogPrimitive.Overlay>
+>(({ className, ...props }, ref) => (
+  <DialogPrimitive.Overlay
+    ref={ref}
+    className={cn(
+      "fixed inset-0 z-50 bg-black/80  data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0",
+      className
+    )}
+    {...props}
+  />
+))
+DialogOverlay.displayName = DialogPrimitive.Overlay.displayName
+
+const DialogContent = React.forwardRef<
+  React.ElementRef<typeof DialogPrimitive.Content>,
+  React.ComponentPropsWithoutRef<typeof DialogPrimitive.Content>
+>(({ className, children, ...props }, ref) => (
+  <DialogPortal>
+    <DialogOverlay />
+    <DialogPrimitive.Content
+      ref={ref}
+      className={cn(
+        "fixed left-[50%] top-[50%] z-50 grid w-full max-w-lg translate-x-[-50%] translate-y-[-50%] gap-4 border bg-background p-6 shadow-lg duration-200 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[state=closed]:slide-out-to-left-1/2 data-[state=closed]:slide-out-to-top-[48%] data-[state=open]:slide-in-from-left-1/2 data-[state=open]:slide-in-from-top-[48%] sm:rounded-lg",
+        className
+      )}
+      {...props}
+    >
+      {children}
+      <DialogPrimitive.Close className="absolute right-4 top-4 rounded-sm opacity-70 ring-offset-background transition-opacity hover:opacity-100 focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2 disabled:pointer-events-none data-[state=open]:bg-accent data-[state=open]:text-muted-foreground">
+        <Cross2Icon className="h-4 w-4" />
+        <span className="sr-only">Close</span>
+      </DialogPrimitive.Close>
+    </DialogPrimitive.Content>
+  </DialogPortal>
+))
+DialogContent.displayName = DialogPrimitive.Content.displayName
+
+const DialogHeader = ({
+  className,
+  ...props
+}: React.HTMLAttributes<HTMLDivElement>) => (
+  <div
+    className={cn(
+      "flex flex-col space-y-1.5 text-center sm:text-left",
+      className
+    )}
+    {...props}
+  />
+)
+DialogHeader.displayName = "DialogHeader"
+
+const DialogFooter = ({
+  className,
+  ...props
+}: React.HTMLAttributes<HTMLDivElement>) => (
+  <div
+    className={cn(
+      "flex flex-col-reverse sm:flex-row sm:justify-end sm:space-x-2",
+      className
+    )}
+    {...props}
+  />
+)
+DialogFooter.displayName = "DialogFooter"
+
+const DialogTitle = React.forwardRef<
+  React.ElementRef<typeof DialogPrimitive.Title>,
+  React.ComponentPropsWithoutRef<typeof DialogPrimitive.Title>
+>(({ className, ...props }, ref) => (
+  <DialogPrimitive.Title
+    ref={ref}
+    className={cn(
+      "text-lg font-semibold leading-none tracking-tight",
+      className
+    )}
+    {...props}
+  />
+))
+DialogTitle.displayName = DialogPrimitive.Title.displayName
+
+const DialogDescription = React.forwardRef<
+  React.ElementRef<typeof DialogPrimitive.Description>,
+  React.ComponentPropsWithoutRef<typeof DialogPrimitive.Description>
+>(({ className, ...props }, ref) => (
+  <DialogPrimitive.Description
+    ref={ref}
+    className={cn("text-sm text-muted-foreground", className)}
+    {...props}
+  />
+))
+DialogDescription.displayName = DialogPrimitive.Description.displayName
+
+export {
+  Dialog,
+  DialogPortal,
+  DialogOverlay,
+  DialogTrigger,
+  DialogClose,
+  DialogContent,
+  DialogHeader,
+  DialogFooter,
+  DialogTitle,
+  DialogDescription,
+}

examples/multimodal-demo/src/components/ui/input.tsx

@@ -0,0 +1,25 @@
+import * as React from "react"
+
+import { cn } from "@/libs/utils"
+
+export interface InputProps
+  extends React.InputHTMLAttributes<HTMLInputElement> {}
+
+const Input = React.forwardRef<HTMLInputElement, InputProps>(
+  ({ className, type, ...props }, ref) => {
+    return (
+      <input
+        type={type}
+        className={cn(
+          "flex h-9 w-full rounded-md border border-input bg-transparent px-3 py-1 text-sm shadow-sm transition-colors file:border-0 file:bg-transparent file:text-sm file:font-medium file:text-foreground placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring disabled:cursor-not-allowed disabled:opacity-50",
+          className
+        )}
+        ref={ref}
+        {...props}
+      />
+    )
+  }
+)
+Input.displayName = "Input"
+
+export { Input }

examples/multimodal-demo/src/components/ui/label.tsx

@@ -0,0 +1,24 @@
+import * as React from "react"
+import * as LabelPrimitive from "@radix-ui/react-label"
+import { cva, type VariantProps } from "class-variance-authority"
+
+import { cn } from "@/libs/utils"
+
+const labelVariants = cva(
+  "text-sm font-medium leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70"
+)
+
+const Label = React.forwardRef<
+  React.ElementRef<typeof LabelPrimitive.Root>,
+  React.ComponentPropsWithoutRef<typeof LabelPrimitive.Root> &
+    VariantProps<typeof labelVariants>
+>(({ className, ...props }, ref) => (
+  <LabelPrimitive.Root
+    ref={ref}
+    className={cn(labelVariants(), className)}
+    {...props}
+  />
+))
+Label.displayName = LabelPrimitive.Root.displayName
+
+export { Label }

examples/multimodal-demo/src/components/ui/scroll-area.tsx

@@ -0,0 +1,46 @@
+import * as React from "react"
+import * as ScrollAreaPrimitive from "@radix-ui/react-scroll-area"
+
+import { cn } from "@/libs/utils"
+
+const ScrollArea = React.forwardRef<
+  React.ElementRef<typeof ScrollAreaPrimitive.Root>,
+  React.ComponentPropsWithoutRef<typeof ScrollAreaPrimitive.Root>
+>(({ className, children, ...props }, ref) => (
+  <ScrollAreaPrimitive.Root
+    ref={ref}
+    className={cn("relative overflow-hidden", className)}
+    {...props}
+  >
+    <ScrollAreaPrimitive.Viewport className="h-full w-full rounded-[inherit]">
+      {children}
+    </ScrollAreaPrimitive.Viewport>
+    <ScrollBar />
+    <ScrollAreaPrimitive.Corner />
+  </ScrollAreaPrimitive.Root>
+))
+ScrollArea.displayName = ScrollAreaPrimitive.Root.displayName
+
+const ScrollBar = React.forwardRef<
+  React.ElementRef<typeof ScrollAreaPrimitive.ScrollAreaScrollbar>,
+  React.ComponentPropsWithoutRef<typeof ScrollAreaPrimitive.ScrollAreaScrollbar>
+>(({ className, orientation = "vertical", ...props }, ref) => (
+  <ScrollAreaPrimitive.ScrollAreaScrollbar
+    ref={ref}
+    orientation={orientation}
+    className={cn(
+      "flex touch-none select-none transition-colors",
+      orientation === "vertical" &&
+        "h-full w-2.5 border-l border-l-transparent p-[1px]",
+      orientation === "horizontal" &&
+        "h-2.5 flex-col border-t border-t-transparent p-[1px]",
+      className
+    )}
+    {...props}
+  >
+    <ScrollAreaPrimitive.ScrollAreaThumb className="relative flex-1 rounded-full bg-border" />
+  </ScrollAreaPrimitive.ScrollAreaScrollbar>
+))
+ScrollBar.displayName = ScrollAreaPrimitive.ScrollAreaScrollbar.displayName
+
+export { ScrollArea, ScrollBar }

examples/multimodal-demo/src/components/ui/select.tsx

@@ -0,0 +1,164 @@
+"use client"
+
+import * as React from "react"
+import {
+  CaretSortIcon,
+  CheckIcon,
+  ChevronDownIcon,
+  ChevronUpIcon,
+} from "@radix-ui/react-icons"
+import * as SelectPrimitive from "@radix-ui/react-select"
+
+import { cn } from "@/libs/utils"
+
+const Select = SelectPrimitive.Root
+
+const SelectGroup = SelectPrimitive.Group
+
+const SelectValue = SelectPrimitive.Value
+
+const SelectTrigger = React.forwardRef<
+  React.ElementRef<typeof SelectPrimitive.Trigger>,
+  React.ComponentPropsWithoutRef<typeof SelectPrimitive.Trigger>
+>(({ className, children, ...props }, ref) => (
+  <SelectPrimitive.Trigger
+    ref={ref}
+    className={cn(
+      "flex h-9 w-full items-center justify-between whitespace-nowrap rounded-md border border-input bg-transparent px-3 py-2 text-sm shadow-sm ring-offset-background placeholder:text-muted-foreground focus:outline-none focus:ring-1 focus:ring-ring disabled:cursor-not-allowed disabled:opacity-50 [&>span]:line-clamp-1",
+      className
+    )}
+    {...props}
+  >
+    {children}
+    <SelectPrimitive.Icon asChild>
+      <CaretSortIcon className="h-4 w-4 opacity-50" />
+    </SelectPrimitive.Icon>
+  </SelectPrimitive.Trigger>
+))
+SelectTrigger.displayName = SelectPrimitive.Trigger.displayName
+
+const SelectScrollUpButton = React.forwardRef<
+  React.ElementRef<typeof SelectPrimitive.ScrollUpButton>,
+  React.ComponentPropsWithoutRef<typeof SelectPrimitive.ScrollUpButton>
+>(({ className, ...props }, ref) => (
+  <SelectPrimitive.ScrollUpButton
+    ref={ref}
+    className={cn(
+      "flex cursor-default items-center justify-center py-1",
+      className
+    )}
+    {...props}
+  >
+    <ChevronUpIcon />
+  </SelectPrimitive.ScrollUpButton>
+))
+SelectScrollUpButton.displayName = SelectPrimitive.ScrollUpButton.displayName
+
+const SelectScrollDownButton = React.forwardRef<
+  React.ElementRef<typeof SelectPrimitive.ScrollDownButton>,
+  React.ComponentPropsWithoutRef<typeof SelectPrimitive.ScrollDownButton>
+>(({ className, ...props }, ref) => (
+  <SelectPrimitive.ScrollDownButton
+    ref={ref}
+    className={cn(
+      "flex cursor-default items-center justify-center py-1",
+      className
+    )}
+    {...props}
+  >
+    <ChevronDownIcon />
+  </SelectPrimitive.ScrollDownButton>
+))
+SelectScrollDownButton.displayName =
+  SelectPrimitive.ScrollDownButton.displayName
+
+const SelectContent = React.forwardRef<
+  React.ElementRef<typeof SelectPrimitive.Content>,
+  React.ComponentPropsWithoutRef<typeof SelectPrimitive.Content>
+>(({ className, children, position = "popper", ...props }, ref) => (
+  <SelectPrimitive.Portal>
+    <SelectPrimitive.Content
+      ref={ref}
+      className={cn(
+        "relative z-50 max-h-96 min-w-[8rem] overflow-hidden rounded-md border bg-popover text-popover-foreground shadow-md data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2",
+        position === "popper" &&
+          "data-[side=bottom]:translate-y-1 data-[side=left]:-translate-x-1 data-[side=right]:translate-x-1 data-[side=top]:-translate-y-1",
+        className
+      )}
+      position={position}
+      {...props}
+    >
+      <SelectScrollUpButton />
+      <SelectPrimitive.Viewport
+        className={cn(
+          "p-1",
+          position === "popper" &&
+            "h-[var(--radix-select-trigger-height)] w-full min-w-[var(--radix-select-trigger-width)]"
+        )}
+      >
+        {children}
+      </SelectPrimitive.Viewport>
+      <SelectScrollDownButton />
+    </SelectPrimitive.Content>
+  </SelectPrimitive.Portal>
+))
+SelectContent.displayName = SelectPrimitive.Content.displayName
+
+const SelectLabel = React.forwardRef<
+  React.ElementRef<typeof SelectPrimitive.Label>,
+  React.ComponentPropsWithoutRef<typeof SelectPrimitive.Label>
+>(({ className, ...props }, ref) => (
+  <SelectPrimitive.Label
+    ref={ref}
+    className={cn("px-2 py-1.5 text-sm font-semibold", className)}
+    {...props}
+  />
+))
+SelectLabel.displayName = SelectPrimitive.Label.displayName
+
+const SelectItem = React.forwardRef<
+  React.ElementRef<typeof SelectPrimitive.Item>,
+  React.ComponentPropsWithoutRef<typeof SelectPrimitive.Item>
+>(({ className, children, ...props }, ref) => (
+  <SelectPrimitive.Item
+    ref={ref}
+    className={cn(
+      "relative flex w-full cursor-default select-none items-center rounded-sm py-1.5 pl-2 pr-8 text-sm outline-none focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50",
+      className
+    )}
+    {...props}
+  >
+    <span className="absolute right-2 flex h-3.5 w-3.5 items-center justify-center">
+      <SelectPrimitive.ItemIndicator>
+        <CheckIcon className="h-4 w-4" />
+      </SelectPrimitive.ItemIndicator>
+    </span>
+    <SelectPrimitive.ItemText>{children}</SelectPrimitive.ItemText>
+  </SelectPrimitive.Item>
+))
+SelectItem.displayName = SelectPrimitive.Item.displayName
+
+const SelectSeparator = React.forwardRef<
+  React.ElementRef<typeof SelectPrimitive.Separator>,
+  React.ComponentPropsWithoutRef<typeof SelectPrimitive.Separator>
+>(({ className, ...props }, ref) => (
+  <SelectPrimitive.Separator
+    ref={ref}
+    className={cn("-mx-1 my-1 h-px bg-muted", className)}
+    {...props}
+  />
+))
+SelectSeparator.displayName = SelectPrimitive.Separator.displayName
+
+export {
+  Select,
+  SelectGroup,
+  SelectValue,
+  SelectTrigger,
+  SelectContent,
+  SelectLabel,
+  SelectItem,
+  SelectSeparator,
+  SelectScrollUpButton,
+  SelectScrollDownButton,
+}

examples/multimodal-demo/src/constants/messages.ts

@@ -0,0 +1,31 @@
+import { Message } from "@/types";
+
+export const WELCOME_MESSAGE: Message = {
+  id: "1",
+  content: "👋 Hi there! I'm your personal assistant. How can I help you today? 😊",
+  sender: "assistant",
+  timestamp: new Date().toLocaleTimeString(),
+};
+
+export const INVALID_CONFIG_MESSAGE: Message = {
+  id: "2",
+  content: "Invalid configuration. Please check your API keys, and add a user and try again.",
+  sender: "assistant",
+  timestamp: new Date().toLocaleTimeString(),
+};
+
+export const ERROR_MESSAGE: Message = {
+  id: "3",
+  content: "Something went wrong. Please try again.",
+  sender: "assistant",
+  timestamp: new Date().toLocaleTimeString(),
+};
+
+export const AI_MODELS = {
+  openai: "gpt-4o",
+  anthropic: "claude-3-haiku-20240307",
+  cohere: "command-r-plus",
+  groq: "gemma2-9b-it",
+} as const;
+
+export type Provider = keyof typeof AI_MODELS; 

examples/multimodal-demo/src/contexts/GlobalContext.tsx

@@ -0,0 +1,110 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { createContext } from 'react';
+import { Message, Memory, FileInfo } from '@/types';
+import { useAuth } from '@/hooks/useAuth';
+import { useChat } from '@/hooks/useChat';
+import { useFileHandler } from '@/hooks/useFileHandler';
+import { Provider } from '@/constants/messages';
+
+interface GlobalContextType {
+  selectedUser: string;
+  selectUserHandler: (user: string) => void;
+  clearUserHandler: () => void;
+  messages: Message[];
+  memories: Memory[];
+  handleSend: (content: string) => Promise<void>;
+  thinking: boolean;
+  selectedMem0Key: string;
+  selectedOpenAIKey: string;
+  selectedProvider: Provider;
+  selectorHandler: (mem0: string, openai: string, provider: Provider) => void;
+  clearConfiguration: () => void;
+  selectedFile: FileInfo | null;
+  setSelectedFile: (file: FileInfo | null) => void;
+  file: File | null;
+  setFile: (file: File | null) => void;
+}
+
+const GlobalContext = createContext<GlobalContextType>({} as GlobalContextType);
+
+const GlobalState = (props: { children: React.ReactNode }) => {
+  const {
+    mem0ApiKey: selectedMem0Key,
+    openaiApiKey: selectedOpenAIKey,
+    provider: selectedProvider,
+    user: selectedUser,
+    setAuth: selectorHandler,
+    setUser: selectUserHandler,
+    clearAuth: clearConfiguration,
+    clearUser: clearUserHandler,
+  } = useAuth();
+
+  const {
+    selectedFile,
+    file,
+    fileData,
+    setSelectedFile,
+    handleFile,
+    clearFile,
+  } = useFileHandler();
+
+  const {
+    messages,
+    memories,
+    thinking,
+    sendMessage,
+  } = useChat({
+    user: selectedUser,
+    mem0ApiKey: selectedMem0Key,
+    openaiApiKey: selectedOpenAIKey,
+    provider: selectedProvider,
+  });
+
+  const handleSend = async (content: string) => {
+    if (file) {
+      await sendMessage(content, {
+        type: file.type,
+        data: fileData!,
+      });
+      clearFile();
+    } else {
+      await sendMessage(content);
+    }
+  };
+
+  const setFile = async (newFile: File | null) => {
+    if (newFile) {
+      await handleFile(newFile);
+    } else {
+      clearFile();
+    }
+  };
+
+  return (
+    <GlobalContext.Provider
+      value={{
+        selectedUser,
+        selectUserHandler,
+        clearUserHandler,
+        messages,
+        memories,
+        handleSend,
+        thinking,
+        selectedMem0Key,
+        selectedOpenAIKey,
+        selectedProvider,
+        selectorHandler,
+        clearConfiguration,
+        selectedFile,
+        setSelectedFile,
+        file,
+        setFile,
+      }}
+    >
+      {props.children}
+    </GlobalContext.Provider>
+  );
+};
+
+export default GlobalContext;
+export { GlobalState };

examples/multimodal-demo/src/hooks/useAuth.ts

@@ -0,0 +1,73 @@
+import { useState, useEffect } from 'react';
+import { Provider } from '@/constants/messages';
+
+interface UseAuthReturn {
+  mem0ApiKey: string;
+  openaiApiKey: string;
+  provider: Provider;
+  user: string;
+  setAuth: (mem0: string, openai: string, provider: Provider) => void;
+  setUser: (user: string) => void;
+  clearAuth: () => void;
+  clearUser: () => void;
+}
+
+export const useAuth = (): UseAuthReturn => {
+  const [mem0ApiKey, setMem0ApiKey] = useState<string>('');
+  const [openaiApiKey, setOpenaiApiKey] = useState<string>('');
+  const [provider, setProvider] = useState<Provider>('openai');
+  const [user, setUser] = useState<string>('');
+
+  useEffect(() => {
+    const mem0 = localStorage.getItem('mem0ApiKey');
+    const openai = localStorage.getItem('openaiApiKey');
+    const savedProvider = localStorage.getItem('provider') as Provider;
+    const savedUser = localStorage.getItem('user');
+
+    if (mem0 && openai && savedProvider) {
+      setAuth(mem0, openai, savedProvider);
+    }
+    if (savedUser) {
+      setUser(savedUser);
+    }
+  }, []);
+
+  const setAuth = (mem0: string, openai: string, provider: Provider) => {
+    setMem0ApiKey(mem0);
+    setOpenaiApiKey(openai);
+    setProvider(provider);
+    localStorage.setItem('mem0ApiKey', mem0);
+    localStorage.setItem('openaiApiKey', openai);
+    localStorage.setItem('provider', provider);
+  };
+
+  const clearAuth = () => {
+    localStorage.removeItem('mem0ApiKey');
+    localStorage.removeItem('openaiApiKey');
+    localStorage.removeItem('provider');
+    setMem0ApiKey('');
+    setOpenaiApiKey('');
+    setProvider('openai');
+  };
+
+  const updateUser = (user: string) => {
+    setUser(user);
+    localStorage.setItem('user', user);
+  };
+
+  const clearUser = () => {
+    localStorage.removeItem('user');
+    setUser('');
+  };
+
+  return {
+    mem0ApiKey,
+    openaiApiKey,
+    provider,
+    user,
+    setAuth,
+    setUser: updateUser,
+    clearAuth,
+    clearUser,
+  };
+}; 

examples/multimodal-demo/src/hooks/useChat.ts

@@ -0,0 +1,223 @@
+import { useState } from 'react';
+import { MemoryClient, Memory as Mem0Memory } from 'mem0ai';
+import { OpenAI } from 'openai';
+import { Message, Memory } from '@/types';
+import { WELCOME_MESSAGE, INVALID_CONFIG_MESSAGE, ERROR_MESSAGE, Provider } from '@/constants/messages';
+
+interface UseChatProps {
+  user: string;
+  mem0ApiKey: string;
+  openaiApiKey: string;
+  provider: Provider;
+}
+
+interface UseChatReturn {
+  messages: Message[];
+  memories: Memory[];
+  thinking: boolean;
+  sendMessage: (content: string, fileData?: { type: string; data: string | Buffer }) => Promise<void>;
+}
+
+type MessageContent = string | {
+  type: 'image_url';
+  image_url: {
+    url: string;
+  };
+};
+
+interface PromptMessage {
+  role: string;
+  content: MessageContent;
+}
+
+export const useChat = ({ user, mem0ApiKey, openaiApiKey }: UseChatProps): UseChatReturn => {
+  const [messages, setMessages] = useState<Message[]>([WELCOME_MESSAGE]);
+  const [memories, setMemories] = useState<Memory[]>();
+  const [thinking, setThinking] = useState(false);
+
+  const openai = new OpenAI({ apiKey: openaiApiKey, dangerouslyAllowBrowser: true});
+  
+  const updateMemories = async (messages: PromptMessage[]) => {
+    const memoryClient = new MemoryClient({ apiKey: mem0ApiKey || '' });
+    try {
+      await memoryClient.add(messages, {
+        user_id: user,
+      });
+
+      const response = await memoryClient.getAll({
+        user_id: user,
+      });
+
+      const newMemories = response.map((memory: Mem0Memory) => ({
+        id: memory.id || '',
+        content: memory.memory || '',
+        timestamp: String(memory.updated_at) || '',
+        tags: memory.categories || [],
+      }));
+      setMemories(newMemories);
+    } catch (error) {
+      console.error('Error in updateMemories:', error);
+    }
+  };
+
+  const formatMessagesForPrompt = (messages: Message[]): PromptMessage[] => {
+    return messages.map((message) => {
+      if (message.image) {
+        return {
+          role: message.sender,
+          content: {
+            type: 'image_url',
+            image_url: {
+              url: message.image
+            }
+          },
+        };
+      }
+
+      return {
+        role: message.sender,
+        content: message.content,
+      };
+    });
+  };
+
+  const sendMessage = async (content: string, fileData?: { type: string; data: string | Buffer }) => {
+    if (!content.trim() && !fileData) return;
+
+    const memoryClient = new MemoryClient({ apiKey: mem0ApiKey || '' });
+
+    if (!user) {
+      const newMessage: Message = {
+        id: Date.now().toString(),
+        content,
+        sender: 'user',
+        timestamp: new Date().toLocaleTimeString(),
+      };
+      setMessages((prev) => [...prev, newMessage, INVALID_CONFIG_MESSAGE]);
+      return;
+    }
+
+    const userMessage: Message = {
+      id: Date.now().toString(),
+      content,
+      sender: 'user',
+      timestamp: new Date().toLocaleTimeString(),
+      ...(fileData?.type.startsWith('image/') && { image: fileData.data.toString() }),
+    };
+
+    setMessages((prev) => [...prev, userMessage]);
+    setThinking(true);
+
+    // Get all messages for memory update
+    const allMessagesForMemory = formatMessagesForPrompt([...messages, userMessage]);
+    await updateMemories(allMessagesForMemory);
+
+    try {
+      // Get only the last assistant message (if exists) and the current user message
+      const lastAssistantMessage = messages.filter(msg => msg.sender === 'assistant').slice(-1)[0];
+      let messagesForLLM = lastAssistantMessage 
+        ? [
+            formatMessagesForPrompt([lastAssistantMessage])[0],
+            formatMessagesForPrompt([userMessage])[0]
+          ]
+        : [formatMessagesForPrompt([userMessage])[0]];
+
+      // Check if any message has image content
+      const hasImage = messagesForLLM.some(msg => {
+        if (typeof msg.content === 'object' && msg.content !== null) {
+          const content = msg.content as MessageContent;
+          return typeof content === 'object' && content !== null && 'type' in content && content.type === 'image_url';
+        }
+        return false;
+      });
+
+      // For image messages, only use the text content
+      if (hasImage) {
+        messagesForLLM = [
+          ...messagesForLLM,
+          {
+            role: 'user',
+            content: userMessage.content
+          }
+        ];
+      }
+
+      // Fetch relevant memories if there's an image
+      let relevantMemories = '';
+        try {
+          const searchResponse = await memoryClient.getAll({
+            user_id: user
+          });
+
+          relevantMemories = searchResponse
+            .map((memory: Mem0Memory) => `Previous context: ${memory.memory}`)
+            .join('\n');
+        } catch (error) {
+          console.error('Error fetching memories:', error);
+        }
+
+      // Add a system message with memories context if there are memories and image
+      if (relevantMemories.length > 0 && hasImage) {
+        messagesForLLM = [
+          {
+            role: 'system',
+            content: `Here are some relevant details about the user:\n${relevantMemories}\n\nPlease use this context when responding to the user's message.`
+          },
+          ...messagesForLLM
+        ];
+      }
+
+      const generateRandomId = () => {
+        return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
+      }
+
+      const completion = await openai.chat.completions.create({
+        model: "gpt-4o-mini",
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-expect-error
+        messages: messagesForLLM.map(msg => ({
+          role: msg.role === 'user' ? 'user' : 'assistant',
+          content: typeof msg.content === 'object' && msg.content !== null ? [msg.content] : msg.content,
+          name: generateRandomId(),
+        })),
+        stream: true,
+      });
+
+      const assistantMessageId = Date.now() + 1;
+      const assistantMessage: Message = {
+        id: assistantMessageId.toString(),
+        content: '',
+        sender: 'assistant',
+        timestamp: new Date().toLocaleTimeString(),
+      };
+
+      setMessages((prev) => [...prev, assistantMessage]);
+
+      for await (const chunk of completion) {
+        const textPart = chunk.choices[0]?.delta?.content || '';
+        assistantMessage.content += textPart;
+        setThinking(false);
+
+        setMessages((prev) =>
+          prev.map((msg) =>
+            msg.id === assistantMessageId.toString()
+              ? { ...msg, content: assistantMessage.content }
+              : msg
+          )
+        );
+      }
+    } catch (error) {
+      console.error('Error in sendMessage:', error);
+      setMessages((prev) => [...prev, ERROR_MESSAGE]);
+    } finally {
+      setThinking(false);
+    }
+  };
+
+  return {
+    messages,
+    memories: memories || [],
+    thinking,
+    sendMessage,
+  };
+}; 

examples/multimodal-demo/src/hooks/useFileHandler.ts

@@ -0,0 +1,45 @@
+import { useState } from 'react';
+import { FileInfo } from '@/types';
+import { convertToBase64, getFileBuffer } from '@/utils/fileUtils';
+
+interface UseFileHandlerReturn {
+  selectedFile: FileInfo | null;
+  file: File | null;
+  fileData: string | Buffer | null;
+  setSelectedFile: (file: FileInfo | null) => void;
+  handleFile: (file: File) => Promise<void>;
+  clearFile: () => void;
+}
+
+export const useFileHandler = (): UseFileHandlerReturn => {
+  const [selectedFile, setSelectedFile] = useState<FileInfo | null>(null);
+  const [file, setFile] = useState<File | null>(null);
+  const [fileData, setFileData] = useState<string | Buffer | null>(null);
+
+  const handleFile = async (file: File) => {
+    setFile(file);
+    
+    if (file.type.startsWith('image/')) {
+      const base64Data = await convertToBase64(file);
+      setFileData(base64Data);
+    } else if (file.type.startsWith('audio/')) {
+      const bufferData = await getFileBuffer(file);
+      setFileData(bufferData);
+    }
+  };
+
+  const clearFile = () => {
+    setSelectedFile(null);
+    setFile(null);
+    setFileData(null);
+  };
+
+  return {
+    selectedFile,
+    file,
+    fileData,
+    setSelectedFile,
+    handleFile,
+    clearFile,
+  };
+}; 

examples/multimodal-demo/src/index.css

@@ -0,0 +1,97 @@
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+@layer base {
+  :root {
+    --background: 0 0% 100%;
+    --foreground: 240 10% 3.9%;
+    --card: 0 0% 100%;
+    --card-foreground: 240 10% 3.9%;
+    --popover: 0 0% 100%;
+    --popover-foreground: 240 10% 3.9%;
+    --primary: 240 5.9% 10%;
+    --primary-foreground: 0 0% 98%;
+    --secondary: 240 4.8% 95.9%;
+    --secondary-foreground: 240 5.9% 10%;
+    --muted: 240 4.8% 95.9%;
+    --muted-foreground: 240 3.8% 46.1%;
+    --accent: 240 4.8% 95.9%;
+    --accent-foreground: 240 5.9% 10%;
+    --destructive: 0 84.2% 60.2%;
+    --destructive-foreground: 0 0% 98%;
+    --border: 240 5.9% 90%;
+    --input: 240 5.9% 90%;
+    --ring: 240 10% 3.9%;
+    --chart-1: 12 76% 61%;
+    --chart-2: 173 58% 39%;
+    --chart-3: 197 37% 24%;
+    --chart-4: 43 74% 66%;
+    --chart-5: 27 87% 67%;
+    --radius: 0.5rem
+  }
+  .dark {
+    --background: 240 10% 3.9%;
+    --foreground: 0 0% 98%;
+    --card: 240 10% 3.9%;
+    --card-foreground: 0 0% 98%;
+    --popover: 240 10% 3.9%;
+    --popover-foreground: 0 0% 98%;
+    --primary: 0 0% 98%;
+    --primary-foreground: 240 5.9% 10%;
+    --secondary: 240 3.7% 15.9%;
+    --secondary-foreground: 0 0% 98%;
+    --muted: 240 3.7% 15.9%;
+    --muted-foreground: 240 5% 64.9%;
+    --accent: 240 3.7% 15.9%;
+    --accent-foreground: 0 0% 98%;
+    --destructive: 0 62.8% 30.6%;
+    --destructive-foreground: 0 0% 98%;
+    --border: 240 3.7% 15.9%;
+    --input: 240 3.7% 15.9%;
+    --ring: 240 4.9% 83.9%;
+    --chart-1: 220 70% 50%;
+    --chart-2: 160 60% 45%;
+    --chart-3: 30 80% 55%;
+    --chart-4: 280 65% 60%;
+    --chart-5: 340 75% 55%
+  }
+}
+@layer base {
+  * {
+    @apply border-border;
+  }
+  body {
+    @apply bg-background text-foreground;
+  }
+}
+
+.loader {
+  display: flex;
+  align-items: flex-end;
+  gap: 5px;
+}
+
+.ball {
+  width: 6px;
+  height: 6px;
+  background-color: #4e4e4e;
+  border-radius: 50%;
+  animation: bounce 0.6s infinite alternate;
+}
+
+.ball:nth-child(2) {
+  animation-delay: 0.2s;
+}
+
+.ball:nth-child(3) {
+  animation-delay: 0.4s;
+}
+
+@keyframes bounce {
+  from {
+    transform: translateY(0);
+  }
+  to {
+    transform: translateY(-4px);
+  }
+}

examples/multimodal-demo/src/libs/utils.ts

@@ -0,0 +1,6 @@
+import { clsx, type ClassValue } from "clsx"
+import { twMerge } from "tailwind-merge"
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs))
+}

examples/multimodal-demo/src/main.tsx

@@ -0,0 +1,10 @@
+import { StrictMode } from 'react'
+import { createRoot } from 'react-dom/client'
+import './index.css'
+import App from './App.tsx'
+
+createRoot(document.getElementById('root')!).render(
+  <StrictMode>
+    <App />
+  </StrictMode>,
+)

examples/multimodal-demo/src/page.tsx

@@ -0,0 +1,14 @@
+"use client";
+import { GlobalState } from "./contexts/GlobalContext";
+import Component from "./pages/home";
+
+
+export default function Home() {
+  return (
+    <div>
+      <GlobalState>
+        <Component />
+      </GlobalState>
+    </div>
+  );
+}

examples/multimodal-demo/src/pages/home.tsx

@@ -0,0 +1,41 @@
+import { useState } from "react";
+import ApiSettingsPopup from "../components/api-settings-popup";
+import Memories from "../components/memories";
+import Header from "../components/header";
+import Messages from "../components/messages";
+import InputArea from "../components/input-area";
+import ChevronToggle from "../components/chevron-toggle";
+
+
+export default function Home() {
+  const [isMemoriesExpanded, setIsMemoriesExpanded] = useState(true);
+  const [isSettingsOpen, setIsSettingsOpen] = useState(false);
+
+  return (
+    <>
+      <ApiSettingsPopup isOpen={isSettingsOpen} setIsOpen={setIsSettingsOpen} />
+      <div className="flex h-screen bg-background">
+        {/* Main Chat Area */}
+        <div className="flex-1 flex flex-col">
+          {/* Header */}
+          <Header setIsSettingsOpen={setIsSettingsOpen} />
+
+          {/* Messages */}
+          <Messages />
+
+          {/* Input Area */}
+          <InputArea />
+        </div>
+
+        {/* Chevron Toggle */}
+        <ChevronToggle
+          isMemoriesExpanded={isMemoriesExpanded}
+          setIsMemoriesExpanded={setIsMemoriesExpanded}
+        />
+
+        {/* Memories Sidebar */}
+        <Memories isMemoriesExpanded={isMemoriesExpanded} />
+      </div>
+    </>
+  );
+}

examples/multimodal-demo/src/types.ts

@@ -0,0 +1,22 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export interface Memory {
+  id: string;
+  content: string;
+  timestamp: string;
+  tags: string[];
+}
+
+export interface Message {
+  id: string;
+  content: string;
+  sender: "user" | "assistant";
+  timestamp: string;
+  image?: string;
+  audio?: any;
+}
+
+export interface FileInfo {
+  name: string;
+  type: string;
+  size: number;
+}

examples/multimodal-demo/src/utils/fileUtils.ts

@@ -0,0 +1,16 @@
+import { Buffer } from 'buffer';
+
+export const convertToBase64 = (file: File): Promise<string> => {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.readAsDataURL(file);
+    reader.onload = () => resolve(reader.result as string);
+    reader.onerror = error => reject(error);
+  });
+};
+
+export const getFileBuffer = async (file: File): Promise<Buffer> => {
+  const response = await fetch(URL.createObjectURL(file));
+  const arrayBuffer = await response.arrayBuffer();
+  return Buffer.from(arrayBuffer);
+}; 

examples/multimodal-demo/src/vite-env.d.ts

@@ -0,0 +1 @@
+/// <reference types="vite/client" />

examples/multimodal-demo/tailwind.config.js

@@ -0,0 +1,62 @@
+// tailwind.config.js
+/* eslint-env node */
+
+/** @type {import('tailwindcss').Config} */
+import tailwindcssAnimate from 'tailwindcss-animate';
+
+export default {
+  darkMode: ["class"],
+  content: ["./index.html", "./src/**/*.{ts,tsx,js,jsx}"],
+  theme: {
+    extend: {
+      borderRadius: {
+        lg: 'var(--radius)',
+        md: 'calc(var(--radius) - 2px)',
+        sm: 'calc(var(--radius) - 4px)',
+      },
+      colors: {
+        background: 'hsl(var(--background))',
+        foreground: 'hsl(var(--foreground))',
+        card: {
+          DEFAULT: 'hsl(var(--card))',
+          foreground: 'hsl(var(--card-foreground))',
+        },
+        popover: {
+          DEFAULT: 'hsl(var(--popover))',
+          foreground: 'hsl(var(--popover-foreground))',
+        },
+        primary: {
+          DEFAULT: 'hsl(var(--primary))',
+          foreground: 'hsl(var(--primary-foreground))',
+        },
+        secondary: {
+          DEFAULT: 'hsl(var(--secondary))',
+          foreground: 'hsl(var(--secondary-foreground))',
+        },
+        muted: {
+          DEFAULT: 'hsl(var(--muted))',
+          foreground: 'hsl(var(--muted-foreground))',
+        },
+        accent: {
+          DEFAULT: 'hsl(var(--accent))',
+          foreground: 'hsl(var(--accent-foreground))',
+        },
+        destructive: {
+          DEFAULT: 'hsl(var(--destructive))',
+          foreground: 'hsl(var(--destructive-foreground))',
+        },
+        border: 'hsl(var(--border))',
+        input: 'hsl(var(--input))',
+        ring: 'hsl(var(--ring))',
+        chart: {
+          '1': 'hsl(var(--chart-1))',
+          '2': 'hsl(var(--chart-2))',
+          '3': 'hsl(var(--chart-3))',
+          '4': 'hsl(var(--chart-4))',
+          '5': 'hsl(var(--chart-5))',
+        },
+      },
+    },
+  },
+  plugins: [tailwindcssAnimate],
+};

examples/multimodal-demo/tsconfig.app.json

@@ -0,0 +1,32 @@
+{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
+    "target": "ES2020",
+    "useDefineForClassFields": true,
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+    "baseUrl": ".",
+    "paths": {
+      "@/*": [
+        "./src/*"
+      ]
+    },
+
+    /* Bundler mode */
+    "moduleResolution": "Bundler",
+    "allowImportingTsExtensions": true,
+    "isolatedModules": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+    "jsx": "react-jsx",
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true
+  },
+  "include": ["src"]
+}

examples/multimodal-demo/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "files": [],
+  "references": [
+    { "path": "./tsconfig.app.json" },
+    { "path": "./tsconfig.node.json" }
+  ],
+  "compilerOptions": {
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  }
+}

examples/multimodal-demo/tsconfig.node.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
+    "target": "ES2022",
+    "lib": ["ES2023"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "Bundler",
+    "allowImportingTsExtensions": true,
+    "isolatedModules": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true
+  },
+  "include": ["vite.config.ts"]
+}

examples/multimodal-demo/useChat.ts

@@ -0,0 +1,223 @@
+import { useState } from 'react';
+import { MemoryClient, Memory as Mem0Memory } from 'mem0ai';
+import { OpenAI } from 'openai';
+import { Message, Memory } from '@/types';
+import { WELCOME_MESSAGE, INVALID_CONFIG_MESSAGE, ERROR_MESSAGE, Provider } from '@/constants/messages';
+
+interface UseChatProps {
+  user: string;
+  mem0ApiKey: string;
+  openaiApiKey: string;
+  provider: Provider;
+}
+
+interface UseChatReturn {
+  messages: Message[];
+  memories: Memory[];
+  thinking: boolean;
+  sendMessage: (content: string, fileData?: { type: string; data: string | Buffer }) => Promise<void>;
+}
+
+type MessageContent = string | {
+  type: 'image_url';
+  image_url: {
+    url: string;
+  };
+};
+
+interface PromptMessage {
+  role: string;
+  content: MessageContent;
+}
+
+export const useChat = ({ user, mem0ApiKey, openaiApiKey }: UseChatProps): UseChatReturn => {
+  const [messages, setMessages] = useState<Message[]>([WELCOME_MESSAGE]);
+  const [memories, setMemories] = useState<Memory[]>();
+  const [thinking, setThinking] = useState(false);
+
+  const openai = new OpenAI({ apiKey: openaiApiKey, dangerouslyAllowBrowser: true});
+  
+  const updateMemories = async (messages: PromptMessage[]) => {
+    const memoryClient = new MemoryClient({ apiKey: mem0ApiKey || '' });
+    try {
+      await memoryClient.add(messages, {
+        user_id: user,
+      });
+
+      const response = await memoryClient.getAll({
+        user_id: user,
+      });
+
+      const newMemories = response.map((memory: Mem0Memory) => ({
+        id: memory.id || '',
+        content: memory.memory || '',
+        timestamp: String(memory.updated_at) || '',
+        tags: memory.categories || [],
+      }));
+      setMemories(newMemories);
+    } catch (error) {
+      console.error('Error in updateMemories:', error);
+    }
+  };
+
+  const formatMessagesForPrompt = (messages: Message[]): PromptMessage[] => {
+    return messages.map((message) => {
+      if (message.image) {
+        return {
+          role: message.sender,
+          content: {
+            type: 'image_url',
+            image_url: {
+              url: message.image
+            }
+          },
+        };
+      }
+
+      return {
+        role: message.sender,
+        content: message.content,
+      };
+    });
+  };
+
+  const sendMessage = async (content: string, fileData?: { type: string; data: string | Buffer }) => {
+    if (!content.trim() && !fileData) return;
+
+    const memoryClient = new MemoryClient({ apiKey: mem0ApiKey || '' });
+
+    if (!user) {
+      const newMessage: Message = {
+        id: Date.now().toString(),
+        content,
+        sender: 'user',
+        timestamp: new Date().toLocaleTimeString(),
+      };
+      setMessages((prev) => [...prev, newMessage, INVALID_CONFIG_MESSAGE]);
+      return;
+    }
+
+    const userMessage: Message = {
+      id: Date.now().toString(),
+      content,
+      sender: 'user',
+      timestamp: new Date().toLocaleTimeString(),
+      ...(fileData?.type.startsWith('image/') && { image: fileData.data.toString() }),
+    };
+
+    setMessages((prev) => [...prev, userMessage]);
+    setThinking(true);
+
+    // Get all messages for memory update
+    const allMessagesForMemory = formatMessagesForPrompt([...messages, userMessage]);
+    await updateMemories(allMessagesForMemory);
+
+    try {
+      // Get only the last assistant message (if exists) and the current user message
+      const lastAssistantMessage = messages.filter(msg => msg.sender === 'assistant').slice(-1)[0];
+      let messagesForLLM = lastAssistantMessage 
+        ? [
+            formatMessagesForPrompt([lastAssistantMessage])[0],
+            formatMessagesForPrompt([userMessage])[0]
+          ]
+        : [formatMessagesForPrompt([userMessage])[0]];
+
+      // Check if any message has image content
+      const hasImage = messagesForLLM.some(msg => {
+        if (typeof msg.content === 'object' && msg.content !== null) {
+          const content = msg.content as MessageContent;
+          return typeof content === 'object' && content !== null && 'type' in content && content.type === 'image_url';
+        }
+        return false;
+      });
+
+      // For image messages, only use the text content
+      if (hasImage) {
+        messagesForLLM = [
+          ...messagesForLLM,
+          {
+            role: 'user',
+            content: userMessage.content
+          }
+        ];
+      }
+
+      // Fetch relevant memories if there's an image
+      let relevantMemories = '';
+        try {
+          const searchResponse = await memoryClient.getAll({
+            user_id: user
+          });
+
+          relevantMemories = searchResponse
+            .map((memory: Mem0Memory) => `Previous context: ${memory.memory}`)
+            .join('\n');
+        } catch (error) {
+          console.error('Error fetching memories:', error);
+        }
+
+      // Add a system message with memories context if there are memories and image
+      if (relevantMemories.length > 0 && hasImage) {
+        messagesForLLM = [
+          {
+            role: 'system',
+            content: `Here are some relevant details about the user:\n${relevantMemories}\n\nPlease use this context when responding to the user's message.`
+          },
+          ...messagesForLLM
+        ];
+      }
+
+      const generateRandomId = () => {
+        return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
+      }
+
+      const completion = await openai.chat.completions.create({
+        model: "gpt-4o-mini",
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-expect-error
+        messages: messagesForLLM.map(msg => ({
+          role: msg.role === 'user' ? 'user' : 'assistant',
+          content: typeof msg.content === 'object' && msg.content !== null ? [msg.content] : msg.content,
+          name: generateRandomId(),
+        })),
+        stream: true,
+      });
+
+      const assistantMessageId = Date.now() + 1;
+      const assistantMessage: Message = {
+        id: assistantMessageId.toString(),
+        content: '',
+        sender: 'assistant',
+        timestamp: new Date().toLocaleTimeString(),
+      };
+
+      setMessages((prev) => [...prev, assistantMessage]);
+
+      for await (const chunk of completion) {
+        const textPart = chunk.choices[0]?.delta?.content || '';
+        assistantMessage.content += textPart;
+        setThinking(false);
+
+        setMessages((prev) =>
+          prev.map((msg) =>
+            msg.id === assistantMessageId.toString()
+              ? { ...msg, content: assistantMessage.content }
+              : msg
+          )
+        );
+      }
+    } catch (error) {
+      console.error('Error in sendMessage:', error);
+      setMessages((prev) => [...prev, ERROR_MESSAGE]);
+    } finally {
+      setThinking(false);
+    }
+  };
+
+  return {
+    messages,
+    memories: memories || [],
+    thinking,
+    sendMessage,
+  };
+};