version bump -> 0.1.67 (#2357)

Co-authored-by: Deshraj Yadav <deshrajdry@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/

.github/workflows/ci.yml

@@ -52,7 +52,7 @@ jobs:
           virtualenvs-in-project: true
       - name: Load cached venv
         id: cached-poetry-dependencies
-        uses: actions/cache@v2
+        uses: actions/cache@v3
         with:
           path: .venv
           key: venv-mem0-${{ runner.os }}-${{ hashFiles('**/poetry.lock') }}
@@ -83,7 +83,7 @@ jobs:
           virtualenvs-in-project: true
       - name: Load cached venv
         id: cached-poetry-dependencies
-        uses: actions/cache@v2
+        uses: actions/cache@v3
         with:
           path: .venv
           key: venv-embedchain-${{ runner.os }}-${{ hashFiles('**/poetry.lock') }}

.gitignore

@@ -2,6 +2,7 @@
 __pycache__/
 *.py[cod]
 *$py.class
+**/node_modules/
 
 # C extensions
 *.so

Makefile

@@ -13,7 +13,7 @@ install:
 install_all:
 	poetry install
 	poetry run pip install groq together boto3 litellm ollama chromadb sentence_transformers vertexai \
-	                        google-generativeai elasticsearch
+	                        google-generativeai elasticsearch opensearch-py vecs
 
 # 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>
 
@@ -45,50 +47,25 @@
 
 [Mem0](https://mem0.ai) (pronounced as "mem-zero") enhances AI assistants and agents with an intelligent memory layer, enabling personalized AI interactions. Mem0 remembers user preferences, adapts to individual needs, and continuously improves over time, making it ideal for customer support chatbots, AI assistants, and autonomous systems.
 
-<!-- Start of Selection -->
-<p style="display: flex;">
-  <span style="font-size: 1.2em;">New Feature: Introducing Graph Memory. Check out our <a href="https://docs.mem0.ai/open-source/graph-memory" target="_blank">documentation</a>.</span>
-</p>
-<!-- End of Selection -->
+### Features & Use Cases
 
+Core Capabilities:
+- **Multi-Level Memory**: User, Session, and AI Agent memory retention with adaptive personalization
+- **Developer-Friendly**: Simple API integration, cross-platform consistency, and hassle-free managed service
 
-### Core Features
-
-- **Multi-Level Memory**: User, Session, and AI Agent memory retention
-- **Adaptive Personalization**: Continuous improvement based on interactions
-- **Developer-Friendly API**: Simple integration into various applications
-- **Cross-Platform Consistency**: Uniform behavior across devices
-- **Managed Service**: Hassle-free hosted solution
-
-### How Mem0 works?
-
-Mem0 leverages a hybrid database approach to manage and retrieve long-term memories for AI agents and assistants. Each memory is associated with a unique identifier, such as a user ID or agent ID, allowing Mem0 to organize and access memories specific to an individual or context.
-
-When a message is added to the Mem0 using add()  method, the system extracts relevant facts and preferences and stores it across data stores: a vector database, a key-value database, and a graph database. This hybrid approach ensures that different types of information are stored in the most efficient manner, making subsequent searches quick and effective.
-
-When an AI agent or LLM needs to recall memories, it uses the search() method. Mem0 then performs search across these data stores, retrieving relevant information from each source. This information is then passed through a scoring layer, which evaluates their importance based on relevance, importance, and recency. This ensures that only the most personalized and useful context is surfaced.
-
-The retrieved memories can then be appended to the LLM's prompt as needed, enhancing the personalization and relevance of its responses.
-
-### Use Cases
-
-Mem0 empowers organizations and individuals to enhance:
-
-- **AI Assistants and agents**: Seamless conversations with a touch of déjà vu
-- **Personalized Learning**: Tailored content recommendations and progress tracking
-- **Customer Support**: Context-aware assistance with user preference memory
-- **Healthcare**: Patient history and treatment plan management
-- **Virtual Companions**: Deeper user relationships through conversation memory
-- **Productivity**: Streamlined workflows based on user habits and task history
-- **Gaming**: Adaptive environments reflecting player choices and progress
+Applications:
+- **AI Assistants**: Seamless conversations with context and personalization
+- **Learning & Support**: Tailored content recommendations and context-aware customer assistance
+- **Healthcare & Companions**: Patient history tracking and deeper relationship building
+- **Productivity & Gaming**: Streamlined workflows and adaptive environments based on user behavior
 
 ## Get Started
 
-The easiest way to set up Mem0 is through the managed [Mem0 Platform](https://app.mem0.ai). This hosted solution offers automatic updates, advanced analytics, and dedicated support. [Sign up](https://app.mem0.ai) to get started.
+Get started quickly with [Mem0 Platform](https://app.mem0.ai) - our fully managed solution that provides automatic updates, advanced analytics, enterprise security, and dedicated support. [Create a free account](https://app.mem0.ai) to begin.
 
-If you prefer to self-host, use the open-source Mem0 package. Follow the [installation instructions](#install) to get started.
+For complete control, you can self-host Mem0 using our open-source package. See the [Quickstart guide](#quickstart) below to set up your own instance.
 
-## Installation Instructions <a name="install"></a>
+## Quickstart Guide <a name="quickstart"></a>
 
 Install the Mem0 package via pip:
 
@@ -96,110 +73,108 @@ Install the Mem0 package via pip:
 pip install mem0ai
 ```
 
-Alternatively, you can use Mem0 with one click on the hosted platform [here](https://app.mem0.ai/).
+Install the Mem0 package via npm:
+
+```bash
+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:
 
 ```python
+from openai import OpenAI
 from mem0 import Memory
 
-m = Memory()
+openai_client = OpenAI()
+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["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}"
+    messages = [{"role": "system", "content": system_prompt}, {"role": "user", "content": message}]
+    response = openai_client.chat.completions.create(model="gpt-4o-mini", messages=messages)
+    assistant_response = response.choices[0].message.content
+
+    # Create new memories from the conversation
+    messages.append({"role": "assistant", "content": assistant_response})
+    memory.add(messages, user_id=user_id)
+
+    return assistant_response
+
+def main():
+    print("Chat with AI (type 'exit' to quit)")
+    while True:
+        user_input = input("You: ").strip()
+        if user_input.lower() == 'exit':
+            print("Goodbye!")
+            break
+        print(f"AI: {chat_with_memories(user_input)}")
+
+if __name__ == "__main__":
+    main()
 ```
 
-<details>
-<summary>How to set OPENAI_API_KEY</summary>
+See the example for [Node.js](https://docs.mem0.ai/examples/ai_companion_js).
 
-```python
-import os
-os.environ["OPENAI_API_KEY"] = "sk-xxx"
-```
-</details>
-
-
-You can perform the following task on the memory:
-
-1. Add: Store a memory from any unstructured text
-2. Update: Update memory of a given memory_id
-3. Search: Fetch memories based on a query
-4. Get: Return memories for a certain user/agent/session
-5. History: Describe how a memory has changed over time for a specific memory ID
-
-```python
-# 1. Add: Store a memory from any unstructured text
-result = m.add("I am working on improving my tennis skills. Suggest some online courses.", user_id="alice", metadata={"category": "hobbies"})
-
-# Created memory --> 'Improving her tennis skills.' and 'Looking for online suggestions.'
-```
-
-```python
-# 2. Update: update the memory
-result = m.update(memory_id=<memory_id_1>, data="Likes to play tennis on weekends")
-
-# Updated memory --> 'Likes to play tennis on weekends.' and 'Looking for online suggestions.'
-```
-
-```python
-# 3. Search: search related memories
-related_memories = m.search(query="What are Alice's hobbies?", user_id="alice")
-
-# Retrieved memory --> 'Likes to play tennis on weekends'
-```
-
-```python
-# 4. Get all memories
-all_memories = m.get_all()
-memory_id = all_memories["memories"][0] ["id"] # get a memory_id
-
-# All memory items --> 'Likes to play tennis on weekends.' and 'Looking for online suggestions.'
-```
-
-```python
-# 5. Get memory history for a particular memory_id
-history = m.history(memory_id=<memory_id_1>)
-
-# Logs corresponding to memory_id_1 --> {'prev_value': 'Working on improving tennis skills and interested in online courses for tennis.', 'new_value': 'Likes to play tennis on weekends' }
-```
+For more advanced usage and API documentation, visit our [documentation](https://docs.mem0.ai).
 
 > [!TIP]
-> If you prefer a hosted version without the need to set up infrastructure yourself, check out the [Mem0 Platform](https://app.mem0.ai/) to get started in minutes.
+> For a hassle-free experience, try our [hosted platform](https://app.mem0.ai) with automatic updates and enterprise features.
+
+## Demos
+
+- Mem0 - ChatGPT with Memory: A personalized AI chat app powered by Mem0 that remembers your preferences, facts, and memories.
+
+[Mem0 - ChatGPT with Memory](https://github.com/user-attachments/assets/cebc4f8e-bdb9-4837-868d-13c5ab7bb433)
+
+Try live [demo](https://mem0.dev/demo/)
+
+<br/><br/>
+
+- AI Companion: Experience personalized conversations with an AI that remembers your preferences and past interactions
+
+[AI Companion Demo](https://github.com/user-attachments/assets/3fc72023-a72c-4593-8be0-3cee3ba744da)
+
+<br/><br/>
+
+- Enhance your AI interactions by storing memories across ChatGPT, Perplexity, and Claude using our browser extension. Get [chrome extension](https://chromewebstore.google.com/detail/mem0/onihkkbipkfeijkadecaafbgagkhglop?hl=en).
 
 
-### Graph Memory
-To initialize Graph Memory you'll need to set up your configuration with graph store providers.
-Currently, we support Neo4j as a graph store provider. You can setup [Neo4j](https://neo4j.com/) locally or use the hosted [Neo4j AuraDB](https://neo4j.com/product/auradb/). 
-Moreover, you also need to set the version to `v1.1` (*prior versions are not supported*). 
-Here's how you can do it:
+[Chrome Extension Demo](https://github.com/user-attachments/assets/ca92e40b-c453-4ff6-b25e-739fb18a8650)
 
-```python
-from mem0 import Memory
+<br/><br/>
 
-config = {
-    "graph_store": {
-        "provider": "neo4j",
-        "config": {
-            "url": "neo4j+s://xxx",
-            "username": "neo4j",
-            "password": "xxx"
-        }
-    },
-    "version": "v1.1"
-}
+- Customer support bot using <strong>Langgraph and Mem0</strong>. Get the complete code from [here](https://docs.mem0.ai/integrations/langgraph)
+
+
+[Langgraph: Customer Bot](https://github.com/user-attachments/assets/ca6b482e-7f46-42c8-aa08-f88d1d93a5f4)
+
+<br/><br/>
+
+- Use Mem0 with CrewAI to get personalized results. Full example [here](https://docs.mem0.ai/integrations/crewai)
+
+[CrewAI Demo](https://github.com/user-attachments/assets/69172a79-ccb9-4340-91f1-caa7d2dd4213)
 
-m = Memory.from_config(config_dict=config)
 
-```
 
 ## Documentation
 
-For detailed usage instructions and API reference, visit our documentation at [docs.mem0.ai](https://docs.mem0.ai). Here, you can find more information on both the open-source version and the hosted [Mem0 Platform](https://app.mem0.ai).
-
-## Star History
-
-[![Star History Chart](https://api.star-history.com/svg?repos=mem0ai/mem0&type=Date)](https://star-history.com/#mem0ai/mem0&Date)
+For detailed usage instructions and API reference, visit our [documentation](https://docs.mem0.ai). You'll find:
+- Complete API reference
+- Integration guides
+- Advanced configuration options
+- Best practices and examples
+- More details about:
+  - Open-source version
+  - [Hosted Mem0 Platform](https://app.mem0.ai)
 
 ## Support
 
@@ -209,20 +184,6 @@ Join our community for support and discussions. If you have any questions, feel
 - [Follow us on Twitter](https://x.com/mem0ai)
 - [Email founders](mailto:founders@mem0.ai)
 
-## Contributors
-
-Join our [Discord community](https://mem0.dev/DiG) to learn about memory management for AI agents and LLMs, and connect with Mem0 users and contributors. Share your ideas, questions, or feedback in our [GitHub Issues](https://github.com/mem0ai/mem0/issues).
-
-We value and appreciate the contributions of our community. Special thanks to our contributors for helping us improve Mem0.
-
-<a href="https://github.com/mem0ai/mem0/graphs/contributors">
-  <img src="https://contrib.rocks/image?repo=mem0ai/mem0" />
-</a>
-
-## Anonymous Telemetry
-
-We collect anonymous usage metrics to enhance our package's quality and user experience. This includes data like feature usage frequency and system info, but never personal details. The data helps us prioritize improvements and ensure compatibility. If you wish to opt-out, set the environment variable MEM0_TELEMETRY=false. We prioritize data security and don't share this data externally.
-
 ## License
 
 This project is licensed under the Apache 2.0 License - see the [LICENSE](LICENSE) file for details.

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

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

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

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

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

@@ -1,74 +1,43 @@
 ---
-title: 'V2 Get Memories'
+title: 'Get Memories (v2)'
 openapi: post /v2/memories/
 ---
 
+The v2 get memories API is powerful and flexible, allowing for more precise memory listing without the need for a search query. It supports complex logical operations (AND, OR) and comparison operators for advanced filtering capabilities. The comparison operators include:
+- `in`: Matches any of the values specified
+- `gte`: Greater than or equal to
+- `lte`: Less than or equal to
+- `gt`: Greater than
+- `lt`: Less than
 
-Mem0 offers two versions of the get memories API: v1 and v2. Here's how they differ:
+<CodeGroup>
+```python Code
+memories = m.get_all(
+    filters={
+        "AND": [
+            {
+                "user_id": "alex"
+            },
+            {
+                "created_at": {"gte": "2024-07-01", "lte": "2024-07-31"}
+            }
+        ]
+    },
+    version="v2"
+)
+```
 
-<Tabs>
-  <Tab title="v1 Get Memories">
-    <CodeGroup>
-    ```python Code
-    memories = m.get_all(user_id="alex")
-    ```
-
-    ```json Output
-    [
-   {
-      "id":"f38b689d-6b24-45b7-bced-17fbb4d8bac7",
-      "memory":"travelling to Paris",
-      "user_id":"alex",
-      "hash":"62bc074f56d1f909f1b4c2b639f56f6a",
-      "metadata":null,
-      "created_at":"2023-02-25T23:57:00.108347-07:00",
-      "updated_at":"2024-07-25T23:57:00.108367-07:00"
-   }
+```json Output
+[
+{
+    "id":"f38b689d-6b24-45b7-bced-17fbb4d8bac7",
+    "memory":"Name: Alex. Vegetarian. Allergic to nuts.",
+    "user_id":"alex",
+    "hash":"62bc074f56d1f909f1b4c2b639f56f6a",
+    "metadata":null,
+    "created_at":"2024-07-25T23:57:00.108347-07:00",
+    "updated_at":"2024-07-25T23:57:00.108367-07:00"
+}
 ]
-    ```
-    </CodeGroup>
-  </Tab>
-
-  <Tab title="v2 Get Memories">
-    <CodeGroup>
-    ```python Code
-    memories = m.get_all(
-        filters={
-            "AND": [
-                {
-                    "user_id": "alex"
-                },
-                {
-                    "created_at": {
-                        "gte": "2024-07-01",
-                        "lte": "2024-07-31"
-                    }
-                }
-            ]
-        },
-        version="v2"
-    )
-    ```
-
-    ```json Output
-    [
-   {
-      "id":"f38b689d-6b24-45b7-bced-17fbb4d8bac7",
-      "memory":"Name: Alex. Vegetarian. Allergic to nuts.",
-      "user_id":"alex",
-      "hash":"62bc074f56d1f909f1b4c2b639f56f6a",
-      "metadata":null,
-      "created_at":"2024-07-25T23:57:00.108347-07:00",
-      "updated_at":"2024-07-25T23:57:00.108367-07:00"
-   }
-]
-    ```
-    </CodeGroup>
-  </Tab>
-</Tabs>
-
-Key difference between v1 and v2 get memories:
-
-• **Filters**: v2 allows you to apply filters to narrow down memory retrieval based on specific criteria. This includes support for complex logical operations (AND, OR) and comparison operators (IN, gte, lte, gt, lt, ne, icontains) for advanced filtering capabilities.
-
-The v2 get memories API is more powerful and flexible, allowing for more precise memory retrieval without the need for a search query.
+```
+</CodeGroup>

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

@@ -1,85 +1,51 @@
 ---
-title: 'V2 Search Memories'
+title: 'Search Memories (v2)'
 openapi: post /v2/memories/search/
 ---
 
-Mem0 offers two versions of the search API: v1 and v2. Here's how they differ:
+The v2 search API is powerful and flexible, allowing for more precise memory retrieval. It supports complex logical operations (AND, OR) and comparison operators for advanced filtering capabilities. The comparison operators include:
+- `in`: Matches any of the values specified
+- `gte`: Greater than or equal to
+- `lte`: Less than or equal to
+- `gt`: Greater than
+- `lt`: Less than
+- `ne`: Not equal to
+- `icontains`: Case-insensitive containment check
 
-<Tabs>
-  <Tab title="v1 Search">
-    <CodeGroup>
-    ```python Code
-    related_memories = m.search(query="What are Alice's hobbies?", user_id="alice")
-    ```
+  <CodeGroup>
+  ```python Code
+  related_memories = m.vsearch(
+      query="What are Alice's hobbies?",
+      version="v2",
+      filters={
+          "AND": [
+              {
+                "user_id": "alice"
+              },
+              {
+                "agent_id": {"in": ["travel-agent", "sports-agent"]}
+              }
+          ]
+      },
+  )
+  ```
 
-    ```json Output
-    [
-       {
-          "id":"ea925981-272f-40dd-b576-be64e4871429",
-          "memory":"Likes to play cricket and plays cricket on weekends.",
-          "hash":"c8809002-25c1-4c97-a3a2-227ce9c20c53",
-          "metadata":{
-             "category":"hobbies"
-          },
-          "score":0.32116443111457704,
-          "created_at":"2024-07-26T10:29:36.630547-07:00",
-          "updated_at":"None",
-          "user_id":"alice"
-       }
-    ]
-    ```
-    </CodeGroup>
-  </Tab>
-
-  <Tab title="v2 Search">
-    <CodeGroup>
-    ```python Code
-    related_memories = m.vsearch(
-        query="What are Alice's hobbies?",
-        filters={
-        "AND":[
-            {
-                "user_id":"alice"
-            },
-            {
-                "agent_id":{
-                    "in":[
-                    "travelling",
-                    "sports"
-                    ]
-                }
-            }
-        ]
-    },
-    version="v2"
-    )
-    ```
-
-    ```json Output
-    {
-      "memories": [
-        {
-          "id": "ea925981-272f-40dd-b576-be64e4871429",
-          "memory": "Likes to play cricket and plays cricket on weekends.",
-          "hash": "c8809002-25c1-4c97-a3a2-227ce9c20c53",
-          "metadata": {
-            "category": "hobbies"
-          },
-          "score": 0.32116443111457704,
-          "created_at": "2024-07-26T10:29:36.630547-07:00",
-          "updated_at": null,
-          "user_id": "alice",
-          "agent_id": "sports"
-        }
-      ],
-    }
-    ```
-    </CodeGroup>
-  </Tab>
-</Tabs>
-
-Key difference between v1 and v2 search:
-
-• **Filters**: v2 allows you to apply filters to narrow down search results based on specific criteria. This includes support for complex logical operations (AND, OR) and comparison operators (IN, gte, lte, gt, lt, ne, icontains) for advanced filtering capabilities.
-
-The v2 search API is more powerful and flexible, allowing for more precise memory retrieval.
+  ```json Output
+  {
+    "memories": [
+      {
+        "id": "ea925981-272f-40dd-b576-be64e4871429",
+        "memory": "Likes to play cricket and plays cricket on weekends.",
+        "metadata": {
+          "category": "hobbies"
+        },
+        "score": 0.32116443111457704,
+        "created_at": "2024-07-26T10:29:36.630547-07:00",
+        "updated_at": null,
+        "user_id": "alice",
+        "agent_id": "sports-agent"
+      }
+    ],
+  }
+  ```
+  </CodeGroup>

docs/api-reference/overview.mdx

@@ -1,4 +1,8 @@
-# Mem0 API Overview
+---
+title: Overview
+icon: "info"
+iconType: "solid"
+---
 
 Mem0 provides a powerful set of APIs that allow you to integrate advanced memory management capabilities into your applications. Our APIs are designed to be intuitive, efficient, and scalable, enabling you to create, retrieve, update, and delete memories across various entities such as users, agents, apps, and runs.
 
@@ -34,30 +38,26 @@ Organizations and projects provide the following capabilities:
 
 Example with the mem0 Python package:
 
+<Tabs>
+  <Tab title="Python">
+
 ```python
 from mem0 import MemoryClient
-
-# Recommended: Using organization and project IDs
-client = MemoryClient(
-    org_id='YOUR_ORG_ID', # It can be found on the organization settings page in dashboard
-    project_id='YOUR_PROJECT_ID',
-)
+client = MemoryClient(org_id='YOUR_ORG_ID', project_id='YOUR_PROJECT_ID')
 ```
-> **Note**: The use of `organization` and `project` parameters is deprecated and will be removed in version `0.1.40`. Please use `org_id` and `project_id` instead.
 
+  </Tab>
 
-Example with the mem0 Node.js package:
+  <Tab title="Node.js">
 
 ```javascript
 import { MemoryClient } from "mem0ai";
-
-# Recommended: Using organization and project IDs
-const client = new MemoryClient({
-    organizationId: "YOUR_ORG_ID",
-    projectId: "YOUR_PROJECT_ID"
-});
+const client = new MemoryClient({organizationId: "YOUR_ORG_ID", projectId: "YOUR_PROJECT_ID"});
 ```
 
+  </Tab>
+</Tabs>
+
 ## Getting Started
 
 To begin using the Mem0 API, you'll need to:

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

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

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

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

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

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

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

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

docs/components/embedders/config.mdx

@@ -1,19 +1,25 @@
-## What is Config?
+---
+title: Configurations
+icon: "gear"
+iconType: "solid"
+---
 
 Config in mem0 is a dictionary that specifies the settings for your embedding models. It allows you to customize the behavior and connection details of your chosen embedder.
 
-## How to Define Config
+## How to define configurations?
 
-The config is defined as a Python dictionary with two main keys:
+The config is defined as an object (or dictionary) with two main keys:
 - `embedder`: Specifies the embedder provider and its configuration
   - `provider`: The name of the embedder (e.g., "openai", "ollama")
-  - `config`: A nested dictionary containing provider-specific settings
+  - `config`: A nested object or dictionary containing provider-specific settings
 
-## How to Use Config
+
+## How to use configurations?
 
 Here's a general example of how to use the config with mem0:
 
-```python
+<CodeGroup>
+```python Python
 import os
 from mem0 import Memory
 
@@ -32,6 +38,25 @@ m = Memory.from_config(config)
 m.add("Your text here", user_id="user", metadata={"category": "example"})
 ```
 
+```typescript TypeScript
+import { Memory } from 'mem0ai/oss';
+
+const config = {
+  embedder: {
+    provider: 'openai',
+    config: {
+      apiKey: process.env.OPENAI_API_KEY || '',
+      model: 'text-embedding-3-small',
+      // Provider-specific settings go here
+    },
+  },
+};
+
+const memory = new Memory(config);
+await memory.add("Your text here", { userId: "user", metadata: { category: "example" } });
+```
+</CodeGroup>
+
 ## Why is Config Needed?
 
 Config is essential for:
@@ -43,18 +68,31 @@ Config is essential for:
 
 Here's a comprehensive list of all parameters that can be used across different embedders:
 
-| Parameter | Description |
-|-----------|-------------|
-| `model` | Embedding model to use |
-| `api_key` | API key of the provider |
-| `embedding_dims` | Dimensions of the embedding model |
-| `http_client_proxies` | Allow proxy server settings |
-| `ollama_base_url` | Base URL for the Ollama embedding model |
-| `model_kwargs` | Key-Value arguments for the Huggingface embedding model |
-| `azure_kwargs` | Key-Value arguments for the AzureOpenAI embedding model |
+<Tabs>
+<Tab title="Python">
+| Parameter | Description | Provider |
+|-----------|-------------|----------|
+| `model` | Embedding model to use | All |
+| `api_key` | API key of the provider | All |
+| `embedding_dims` | Dimensions of the embedding model | All |
+| `http_client_proxies` | Allow proxy server settings | All |
+| `ollama_base_url` | Base URL for the Ollama embedding model | Ollama |
+| `model_kwargs` | Key-Value arguments for the Huggingface embedding model | Huggingface |
+| `azure_kwargs` | Key-Value arguments for the AzureOpenAI embedding model | Azure OpenAI |
 | `openai_base_url`    | Base URL for OpenAI API                       | OpenAI            |
-| `vertex_credentials_json` | Path to the Google Cloud credentials JSON file for VertexAI |
-
+| `vertex_credentials_json` | Path to the Google Cloud credentials JSON file for VertexAI                       | VertexAI            |
+| `memory_add_embedding_type` | The type of embedding to use for the add memory action                       | VertexAI            |
+| `memory_update_embedding_type` | The type of embedding to use for the update memory action                       | VertexAI            |
+| `memory_search_embedding_type` | The type of embedding to use for the search memory action                       | VertexAI            |
+</Tab>
+<Tab title="TypeScript">
+| Parameter | Description | Provider |
+|-----------|-------------|----------|
+| `model` | Embedding model to use | All |
+| `apiKey` | API key of the provider | All |
+| `embeddingDims` | Dimensions of the embedding model | All |
+</Tab>
+</Tabs>
 
 ## Supported Embedding Models
 

docs/components/embedders/models/azure_openai.mdx

@@ -37,7 +37,13 @@ config = {
 }
 
 m = Memory.from_config(config)
-m.add("I'm visiting Paris", user_id="john")
+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="john")
 ```
 
 ### Config

docs/components/embedders/models/gemini.mdx

@@ -23,7 +23,13 @@ config = {
 }
 
 m = Memory.from_config(config)
-m.add("I'm visiting Paris", user_id="john")
+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="john")
 ```
 
 ### Config

docs/components/embedders/models/huggingface.mdx

@@ -22,7 +22,13 @@ config = {
 }
 
 m = Memory.from_config(config)
-m.add("I'm visiting Paris", user_id="john")
+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="john")
 ```
 
 ### Config

docs/components/embedders/models/ollama.mdx

@@ -18,7 +18,13 @@ config = {
 }
 
 m = Memory.from_config(config)
-m.add("I'm visiting Paris", user_id="john")
+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="john")
 ```
 
 ### Config

docs/components/embedders/models/openai.mdx

@@ -6,7 +6,8 @@ To use OpenAI embedding models, set the `OPENAI_API_KEY` environment variable. Y
 
 ### Usage
 
-```python
+<CodeGroup>
+```python Python
 import os
 from mem0 import Memory
 
@@ -22,15 +23,50 @@ config = {
 }
 
 m = Memory.from_config(config)
-m.add("I'm visiting Paris", user_id="john")
+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="john")
 ```
 
+```typescript TypeScript
+import { Memory } from 'mem0ai/oss';
+
+const config = {
+  embedder: {
+    provider: 'openai',
+    config: {
+      apiKey: 'your-openai-api-key',
+      model: 'text-embedding-3-large',
+    },
+  },
+};
+
+const memory = new Memory(config);
+await memory.add("I'm visiting Paris", { userId: "john" });
+```
+</CodeGroup>
+
 ### Config
 
 Here are the parameters available for configuring OpenAI embedder:
 
+<Tabs>
+<Tab title="Python">
 | Parameter | Description | Default Value |
 | --- | --- | --- |
 | `model` | The name of the embedding model to use | `text-embedding-3-small` |
 | `embedding_dims` | Dimensions of the embedding model | `1536` |
 | `api_key` | The OpenAI API key | `None` |
+</Tab>
+<Tab title="TypeScript">
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `model` | The name of the embedding model to use | `text-embedding-3-small` |
+| `embeddingDims` | Dimensions of the embedding model | `1536` |
+| `apiKey` | The OpenAI API key | `None` |
+</Tab>
+</Tabs>

docs/components/embedders/models/together.mdx

@@ -25,7 +25,13 @@ config = {
 }
 
 m = Memory.from_config(config)
-m.add("I'm visiting Paris", user_id="john")
+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="john")
 ```
 
 ### Config

docs/components/embedders/models/vertexai.mdx

@@ -16,15 +16,31 @@ config = {
     "embedder": {
         "provider": "vertexai",
         "config": {
-            "model": "text-embedding-004"
+            "model": "text-embedding-004",
+            "memory_add_embedding_type": "RETRIEVAL_DOCUMENT",
+            "memory_update_embedding_type": "RETRIEVAL_DOCUMENT",
+            "memory_search_embedding_type": "RETRIEVAL_QUERY"
         }
     }
 }
 
 m = Memory.from_config(config)
-m.add("I'm visiting Paris", user_id="john")
+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="john")
 ```
-
+The embedding types can be one of the following:
+- SEMANTIC_SIMILARITY
+- CLASSIFICATION
+- CLUSTERING
+- RETRIEVAL_DOCUMENT, RETRIEVAL_QUERY, QUESTION_ANSWERING, FACT_VERIFICATION
+- CODE_RETRIEVAL_QUERY  
+Check out the [Vertex AI documentation](https://cloud.google.com/vertex-ai/generative-ai/docs/embeddings/task-types#supported_task_types) for more information.  
+  
 ### Config
 
 Here are the parameters available for configuring the Vertex AI embedder:
@@ -34,3 +50,6 @@ Here are the parameters available for configuring the Vertex AI embedder:
 | `model`                   | The name of the Vertex AI embedding model to use | `text-embedding-004` |
 | `vertex_credentials_json` | Path to the Google Cloud credentials JSON file   | `None`               |
 | `embedding_dims`          | Dimensions of the embedding model                | `256`                |
+| `memory_add_embedding_type` | The type of embedding to use for the add memory action | `RETRIEVAL_DOCUMENT` |
+| `memory_update_embedding_type` | The type of embedding to use for the update memory action | `RETRIEVAL_DOCUMENT` |
+| `memory_search_embedding_type` | The type of embedding to use for the search memory action | `RETRIEVAL_QUERY` |

docs/components/embedders/overview.mdx

@@ -1,5 +1,7 @@
 ---
 title: Overview
+icon: "info"
+iconType: "solid"
 ---
 
 Mem0 offers support for various embedding models, allowing users to choose the one that best suits their needs.
@@ -8,6 +10,10 @@ Mem0 offers support for various embedding models, allowing users to choose the o
 
 See the list of supported embedders below.
 
+<Note>
+  The following embedders are supported in the Python implementation. The TypeScript implementation currently only supports OpenAI.
+</Note>
+
 <CardGroup cols={4}>
   <Card title="OpenAI" href="/components/embedders/models/openai"></Card>
   <Card title="Azure OpenAI" href="/components/embedders/models/azure_openai"></Card>

docs/components/llms/config.mdx

@@ -1,29 +1,45 @@
-## What is Config?
+---
+title: Configurations
+icon: "gear"
+iconType: "solid"
+---
 
-Config in mem0 is a dictionary that specifies the settings for your llms. It allows you to customize the behavior and connection details of your chosen llm.
+## How to define configurations?
 
-## How to Define Config
-
-The config is defined as a Python dictionary with two main keys:
-- `llm`: Specifies the llm provider and its configuration
-  - `provider`: The name of the llm (e.g., "openai", "groq")
-  - `config`: A nested dictionary containing provider-specific settings
+<Tabs>
+  <Tab title="Python">
+    The `config` is defined as a Python dictionary with two main keys:
+    - `llm`: Specifies the llm provider and its configuration
+      - `provider`: The name of the llm (e.g., "openai", "groq")
+      - `config`: A nested dictionary containing provider-specific settings
+  </Tab>
+  <Tab title="TypeScript">
+    The `config` is defined as a TypeScript object with these keys:
+    - `llm`: Specifies the LLM provider and its configuration (required)
+      - `provider`: The name of the LLM (e.g., "openai", "groq")
+      - `config`: A nested object containing provider-specific settings
+    - `embedder`: Specifies the embedder provider and its configuration (optional)
+    - `vectorStore`: Specifies the vector store provider and its configuration (optional)
+    - `historyDbPath`: Path to the history database file (optional)
+  </Tab>
+</Tabs>
 
 ### Config Values Precedence
 
 Config values are applied in the following order of precedence (from highest to lowest):
 
-1. Values explicitly set in the `config` dictionary
+1. Values explicitly set in the `config` object/dictionary
 2. Environment variables (e.g., `OPENAI_API_KEY`, `OPENAI_API_BASE`)
 3. Default values defined in the LLM implementation
 
-This means that values specified in the `config` dictionary will override corresponding environment variables, which in turn override default values.
+This means that values specified in the `config` will override corresponding environment variables, which in turn override default values.
 
 ## How to Use Config
 
-Here's a general example of how to use the config with mem0:
+Here's a general example of how to use the config with Mem0:
 
-```python
+<CodeGroup>
+```python Python
 import os
 from mem0 import Memory
 
@@ -42,39 +58,70 @@ m = Memory.from_config(config)
 m.add("Your text here", user_id="user", metadata={"category": "example"})
 ```
 
+```typescript TypeScript
+import { Memory } from 'mem0ai/oss';
+
+// Minimal configuration with just the LLM settings
+const config = {
+  llm: {
+    provider: 'your_chosen_provider',
+    config: {
+      // Provider-specific settings go here
+    }
+  }
+};
+
+const memory = new Memory(config);
+await memory.add("Your text here", { userId: "user123", metadata: { category: "example" } });
+```
+</CodeGroup>
+
 ## Why is Config Needed?
 
 Config is essential for:
-1. Specifying which llm to use.
+1. Specifying which LLM to use.
 2. Providing necessary connection details (e.g., model, api_key, temperature).
-3. Ensuring proper initialization and connection to your chosen llm.
+3. Ensuring proper initialization and connection to your chosen LLM.
 
 ## Master List of All Params in Config
 
-Here's a comprehensive list of all parameters that can be used across different llms:
-
-Here's the table based on the provided parameters:
-
-| Parameter            | Description                                   | Provider          |
-|----------------------|-----------------------------------------------|-------------------|
-| `model`              | Embedding model to use                        | All               |
-| `temperature`        | Temperature of the model                      | All               |
-| `api_key`            | API key to use                                | All               |
-| `max_tokens`         | Tokens to generate                            | All               |
-| `top_p`              | Probability threshold for nucleus sampling    | All               |
-| `top_k`              | Number of highest probability tokens to keep  | All               |
-| `http_client_proxies`| Allow proxy server settings                   | AzureOpenAI       |
-| `models`             | List of models                                | Openrouter        |
-| `route`              | Routing strategy                              | Openrouter        |
-| `openrouter_base_url`| Base URL for Openrouter API                   | Openrouter        |
-| `site_url`           | Site URL                                      | Openrouter        |
-| `app_name`           | Application name                              | Openrouter        |
-| `ollama_base_url`    | Base URL for Ollama API                       | Ollama            |
-| `openai_base_url`    | Base URL for OpenAI API                       | OpenAI            |
-| `azure_kwargs`       | Azure LLM args for initialization             | AzureOpenAI       |
-| `deepseek_base_url`  | Base URL for DeepSeek API                     | DeepSeek          |
+Here's a comprehensive list of all parameters that can be used across different LLMs:
 
+<Tabs>
+  <Tab title="Python">
+    | Parameter            | Description                                   | Provider          |
+    |----------------------|-----------------------------------------------|-------------------|
+    | `model`              | Embedding model to use                        | All               |
+    | `temperature`        | Temperature of the model                      | All               |
+    | `api_key`            | API key to use                                | All               |
+    | `max_tokens`         | Tokens to generate                            | All               |
+    | `top_p`              | Probability threshold for nucleus sampling    | All               |
+    | `top_k`              | Number of highest probability tokens to keep  | All               |
+    | `http_client_proxies`| Allow proxy server settings                   | AzureOpenAI       |
+    | `models`             | List of models                                | Openrouter        |
+    | `route`              | Routing strategy                              | Openrouter        |
+    | `openrouter_base_url`| Base URL for Openrouter API                   | Openrouter        |
+    | `site_url`           | Site URL                                      | Openrouter        |
+    | `app_name`           | Application name                              | Openrouter        |
+    | `ollama_base_url`    | Base URL for Ollama API                       | Ollama            |
+    | `openai_base_url`    | Base URL for OpenAI API                       | OpenAI            |
+    | `azure_kwargs`       | Azure LLM args for initialization             | AzureOpenAI       |
+    | `deepseek_base_url`  | Base URL for DeepSeek API                     | DeepSeek          |
+    | `xai_base_url`       | Base URL for XAI API                          | XAI               |
+  </Tab>
+  <Tab title="TypeScript">
+    | Parameter            | Description                                   | Provider          |
+    |----------------------|-----------------------------------------------|-------------------|
+    | `model`              | Embedding model to use                        | All               |
+    | `temperature`        | Temperature of the model                      | All               |
+    | `apiKey`             | API key to use                                | All               |
+    | `maxTokens`          | Tokens to generate                            | All               |
+    | `topP`               | Probability threshold for nucleus sampling    | All               |
+    | `topK`               | Number of highest probability tokens to keep  | All               |
+    | `openaiBaseUrl`      | Base URL for OpenAI API                       | OpenAI            |
+  </Tab>
+</Tabs>
 
 ## Supported LLMs
 
-For detailed information on configuring specific llms, please visit the [LLMs](./models) section. There you'll find information for each supported llm with provider-specific usage examples and configuration details.
+For detailed information on configuring specific LLMs, please visit the [LLMs](./models) section. There you'll find information for each supported LLM with provider-specific usage examples and configuration details.

docs/components/llms/models/anthropic.mdx

@@ -1,8 +1,13 @@
+---
+title: Anthropic
+---
+
 To use anthropic's models, please set the `ANTHROPIC_API_KEY` which you find on their [Account Settings Page](https://console.anthropic.com/account/keys).
 
 ## Usage
 
-```python
+<CodeGroup>
+```python Python
 import os
 from mem0 import Memory
 
@@ -13,7 +18,7 @@ config = {
     "llm": {
         "provider": "anthropic",
         "config": {
-            "model": "claude-3-5-sonnet-latest",
+            "model": "claude-3-7-sonnet-latest",
             "temperature": 0.1,
             "max_tokens": 2000,
         }
@@ -21,9 +26,41 @@ config = {
 }
 
 m = Memory.from_config(config)
-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."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
 ```
 
+```typescript TypeScript
+import { Memory } from 'mem0ai/oss';
+
+const config = {
+  llm: {
+    provider: 'anthropic',
+    config: {
+      apiKey: process.env.ANTHROPIC_API_KEY || '',
+      model: 'claude-3-7-sonnet-latest',
+      temperature: 0.1,
+      maxTokens: 2000,
+    },
+  },
+};
+
+const memory = new Memory(config);
+const messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "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."}
+]
+await memory.add(messages, { userId: "alice", metadata: { category: "movies" } });
+```
+</CodeGroup>
+
 ## Config
 
 All available parameters for the `anthropic` config are present in [Master List of All Params in Config](../config).

docs/components/llms/models/aws_bedrock.mdx

@@ -24,13 +24,19 @@ config = {
         "config": {
             "model": "arn:aws:bedrock:us-east-1:123456789012:model/your-model-name",
             "temperature": 0.2,
-            "max_tokens": 1500,
+            "max_tokens": 2000,
         }
     }
 }
 
 m = Memory.from_config(config)
-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."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
 ```
 
 ### Config

docs/components/llms/models/azure_openai.mdx

@@ -36,7 +36,13 @@ config = {
 }
 
 m = Memory.from_config(config)
-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."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
 ```
 
 We also support the new [OpenAI structured-outputs](https://platform.openai.com/docs/guides/structured-outputs/introduction) model.

docs/components/llms/models/deepseek.mdx

@@ -19,14 +19,20 @@ config = {
         "config": {
             "model": "deepseek-chat",  # default model
             "temperature": 0.2,
-            "max_tokens": 1500,
+            "max_tokens": 2000,
             "top_p": 1.0
         }
     }
 }
 
 m = Memory.from_config(config)
-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."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
 ```
 
 You can also configure the API base URL in the config:

docs/components/llms/models/gemini.mdx

@@ -19,13 +19,19 @@ config = {
         "config": {
             "model": "gemini-1.5-flash-latest",
             "temperature": 0.2,
-            "max_tokens": 1500,
+            "max_tokens": 2000,
         }
     }
 }
 
 m = Memory.from_config(config)
-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."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
 ```
 
 ## Config

docs/components/llms/models/google_AI.mdx

@@ -19,13 +19,19 @@ config = {
         "config": {
             "model": "gemini/gemini-pro",
             "temperature": 0.2,
-            "max_tokens": 1500,
+            "max_tokens": 2000,
         }
     }
 }
 
 m = Memory.from_config(config)
-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."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
 ```
 
 ## Config

docs/components/llms/models/groq.mdx

@@ -1,10 +1,15 @@
+---
+title: Groq
+---
+
 [Groq](https://groq.com/) is the creator of the world's first Language Processing Unit (LPU), providing exceptional speed performance for AI workloads running on their LPU Inference Engine.
 
 In order to use LLMs from Groq, go to their [platform](https://console.groq.com/keys) and get the API key. Set the API key as `GROQ_API_KEY` environment variable to use the model as given below in the example.
 
 ## Usage
 
-```python
+<CodeGroup>
+```python Python
 import os
 from mem0 import Memory
 
@@ -17,15 +22,47 @@ config = {
         "config": {
             "model": "mixtral-8x7b-32768",
             "temperature": 0.1,
-            "max_tokens": 1000,
+            "max_tokens": 2000,
         }
     }
 }
 
 m = Memory.from_config(config)
-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."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
 ```
 
+```typescript TypeScript
+import { Memory } from 'mem0ai/oss';
+
+const config = {
+  llm: {
+    provider: 'groq',
+    config: {
+      apiKey: process.env.GROQ_API_KEY || '',
+      model: 'mixtral-8x7b-32768',
+      temperature: 0.1,
+      maxTokens: 1000,
+    },
+  },
+};
+
+const memory = new Memory(config);
+const messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "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."}
+]
+await memory.add(messages, { userId: "alice", metadata: { category: "movies" } });
+```
+</CodeGroup>
+
 ## Config
 
 All available parameters for the `groq` config are present in [Master List of All Params in Config](../config).

docs/components/llms/models/litellm.mdx

@@ -14,13 +14,19 @@ config = {
         "config": {
             "model": "gpt-4o-mini",
             "temperature": 0.2,
-            "max_tokens": 1500,
+            "max_tokens": 2000,
         }
     }
 }
 
 m = Memory.from_config(config)
-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."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
 ```
 
 ## Config

docs/components/llms/models/mistral_AI.mdx

@@ -25,7 +25,13 @@ config = {
 }
 
 m = Memory.from_config(config)
-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."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
 ```
 
 ## Config

docs/components/llms/models/ollama.mdx

@@ -20,7 +20,13 @@ config = {
 }
 
 m = Memory.from_config(config)
-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."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
 ```
 
 ## Config

docs/components/llms/models/openai.mdx

@@ -6,7 +6,8 @@ To use OpenAI LLM models, you have to set the `OPENAI_API_KEY` environment varia
 
 ## Usage
 
-```python
+<CodeGroup>
+```python Python
 import os
 from mem0 import Memory
 
@@ -18,7 +19,7 @@ config = {
         "config": {
             "model": "gpt-4o",
             "temperature": 0.2,
-            "max_tokens": 1500,
+            "max_tokens": 2000,
         }
     }
 }
@@ -35,9 +36,41 @@ config = {
 # }
 
 m = Memory.from_config(config)
-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."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
 ```
 
+```typescript TypeScript
+import { Memory } from 'mem0ai/oss';
+
+const config = {
+  llm: {
+    provider: 'openai',
+    config: {
+      apiKey: process.env.OPENAI_API_KEY || '',
+      model: 'gpt-4-turbo-preview',
+      temperature: 0.2,
+      maxTokens: 1500,
+    },
+  },
+};
+
+const memory = new Memory(config);
+const messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "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."}
+]
+await memory.add(messages, { userId: "alice", metadata: { category: "movies" } });
+```
+</CodeGroup>
+
 We also support the new [OpenAI structured-outputs](https://platform.openai.com/docs/guides/structured-outputs/introduction) model.
 
 ```python
@@ -59,7 +92,9 @@ config = {
 m = Memory.from_config(config)
 ```
 
-
+<Note>
+  OpenAI structured-outputs is currently only available in the Python implementation.
+</Note>
 
 ## Config
 

docs/components/llms/models/together.mdx

@@ -15,13 +15,19 @@ config = {
         "config": {
             "model": "mistralai/Mixtral-8x7B-Instruct-v0.1",
             "temperature": 0.2,
-            "max_tokens": 1500,
+            "max_tokens": 2000,
         }
     }
 }
 
 m = Memory.from_config(config)
-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."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
 ```
 
 ## Config

docs/components/llms/models/xAI.mdx

@@ -0,0 +1,41 @@
+---
+title: xAI
+---
+
+[xAI](https://x.ai/) is a new AI company founded by Elon Musk that develops large language models, including Grok. Grok is trained on real-time data from X (formerly Twitter) and aims to provide accurate, up-to-date responses with a touch of wit and humor.
+
+In order to use LLMs from xAI, go to their [platform](https://console.x.ai) and get the API key. Set the API key as `XAI_API_KEY` environment variable to use the model as given below in the example.
+
+## Usage
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "your-api-key" # used for embedding model
+os.environ["XAI_API_KEY"] = "your-api-key"
+
+config = {
+    "llm": {
+        "provider": "xai",
+        "config": {
+            "model": "grok-2-latest",
+            "temperature": 0.1,
+            "max_tokens": 2000,
+        }
+    }
+}
+
+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
+
+All available parameters for the `xai` config are present in [Master List of All Params in Config](../config).

docs/components/llms/overview.mdx

@@ -1,5 +1,7 @@
 ---
 title: Overview
+icon: "info"
+iconType: "solid"
 ---
 
 Mem0 includes built-in support for various popular large language models. Memory can utilize the LLM provided by the user, ensuring efficient use for specific needs.
@@ -12,19 +14,24 @@ For a comprehensive list of available parameters for llm configuration, please r
 
 To view all supported llms, visit the [Supported LLMs](./models).
 
+<Note>
+  All LLMs are supported in Python. The following LLMs are also supported in TypeScript: **OpenAI**, **Anthropic**, and **Groq**.
+</Note>
+
 <CardGroup cols={4}>
-  <Card title="OpenAI" href="/components/llms/models/openai"></Card>
-    <Card title="Ollama" href="/components/llms/models/ollama"></Card>
-    <Card title="Azure OpenAI" href="/components/llms/models/azure_openai"></Card>
-    <Card title="Anthropic" href="/components/llms/models/anthropic"></Card>
-    <Card title="Together" href="/components/llms/models/together"></Card>
-    <Card title="Groq" href="/components/llms/models/groq"></Card>
-    <Card title="Litellm" href="/components/llms/models/litellm"></Card>
-    <Card title="Mistral AI" href="/components/llms/models/mistral_ai"></Card>
-    <Card title="Google AI" href="/components/llms/models/google_ai"></Card>
-    <Card title="AWS bedrock" href="/components/llms/models/aws_bedrock"></Card>
-    <Card title="Gemini" href="/components/llms/models/gemini"></Card>
-    <Card title="DeepSeek" href="/components/llms/models/deepseek"></Card>
+  <Card title="OpenAI" href="/components/llms/models/openai" />
+  <Card title="Ollama" href="/components/llms/models/ollama" />
+  <Card title="Azure OpenAI" href="/components/llms/models/azure_openai" />
+  <Card title="Anthropic" href="/components/llms/models/anthropic" />
+  <Card title="Together" href="/components/llms/models/together" />
+  <Card title="Groq" href="/components/llms/models/groq" />
+  <Card title="Litellm" href="/components/llms/models/litellm" />
+  <Card title="Mistral AI" href="/components/llms/models/mistral_ai" />
+  <Card title="Google AI" href="/components/llms/models/google_ai" />
+  <Card title="AWS bedrock" href="/components/llms/models/aws_bedrock" />
+  <Card title="Gemini" href="/components/llms/models/gemini" />
+  <Card title="DeepSeek" href="/components/llms/models/deepseek" />
+  <Card title="xAI" href="/components/llms/models/xAI" />
 </CardGroup>
 
 ## Structured vs Unstructured Outputs

docs/components/vectordbs/config.mdx

@@ -1,19 +1,23 @@
-## What is Config?
+---
+title: Configurations
+icon: "gear"
+iconType: "solid"
+---
 
-Config in mem0 is a dictionary that specifies the settings for your vector database. It allows you to customize the behavior and connection details of your chosen vector store.
+## How to define configurations?
 
-## How to Define Config
-
-The config is defined as a Python dictionary with two main keys:
+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")
+  - `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
 
 Here's a general example of how to use the config with mem0:
 
-```python
+<CodeGroup>
+```python Python
 import os
 from mem0 import Memory
 
@@ -32,6 +36,29 @@ m = Memory.from_config(config)
 m.add("Your text here", user_id="user", metadata={"category": "example"})
 ```
 
+```typescript TypeScript
+// Example for in-memory vector database (Only supported in TypeScript)
+import { Memory } from 'mem0ai/oss';
+
+const configMemory = {
+  vector_store: {
+    provider: 'memory',
+    config: {
+      collectionName: 'memories',
+      dimension: 1536,
+    },
+  },
+};
+
+const memory = new Memory(configMemory);
+await memory.add("Your text here", { userId: "user", metadata: { category: "example" } });
+```
+</CodeGroup>
+
+<Note>
+  The in-memory vector database is only supported in the TypeScript implementation.
+</Note>
+
 ## Why is Config Needed?
 
 Config is essential for:
@@ -44,6 +71,8 @@ Config is essential for:
 
 Here's a comprehensive list of all parameters that can be used across different vector databases:
 
+<Tabs>
+<Tab title="Python">
 | Parameter | Description |
 |-----------|-------------|
 | `collection_name` | Name of the collection |
@@ -58,6 +87,33 @@ 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) |
+</Tab>
+<Tab title="TypeScript">
+| Parameter | Description |
+|-----------|-------------|
+| `collectionName` | Name of the collection |
+| `embeddingModelDims` | Dimensions of the embedding model |
+| `dimension` | Dimensions of the embedding model (for memory provider) |
+| `host` | Host where the server is running |
+| `port` | Port where the server is running |
+| `url` | URL for the server |
+| `apiKey` | API key for the server |
+| `path` | Path for the database |
+| `onDisk` | Enable persistent storage |
+| `redisUrl` | URL for the Redis server |
+| `username` | Username for database connection |
+| `password` | Password for database connection |
+</Tab>
+</Tabs>
 
 ## Customizing Config
 

docs/components/vectordbs/dbs/azure_ai_search.mdx

@@ -22,7 +22,13 @@ config = {
 }
 
 m = Memory.from_config(config)
-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."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
 ```
 
 ### Config

docs/components/vectordbs/dbs/chroma.mdx

@@ -19,7 +19,13 @@ config = {
 }
 
 m = Memory.from_config(config)
-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."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
 ```
 
 ### Config

docs/components/vectordbs/dbs/elasticsearch.mdx

@@ -29,7 +29,13 @@ config = {
 }
 
 m = Memory.from_config(config)
-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."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
 ```
 
 ### Config

docs/components/vectordbs/dbs/milvus.mdx

@@ -19,7 +19,13 @@ config = {
 }
 
 m = Memory.from_config(config)
-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."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
 ```
 
 ### Config

docs/components/vectordbs/dbs/opensearch.mdx

@@ -0,0 +1,65 @@
+[OpenSearch](https://opensearch.org/) is an open-source, enterprise-grade search and observability suite that brings order to unstructured data at scale. OpenSearch supports k-NN (k-Nearest Neighbors) and allows you to store and retrieve high-dimensional vector embeddings efficiently.
+
+### Installation
+
+OpenSearch support requires additional dependencies. Install them with:
+
+```bash
+pip install opensearch>=2.8.0
+```
+
+### Usage
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "sk-xx"
+
+config = {
+    "vector_store": {
+        "provider": "opensearch",
+        "config": {
+            "collection_name": "mem0",
+            "host": "localhost",
+            "port": 9200,
+            "embedding_model_dims": 1536
+        }
+    }
+}
+
+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
+
+Let's see the available parameters for the `opensearch` config:
+
+| Parameter              | Description                                        | Default Value |
+| ---------------------- | -------------------------------------------------- | ------------- |
+| `collection_name`      | The name of the index to store the vectors         | `mem0`        |
+| `embedding_model_dims` | Dimensions of the embedding model                  | `1536`        |
+| `host`                 | The host where the OpenSearch server is running    | `localhost`   |
+| `port`                 | The port where the OpenSearch server is running    | `9200`        |
+| `api_key`              | API key for authentication                         | `None`        |
+| `user`                 | Username for basic authentication                  | `None`        |
+| `password`             | Password for basic authentication                  | `None`        |
+| `verify_certs`         | Whether to verify SSL certificates                 | `False`        |
+| `auto_create_index`    | Whether to automatically create the index          | `True`        |
+| `use_ssl`              | Whether to use SSL for connection                  | `False`        |
+
+### Features
+
+- Fast and Efficient Vector Search
+- Can be deployed on-premises, in containers, or on cloud platforms like AWS OpenSearch Service.
+- Multiple Authentication and Security Methods (Basic Authentication, API Keys, LDAP, SAML, and OpenID Connect)
+- Automatic index creation with optimized mappings for vector search
+- Memory Optimization through Disk-Based Vector Search and Quantization
+- Real-Time Analytics and Observability

docs/components/vectordbs/dbs/pgvector.mdx

@@ -21,7 +21,13 @@ config = {
 }
 
 m = Memory.from_config(config)
-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."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
 ```
 
 ### Config

docs/components/vectordbs/dbs/qdrant.mdx

@@ -2,7 +2,8 @@
 
 ### Usage
 
-```python
+<CodeGroup>
+```python Python
 import os
 from mem0 import Memory
 
@@ -20,13 +21,47 @@ config = {
 }
 
 m = Memory.from_config(config)
-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."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
 ```
 
+```typescript TypeScript
+import { Memory } from 'mem0ai/oss';
+
+const config = {
+  vectorStore: {
+    provider: 'qdrant',
+    config: {
+      collectionName: 'memories',
+      embeddingModelDims: 1536,
+      host: 'localhost',
+      port: 6333,
+    },
+  },
+};
+
+const memory = new Memory(config);
+const messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "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."}
+]
+await memory.add(messages, { userId: "alice", metadata: { category: "movies" } });
+```
+</CodeGroup>
+
 ### Config
 
 Let's see the available parameters for the `qdrant` config:
 
+<Tabs>
+<Tab title="Python">
 | Parameter | Description | Default Value |
 | --- | --- | --- |
 | `collection_name` | The name of the collection to store the vectors | `mem0` |
@@ -37,4 +72,18 @@ Let's see the available parameters for the `qdrant` config:
 | `path` | Path for the qdrant database | `/tmp/qdrant` |
 | `url` | Full URL for the qdrant server | `None` |
 | `api_key` | API key for the qdrant server | `None` |
-| `on_disk` | For enabling persistent storage | `False` |
+| `on_disk` | For enabling persistent storage | `False` |
+</Tab>
+<Tab title="TypeScript">
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `collectionName` | The name of the collection to store the vectors | `mem0` |
+| `embeddingModelDims` | Dimensions of the embedding model | `1536` |
+| `host` | The host where the Qdrant server is running | `None` |
+| `port` | The port where the Qdrant server is running | `None` |
+| `path` | Path for the Qdrant database | `/tmp/qdrant` |
+| `url` | Full URL for the Qdrant server | `None` |
+| `apiKey` | API key for the Qdrant server | `None` |
+| `onDisk` | For enabling persistent storage | `False` |
+</Tab>
+</Tabs>

docs/components/vectordbs/dbs/redis.mdx

@@ -12,7 +12,8 @@ docker run -d --name redis-stack -p 6379:6379 -p 8001:8001 redis/redis-stack:lat
 
 ### Usage
 
-```python
+<CodeGroup>
+```python Python
 import os
 from mem0 import Memory
 
@@ -26,19 +27,66 @@ config = {
             "embedding_model_dims": 1536,
             "redis_url": "redis://localhost:6379"
         }
-    }
+    },
+    "version": "v1.1"
 }
 
 m = Memory.from_config(config)
-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."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
 ```
 
+```typescript TypeScript
+import { Memory } from 'mem0ai/oss';
+
+const config = {
+  vectorStore: {
+    provider: 'redis',
+    config: {
+      collectionName: 'memories',
+      embeddingModelDims: 1536,
+      redisUrl: 'redis://localhost:6379',
+      username: 'your-redis-username',
+      password: 'your-redis-password',
+    },
+  },
+};
+
+const memory = new Memory(config);
+const messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "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."}
+]
+await memory.add(messages, { userId: "alice", metadata: { category: "movies" } });
+```
+</CodeGroup>
+
 ### Config
 
 Let's see the available parameters for the `redis` config:
 
+<Tabs>
+<Tab title="Python">
 | 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` |
-| `redis_url` | The URL of the Redis server | `None` |
+| `redis_url` | The URL of the Redis server | `None` |
+</Tab>
+<Tab title="TypeScript">
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `collectionName` | The name of the collection to store the vectors | `mem0` |
+| `embeddingModelDims` | Dimensions of the embedding model | `1536` |
+| `redisUrl` | The URL of the Redis server | `None` |
+| `username` | Username for Redis connection | `None` |
+| `password` | Password for Redis connection | `None` |
+</Tab>
+</Tabs>

docs/components/vectordbs/dbs/supabase.mdx

@@ -0,0 +1,78 @@
+[Supabase](https://supabase.com/) is an open-source Firebase alternative that provides a PostgreSQL database with pgvector extension for vector similarity search. It offers a powerful and scalable solution for storing and querying vector embeddings.
+
+Create a [Supabase](https://supabase.com/dashboard/projects) account and project, then get your connection string from Project Settings > Database. See the [docs](https://supabase.github.io/vecs/hosting/) for details.
+
+### Usage
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "sk-xx"
+
+config = {
+    "vector_store": {
+        "provider": "supabase",
+        "config": {
+            "connection_string": "postgresql://user:password@host:port/database",
+            "collection_name": "memories",
+            "index_method": "hnsw",  # Optional: defaults to "auto"
+            "index_measure": "cosine_distance"  # Optional: defaults to "cosine_distance"
+        }
+    }
+}
+
+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 Supabase:
+
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `connection_string` | PostgreSQL connection string (required) | None |
+| `collection_name` | Name for the vector collection | `mem0` |
+| `embedding_model_dims` | Dimensions of the embedding model | `1536` |
+| `index_method` | Vector index method to use | `auto` |
+| `index_measure` | Distance measure for similarity search | `cosine_distance` |
+
+### Index Methods
+
+The following index methods are supported:
+
+- `auto`: Automatically selects the best available index method
+- `hnsw`: Hierarchical Navigable Small World graph index (faster search, more memory usage)
+- `ivfflat`: Inverted File Flat index (good balance of speed and memory)
+
+### Distance Measures
+
+Available distance measures for similarity search:
+
+- `cosine_distance`: Cosine similarity (recommended for most embedding models)
+- `l2_distance`: Euclidean distance
+- `l1_distance`: Manhattan distance
+- `max_inner_product`: Maximum inner product similarity
+
+### Best Practices
+
+1. **Index Method Selection**:
+   - Use `hnsw` for fastest search performance when memory is not a constraint
+   - Use `ivfflat` for a good balance of search speed and memory usage
+   - Use `auto` if unsure, it will select the best method based on your data
+
+2. **Distance Measure Selection**:
+   - Use `cosine_distance` for most embedding models (OpenAI, Hugging Face, etc.)
+   - Use `max_inner_product` if your vectors are normalized
+   - Use `l2_distance` or `l1_distance` if working with raw feature vectors
+
+3. **Connection String**:
+   - Always use environment variables for sensitive information in the connection string
+   - Format: `postgresql://user:password@host:port/database`

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/overview.mdx

@@ -1,5 +1,7 @@
 ---
 title: Overview
+icon: "info"
+iconType: "solid"
 ---
 
 Mem0 includes built-in support for various popular databases. Memory can utilize the database provided by the user, ensuring efficient use for specific needs.
@@ -8,6 +10,10 @@ Mem0 includes built-in support for various popular databases. Memory can utilize
 
 See the list of supported vector databases below.
 
+<Note>
+  The following vector databases are supported in the Python implementation. The TypeScript implementation currently only supports Qdrant, Redis and in-memory vector database.
+</Note>
+
 <CardGroup cols={3}>
   <Card title="Qdrant" href="/components/vectordbs/dbs/qdrant"></Card>
   <Card title="Chroma" href="/components/vectordbs/dbs/chroma"></Card>
@@ -16,6 +22,9 @@ See the list of supported vector databases below.
   <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>
 </CardGroup>
 
 ## Usage

docs/contributing/development.mdx

@@ -0,0 +1,87 @@
+---
+title: Development
+icon: "code"
+---
+
+# Development Contributions
+
+We strive to make contributions **easy, collaborative, and enjoyable**. Follow the steps below to ensure a smooth contribution process.
+
+## Submitting Your Contribution through PR
+
+To contribute, follow these steps:
+
+1. **Fork & Clone** the repository: [Mem0 on GitHub](https://github.com/mem0ai/mem0)
+2. **Create a Feature Branch**: Use a dedicated branch for your changes, e.g., `feature/my-new-feature`
+3. **Implement Changes**: If adding a feature or fixing a bug, ensure to:
+   - Write necessary **tests**
+   - Add **documentation, docstrings, and runnable examples**
+4. **Code Quality Checks**:
+   - Run **linting** to catch style issues
+   - Ensure **all tests pass**
+5. **Submit a Pull Request** 🚀
+
+For detailed guidance on pull requests, refer to [GitHub's documentation](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-a-pull-request).
+
+---
+
+## 📦 Dependency Management
+
+We use `poetry` as our package manager. Install it by following the [official instructions](https://python-poetry.org/docs/#installation).
+
+⚠️ **Do NOT use `pip` or `conda` for dependency management.** Instead, run:
+
+```bash
+make install_all
+
+# Activate virtual environment
+poetry shell
+```
+
+---
+
+## 🛠️ Development Standards
+
+### ✅ Pre-commit Hooks
+
+Ensure `pre-commit` is installed before contributing:
+
+```bash
+pre-commit install
+```
+
+### 🔍 Linting with `ruff`
+
+Run the linter and fix any reported issues before submitting your PR:
+
+```bash
+make lint
+```
+
+### 🎨 Code Formatting with `black`
+
+To maintain a consistent code style, format your code using `black`:
+
+```bash
+make format
+```
+
+### 🧪 Testing with `pytest`
+
+Run tests to verify functionality before submitting your PR:
+
+```bash
+make test
+```
+
+💡 **Note:** Some dependencies have been removed from Poetry to reduce package size. Run `make install_all` to install necessary dependencies before running tests.
+
+---
+
+## 🚀 Release Process
+
+Currently, releases are handled manually. We aim for frequent releases, typically when new features or bug fixes are introduced.
+
+---
+
+Thank you for contributing to Mem0! 🎉

docs/contributing/documentation.mdx

@@ -0,0 +1,55 @@
+---
+title: Documentation
+icon: "book"
+---
+
+# Documentation Contributions
+
+## 📌 Prerequisites
+
+Before getting started, ensure you have **Node.js (version 23.6.0 or higher)** installed on your system.
+
+---
+
+## 🚀 Setting Up Mintlify
+
+### Step 1: Install Mintlify
+
+Install Mintlify globally using your preferred package manager:
+
+<CodeGroup>
+
+```bash npm
+npm i -g mintlify
+```
+
+```bash yarn
+yarn global add mintlify
+```
+
+</CodeGroup>
+
+### Step 2: Run the Documentation Server
+
+Navigate to the `docs/` directory (where `docs.json` is located) and start the development server:
+
+```bash
+mintlify dev
+```
+
+The documentation website will be available at: [http://localhost:3000](http://localhost:3000).
+
+---
+
+## 🔧 Custom Ports
+
+By default, Mintlify runs on **port 3000**. To use a different port, add the `--port` flag:
+
+```bash
+mintlify dev --port 3333
+```
+
+---
+
+By following these steps, you can efficiently contribute to **Mem0's documentation**. Happy documenting! ✍️
+

docs/core-concepts/memory-operations.mdx

@@ -0,0 +1,60 @@
+---
+title: Memory Operations
+description: Understanding the core operations for managing memories in AI applications
+icon: "gear"
+iconType: "solid"
+---
+
+Mem0 provides two core operations for managing memories in AI applications: adding new memories and searching existing ones. This guide covers how these operations work and how to use them effectively in your application.
+
+
+## Core Operations
+
+Mem0 exposes two main endpoints for interacting with memories:
+- The `add` endpoint for ingesting conversations and storing them as memories
+- The `search` endpoint for retrieving relevant memories based on queries
+
+### Adding Memories
+
+<Frame caption="Architecture diagram illustrating the process of adding memories.">
+  <img src="../images/add_architecture.png" />
+</Frame>
+
+The add operation processes conversations through several steps:
+
+1. **Information Extraction**
+   * An LLM extracts relevant memories from the conversation
+   * It identifies important entities and their relationships
+
+2. **Conflict Resolution**
+   * The system compares new information with existing data
+   * It identifies and resolves any contradictions
+
+3. **Memory Storage**
+   * Vector database stores the actual memories
+   * Graph database maintains relationship information
+   * Information is continuously updated with each interaction
+
+### Searching Memories
+
+<Frame caption="Architecture diagram illustrating the memory search process.">
+  <img src="../images/search_architecture.png" />
+</Frame>
+
+The search operation retrieves memories through a multi-step process:
+
+1. **Query Processing**
+   * LLM processes and optimizes the search query
+   * System prepares filters for targeted search
+
+2. **Vector Search**
+   * Performs semantic search using the optimized query
+   * Ranks results by relevance to the query
+   * Applies specified filters (user, agent, metadata, etc.)
+
+3. **Result Processing**
+   * Combines and ranks the search results
+   * Returns memories with relevance scores
+   * Includes associated metadata and timestamps
+
+This semantic search approach ensures accurate memory retrieval, whether you're looking for specific information or exploring related concepts.

docs/core-concepts/memory-types.mdx

@@ -0,0 +1,48 @@
+---
+title: Memory Types
+description: Understanding different types of memory in AI Applications
+icon: "memory"
+iconType: "solid"
+---
+To build useful AI applications, we need to understand how different memory systems work together. This guide explores the fundamental types of memory in AI systems and shows how Mem0 implements these concepts.
+
+## Why Memory Matters
+
+AI systems need memory for three key purposes:
+1. Maintaining context during conversations
+2. Learning from past interactions
+3. Building personalized experiences over time
+
+Without proper memory systems, AI applications would treat each interaction as completely new, losing valuable context and personalization opportunities.
+
+## Short-Term Memory
+
+The most basic form of memory in AI systems holds immediate context - like a person remembering what was just said in a conversation. This includes:
+
+- **Conversation History**: Recent messages and their order
+- **Working Memory**: Temporary variables and state
+- **Attention Context**: Current focus of the conversation
+
+## Long-Term Memory
+
+More sophisticated AI applications implement long-term memory to retain information across conversations. This includes:
+
+- **Factual Memory**: Stored knowledge about users, preferences, and domain-specific information
+- **Episodic Memory**: Past interactions and experiences
+- **Semantic Memory**: Understanding of concepts and their relationships
+
+## Memory Characteristics
+
+Each memory type has distinct characteristics:
+
+| Type | Persistence | Access Speed | Use Case |
+|------|-------------|--------------|-----------|
+| Short-Term | Temporary | Instant | Active conversations |
+| Long-Term | Persistent | Fast | User preferences and history |
+
+## How Mem0 Implements Long-Term Memory
+Mem0's long-term memory system builds on these foundations by:
+
+1. Using vector embeddings to store and retrieve semantic information
+2. Maintaining user-specific context across sessions
+3. Implementing efficient retrieval mechanisms for relevant past interactions

docs/docs.json

@@ -0,0 +1,338 @@
+{
+  "$schema": "https://mintlify.com/docs.json",
+  "theme": "maple",
+  "name": "Mem0",
+  "description": "Mem0 is a self-improving memory layer for LLM applications, enabling personalized AI experiences that save costs and delight users.",
+  "colors": {
+    "primary": "#6c60f0",
+    "light": "#E6FFA2",
+    "dark": "#a3df02"
+  },
+  "favicon": "/logo/favicon.png",
+  "navigation": {
+    "anchors": [
+      {
+        "anchor": "Documentation",
+        "icon": "book-open",
+        "tabs": [
+          {
+            "tab": "Documentation",
+            "groups": [
+              {
+                "group": "Get Started",
+                "icon": "rocket",
+                "pages": [
+                  "overview",
+                  "quickstart",
+                  "faqs"
+                ]
+              },
+              {
+                "group": "Core Concepts",
+                "icon": "brain",
+                "pages": [
+                  "core-concepts/memory-types",
+                  "core-concepts/memory-operations"
+                ]
+              },
+              {
+                "group": "Platform",
+                "icon": "cogs",
+                "pages": [
+                  "platform/overview",
+                  "platform/quickstart",
+                  {
+                    "group": "Features",
+                    "icon": "star",
+                    "pages": [
+                      "features/platform-overview",
+                      "features/advanced-retrieval",
+                      "features/multimodal-support",
+                      "features/selective-memory",
+                      "features/custom-categories",
+                      "features/custom-instructions",
+                      "features/direct-import",
+                      "features/async-client",
+                      "features/memory-export",
+                      "features/webhooks"
+                    ]
+                  }
+                ]
+              },
+              {
+                "group": "Open Source",
+                "icon": "code-branch",
+                "pages": [
+                  "open-source/quickstart",
+                  "open-source/python-quickstart",
+                  "open-source/node-quickstart",
+                  {
+                    "group": "Features",
+                    "icon": "wrench",
+                    "pages": [
+                      "features/openai_compatibility",
+                      "features/custom-prompts",
+                      "open-source/multimodal-support",
+                      "open-source/features/rest-api"
+                    ]
+                  },
+                  {
+                    "group": "Graph Memory",
+                    "icon": "spider-web",
+                    "pages": [
+                      "open-source/graph_memory/overview",
+                      "open-source/graph_memory/features"
+                    ]
+                  },
+                  {
+                    "group": "LLMs",
+                    "icon": "brain",
+                    "pages": [
+                      "components/llms/overview",
+                      "components/llms/config",
+                      {
+                        "group": "Supported LLMs",
+                        "icon": "list",
+                        "pages": [
+                          "components/llms/models/openai",
+                          "components/llms/models/anthropic",
+                          "components/llms/models/azure_openai",
+                          "components/llms/models/ollama",
+                          "components/llms/models/together",
+                          "components/llms/models/groq",
+                          "components/llms/models/litellm",
+                          "components/llms/models/mistral_AI",
+                          "components/llms/models/google_AI",
+                          "components/llms/models/aws_bedrock",
+                          "components/llms/models/gemini",
+                          "components/llms/models/deepseek",
+                          "components/llms/models/xAI"
+                        ]
+                      }
+                    ]
+                  },
+                  {
+                    "group": "Vector Databases",
+                    "icon": "database",
+                    "pages": [
+                      "components/vectordbs/overview",
+                      "components/vectordbs/config",
+                      {
+                        "group": "Supported Vector Databases",
+                        "icon": "server",
+                        "pages": [
+                          "components/vectordbs/dbs/qdrant",
+                          "components/vectordbs/dbs/chroma",
+                          "components/vectordbs/dbs/pgvector",
+                          "components/vectordbs/dbs/milvus",
+                          "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/vertex_ai_vector_search"
+                        ]
+                      }
+                    ]
+                  },
+                  {
+                    "group": "Embedding Models",
+                    "icon": "layer-group",
+                    "pages": [
+                      "components/embedders/overview",
+                      "components/embedders/config",
+                      {
+                        "group": "Supported Embedding Models",
+                        "icon": "list",
+                        "pages": [
+                          "components/embedders/models/openai",
+                          "components/embedders/models/azure_openai",
+                          "components/embedders/models/ollama",
+                          "components/embedders/models/huggingface",
+                          "components/embedders/models/vertexai",
+                          "components/embedders/models/gemini"
+                        ]
+                      }
+                    ]
+                  }
+                ]
+              },
+              {
+                "group": "Contribution",
+                "icon": "handshake",
+                "pages": [
+                  "contributing/development",
+                  "contributing/documentation"
+                ]
+              }
+            ]
+          },
+          {
+            "tab": "Examples",
+            "groups": [
+              {
+                "group": "💡 Examples",
+                "icon": "lightbulb",
+                "pages": [
+                  "examples/overview",
+                  "examples/mem0-demo",
+                  "examples/ai_companion_js",
+                  "examples/mem0-with-ollama",
+                  "examples/personal-ai-tutor",
+                  "examples/customer-support-agent",
+                  "examples/personal-travel-assistant",
+                  "examples/llama-index-mem0",
+                  "examples/chrome-extension",
+                  "examples/document-writing",
+                  "examples/multimodal-demo",
+                  "examples/personalized-deep-research"
+                ]
+              }
+            ]
+          },
+          {
+            "tab": "Integrations",
+            "groups": [
+              {
+                "group": "Integrations",
+                "icon": "plug",
+                "pages": [
+                  "integrations/overview",
+                  "integrations/vercel-ai-sdk",
+                  "integrations/crewai",
+                  "integrations/autogen",
+                  "integrations/langchain",
+                  "integrations/langgraph",
+                  "integrations/llama-index",
+                  "integrations/langchain-tools",
+                  "integrations/dify",
+                  "integrations/mcp-server"
+                ]
+              }
+            ]
+          },
+          {
+            "tab": "API Reference",
+            "icon": "square-terminal",
+            "groups": [
+              {
+                "group": "API Reference",
+                "icon": "terminal",
+                "pages": [
+                  "api-reference/overview",
+                  {
+                    "group": "Memory APIs",
+                    "icon": "microchip",
+                    "pages": [
+                      "api-reference/memory/add-memories",
+                      "api-reference/memory/v2-search-memories",
+                      "api-reference/memory/v1-search-memories",
+                      "api-reference/memory/v2-get-memories",
+                      "api-reference/memory/v1-get-memories",
+                      "api-reference/memory/history-memory",
+                      "api-reference/memory/get-memory",
+                      "api-reference/memory/update-memory",
+                      "api-reference/memory/batch-update",
+                      "api-reference/memory/delete-memory",
+                      "api-reference/memory/batch-delete",
+                      "api-reference/memory/delete-memories",
+                      "api-reference/memory/create-memory-export",
+                      "api-reference/memory/get-memory-export"
+                    ]
+                  },
+                  {
+                    "group": "Entities APIs",
+                    "icon": "users",
+                    "pages": [
+                      "api-reference/entities/get-users",
+                      "api-reference/entities/delete-user"
+                    ]
+                  },
+                  {
+                    "group": "Organizations APIs",
+                    "icon": "building",
+                    "pages": [
+                      "api-reference/organization/create-org",
+                      "api-reference/organization/get-orgs",
+                      "api-reference/organization/get-org",
+                      "api-reference/organization/get-org-members",
+                      "api-reference/organization/add-org-member",
+                      "api-reference/organization/delete-org"
+                    ]
+                  },
+                  {
+                    "group": "Webhook APIs",
+                    "icon": "webhook",
+                    "pages": [
+                      "api-reference/webhook/create-webhook",
+                      "api-reference/webhook/get-webhook",
+                      "api-reference/webhook/update-webhook",
+                      "api-reference/webhook/delete-webhook"
+                    ]
+                  }
+                ]
+              }
+            ]
+          }
+        ]
+      },
+      {
+        "anchor": "Your Dashboard",
+        "href": "https://app.mem0.ai",
+        "icon": "chart-simple"
+      },
+      {
+        "anchor": "Demo",
+        "href": "https://mem0.dev/demo",
+        "icon": "play"
+      },
+      {
+        "anchor": "Discord",
+        "href": "https://mem0.dev/DiD",
+        "icon": "discord"
+      },
+      {
+        "anchor": "GitHub",
+        "href": "https://github.com/mem0ai/mem0",
+        "icon": "github"
+      },
+      {
+        "anchor": "Support",
+        "href": "mailto:founders@mem0.ai",
+        "icon": "envelope"
+      }
+    ]
+  },
+  "logo": {
+    "light": "/logo/light.svg",
+    "dark": "/logo/dark.svg",
+    "href": "https://github.com/mem0ai/mem0"
+  },
+  "background": {
+    "color": {
+      "light": "#fff",
+      "dark": "#0f1117"
+    }
+  },
+  "navbar": {
+    "primary": {
+      "type": "button",
+      "label": "Your Dashboard",
+      "href": "https://app.mem0.ai"
+    }
+  },
+  "footer": {
+    "socials": {
+      "discord": "https://mem0.dev/DiD",
+      "x": "https://x.com/mem0ai",
+      "github": "https://github.com/mem0ai",
+      "linkedin": "https://www.linkedin.com/company/mem0/"
+    }
+  },
+  "integrations": {
+    "posthog": {
+      "apiKey": "phc_hgJkUVJFYtmaJqrvf6CYN67TIQ8yhXAkWzUn9AMU4yX",
+      "apiHost": "https://mango.mem0.ai"
+    }
+  }
+}

docs/examples/ai_companion_js.mdx

@@ -0,0 +1,126 @@
+---
+title: AI Companion in Node.js
+---
+
+You can create a personalised AI Companion using Mem0. This guide will walk you through the necessary steps and provide the complete code to get you started.
+
+## 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.
+
+## Setup
+
+Before you begin, ensure you have Node.js installed and create a new project. Install the required dependencies using npm:
+
+```bash
+npm install openai mem0ai
+```
+
+## Full Code Example
+
+Below is the complete code to create and interact with an AI Companion using Mem0:
+
+```javascript
+import { OpenAI } from 'openai';
+import { Memory } from 'mem0ai/oss';
+import * as readline from 'readline';
+
+const openaiClient = new OpenAI();
+const memory = new Memory();
+
+async function chatWithMemories(message, userId = "default_user") {
+  const relevantMemories = await memory.search(message, { userId: userId });
+  
+  const memoriesStr = relevantMemories.results
+    .map(entry => `- ${entry.memory}`)
+    .join('\n');
+  
+  const systemPrompt = `You are a helpful AI. Answer the question based on query and memories.
+User Memories:
+${memoriesStr}`;
+  
+  const messages = [
+    { role: "system", content: systemPrompt },
+    { role: "user", content: message }
+  ];
+  
+  const response = await openaiClient.chat.completions.create({
+    model: "gpt-4o-mini",
+    messages: messages
+  });
+  
+  const assistantResponse = response.choices[0].message.content || "";
+  
+  messages.push({ role: "assistant", content: assistantResponse });
+  await memory.add(messages, { userId: userId });
+  
+  return assistantResponse;
+}
+
+async function main() {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  
+  console.log("Chat with AI (type 'exit' to quit)");
+  
+  const askQuestion = () => {
+    return new Promise((resolve) => {
+      rl.question("You: ", (input) => {
+        resolve(input.trim());
+      });
+    });
+  };
+  
+  try {
+    while (true) {
+      const userInput = await askQuestion();
+      
+      if (userInput.toLowerCase() === 'exit') {
+        console.log("Goodbye!");
+        rl.close();
+        break;
+      }
+      
+      const response = await chatWithMemories(userInput, "sample_user");
+      console.log(`AI: ${response}`);
+    }
+  } catch (error) {
+    console.error("An error occurred:", error);
+    rl.close();
+  }
+}
+
+main().catch(console.error);
+```
+
+### Key Components
+
+1. **Initialization**
+   - The code initializes both OpenAI and Mem0 Memory clients
+   - Uses Node.js's built-in readline module for command-line interaction
+
+2. **Memory Management (chatWithMemories function)**
+   - Retrieves relevant memories using Mem0's search functionality
+   - Constructs a system prompt that includes past memories
+   - Makes API calls to OpenAI for generating responses
+   - Stores new interactions in memory
+
+3. **Interactive Chat Interface (main function)**
+   - Creates a command-line interface for user interaction
+   - Handles user input and displays AI responses
+   - Includes graceful exit functionality
+
+### Environment Setup
+
+Make sure to set up your environment variables:
+```bash
+export OPENAI_API_KEY=your_api_key
+```
+
+### Conclusion
+
+This implementation demonstrates how to create an AI Companion that maintains context across conversations using Mem0's memory capabilities. The system automatically stores and retrieves relevant information, creating a more personalized and context-aware interaction experience.
+
+As users interact with the system, Mem0's memory system continuously learns and adapts, making future responses more relevant and personalized. This setup is ideal for creating long-term learning AI assistants that can maintain context and provide increasingly personalized responses over time.

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-demo.mdx

@@ -0,0 +1,68 @@
+---
+title: Mem0 Demo
+---
+
+You can create a personalized AI Companion using Mem0. This guide will walk you through the necessary steps and provide the complete setup instructions to get you started.
+
+<video
+  autoPlay
+  muted
+  loop
+  playsInline
+  className="w-full aspect-video rounded-lg"
+  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.
+
+## Setup
+
+Before you begin, follow these steps to set up the demo application:
+
+1. Clone the Mem0 repository:
+   ```bash
+   git clone https://github.com/mem0ai/mem0.git
+   ```
+
+2. Navigate to the demo application folder:
+   ```bash
+   cd mem0/examples/mem0-demo
+   ```
+
+3. Install dependencies:
+   ```bash
+   pnpm install
+   ```
+
+4. Set up environment variables by creating a `.env` file in the project root with the following content:
+   ```bash
+   OPENAI_API_KEY=your_openai_api_key
+   MEM0_API_KEY=your_mem0_api_key
+   ```
+   You can obtain your `MEM0_API_KEY` by signing up at [Mem0 API Dashboard](https://app.mem0.ai/dashboard/api-keys).
+
+5. Start the development server:
+   ```bash
+   pnpm run dev
+   ```
+
+## Enhancing the Next.js Application
+
+Once the demo is running, you can customize and enhance the Next.js application by modifying the components in the `mem0-demo` folder. Consider:
+- Adding new memory features to improve contextual retention.
+- Customizing the UI to better suit your application needs.
+- Integrating additional APIs or third-party services to extend functionality.
+
+## Full Code
+
+You can find the complete source code for this demo on GitHub:
+[Mem0 Demo GitHub](https://github.com/mem0ai/mem0/tree/main/examples/mem0-demo)
+
+## Conclusion
+
+This setup demonstrates how to build an AI Companion that maintains memory across interactions using Mem0. The system continuously adapts to user interactions, making future responses more relevant and personalized. Experiment with the application and enhance it further to suit your use case!
+

docs/examples/mem0-with-ollama.mdx

@@ -37,7 +37,7 @@ config = {
         "config": {
             "model": "llama3.1:latest",
             "temperature": 0,
-            "max_tokens": 8000,
+            "max_tokens": 2000,
             "ollama_base_url": "http://localhost:11434",  # Ensure this URL is correct
         },
     },

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/overview.mdx

@@ -16,20 +16,46 @@ Here are some examples of how Mem0 can be integrated into various applications:
 
 ## Examples
 
-<CardGroup cols={2}>
-  <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>  
 </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

@@ -0,0 +1,131 @@
+---
+title: FAQs
+icon: "question"
+iconType: "solid"
+---
+
+
+<AccordionGroup>
+    <Accordion title="How does Mem0 work?">
+        Mem0 utilizes a sophisticated hybrid database system to efficiently manage and retrieve memories for AI agents and assistants. Each memory is linked to a unique identifier, such as a user ID or agent ID, enabling Mem0 to organize and access memories tailored to specific individuals or contexts.
+
+        When a message is added to Mem0 via the `add` method, the system extracts pertinent facts and preferences, distributing them across various data stores: a vector database and a graph database. This hybrid strategy ensures that diverse types of information are stored optimally, facilitating swift and effective searches.
+
+        When an AI agent or LLM needs to access memories, it employs the `search` method. Mem0 conducts a comprehensive search across these data stores, retrieving relevant information from each.
+
+        The retrieved memories can be seamlessly integrated into the LLM's prompt as required, enhancing the personalization and relevance of responses.
+  </Accordion>
+
+    <Accordion title="What are the key features of Mem0?">
+        - **User, Session, and AI Agent Memory**: Retains information across sessions and interactions for users and AI agents, ensuring continuity and context.
+        - **Adaptive Personalization**: Continuously updates memories based on user interactions and feedback.
+        - **Developer-Friendly API**: Offers a straightforward API for seamless integration into various applications.
+        - **Platform Consistency**: Ensures consistent behavior and data across different platforms and devices.
+        - **Managed Service**: Provides a hosted solution for easy deployment and maintenance.
+        - **Save Costs**: Saves costs by adding relevent memories instead of complete transcripts to context window
+    </Accordion>
+
+    <Accordion title="How Mem0 is different from traditional RAG?">
+        Mem0's memory implementation for Large Language Models (LLMs) offers several advantages over Retrieval-Augmented Generation (RAG):
+
+        - **Entity Relationships**: Mem0 can understand and relate entities across different interactions, unlike RAG which retrieves information from static documents. This leads to a deeper understanding of context and relationships.
+
+        - **Contextual Continuity**: Mem0 retains information across sessions, maintaining continuity in conversations and interactions, which is essential for long-term engagement applications like virtual companions or personalized learning assistants.
+
+        - **Adaptive Learning**: Mem0 improves its personalization based on user interactions and feedback, making the memory more accurate and tailored to individual users over time.
+
+        - **Dynamic Updates**: Mem0 can dynamically update its memory with new information and interactions, unlike RAG which relies on static data. This allows for real-time adjustments and improvements, enhancing the user experience.
+
+        These advanced memory capabilities make Mem0 a powerful tool for developers aiming to create personalized and context-aware AI applications.
+    </Accordion>
+
+
+    <Accordion title="What are the common use-cases of Mem0?">
+        - **Personalized Learning Assistants**: Long-term memory allows learning assistants to remember user preferences, strengths and weaknesses, and progress, providing a more tailored and effective learning experience.
+
+        - **Customer Support AI Agents**: By retaining information from previous interactions, customer support bots can offer more accurate and context-aware assistance, improving customer satisfaction and reducing resolution times.
+
+        - **Healthcare Assistants**: Long-term memory enables healthcare assistants to keep track of patient history, medication schedules, and treatment plans, ensuring personalized and consistent care.
+
+        - **Virtual Companions**: Virtual companions can use long-term memory to build deeper relationships with users by remembering personal details, preferences, and past conversations, making interactions more delightful.
+
+        - **Productivity Tools**: Long-term memory helps productivity tools remember user habits, frequently used documents, and task history, streamlining workflows and enhancing efficiency.
+
+        - **Gaming AI**: In gaming, AI with long-term memory can create more immersive experiences by remembering player choices, strategies, and progress, adapting the game environment accordingly.
+
+    </Accordion>
+
+    <Accordion title="Why aren't my memories being created?">
+        Mem0 uses a sophisticated classification system to determine which parts of text should be extracted as memories. Not all text content will generate memories, as the system is designed to identify specific types of memorable information.
+        There are several scenarios where mem0 may return an empty list of memories:
+
+        - When users input definitional questions (e.g., "What is backpropagation?")
+        - For general concept explanations that don't contain personal or experiential information
+        - Technical definitions and theoretical explanations
+        - General knowledge statements without personal context
+        - Abstract or theoretical content
+
+        Example Scenarios
+
+        ```
+        Input: "What is machine learning?"
+        No memories extracted - Content is definitional and does not meet memory classification criteria.
+
+        Input: "Yesterday I learned about machine learning in class"
+        Memory extracted - Contains personal experience and temporal context.
+        ```
+
+        Best Practices
+
+        To ensure successful memory extraction:
+        - Include temporal markers (when events occurred)
+        - Add personal context or experiences
+        - Frame information in terms of real-world applications or experiences
+        - 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.mdx

@@ -1,5 +1,7 @@
 ---
 title: Features
+icon: "wrench"
+iconType: "solid"
 ---
 
 ## Core features
@@ -13,44 +15,6 @@ title: Features
 
 
 
-## How does Mem0 work?
-
-Mem0 leverages a hybrid database approach to manage and retrieve long-term memories for AI agents and assistants. Each memory is associated with a unique identifier, such as a user ID or agent ID, allowing Mem0 to organize and access memories specific to an individual or context.
-
-When a message is added to the Mem0 using add()  method, the system extracts relevant facts and preferences and stores it across data stores: a vector database, a key-value database, and a graph database. This hybrid approach ensures that different types of information are stored in the most efficient manner, making subsequent searches quick and effective.
-
-When an AI agent or LLM needs to recall memories, it uses the search() method. Mem0 then performs search across these data stores, retrieving relevant information from each source. This information is then passed through a scoring layer, which evaluates their importance based on relevance, importance, and recency. This ensures that only the most personalized and useful context is surfaced.
-
-The retrieved memories can then be appended to the LLM's prompt as needed, making responses personalized and relevant.
-
-
-## Common Use Cases
-
-- **Personalized Learning Assistants**: Long-term memory allows learning assistants to remember user preferences, strengths and weaknesses, and progress, providing a more tailored and effective learning experience.
-
-- **Customer Support AI Agents**: By retaining information from previous interactions, customer support bots can offer more accurate and context-aware assistance, improving customer satisfaction and reducing resolution times.
-
-- **Healthcare Assistants**: Long-term memory enables healthcare assistants to keep track of patient history, medication schedules, and treatment plans, ensuring personalized and consistent care.
-
-- **Virtual Companions**: Virtual companions can use long-term memory to build deeper relationships with users by remembering personal details, preferences, and past conversations, making interactions more delightful.
-
-- **Productivity Tools**: Long-term memory helps productivity tools remember user habits, frequently used documents, and task history, streamlining workflows and enhancing efficiency.
-
-- **Gaming AI**: In gaming, AI with long-term memory can create more immersive experiences by remembering player choices, strategies, and progress, adapting the game environment accordingly.
-
-## How is Mem0 different from RAG?
-
-Mem0's memory implementation for Large Language Models (LLMs) offers several advantages over Retrieval-Augmented Generation (RAG):
-
-- **Entity Relationships**: Mem0 can understand and relate entities across different interactions, unlike RAG which retrieves information from static documents. This leads to a deeper understanding of context and relationships.
-
-- **Contextual Continuity**: Mem0 retains information across sessions, maintaining continuity in conversations and interactions, which is essential for long-term engagement applications like virtual companions or personalized learning assistants.
-
-- **Adaptive Learning**: Mem0 improves its personalization based on user interactions and feedback, making the memory more accurate and tailored to individual users over time.
-
-- **Dynamic Updates**: Mem0 can dynamically update its memory with new information and interactions, unlike RAG which relies on static data. This allows for real-time adjustments and improvements, enhancing the user experience.
-
-These advanced memory capabilities make Mem0 a powerful tool for developers aiming to create personalized and context-aware AI applications.
 
 If you have any questions, please feel free to reach out to us using one of the following methods:
 

docs/features/advanced-retrieval.mdx

@@ -0,0 +1,103 @@
+---
+title: Advanced Retrieval
+icon: "magnifying-glass"
+iconType: "solid"
+---
+
+Mem0's **Advanced Retrieval** feature delivers superior search results by leveraging state-of-the-art search algorithms. Beyond the default search functionality, Mem0 offers the following advanced retrieval modes:
+
+1. **Keyword Search**
+
+   This mode emphasizes keywords within the query, returning memories that contain the most relevant keywords alongside those from the default search. By default, this parameter is set to `false`. Enabling it enhances search recall, though it may slightly impact precision.
+
+   ```python
+   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**
+
+   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 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')
+   ```
+
+   **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
+
+Here are the typical latency ranges for each search mode:
+
+| **Mode**            | **Latency**      |
+|---------------------|------------------|
+| **Keyword Search**  | **&lt;10ms**        |
+| **Reranking**       | **150-200ms**    |
+| **Filtering**       | **200-300ms**    |
+
+
+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/async-client.mdx

@@ -1,6 +1,8 @@
 ---
 title: Async Client
 description: 'Asynchronous client for Mem0'
+icon: "bolt"
+iconType: "solid"
 ---
 
 The `AsyncMemoryClient` is an asynchronous client for interacting with the Mem0 API. It provides similar functionality to the synchronous `MemoryClient` but allows for non-blocking operations, which can be beneficial in applications that require high concurrency.
@@ -12,13 +14,17 @@ To use the async client, you first need to initialize it:
 <CodeGroup>
 
 ```python Python
+import os
 from mem0 import AsyncMemoryClient
-client = AsyncMemoryClient(api_key="your-api-key")
+
+os.environ["MEM0_API_KEY"] = "your-api-key"
+
+client = AsyncMemoryClient()
 ```
 
 ```javascript JavaScript
 const { MemoryClient } = require('mem0ai');
-const client = new MemoryClient('your-api-key');
+const client = new MemoryClient({ apiKey: 'your-api-key'});
 ```
 
 </CodeGroup>
@@ -58,7 +64,7 @@ Search for memories based on a query asynchronously.
 <CodeGroup>
 
 ```python Python
-await client.search(query="What is Alice's favorite sport?", user_id="alice")
+await client.search("What is Alice's favorite sport?", user_id="alice")
 ```
 
 ```javascript JavaScript

docs/features/custom-categories.mdx

@@ -1,6 +1,8 @@
 ---
 title: Custom Categories
 description: 'Enhance your product experience by adding custom categories tailored to your needs'
+icon: "tags"
+iconType: "solid"
 ---
 
 ## How to set custom categories?
@@ -17,9 +19,12 @@ Here's how to set custom categories:
 
 <CodeGroup>
 ```python Code
+import os
 from mem0 import MemoryClient
 
-client = MemoryClient(api_key="<your_mem0_api_key>")
+os.environ["MEM0_API_KEY"] = "your-api-key"
+
+client = MemoryClient()
 
 # Update custom categories
 new_categories = [
@@ -28,7 +33,7 @@ new_categories = [
     {"personal_information": "Basic information about the user including name, preferences, and personality traits"}
 ]
 
-response = client.update_custom_instructions_and_categories({"custom_categories": new_categories})
+response = client.update_project(custom_categories = new_categories)
 print(response)
 ```
 
@@ -51,7 +56,7 @@ messages = [
 ]
 
 # Add memories with custom categories
-client.add(messages, user_id="alice"))
+client.add(messages, user_id="alice")
 ```
 
 ```python Memories with categories
@@ -93,8 +98,11 @@ You can also set custom categories during the `add` API call. This will override
 
 <CodeGroup>
 ```python Code
+import os
 from mem0 import MemoryClient
 
+os.environ["MEM0_API_KEY"] = "your-api-key"
+
 client = MemoryClient(api_key="<your_mem0_api_key>")
 
 custom_categories = [
@@ -146,9 +154,12 @@ Here is the list of **default categories**. If you don't specify any custom cate
 
 <CodeGroup>
 ```python Code
+import os
 from mem0 import MemoryClient
 
-client = MemoryClient(api_key="<your_mem0_api_key>")
+os.environ["MEM0_API_KEY"] = "your-api-key"
+
+client = MemoryClient()
 
 messages = [
     {"role": "user", "content": "Hi, my name is Alice."},
@@ -172,11 +183,11 @@ Name is Alice (personal_details)
 ```
 </CodeGroup>
 
-You can check whether default categories are being used by calling `get_custom_instructions_and_categories()`. If `custom_categories` returns `None`, it means the default categories are being used.
+You can check whether default categories are being used by calling `get_project()`. If `custom_categories` returns `None`, it means the default categories are being used.
 
 <CodeGroup>
 ```python Code
-client.get_custom_instructions_and_categories(["custom_categories"])
+client.get_project(["custom_categories"])
 ```
 
 ```json Output

docs/features/custom-instructions.mdx

@@ -1,6 +1,8 @@
 ---
 title: Custom Instructions
 description: 'Enhance your product experience by adding custom instructions tailored to your needs'
+icon: "pencil"
+iconType: "solid"
 ---
 
 ## Introduction to Custom Instructions

docs/features/custom-prompts.mdx

@@ -1,6 +1,8 @@
 ---
 title: Custom Prompts
 description: 'Enhance your product experience by adding custom prompts tailored to your needs'
+icon: "pencil"
+iconType: "solid"
 ---
 
 ## Introduction to Custom Prompts
@@ -15,7 +17,8 @@ To create an effective custom prompt:
 
 Example of a custom prompt:
 
-```python
+<CodeGroup>
+```python Python
 custom_prompt = """
 Please only extract entities containing customer support information, order details, and user information. 
 Here are some few shot examples:
@@ -37,12 +40,37 @@ Output: {{"facts" : ["Ordered red shirt, size medium", "Received blue shirt inst
 
 Return the facts and customer information in a json format as shown above.
 """
-
 ```
 
-Here we initialize the custom prompt in the config.
+```typescript TypeScript
+const customPrompt = `
+Please only extract entities containing customer support information, order details, and user information. 
+Here are some few shot examples:
 
-```python
+Input: Hi.
+Output: {"facts" : []}
+
+Input: The weather is nice today.
+Output: {"facts" : []}
+
+Input: My order #12345 hasn't arrived yet.
+Output: {"facts" : ["Order #12345 not received"]}
+
+Input: I am John Doe, and I would like to return the shoes I bought last week.
+Output: {"facts" : ["Customer name: John Doe", "Wants to return shoes", "Purchase made last week"]}
+
+Input: I ordered a red shirt, size medium, but received a blue one instead.
+Output: {"facts" : ["Ordered red shirt, size medium", "Received blue shirt instead"]}
+
+Return the facts and customer information in a json format as shown above.
+`;
+```
+</CodeGroup>
+
+Here we initialize the custom prompt in the config:
+
+<CodeGroup>
+```python Python
 from mem0 import Memory
 
 config = {
@@ -51,7 +79,7 @@ config = {
         "config": {
             "model": "gpt-4o",
             "temperature": 0.2,
-            "max_tokens": 1500,
+            "max_tokens": 2000,
         }
     },
     "custom_prompt": custom_prompt,
@@ -61,15 +89,40 @@ config = {
 m = Memory.from_config(config_dict=config, user_id="alice")
 ```
 
+```typescript TypeScript
+import { Memory } from 'mem0ai/oss';
+
+const config = {
+  version: 'v1.1',
+  llm: {
+    provider: 'openai',
+    config: {
+      apiKey: process.env.OPENAI_API_KEY || '',
+      model: 'gpt-4-turbo-preview',
+      temperature: 0.2,
+      maxTokens: 1500,
+    },
+  },
+  customPrompt: customPrompt
+};
+
+const memory = new Memory(config);
+```
+</CodeGroup>
+
 ### Example 1
 
 In this example, we are adding a memory of a user ordering a laptop. As seen in the output, the custom prompt is used to extract the relevant information from the user's message.
 
 <CodeGroup>
-```python Code
+```python Python
 m.add("Yesterday, I ordered a laptop, the order id is 12345", user_id="alice")
 ```
 
+```typescript TypeScript
+await memory.add('Yesterday, I ordered a laptop, the order id is 12345', { userId: "user123" });
+```
+
 ```json Output
 {
   "results": [
@@ -95,11 +148,16 @@ m.add("Yesterday, I ordered a laptop, the order id is 12345", user_id="alice")
 
 In this example, we are adding a memory of a user liking to go on hikes. This add message is not specific to the use-case mentioned in the custom prompt. 
 Hence, the memory is not added.
+
 <CodeGroup>
-```python Code
+```python Python
 m.add("I like going to hikes", user_id="alice")
 ```
 
+```typescript TypeScript
+await memory.add('I like going to hikes', { userId: "user123" });
+```
+
 ```json Output
 {
   "results": [],
@@ -107,3 +165,5 @@ m.add("I like going to hikes", user_id="alice")
 }
 ```
 </CodeGroup>
+
+The custom prompt will process both the user and assistant messages to extract relevant information according to the defined format.

docs/features/direct-import.mdx

@@ -1,6 +1,8 @@
 ---
 title: Direct Import
 description: 'Bypass the memory deduction phase and directly store pre-defined memories for efficient retrieval'
+icon: "arrow-right"
+iconType: "solid"
 ---
 
 ## How to use Direct Import?
@@ -39,7 +41,7 @@ You can retrieve memories using the `search` method.
 <CodeGroup>
 
 ```python Python
-client.search(query="What is Alice's favorite sport?", user_id="alice", output_format="v1.1")
+client.search("What is Alice's favorite sport?", user_id="alice", output_format="v1.1")
 ```
 
 ```json Output

docs/features/memory-export.mdx

@@ -1,6 +1,8 @@
 ---
 title: Memory Export
 description: 'Export memories in a structured format using customizable Pydantic schemas'
+icon: "file-export"
+iconType: "solid"
 ---
 
 ## Overview

docs/features/multimodal-support.mdx

@@ -0,0 +1,171 @@
+---
+title: Multimodal Support
+description: Integrate images into your interactions with Mem0
+icon: "image"
+iconType: "solid"
+---
+
+Mem0 extends its capabilities beyond text by supporting multimodal data, including images. With this feature, users can seamlessly integrate images into their interactions—allowing Mem0 to extract relevant information from visual content and enrich the memory system.
+
+## How It Works
+
+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 Python
+import os
+from mem0 import MemoryClient
+
+os.environ["MEM0_API_KEY"] = "your-api-key"
+
+client = MemoryClient()
+
+messages = [
+    {
+        "role": "user",
+        "content": "Hi, my name is Alice."
+    },
+    {
+        "role": "assistant",
+        "content": "Nice to meet you, Alice! What do you like to eat?"
+    },
+    {
+        "role": "user",
+        "content": {
+            "type": "image_url",
+            "image_url": {
+                "url": "https://www.superhealthykids.com/wp-content/uploads/2021/10/best-veggie-pizza-featured-image-square-2.jpg"
+            }
+        }
+    },
+]
+
+# Calling the add method to ingest messages into the memory system
+client.add(messages, user_id="alice")
+```
+
+```typescript 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": [
+    {
+      "memory": "Name is Alice",
+      "event": "ADD",
+      "id": "7ae113a3-3cb5-46e9-b6f7-486c36391847"
+    },
+    {
+      "memory": "Likes large pizza with toppings including cherry tomatoes, black olives, green spinach, yellow bell peppers, diced ham, and sliced mushrooms",
+      "event": "ADD",
+      "id": "56545065-7dee-4acf-8bf2-a5b2535aabb3"
+    }
+  ]
+}
+```
+</CodeGroup>
+
+## Image Integration Methods
+
+Mem0 supports incorporating images into user interactions using two primary methods: by providing an image URL or by using a Base64-encoded image. The examples below demonstrate both approaches.
+
+## 1. Using an Image URL (Recommended)
+
+You can include an image by providing its direct URL. This method is simple and efficient for online images.
+
+```python {2, 5-13}
+# Define the image URL
+image_url = "https://www.superhealthykids.com/wp-content/uploads/2021/10/best-veggie-pizza-featured-image-square-2.jpg"
+
+# Create the message dictionary with the image URL
+image_message = {
+    "role": "user",
+    "content": {
+        "type": "image_url",
+        "image_url": {
+            "url": image_url
+        }
+    }
+}
+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.
+
+<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 dictionary with the Base64-encoded image
+image_message = {
+    "role": "user",
+    "content": {
+        "type": "image_url",
+        "image_url": {
+            "url": f"data:image/jpeg;base64,{base64_image}"
+        }
+    }
+}
+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:
+
+<Snippet file="get-help.mdx" />

docs/features/openai_compatibility.mdx

@@ -1,5 +1,7 @@
 ---
 title: OpenAI Compatibility
+icon: "code"
+iconType: "solid"
 ---
 
 Mem0 can be easily integrated into chat applications to enhance conversational agents with structured memory. Mem0's APIs are designed to be compatible with OpenAI's, with the goal of making it easy to leverage Mem0 in applications you may have already built.

docs/features/platform-overview.mdx

@@ -0,0 +1,42 @@
+---
+title: Overview
+icon: "info"
+iconType: "solid"
+---
+
+Learn about the key features and capabilities that make Mem0 a powerful platform for memory management and retrieval.
+
+## Core Features
+
+<CardGroup>
+  <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="Multimodal Support" icon="photo-film" href="/features/multimodal-support">
+    Process and analyze various types of content including images.
+  </Card>
+  <Card title="Memory Customization" icon="filter" href="/features/selective-memory">
+    Customize and curate stored memories to focus on relevant information while excluding unnecessary data, enabling improved accuracy, privacy control, and resource efficiency.
+  </Card>
+  <Card title="Custom Categories" icon="tags" href="/features/custom-categories">
+    Create and manage custom categories to organize memories based on your specific needs and requirements.
+  </Card>
+  <Card title="Custom Instructions" icon="list-check" href="/features/custom-instructions">
+    Define specific guidelines for your project to ensure consistent handling of information and requirements.
+  </Card>
+  <Card title="Direct Import" icon="message-bot" href="/features/direct-import">
+    Tailor the behavior of your Mem0 instance with custom prompts for specific use cases or domains.
+  </Card>
+  <Card title="Async Client" icon="bolt" href="/features/async-client">
+    Asynchronous client for non-blocking operations and high concurrency applications.
+  </Card>
+  <Card title="Memory Export" icon="file-export" href="/features/memory-export">
+    Export memories in structured formats using customizable Pydantic schemas.
+  </Card>
+</CardGroup>
+
+## Getting Help
+
+If you have any questions about these features or need assistance, our team is here to help:
+
+<Snippet file="get-help.mdx" />

docs/features/selective-memory.mdx

@@ -1,6 +1,8 @@
 ---
 title: Memory Customization
 description: 'Mem0 supports customizing the memories you store, allowing you to focus on pertinent information while omitting irrelevant data.'
+icon: "filter"
+iconType: "solid"
 ---
 
 ## Benefits of Memory Customization
@@ -27,9 +29,12 @@ Users can define specific kinds of memories to store. This feature enhances memo
 Here’s how you can do it:
 
 ```python
+import os
 from mem0 import MemoryClient
 
-m = MemoryClient(api_key="xxx")
+os.environ["MEM0_API_KEY"] = "your-api-key"
+
+m = MemoryClient()
 
 # Define what to include
 includes = "sports related things"

docs/features/webhooks.mdx

@@ -0,0 +1,201 @@
+---
+title: Webhooks
+description: 'Configure and manage webhooks to receive real-time notifications about memory events'
+icon: "webhook"
+iconType: "solid"
+---
+
+## Overview
+
+Webhooks enable real-time notifications for memory events in your Mem0 project. Webhooks are configured at the project level, meaning each webhook is tied to a specific project and receives events solely from that project. You can configure webhooks to send HTTP POST requests to your specified URLs whenever memories are created, updated, or deleted.
+
+## Managing Webhooks
+
+### Create Webhook
+
+Create a webhook for your project; it will receive events only from that project:
+<CodeGroup>
+
+```python Python
+import os
+from mem0 import MemoryClient
+
+os.environ["MEM0_API_KEY"] = "your-api-key"
+
+client = MemoryClient()
+
+# Create webhook in a specific project
+webhook = client.create_webhook(
+    url="https://your-app.com/webhook",
+    name="Memory Logger",
+    project_id="proj_123",
+    event_types=["memory_add"]
+)
+print(webhook)
+```
+
+```javascript JavaScript
+const { MemoryClient } = require('mem0ai');
+const client = new MemoryClient({ apiKey: 'your-api-key'});
+
+// Create webhook in a specific project
+const webhook = await client.createWebhook({
+    url: "https://your-app.com/webhook",
+    name: "Memory Logger",
+    projectId: "proj_123",
+    eventTypes: ["memory_add"]
+});
+console.log(webhook);
+```
+
+```json Output
+{
+  "webhook_id": "wh_123",
+  "name": "Memory Logger",
+  "url": "https://your-app.com/webhook",
+  "event_types": ["memory_add"],
+  "project": "default-project",
+  "is_active": true,
+  "created_at": "2025-02-18T22:59:56.804993-08:00",
+  "updated_at": "2025-02-18T23:06:41.479361-08:00"
+}
+```
+
+</CodeGroup>
+
+### Get Webhooks
+
+Retrieve all webhooks for your project:
+
+<CodeGroup>
+
+```python Python
+# Get webhooks for a specific project
+webhooks = client.get_webhooks(project_id="proj_123")
+print(webhooks)
+```
+
+```javascript JavaScript
+// Get webhooks for a specific project
+const webhooks = await client.getWebhooks({projectId: "proj_123"});
+console.log(webhooks);
+```
+
+```json Output
+[
+    {
+        "webhook_id": "wh_123",
+        "url": "https://mem0.ai",
+        "name": "mem0",
+        "owner": "john",
+        "event_types": ["memory_add"],
+        "project": "default-project",
+        "is_active": true,
+        "created_at": "2025-02-18T22:59:56.804993-08:00",
+        "updated_at": "2025-02-18T23:06:41.479361-08:00"
+    }
+]
+
+```
+
+</CodeGroup>
+
+### Update Webhook
+
+Update an existing webhook’s configuration by specifying its `webhook_id`:
+
+<CodeGroup>
+
+```python Python
+# Update webhook for a specific project
+updated_webhook = client.update_webhook(
+    name="Updated Logger",
+    url="https://your-app.com/new-webhook",
+    event_types=["memory_update", "memory_add"],
+    webhook_id="wh_123"
+)
+print(updated_webhook)
+```
+
+```javascript JavaScript
+// Update webhook for a specific project
+const updatedWebhook = await client.updateWebhook({
+    name: "Updated Logger",
+    url: "https://your-app.com/new-webhook",
+    eventTypes: ["memory_update", "memory_add"],
+    webhookId: "wh_123"
+});
+console.log(updatedWebhook);
+```
+
+```json Output
+{
+  "message": "Webhook updated successfully"
+}
+```
+
+</CodeGroup>
+
+### Delete Webhook
+
+Delete a webhook by providing its `webhook_id`:
+
+<CodeGroup>
+
+```python Python
+# Delete webhook from a specific project
+response = client.delete_webhook(webhook_id="wh_123")
+print(response)
+```
+
+```javascript JavaScript
+// Delete webhook from a specific project
+const response = await client.deleteWebhook({webhookId: "wh_123"});
+console.log(response);
+```
+
+```json Output
+{
+  "message": "Webhook deleted successfully"
+}
+```
+
+</CodeGroup>
+
+## Event Types
+
+Mem0 supports the following event types for webhooks:
+
+- `memory_add`: Triggered when a memory is added.
+- `memory_update`: Triggered when an existing memory is updated.
+- `memory_delete`: Triggered when a memory is deleted.
+
+## Webhook Payload
+
+When a memory event occurs, Mem0 sends an HTTP POST request to your webhook URL with the following payload:
+
+```json
+{
+    "event_details": {
+        "id": "a1b2c3d4-e5f6-4g7h-8i9j-k0l1m2n3o4p5",
+            "data": {
+            "memory": "Name is Alex"
+            },
+        "event": "ADD"
+    }
+}
+```
+
+## Best Practices
+
+1. **Implement Retry Logic**: Ensure your webhook endpoint can handle temporary failures by implementing retry logic.
+
+2. **Verify Webhook Source**: Implement security measures to verify that webhook requests originate from Mem0.
+
+3. **Process Events Asynchronously**: Process webhook events asynchronously to avoid timeouts and ensure reliable handling.
+
+4. **Monitor Webhook Health**: Regularly review your webhook logs to ensure functionality and promptly address any delivery failures.
+
+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/integrations/autogen.mdx

@@ -30,9 +30,10 @@ USER_ID = "customer_service_bot"
 
 # Set up OpenAI API key
 os.environ['OPENAI_API_KEY'] = OPENAI_API_KEY
+os.environ['MEM0_API_KEY'] = MEM0_API_KEY
 
 # Initialize Mem0 and AutoGen agents
-memory_client = MemoryClient(api_key=MEM0_API_KEY)
+memory_client = MemoryClient()
 agent = ConversableAgent(
     "chatbot",
     llm_config={"config_list": [{"model": "gpt-4", "api_key": OPENAI_API_KEY}]},

docs/integrations/crewai.mdx

@@ -164,3 +164,5 @@ By combining CrewAI with Mem0, you can create sophisticated AI systems that main
 
 - For CrewAI documentation, visit [CrewAI Documentation](https://docs.crewai.com/)
 - For Mem0 documentation, refer to the [Mem0 Platform](https://app.mem0.ai/)
+
+<Snippet file="get-help.mdx" />

docs/integrations/dify.mdx

@@ -0,0 +1,34 @@
+---
+title: Dify
+---
+
+# Integrating Mem0 with Dify AI
+
+Mem0 brings a robust memory layer to Dify AI, empowering your AI agents with persistent conversation storage and retrieval capabilities. With Mem0, your Dify applications gain the ability to recall past interactions and maintain context, ensuring more natural and insightful conversations.
+
+---
+
+## How to Integrate Mem0 in Your Dify Workflow
+
+1. **Install the Mem0 Plugin:**  
+   Head to the [Dify Marketplace](https://marketplace.dify.ai/plugins/yevanchen/mem0) and install the Mem0 plugin. This is your first step toward adding intelligent memory to your AI applications.
+
+2. **Create or Open Your Dify Project:**  
+   Whether you're starting fresh or updating an existing project, simply create or open your Dify workspace.
+
+3. **Add the Mem0 Plugin to Your Project:**  
+   Within your project, add the Mem0 plugin. This integration connects Mem0’s memory management capabilities directly to your Dify application.
+
+4. **Configure Your Mem0 Settings:**  
+   Customize Mem0 to suit your needs—set preferences for how conversation history is stored, the search parameters, and any other context-aware features.
+
+5. **Leverage Mem0 in Your Workflow:**  
+   Use Mem0 to store every conversation turn and retrieve past interactions seamlessly. This integration ensures that your AI agents can refer back to important context, making multi-turn dialogues more effective and user-centric.
+
+---
+
+![Mem0 Dify Integration](/images/dify-mem0-integration.png)
+
+Enhance your Dify-powered AI with Mem0 and transform your conversational experiences. Start integrating intelligent memory management today and give your agents the context they need to excel!
+
+[Explore Mem0 on Dify Marketplace](https://marketplace.dify.ai/plugins/yevanchen/mem0)

docs/integrations/langchain-tools.mdx

@@ -25,9 +25,11 @@ from langchain_core.tools import StructuredTool
 from mem0 import MemoryClient
 from pydantic import BaseModel, Field
 from typing import List, Dict, Any, Optional
+import os
+
+os.environ["MEM0_API_KEY"] = "your-api-key"
 
 client = MemoryClient(
-    api_key=your_api_key,
     org_id=your_org_id,
     project_id=your_project_id
 )
@@ -325,4 +327,10 @@ All tools are implemented as Langchain `StructuredTool` instances, making them c
 2. Add the tools to your agent's toolset
 3. The agent can now use these tools to manage memories through natural language interactions
 
-Each tool provides structured input validation through Pydantic models and returns consistent responses that can be processed by your agent.
+Each tool provides structured input validation through Pydantic models and returns consistent responses that can be processed by your agent.
+
+## Help
+
+In case of any questions, please feel free to reach out to us using one of the following methods:
+
+<Snippet file="get-help.mdx" />

docs/integrations/langchain.mdx

@@ -37,7 +37,7 @@ os.environ["MEM0_API_KEY"] = "your-mem0-api-key"
 
 # Initialize LangChain and Mem0
 llm = ChatOpenAI(model="gpt-4o-mini")
-mem0 = MemoryClient(api_key=os.environ["MEM0_API_KEY"])
+mem0 = MemoryClient()
 ```
 
 ## Create Prompt Template

docs/integrations/llama-index.mdx

@@ -80,7 +80,7 @@ config = {
         "config": {
             "model": "gpt-4o",
             "temperature": 0.2,
-            "max_tokens": 1500,
+            "max_tokens": 2000,
         },
     },
     "embedder": {

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/multion.mdx

@@ -34,10 +34,11 @@ USER_ID = "your-user-id"
 
 # Set up OpenAI API key
 os.environ['OPENAI_API_KEY'] = OPENAI_API_KEY
+os.environ['MEM0_API_KEY'] = MEM0_API_KEY
 
 # Initialize Mem0 and MultiOn
 memory = Memory()  # For local usage
-memory_client = MemoryClient(api_key=MEM0_API_KEY)  # For API usage
+memory_client = MemoryClient()  # For API usage
 multion = MultiOn(api_key=MULTION_API_KEY)
 ```
 
@@ -209,3 +210,5 @@ These examples illustrate how combining memory management with web browsing capa
 - For more details and advanced usage, refer to the full [cookbooks here](https://github.com/mem0ai/mem0/blob/main/cookbooks).
 - Feel free to visit our [Github](https://github.com/mem0ai/mem0) or [Mem0 Platform](https://app.mem0.ai/).
 - For any questions or assistance, please reach out to `taranjeetio` on [Discord](https://mem0.dev/DiD).
+
+<Snippet file="get-help.mdx" />

docs/integrations/vercel-ai-sdk.mdx

@@ -5,7 +5,7 @@ title: Vercel AI SDK
 The [**Mem0 AI SDK Provider**](https://www.npmjs.com/package/@mem0/vercel-ai-provider) is a library developed by **Mem0** to integrate with the Vercel AI SDK. This library brings enhanced AI interaction capabilities to your applications by introducing persistent memory functionality.
 
 <Note type="info">
-  🎉 Exciting news! Mem0 AI SDK now supports **OpenAI**, **Anthropic**, **Cohere**, and **Groq** providers.
+  🎉 Exciting news! Mem0 AI SDK now supports <strong>Tools Call</strong>.
 </Note>
 
 ## Overview
@@ -43,11 +43,19 @@ npm install @mem0/vercel-ai-provider
       config: {
         compatibility: "strict",
       },
+      // Optional Mem0 Global Config
+      mem0Config: {
+        user_id: "mem0-user-id",
+        org_id: "mem0-org-id",
+        project_id: "mem0-project-id",
+      },
     });
     ```
 
     > **Note**: The `openai` provider is set as default. Consider using `MEM0_API_KEY` and `OPENAI_API_KEY` as environment variables for security.
 
+    > **Note**: The `mem0Config` is optional. It is used to set the global config for the Mem0 Client (eg. `user_id`, `agent_id`, `app_id`, `run_id`, `org_id`, `project_id` etc).
+
 3. Add Memories to Enhance Context:
 
     ```typescript
@@ -145,6 +153,44 @@ npm install @mem0/vercel-ai-provider
     }
     ```
 
+### 4. Generate Responses with Tools Call
+
+    ```typescript
+    import { generateText } from "ai";
+    import { createMem0 } from "@mem0/vercel-ai-provider";
+    import { z } from "zod";
+
+    const mem0 = createMem0({
+      provider: "anthropic",
+      apiKey: "anthropic-api-key",
+      mem0Config: {
+        // Global User ID
+        user_id: "borat"
+      }
+    });
+
+    const prompt = "What the temperature in the city that I live in?"
+
+    const result = await generateText({
+      model: mem0('claude-3-5-sonnet-20240620'),
+      tools: {
+        weather: tool({
+          description: 'Get the weather in a location',
+          parameters: z.object({
+            location: z.string().describe('The location to get the weather for'),
+          }),
+          execute: async ({ location }) => ({
+            location,
+            temperature: 72 + Math.floor(Math.random() * 21) - 10,
+          }),
+        }),
+      },
+      prompt: prompt,
+    });
+
+    console.log(result);
+    ```
+
 ## Key Features
 
 - `createMem0()`: Initializes a new Mem0 provider instance.