version bump -> 0.1.72 (#2405)

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

.github/workflows/cd.yml

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

.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
@@ -103,7 +104,7 @@ ipython_config.py
 # pdm
 #   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
 #pdm.lock
-#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended not to include it
 #   in version control.
 #   https://pdm.fming.dev/#use-with-ide
 .pdm.toml
@@ -184,3 +185,4 @@ notebooks/*.yaml
 eval/
 qdrant_storage/
 .crossnote
+testing.ipynb

.pre-commit-config.yaml

@@ -0,0 +1,16 @@
+repos:
+  - repo: local
+    hooks:
+      - id: ruff
+        name: Ruff
+        entry: ruff check
+        language: system
+        types: [python]
+        args: [--fix] 
+
+      - id: isort
+        name: isort
+        entry: isort
+        language: system
+        types: [python]
+        args: ["--profile", "black"]

CONTRIBUTING.md

@@ -0,0 +1,55 @@
+# Contributing to mem0
+
+Let us make contribution easy, collaborative and fun.
+
+## Submit your Contribution through PR
+
+To make a contribution, follow these steps:
+
+1. Fork and clone this repository
+2. Do the changes on your fork with dedicated feature branch `feature/f1`
+3. If you modified the code (new feature or bug-fix), please add tests for it
+4. Include proper documentation / docstring and examples to run the feature
+5. Ensure that all tests pass
+6. Submit a pull request
+
+For more details about pull requests, please read [GitHub's guides](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-a-pull-request).
+
+
+### 📦 Package manager
+
+We use `poetry` as our package manager. You can install poetry by following the instructions [here](https://python-poetry.org/docs/#installation).
+
+Please DO NOT use pip or conda to install the dependencies. Instead, use poetry:
+
+```bash
+make install_all
+
+#activate
+
+poetry shell
+```
+
+### 📌 Pre-commit
+
+To ensure our standards, make sure to install pre-commit before starting to contribute.
+
+```bash
+pre-commit install
+```
+
+### 🧪 Testing
+
+We use `pytest` to test our code. You can run the tests by running the following command:
+
+```bash
+poetry run pytest tests
+
+# or
+
+make test
+```
+
+Several packages have been removed from Poetry to make the package lighter. Therefore, it is recommended to run `make install_all` to install the remaining packages and ensure all tests pass. Make sure that all tests pass before submitting a pull request.
+
+We look forward to your pull requests and can't wait to see your contributions!

Makefile

@@ -12,19 +12,20 @@ install:
 
 install_all:
 	poetry install
-	poetry run pip install groq together boto3 litellm ollama
+	poetry run pip install groq together boto3 litellm ollama chromadb weaviate weaviate-client sentence_transformers vertexai \
+	                        google-generativeai elasticsearch opensearch-py vecs
 
 # Format code with ruff
 format:
-	poetry run ruff check . --fix $(RUFF_OPTIONS)
+	poetry run ruff format mem0/
 
 # Sort imports with isort
 sort:
-	poetry run isort . $(ISORT_OPTIONS)
+	poetry run isort mem0/
 
 # Lint code with ruff
 lint:
-	poetry run ruff .
+	poetry run ruff check mem0/
 
 docs:
 	cd docs && mintlify dev

README.md

@@ -2,66 +2,70 @@
   <a href="https://github.com/mem0ai/mem0">
   <img src="docs/images/banner-sm.png" width="800px" alt="Mem0 - The Memory Layer for Personalized AI">
   </a>
+<p align="center" style="display: flex; justify-content: center; gap: 20px; align-items: center;">
+  <a href="https://trendshift.io/repositories/11194" target="_blank">
+    <img src="https://trendshift.io/api/badge/repositories/11194" alt="mem0ai%2Fmem0 | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/>
+  </a>
+  <a href="https://www.ycombinator.com/launches/LpA-mem0-open-source-memory-layer-for-ai-apps" target="_blank">
+    <img alt="Launch YC: Mem0 - Open Source Memory Layer for AI Apps" src="https://www.ycombinator.com/launches/LpA-mem0-open-source-memory-layer-for-ai-apps/upvote_embed.svg"/>
+  </a>
+</p>
+
+
   <p align="center">
     <a href="https://mem0.ai">Learn more</a>
     ·
-    <a href="https://mem0.ai/discord">Join Discord</a>
+    <a href="https://mem0.dev/DiG">Join Discord</a>
+    ·
+    <a href="https://mem0.dev/demo">Demo</a>
   </p>
 </p>
 
 <p align="center">
-  <a href="https://mem0.ai/discord">
+  <a href="https://mem0.dev/DiG">
     <img src="https://dcbadge.vercel.app/api/server/6PzXDgEjG5?style=flat" alt="Mem0 Discord">
   </a>
   <a href="https://pepy.tech/project/mem0ai">
     <img src="https://img.shields.io/pypi/dm/mem0ai" alt="Mem0 PyPI - Downloads" >
   </a>
+  <a href="https://github.com/mem0ai/mem0">
+    <img src="https://img.shields.io/github/commit-activity/m/mem0ai/mem0?style=flat-square" alt="GitHub commit activity">
+  </a>
+  <a href="https://pypi.org/project/mem0ai" target="_blank">
+        <img src="https://img.shields.io/pypi/v/mem0ai?color=%2334D058&label=pypi%20package" alt="Package version">
+    </a>
+    <a href="https://www.npmjs.com/package/mem0ai" target="_blank">
+        <img src="https://img.shields.io/npm/v/mem0ai" alt="Npm package">
+    </a>
   <a href="https://www.ycombinator.com/companies/mem0">
     <img src="https://img.shields.io/badge/Y%20Combinator-S24-orange?style=flat-square" alt="Y Combinator S24">
   </a>
 </p>
 
+
 # Introduction
 
-[Mem0](https://mem0.ai)(pronounced "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.
+[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.
 
-### Core Features
+### Features & Use Cases
 
-- **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
+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
 
-### 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:
 
@@ -69,103 +73,117 @@ 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[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).
+
+
+[Chrome Extension Demo](https://github.com/user-attachments/assets/ca92e40b-c453-4ff6-b25e-739fb18a8650)
+
+<br/><br/>
+
+- 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)
+
+
 
 ## 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
 
 Join our community for support and discussions. If you have any questions, feel free to reach out to us using one of the following methods:
 
-- [Join our Discord](https://mem0.ai/discord)
+- [Join our Discord](https://mem0.dev/DiG)
 - [Follow us on Twitter](https://x.com/mem0ai)
 - [Email founders](mailto:founders@mem0.ai)
 
-## Contributors
-
-Join our [Discord community](https://mem0.ai/discord) 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>
-
 ## License
 
-This project is licensed under the Apache 2.0 License - see the [LICENSE](LICENSE) file for details.
+This project is licensed under the Apache 2.0 License - see the [LICENSE](LICENSE) file for details.

cookbooks/add_memory_using_qdrant_cloud.py

@@ -1,40 +0,0 @@
-# This example shows how to use vector config to use QDRANT CLOUD
-import os
-from dotenv import load_dotenv
-from mem0 import Memory
-
-# Loading OpenAI API Key
-load_dotenv()
-OPENAI_API_KEY = os.environ.get('OPENAI_API_KEY')
-USER_ID = "test"
-quadrant_host="xx.gcp.cloud.qdrant.io"
-
-# creating the config attributes
-collection_name="memory" # this is the collection I created in QDRANT cloud
-api_key=os.environ.get("QDRANT_API_KEY") # Getting the QDRANT api KEY
-host=quadrant_host
-port=6333 #Default port for QDRANT cloud
-
-# Creating the config dict
-config = {
-    "vector_store": {
-        "provider": "qdrant",
-        "config": {
-            "collection_name": collection_name,
-            "host": host,
-            "port": port,
-            "path": None,
-            "api_key":api_key
-        }
-    }
-}
-
-# this is the change, create the memory class using from config
-memory = Memory().from_config(config)
-
-USER_DATA = """
-I am a strong believer in memory architecture.
-"""
-
-response = memory.add(USER_DATA, user_id=USER_ID)
-print(response)

cookbooks/customer-support-chatbot.ipynb

@@ -0,0 +1,239 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "from typing import List, Dict\n",
+    "from mem0 import Memory\n",
+    "from datetime import datetime\n",
+    "import anthropic\n",
+    "\n",
+    "# Set up environment variables\n",
+    "os.environ[\"OPENAI_API_KEY\"] = \"your_openai_api_key\" # needed for embedding model\n",
+    "os.environ[\"ANTHROPIC_API_KEY\"] = \"your_anthropic_api_key\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class SupportChatbot:\n",
+    "    def __init__(self):\n",
+    "        # Initialize Mem0 with Anthropic's Claude\n",
+    "        self.config = {\n",
+    "            \"llm\": {\n",
+    "                \"provider\": \"anthropic\",\n",
+    "                \"config\": {\n",
+    "                    \"model\": \"claude-3-5-sonnet-latest\",\n",
+    "                    \"temperature\": 0.1,\n",
+    "                    \"max_tokens\": 2000,\n",
+    "                }\n",
+    "            }\n",
+    "        }\n",
+    "        self.client = anthropic.Client(api_key=os.environ[\"ANTHROPIC_API_KEY\"])\n",
+    "        self.memory = Memory.from_config(self.config)\n",
+    "\n",
+    "        # Define support context\n",
+    "        self.system_context = \"\"\"\n",
+    "        You are a helpful customer support agent. Use the following guidelines:\n",
+    "        - Be polite and professional\n",
+    "        - Show empathy for customer issues\n",
+    "        - Reference past interactions when relevant\n",
+    "        - Maintain consistent information across conversations\n",
+    "        - If you're unsure about something, ask for clarification\n",
+    "        - Keep track of open issues and follow-ups\n",
+    "        \"\"\"\n",
+    "\n",
+    "    def store_customer_interaction(self,\n",
+    "                                 user_id: str,\n",
+    "                                 message: str,\n",
+    "                                 response: str,\n",
+    "                                 metadata: Dict = None):\n",
+    "        \"\"\"Store customer interaction in memory.\"\"\"\n",
+    "        if metadata is None:\n",
+    "            metadata = {}\n",
+    "\n",
+    "        # Add timestamp to metadata\n",
+    "        metadata[\"timestamp\"] = datetime.now().isoformat()\n",
+    "\n",
+    "        # Format conversation for storage\n",
+    "        conversation = [\n",
+    "            {\"role\": \"user\", \"content\": message},\n",
+    "            {\"role\": \"assistant\", \"content\": response}\n",
+    "        ]\n",
+    "\n",
+    "        # Store in Mem0\n",
+    "        self.memory.add(\n",
+    "            conversation,\n",
+    "            user_id=user_id,\n",
+    "            metadata=metadata\n",
+    "        )\n",
+    "\n",
+    "    def get_relevant_history(self, user_id: str, query: str) -> List[Dict]:\n",
+    "        \"\"\"Retrieve relevant past interactions.\"\"\"\n",
+    "        return self.memory.search(\n",
+    "            query=query,\n",
+    "            user_id=user_id,\n",
+    "            limit=5  # Adjust based on needs\n",
+    "        )\n",
+    "\n",
+    "    def handle_customer_query(self, user_id: str, query: str) -> str:\n",
+    "        \"\"\"Process customer query with context from past interactions.\"\"\"\n",
+    "\n",
+    "        # Get relevant past interactions\n",
+    "        relevant_history = self.get_relevant_history(user_id, query)\n",
+    "\n",
+    "        # Build context from relevant history\n",
+    "        context = \"Previous relevant interactions:\\n\"\n",
+    "        for memory in relevant_history:\n",
+    "            context += f\"Customer: {memory['memory']}\\n\"\n",
+    "            context += f\"Support: {memory['memory']}\\n\"\n",
+    "            context += \"---\\n\"\n",
+    "\n",
+    "        # Prepare prompt with context and current query\n",
+    "        prompt = f\"\"\"\n",
+    "        {self.system_context}\n",
+    "\n",
+    "        {context}\n",
+    "\n",
+    "        Current customer query: {query}\n",
+    "\n",
+    "        Provide a helpful response that takes into account any relevant past interactions.\n",
+    "        \"\"\"\n",
+    "\n",
+    "        # Generate response using Claude\n",
+    "        response = self.client.messages.create(\n",
+    "            model=\"claude-3-5-sonnet-latest\",\n",
+    "            messages=[{\"role\": \"user\", \"content\": prompt}],\n",
+    "            max_tokens=2000,\n",
+    "            temperature=0.1\n",
+    "        )\n",
+    "\n",
+    "        # Store interaction\n",
+    "        self.store_customer_interaction(\n",
+    "            user_id=user_id,\n",
+    "            message=query,\n",
+    "            response=response,\n",
+    "            metadata={\"type\": \"support_query\"}\n",
+    "        )\n",
+    "\n",
+    "        return response.content[0].text"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Welcome to Customer Support! Type 'exit' to end the conversation.\n",
+      "Customer: Hi, I'm having trouble connecting my new smartwatch to the mobile app. It keeps showing a connection error.\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/5x/9kmqjfm947g5yh44m7fjk75r0000gn/T/ipykernel_99777/1076713094.py:55: DeprecationWarning: The current get_all API output format is deprecated. To use the latest format, set `api_version='v1.1'`. The current format will be removed in mem0ai 1.1.0 and later versions.\n",
+      "  return self.memory.search(\n",
+      "/var/folders/5x/9kmqjfm947g5yh44m7fjk75r0000gn/T/ipykernel_99777/1076713094.py:47: DeprecationWarning: The current add API output format is deprecated. To use the latest format, set `api_version='v1.1'`. The current format will be removed in mem0ai 1.1.0 and later versions.\n",
+      "  self.memory.add(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Support: Hello! Thank you for reaching out about the connection issue with your smartwatch. I understand how frustrating it can be when a new device won't connect properly. I'll be happy to help you resolve this.\n",
+      "\n",
+      "To better assist you, could you please provide me with:\n",
+      "1. The model of your smartwatch\n",
+      "2. The type of phone you're using (iOS or Android)\n",
+      "3. Whether you've already installed the companion app on your phone\n",
+      "4. If you've tried pairing the devices before\n",
+      "\n",
+      "These details will help me provide you with the most accurate troubleshooting steps. In the meantime, here are some general tips that might help:\n",
+      "- Make sure Bluetooth is enabled on your phone\n",
+      "- Keep your smartwatch and phone within close range (within 3 feet) during pairing\n",
+      "- Ensure both devices have sufficient battery power\n",
+      "- Check if your phone's operating system meets the minimum requirements for the smartwatch\n",
+      "\n",
+      "Please provide the requested information, and I'll guide you through the specific steps to resolve the connection error.\n",
+      "\n",
+      "Is there anything else you'd like to share about the issue? \n",
+      "\n",
+      "\n",
+      "Customer: The connection issue is still happening even after trying the steps you suggested.\n",
+      "Support: I apologize that you're still experiencing connection issues with your smartwatch. I understand how frustrating it must be to have this problem persist even after trying the initial troubleshooting steps. Let's try some additional solutions to resolve this.\n",
+      "\n",
+      "Before we proceed, could you please confirm:\n",
+      "1. Which specific steps you've already attempted?\n",
+      "2. Are you seeing any particular error message?\n",
+      "3. What model of smartwatch and phone are you using?\n",
+      "\n",
+      "This information will help me provide more targeted solutions and avoid suggesting steps you've already tried. In the meantime, here are a few advanced troubleshooting steps we can consider:\n",
+      "\n",
+      "1. Completely resetting the Bluetooth connection\n",
+      "2. Checking for any software updates for both the watch and phone\n",
+      "3. Testing the connection with a different mobile device to isolate the issue\n",
+      "\n",
+      "Would you be able to provide those details so I can better assist you? I'll make sure to document this ongoing issue to help track its resolution. \n",
+      "\n",
+      "\n",
+      "Customer: exit\n",
+      "Thank you for using our support service. Goodbye!\n"
+     ]
+    }
+   ],
+   "source": [
+    "chatbot = SupportChatbot()\n",
+    "user_id = \"customer_bot\"\n",
+    "print(\"Welcome to Customer Support! Type 'exit' to end the conversation.\")\n",
+    "\n",
+    "while True:\n",
+    "    # Get user input\n",
+    "    query = input()\n",
+    "    print(\"Customer:\", query)\n",
+    "    \n",
+    "    # Check if user wants to exit\n",
+    "    if query.lower() == 'exit':\n",
+    "        print(\"Thank you for using our support service. Goodbye!\")\n",
+    "        break\n",
+    "    \n",
+    "    # Handle the query and print the response\n",
+    "    response = chatbot.handle_customer_query(user_id, query)\n",
+    "    print(\"Support:\", response, \"\\n\\n\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

cookbooks/helper/mem0_teachability.py

@@ -0,0 +1,170 @@
+# Copyright (c) 2023 - 2024, Owners of https://github.com/autogen-ai
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# Portions derived from  https://github.com/microsoft/autogen are under the MIT License.
+# SPDX-License-Identifier: MIT
+# forked from autogen.agentchat.contrib.capabilities.teachability.Teachability
+
+from typing import Dict, Optional, Union
+from autogen.agentchat.assistant_agent import ConversableAgent
+from autogen.agentchat.contrib.capabilities.agent_capability import AgentCapability
+from autogen.agentchat.contrib.text_analyzer_agent import TextAnalyzerAgent
+from termcolor import colored
+from mem0 import Memory
+
+
+class Mem0Teachability(AgentCapability):
+    def __init__(
+        self,
+        verbosity: Optional[int] = 0,
+        reset_db: Optional[bool] = False,
+        recall_threshold: Optional[float] = 1.5,
+        max_num_retrievals: Optional[int] = 10,
+        llm_config: Optional[Union[Dict, bool]] = None,
+        agent_id: Optional[str] = None,
+        memory_client: Optional[Memory] = None,
+    ):
+        self.verbosity = verbosity
+        self.recall_threshold = recall_threshold
+        self.max_num_retrievals = max_num_retrievals
+        self.llm_config = llm_config
+        self.analyzer = None
+        self.teachable_agent = None
+        self.agent_id = agent_id
+        self.memory = memory_client if memory_client else Memory()
+
+        if reset_db:
+            self.memory.reset()
+
+    def add_to_agent(self, agent: ConversableAgent):
+        self.teachable_agent = agent
+        agent.register_hook(hookable_method="process_last_received_message", hook=self.process_last_received_message)
+
+        if self.llm_config is None:
+            self.llm_config = agent.llm_config
+        assert self.llm_config, "Teachability requires a valid llm_config."
+
+        self.analyzer = TextAnalyzerAgent(llm_config=self.llm_config)
+
+        agent.update_system_message(
+            agent.system_message
+            + "\nYou've been given the special ability to remember user teachings from prior conversations."
+        )
+
+    def process_last_received_message(self, text: Union[Dict, str]):
+        expanded_text = text
+        if self.memory.get_all(agent_id=self.agent_id):
+            expanded_text = self._consider_memo_retrieval(text)
+        self._consider_memo_storage(text)
+        return expanded_text
+
+    def _consider_memo_storage(self, comment: Union[Dict, str]):
+        response = self._analyze(
+            comment,
+            "Does any part of the TEXT ask the agent to perform a task or solve a problem? Answer with just one word, yes or no.",
+        )
+
+        if "yes" in response.lower():
+            advice = self._analyze(
+                comment,
+                "Briefly copy any advice from the TEXT that may be useful for a similar but different task in the future. But if no advice is present, just respond with 'none'.",
+            )
+
+            if "none" not in advice.lower():
+                task = self._analyze(
+                    comment,
+                    "Briefly copy just the task from the TEXT, then stop. Don't solve it, and don't include any advice.",
+                )
+
+                general_task = self._analyze(
+                    task,
+                    "Summarize very briefly, in general terms, the type of task described in the TEXT. Leave out details that might not appear in a similar problem.",
+                )
+
+                if self.verbosity >= 1:
+                    print(colored("\nREMEMBER THIS TASK-ADVICE PAIR", "light_yellow"))
+                self.memory.add(
+                    [{"role": "user", "content": f"Task: {general_task}\nAdvice: {advice}"}], agent_id=self.agent_id
+                )
+
+        response = self._analyze(
+            comment,
+            "Does the TEXT contain information that could be committed to memory? Answer with just one word, yes or no.",
+        )
+
+        if "yes" in response.lower():
+            question = self._analyze(
+                comment,
+                "Imagine that the user forgot this information in the TEXT. How would they ask you for this information? Include no other text in your response.",
+            )
+
+            answer = self._analyze(
+                comment, "Copy the information from the TEXT that should be committed to memory. Add no explanation."
+            )
+
+            if self.verbosity >= 1:
+                print(colored("\nREMEMBER THIS QUESTION-ANSWER PAIR", "light_yellow"))
+            self.memory.add(
+                [{"role": "user", "content": f"Question: {question}\nAnswer: {answer}"}], agent_id=self.agent_id
+            )
+
+    def _consider_memo_retrieval(self, comment: Union[Dict, str]):
+        if self.verbosity >= 1:
+            print(colored("\nLOOK FOR RELEVANT MEMOS, AS QUESTION-ANSWER PAIRS", "light_yellow"))
+        memo_list = self._retrieve_relevant_memos(comment)
+
+        response = self._analyze(
+            comment,
+            "Does any part of the TEXT ask the agent to perform a task or solve a problem? Answer with just one word, yes or no.",
+        )
+
+        if "yes" in response.lower():
+            if self.verbosity >= 1:
+                print(colored("\nLOOK FOR RELEVANT MEMOS, AS TASK-ADVICE PAIRS", "light_yellow"))
+            task = self._analyze(
+                comment, "Copy just the task from the TEXT, then stop. Don't solve it, and don't include any advice."
+            )
+
+            general_task = self._analyze(
+                task,
+                "Summarize very briefly, in general terms, the type of task described in the TEXT. Leave out details that might not appear in a similar problem.",
+            )
+
+            memo_list.extend(self._retrieve_relevant_memos(general_task))
+
+        memo_list = list(set(memo_list))
+        return comment + self._concatenate_memo_texts(memo_list)
+
+    def _retrieve_relevant_memos(self, input_text: str) -> list:
+        search_results = self.memory.search(input_text, agent_id=self.agent_id, limit=self.max_num_retrievals)
+        memo_list = [result["memory"] for result in search_results if result["score"] <= self.recall_threshold]
+
+        if self.verbosity >= 1 and not memo_list:
+            print(colored("\nTHE CLOSEST MEMO IS BEYOND THE THRESHOLD:", "light_yellow"))
+            if search_results["results"]:
+                print(search_results["results"][0])
+            print()
+
+        return memo_list
+
+    def _concatenate_memo_texts(self, memo_list: list) -> str:
+        memo_texts = ""
+        if memo_list:
+            info = "\n# Memories that might help\n"
+            for memo in memo_list:
+                info += f"- {memo}\n"
+            if self.verbosity >= 1:
+                print(colored(f"\nMEMOS APPENDED TO LAST MESSAGE...\n{info}\n", "light_yellow"))
+            memo_texts += "\n" + info
+        return memo_texts
+
+    def _analyze(self, text_to_analyze: Union[Dict, str], analysis_instructions: Union[Dict, str]):
+        self.analyzer.reset()
+        self.teachable_agent.send(
+            recipient=self.analyzer, message=text_to_analyze, request_reply=False, silent=(self.verbosity < 2)
+        )
+        self.teachable_agent.send(
+            recipient=self.analyzer, message=analysis_instructions, request_reply=True, silent=(self.verbosity < 2)
+        )
+        return self.teachable_agent.last_message(self.analyzer)["content"]

cookbooks/multion_travel_agent.ipynb

@@ -1,306 +0,0 @@
-{
-  "cells": [
-    {
-      "cell_type": "code",
-      "source": [
-        "!pip install mem0ai"
-      ],
-      "metadata": {
-        "id": "fu3euPKZsbaC"
-      },
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "U2VC_0FElQid"
-      },
-      "outputs": [],
-      "source": [
-        "import os\n",
-        "from openai import OpenAI\n",
-        "from mem0 import MemoryClient\n",
-        "from multion.client import MultiOn\n",
-        "\n",
-        "# Configuration\n",
-        "OPENAI_API_KEY = 'sk-xxx'  # Replace with your actual OpenAI API key\n",
-        "MULTION_API_KEY = 'xx'  # Replace with your actual MultiOn API key\n",
-        "MEM0_API_KEY = 'xx'  # Replace with your actual Mem0 API key\n",
-        "USER_ID = \"test_travel_agent\"\n",
-        "\n",
-        "# Set up OpenAI API key\n",
-        "os.environ['OPENAI_API_KEY'] = OPENAI_API_KEY\n",
-        "\n",
-        "# Initialize Mem0 and MultiOn\n",
-        "memory = MemoryClient(api_key=MEM0_API_KEY)\n",
-        "multion = MultiOn(api_key=MULTION_API_KEY)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "sq-OdPHKlQie",
-        "outputId": "1d605222-0bf5-4ac9-99b9-6059b502c20b"
-      },
-      "outputs": [
-        {
-          "data": {
-            "text/plain": [
-              "{'message': 'Memory added successfully!'}"
-            ]
-          },
-          "execution_count": 2,
-          "metadata": {},
-          "output_type": "execute_result"
-        }
-      ],
-      "source": [
-        "# Add conversation to Mem0\n",
-        "conversation = [\n",
-        "    {\n",
-        "        \"role\": \"user\",\n",
-        "        \"content\": \"What are the best travel destinations in the world?\"\n",
-        "    },\n",
-        "    {\n",
-        "        \"role\": \"assistant\",\n",
-        "        \"content\": \"Could you please specify your interests or the type of travel information you are looking for? This will help me find the most relevant information for you.\"\n",
-        "    },\n",
-        "    {\n",
-        "        \"role\": \"user\",\n",
-        "        \"content\": \"Sure, I want to travel to San Francisco.\"\n",
-        "    },\n",
-        "    {\n",
-        "        \"role\": \"assistant\",\n",
-        "        \"content\": \"\"\"\n",
-        "        Based on the information gathered from TripAdvisor, here are some popular attractions, activities, and travel tips for San Francisco:\n",
-        "\n",
-        "        1. **Golden Gate Bridge**: A must-see iconic landmark.\n",
-        "        2. **Alcatraz Island**: Famous former prison offering tours.\n",
-        "        3. **Fisherman's Wharf**: Popular tourist area with shops, restaurants, and sea lions.\n",
-        "        4. **Chinatown**: The largest Chinatown outside of Asia.\n",
-        "        5. **Golden Gate Park**: Large urban park with gardens, museums, and recreational activities.\n",
-        "        6. **Cable Cars**: Historic streetcars offering a unique way to see the city.\n",
-        "        7. **Exploratorium**: Interactive science museum.\n",
-        "        8. **San Francisco Museum of Modern Art (SFMOMA)**: Modern and contemporary art museum.\n",
-        "        9. **Lombard Street**: Known for its steep, one-block section with eight hairpin turns.\n",
-        "        10. **Union Square**: Major shopping and cultural hub.\n",
-        "\n",
-        "        Travel Tips:\n",
-        "        - **Weather**: San Francisco has a mild climate, but it can be foggy and windy. Dress in layers.\n",
-        "        - **Transportation**: Use public transportation like BART, Muni, and cable cars to get around.\n",
-        "        - **Safety**: Be aware of your surroundings, especially in crowded tourist areas.\n",
-        "        - **Dining**: Try local specialties like sourdough bread, seafood, and Mission-style burritos.\n",
-        "        \"\"\"\n",
-        "    },\n",
-        "    {\n",
-        "        \"role\": \"user\",\n",
-        "        \"content\": \"Show me hotels around Golden Gate Bridge.\"\n",
-        "    },\n",
-        "    {\n",
-        "        \"role\": \"assistant\",\n",
-        "        \"content\": \"\"\"\n",
-        "        The search results for hotels around Golden Gate Bridge in San Francisco include:\n",
-        "\n",
-        "        1. Hilton Hotels In San Francisco - Hotel Near Fishermans Wharf (hilton.com)\n",
-        "        2. The 10 Closest Hotels to Golden Gate Bridge (tripadvisor.com)\n",
-        "        3. Hotels near Golden Gate Bridge (expedia.com)\n",
-        "        4. Hotels near Golden Gate Bridge (hotels.com)\n",
-        "        5. Holiday Inn Express & Suites San Francisco Fishermans Wharf, an IHG Hotel $146 (1.8K) 3-star hotel Golden Gate Bridge • 3.5 mi DEAL 19% less than usual\n",
-        "        6. Holiday Inn San Francisco-Golden Gateway, an IHG Hotel $151 (3.5K) 3-star hotel Golden Gate Bridge • 3.7 mi Casual hotel with dining, a bar & a pool\n",
-        "        7. Hotel Zephyr San Francisco $159 (3.8K) 4-star hotel Golden Gate Bridge • 3.7 mi Nautical-themed lodging with bay views\n",
-        "        8. Lodge at the Presidio\n",
-        "        9. The Inn Above Tide\n",
-        "        10. Cavallo Point\n",
-        "        11. Casa Madrona Hotel and Spa\n",
-        "        12. Cow Hollow Inn and Suites\n",
-        "        13. Samesun San Francisco\n",
-        "        14. Inn on Broadway\n",
-        "        15. Coventry Motor Inn\n",
-        "        16. HI San Francisco Fisherman's Wharf Hostel\n",
-        "        17. Loews Regency San Francisco Hotel\n",
-        "        18. Fairmont Heritage Place Ghirardelli Square\n",
-        "        19. Hotel Drisco Pacific Heights\n",
-        "        20. Travelodge by Wyndham Presidio San Francisco\n",
-        "        \"\"\"\n",
-        "    }\n",
-        "]\n",
-        "\n",
-        "memory.add(conversation, user_id=USER_ID)\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "hO8z9aNTlQif"
-      },
-      "outputs": [],
-      "source": [
-        "def get_travel_info(question, use_memory=True):\n",
-        "    \"\"\"\n",
-        "    Get travel information based on user's question and optionally their preferences from memory.\n",
-        "\n",
-        "    \"\"\"\n",
-        "    if use_memory:\n",
-        "        previous_memories = memory.search(question, user_id=USER_ID)\n",
-        "        relevant_memories_text = \"\"\n",
-        "        if previous_memories:\n",
-        "            print(\"Using previous memories to enhance the search...\")\n",
-        "            relevant_memories_text = '\\n'.join(mem[\"memory\"] for mem in previous_memories)\n",
-        "\n",
-        "        command = \"Find travel information based on my interests:\"\n",
-        "        prompt = f\"{command}\\n Question: {question} \\n My preferences: {relevant_memories_text}\"\n",
-        "    else:\n",
-        "        command = \"Find travel information based on my interests:\"\n",
-        "        prompt = f\"{command}\\n Question: {question}\"\n",
-        "\n",
-        "\n",
-        "    print(\"Searching for travel information...\")\n",
-        "    browse_result = multion.browse(cmd=prompt)\n",
-        "    return browse_result.message"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "Wp2xpzMrlQig"
-      },
-      "source": [
-        "## Example 1"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "bPRPwqsplQig"
-      },
-      "outputs": [],
-      "source": [
-        "question = \"Show me flight details for it.\"\n",
-        "answer_without_memory = get_travel_info(question, use_memory=False)\n",
-        "answer_with_memory = get_travel_info(question, use_memory=True)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "a76ifa2HlQig"
-      },
-      "source": [
-        "| Without Memory                                                                                                                                                                                                                                     | With Memory                                                                                                                                                                                                                                                                                      |\n",
-        "|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n",
-        "| I have performed a Google search for \"flight details\" and reviewed the search results. Here are some relevant links and information:                                                                                                     | Memorizing the following information: Flight details for San Francisco:                                                                                                                                                                                                                                                                          |\n",
-        "| 1. **FlightStats Global Flight Tracker** - Track the real-time flight status of your flight. See if your flight has been delayed or cancelled and track the live status. <br> [Flight Tracker - FlightStats](https://www.flightstats.com/flight-tracker/search)          | 1. Prices from $232. Depart Thursday, August 22. Return Thursday, August 29. <br> 2. Prices from $216. Depart Friday, August 23. Return Friday, August 30. <br> 3. Prices from $236. Depart Saturday, August 24. Return Saturday, August 31. <br> 4. Prices from $215. Depart Sunday, August 25. Return Sunday, September 1. |\n",
-        "| 2. **FlightAware - Flight Tracker** - Track live flights worldwide, see flight cancellations, and browse by airport. <br> [FlightAware - Flight Tracker](https://www.flightaware.com)                                                | 5. Prices from $218. Depart Monday, August 26. Return Monday, September 2. <br> 6. Prices from $211. Depart Tuesday, August 27. Return Tuesday, September 3. <br> 7. Prices from $198. Depart Wednesday, August 28. Return Wednesday, September 4. <br> 8. Prices from $218. Depart Thursday, August 29. Return Thursday, September 5.          |\n",
-        "| 3. **Google Flights** - Show flights based on your search. <br> [Google Flights](https://www.google.com/flights)                                                                                                                            | 9. Prices from $194. Depart Friday, August 30. Return Friday, September 6. <br> 10. Prices from $218. Depart Saturday, August 31. Return Saturday, September 7. <br> 11. Prices from $212. Depart Sunday, September 1. Return Sunday, September 8. <br> 12. Prices from $247. Depart Monday, September 2. Return Monday, September 9.         |\n",
-        "|                                                                                                                                                                                                                                            | 13. Prices from $212. Depart Tuesday, September 3. Return Tuesday, September 10. <br> 14. Prices from $203. Depart Wednesday, September 4. Return Wednesday, September 11. <br> 15. Prices from $242. Depart Thursday, September 5. Return Thursday, September 12. <br> 16. Prices from $191. Depart Friday, September 6. Return Friday, September 13.     |\n",
-        "|                                                                                                                                                                                                                                            | 17. Prices from $215. Depart Saturday, September 7. Return Saturday, September 14. <br> 18. Prices from $229. Depart Sunday, September 8. Return Sunday, September 15. <br> 19. Prices from $183. Depart Monday, September 9. Return Monday, September 16. <br> 65. Prices from $194. Depart Friday, October 25. Return Friday, November 1.                |\n",
-        "|                                                                                                                                                                                                                                            | 66. Prices from $205. Depart Saturday, October 26. Return Saturday, November 2. <br> 67. Prices from $241. Depart Sunday, October 27. Return Sunday, November 3.                                                                                                                                                    |\n"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "0cXpiAwMlQig"
-      },
-      "source": [
-        "## Example 2"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "LpprKfpslQih"
-      },
-      "outputs": [],
-      "source": [
-        "question = \"What places to visit there?\"\n",
-        "answer_without_memory = get_travel_info(question, use_memory=False)\n",
-        "answer_with_memory = get_travel_info(question, use_memory=True)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "kpfjeY1_lQih"
-      },
-      "source": [
-        "| Without Memory                                                                                                                                                                                                                                      | With Memory                                                                                                                                                                                                                                                                                            |\n",
-        "|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n",
-        "| Based on the information gathered, here are some top travel destinations to consider visiting:                                                                                                                                              | Based on the information gathered, here are some top places to visit in San Francisco:                                                                                                                                                                                                                 |\n",
-        "| 1. **Paris**: Known for its iconic attractions like the Eiffel Tower and the Louvre, Paris offers quaint cafes, trendy shopping districts, and beautiful Haussmann architecture. It's a city where you can always discover something new with each visit.        | 1. **Golden Gate Bridge** - An iconic symbol of San Francisco, perfect for walking, biking, or simply enjoying the view. <br> 2. **Alcatraz Island** - The historic former prison offers tours and insights into its storied past. <br> 3. **Fisherman's Wharf** - A bustling waterfront area known for its seafood, shopping, and attractions like Pier 39. <br> 4. **Golden Gate Park** - A large urban park with gardens, museums, and recreational activities. <br> 5. **Chinatown San Francisco** - One of the oldest and most famous Chinatowns in North America, offering unique shops and delicious food. <br> 6. **Coit Tower** - Offers panoramic views of the city and murals depicting San Francisco's history. <br> 7. **Lands End** - A beautiful coastal trail with stunning views of the Pacific Ocean and the Golden Gate Bridge. <br> 8. **Palace of Fine Arts** - A picturesque structure and park, perfect for a leisurely stroll or photo opportunities. <br> 9. **Crissy Field & The Presidio Tunnel Tops** - Great for outdoor activities and scenic views of the bay. |\n",
-        "| 2. **Bora Bora**: This small island in French Polynesia is famous for its stunning turquoise waters, luxurious overwater bungalows, and vibrant coral reefs. It's a popular destination for honeymooners and those seeking a tropical paradise.      |                                                                                                                                                                                                                                                                                                        |\n",
-        "| 3. **Glacier National Park**: Located in Montana, USA, this park is known for its breathtaking landscapes, including rugged mountains, pristine lakes, and diverse wildlife. It's a haven for outdoor enthusiasts and hikers.                  |                                                                                                                                                                                                                                                                                                        |\n",
-        "| 4. **Rome**: The capital of Italy, Rome is rich in history and culture, featuring landmarks such as the Colosseum, the Vatican, and the Pantheon. It's a city where ancient history meets modern life.                                          |                                                                                                                                                                                                                                                                                                        |\n",
-        "| 5. **Swiss Alps**: Renowned for their stunning natural beauty, the Swiss Alps offer opportunities for skiing, hiking, and enjoying picturesque mountain villages.                                                                             |                                                                                                                                                                                                                                                                                                        |\n",
-        "| 6. **Maui**: One of Hawaii's most popular islands, Maui is known for its beautiful beaches, lush rainforests, and the scenic Hana Highway. It's a great destination for both relaxation and adventure.                                        |                                                                                                                                                                                                                                                                                                        |\n",
-        "| 7. **London, England**: A vibrant city with a mix of historical landmarks like the Tower of London and modern attractions such as the London Eye. London offers diverse cultural experiences, world-class museums, and a bustling nightlife.    |                                                                                                                                                                                                                                                                                                        |\n",
-        "| 8. **Maldives**: This tropical paradise in the Indian Ocean is famous for its crystal-clear waters, luxurious resorts, and abundant marine life. It's an ideal destination for snorkeling, diving, and relaxation.                            |                                                                                                                                                                                                                                                                                                        |\n",
-        "| 9. **Turks & Caicos**: Known for its pristine beaches and turquoise waters, this Caribbean destination is perfect for water sports, beach lounging, and exploring coral reefs.                                                                 |                                                                                                                                                                                                                                                                                                        |\n",
-        "| 10. **Tokyo**: Japan's bustling capital offers a unique blend of traditional and modern attractions, from ancient temples to futuristic skyscrapers. Tokyo is also known for its vibrant food scene and shopping districts.                   |                                                                                                                                                                                                                                                                                                        |\n"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "XdpkcMrclQih"
-      },
-      "source": [
-        "## Example 3"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "Nntl2FxulQih"
-      },
-      "outputs": [],
-      "source": [
-        "question = \"What the weather there?\"\n",
-        "answer_without_memory = get_travel_info(question, use_memory=False)\n",
-        "answer_with_memory = get_travel_info(question, use_memory=True)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "yt2pj1irlQih"
-      },
-      "source": [
-        "| Without Memory                                                                                                                                                                                                                                      | With Memory                                                                                                                                                                                                                                                                                            |\n",
-        "|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n",
-        "| The current weather in Paris is light rain with a temperature of 67°F. The precipitation is at 50%, humidity is 95%, and the wind speed is 5 mph.                                                                                   | The current weather in San Francisco is as follows: <br> - **Temperature**: 59°F <br> - **Condition**: Clear with periodic clouds <br> - **Precipitation**: 3% <br> - **Humidity**: 87% <br> - **Wind**: 12 mph                                                                        |\n"
-      ]
-    }
-  ],
-  "metadata": {
-    "kernelspec": {
-      "display_name": ".venv",
-      "language": "python",
-      "name": "python3"
-    },
-    "language_info": {
-      "codemirror_mode": {
-        "name": "ipython",
-        "version": 3
-      },
-      "file_extension": ".py",
-      "mimetype": "text/x-python",
-      "name": "python",
-      "nbconvert_exporter": "python",
-      "pygments_lexer": "ipython3",
-      "version": "3.12.3"
-    },
-    "colab": {
-      "provenance": []
-    }
-  },
-  "nbformat": 4,
-  "nbformat_minor": 0
-}

docs/_snippets/get-help.mdx

@@ -1,11 +1,11 @@
 <CardGroup cols={3}>
-  <Card title="Discord" icon="discord" href="https://mem0.ai/discord" color="#7289DA">
+  <Card title="Discord" icon="discord" href="https://mem0.dev/DiD" color="#7289DA">
     Join our community
   </Card>
-  <Card title="GitHub" icon="github" href="https://github.com/mem0ai/mem0">
-    Star us on GitHub
+  <Card title="GitHub" icon="github" href="https://github.com/mem0ai/mem0/discussions/new?category=q-a">
+    Ask questions on GitHub
   </Card>
-  <Card title="Support" icon="calendar" href="mailto:taranjeet@mem0.ai">
+  <Card title="Support" icon="calendar" href="https://cal.com/taranjeetio/meet">
   Talk to founders
   </Card>
 </CardGroup>

docs/api-reference/entities/delete-user.mdx

@@ -0,0 +1,4 @@
+---
+title: 'Delete User'
+openapi: delete /v1/entities/{entity_type}/{entity_id}/
+---

docs/api-reference/entities/get-users.mdx

@@ -0,0 +1,4 @@
+---
+title: 'Get Users'
+openapi: get /v1/entities/
+---

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

@@ -0,0 +1,4 @@
+---
+title: 'Add Memories'
+openapi: post /v1/memories/
+---

docs/api-reference/memory/batch-delete.mdx

@@ -0,0 +1,4 @@
+---
+title: 'Batch Delete Memories'
+openapi: delete /v1/batch/
+---

docs/api-reference/memory/batch-update.mdx

@@ -0,0 +1,4 @@
+---
+title: 'Batch Update Memories'
+openapi: put /v1/batch/
+---

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

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

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

@@ -0,0 +1,4 @@
+---
+title: 'Delete Memories'
+openapi: delete /v1/memories/
+---

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

@@ -0,0 +1,4 @@
+---
+title: 'Delete Memory'
+openapi: delete /v1/memories/{memory_id}/
+---

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

@@ -0,0 +1,6 @@
+---
+title: 'Get Memory Export'
+openapi: get /v1/exports/
+---
+
+Retrieve the latest structured memory export after submitting an export job. You can filter the export by `user_id`, `run_id`, `session_id`, or `app_id` to get the most recent export matching your filters.

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

@@ -0,0 +1,4 @@
+---
+title: 'Get Memory'
+openapi: get /v1/memories/{memory_id}/
+---

docs/api-reference/memory/history-memory.mdx

@@ -0,0 +1,4 @@
+---
+title: 'Memory History'
+openapi: get /v1/memories/{memory_id}/history/
+---

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

@@ -0,0 +1,4 @@
+---
+title: 'Update Memory'
+openapi: put /v1/memories/{memory_id}/
+---

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

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

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

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

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

@@ -0,0 +1,43 @@
+---
+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
+
+<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>

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

@@ -0,0 +1,51 @@
+---
+title: 'Search Memories (v2)'
+openapi: post /v2/memories/search/
+---
+
+The v2 search API is powerful and flexible, allowing for more precise memory retrieval. It supports complex logical operations (AND, OR) 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
+
+  <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
+  {
+    "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/organization/add-org-member.mdx

@@ -0,0 +1,9 @@
+---
+title: 'Add Member'
+openapi: post /api/v1/orgs/organizations/{org_id}/members/
+---
+
+The API provides two roles for organization members:
+
+- `READER`: Allows viewing of organization resources.
+- `OWNER`: Grants full administrative access to manage the organization and its resources.

docs/api-reference/organization/create-org.mdx

@@ -0,0 +1,4 @@
+---
+title: 'Create Organization'
+openapi: post /api/v1/orgs/organizations/
+---

docs/api-reference/organization/delete-org-member.mdx

@@ -0,0 +1,4 @@
+---
+title: 'Delete Member'
+openapi: delete /api/v1/orgs/organizations/{org_id}/members/
+---

docs/api-reference/organization/delete-org.mdx

@@ -0,0 +1,4 @@
+---
+title: 'Delete Organization'
+openapi: delete /api/v1/orgs/organizations/{org_id}/
+---

docs/api-reference/organization/get-org-members.mdx

@@ -0,0 +1,4 @@
+---
+title: 'Get Members'
+openapi: get /api/v1/orgs/organizations/{org_id}/members/
+---

docs/api-reference/organization/get-org.mdx

@@ -0,0 +1,4 @@
+---
+title: 'Get Organization'
+openapi: get /api/v1/orgs/organizations/{org_id}/
+---

docs/api-reference/organization/get-orgs.mdx

@@ -0,0 +1,4 @@
+---
+title: 'Get Organizations'
+openapi: get /api/v1/orgs/organizations/
+---

docs/api-reference/organization/update-org-member.mdx

@@ -0,0 +1,9 @@
+---
+title: 'Update Member'
+openapi: put /api/v1/orgs/organizations/{org_id}/members/
+---
+
+The API provides two roles for organization members:
+
+- `READER`: Allows viewing of organization resources.
+- `OWNER`: Grants full administrative access to manage the organization and its resources.

docs/api-reference/overview.mdx

@@ -0,0 +1,69 @@
+---
+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.
+
+## Key Features
+
+- **Memory Management**: Add, retrieve, update, and delete memories with ease.
+- **Entity-based Operations**: Perform operations on memories associated with specific users, agents, apps, or runs.
+- **Advanced Search**: Utilize our search API to find relevant memories based on various criteria.
+- **History Tracking**: Access the history of memory interactions for comprehensive analysis.
+- **User Management**: Manage user entities and their associated memories.
+
+## API Structure
+
+Our API is organized into several main categories:
+
+1. **Memory APIs**: Core operations for managing individual memories and collections.
+2. **Entities APIs**: Manage different entity types (users, agents, etc.) and their associated memories.
+3. **Search API**: Advanced search functionality to retrieve relevant memories.
+4. **History API**: Track and retrieve the history of memory interactions.
+
+## Authentication
+
+All API requests require authentication using HTTP Basic Auth. Ensure you include your API key in the Authorization header of each request.
+
+## Organizations and projects (optional)
+
+Organizations and projects provide the following capabilities:
+
+- **Multi-org/project Support**: Specify organization and project when initializing the Mem0 client to attribute API usage appropriately
+- **Member Management**: Control access to data through organization and project membership
+- **Access Control**: Only members can access memories and data within their organization/project scope
+- **Team Isolation**: Maintain data separation between different teams and projects for secure collaboration
+
+Example with the mem0 Python package:
+
+<Tabs>
+  <Tab title="Python">
+
+```python
+from mem0 import MemoryClient
+client = MemoryClient(org_id='YOUR_ORG_ID', project_id='YOUR_PROJECT_ID')
+```
+
+  </Tab>
+
+  <Tab title="Node.js">
+
+```javascript
+import { MemoryClient } from "mem0ai";
+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:
+
+1. Sign up for a [Mem0 account](https://app.mem0.ai) and obtain your API key.
+2. Familiarize yourself with the API endpoints and their functionalities.
+3. Make your first API call to add or retrieve a memory.
+
+Explore the detailed documentation for each API endpoint to learn more about request/response formats, parameters, and example usage.

docs/api-reference/project/add-project-member.mdx

@@ -0,0 +1,9 @@
+---
+title: 'Add Member'
+openapi: post /api/v1/orgs/organizations/{org_id}/projects/{project_id}/members/
+---
+
+The API provides two roles for project members:
+
+- `READER`: Allows viewing of project resources.
+- `OWNER`: Grants full administrative access to manage the project and its resources.

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

@@ -0,0 +1,4 @@
+---
+title: 'Create Project'
+openapi: post /api/v1/orgs/organizations/{org_id}/projects/
+---

docs/api-reference/project/delete-project-member.mdx

@@ -0,0 +1,4 @@
+---
+title: 'Delete Member'
+openapi: delete /api/v1/orgs/organizations/{org_id}/projects/{project_id}/members/
+---

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

@@ -0,0 +1,4 @@
+---
+title: 'Delete Project'
+openapi: delete /api/v1/orgs/organizations/{org_id}/projects/{project_id}/
+---

docs/api-reference/project/get-project-members.mdx

@@ -0,0 +1,4 @@
+---
+title: 'Get Members'
+openapi: get /api/v1/orgs/organizations/{org_id}/projects/{project_id}/members/
+---

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

@@ -0,0 +1,4 @@
+---
+title: 'Get Project'
+openapi: get /api/v1/orgs/organizations/{org_id}/projects/{project_id}/
+---

docs/api-reference/project/get-projects.mdx

@@ -0,0 +1,4 @@
+---
+title: 'Get Projects'
+openapi: get /api/v1/orgs/organizations/{org_id}/projects/
+---

docs/api-reference/project/update-project-member.mdx

@@ -0,0 +1,9 @@
+---
+title: 'Update Member'
+openapi: put /api/v1/orgs/organizations/{org_id}/projects/{project_id}/members/
+---
+
+The API provides two roles for project members:
+
+- `READER`: Allows viewing of project resources.
+- `OWNER`: Grants full administrative access to manage the project and its resources.

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

@@ -0,0 +1,4 @@
+---
+title: 'Update Project'
+openapi: patch /api/v1/orgs/organizations/{org_id}/projects/{project_id}/
+---

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,14 +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 |
-| `ollama_base_url` | Base URL for the Ollama embedding model |
-| `model_kwargs` | Key-Value arguments for the Huggingface 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                       | 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

@@ -1,4 +1,8 @@
-To use Azure OpenAI embedding models, set the `AZURE_OPENAI_API_KEY` environment variable. You can obtain the Azure OpenAI API key from the Azure.
+---
+title: Azure OpenAI
+---
+
+To use Azure OpenAI embedding models, set the `EMBEDDING_AZURE_OPENAI_API_KEY`, `EMBEDDING_AZURE_DEPLOYMENT`, `EMBEDDING_AZURE_ENDPOINT` and `EMBEDDING_AZURE_API_VERSION` environment variables. You can obtain the Azure OpenAI API key from the Azure.
 
 ### Usage
 
@@ -6,8 +10,12 @@ To use Azure OpenAI embedding models, set the `AZURE_OPENAI_API_KEY` environment
 import os
 from mem0 import Memory
 
-os.environ["OPENAI_API_KEY"] = "your_api_key"
-os.environ["AZURE_OPENAI_API_KEY"] = "your_api_key"
+os.environ["EMBEDDING_AZURE_OPENAI_API_KEY"] = "your-api-key"
+os.environ["EMBEDDING_AZURE_DEPLOYMENT"] = "your-deployment-name"
+os.environ["EMBEDDING_AZURE_ENDPOINT"] = "your-api-base-url"
+os.environ["EMBEDDING_AZURE_API_VERSION"] = "version-to-use"
+
+os.environ["OPENAI_API_KEY"] = "your_api_key" # For LLM
 
 
 config = {
@@ -15,12 +23,27 @@ config = {
         "provider": "azure_openai",
         "config": {
             "model": "text-embedding-3-large"
+            "azure_kwargs": {
+                  "api_version": "",
+                  "azure_deployment": "",
+                  "azure_endpoint": "",
+                  "api_key": "",
+                  "default_headers": {
+                    "CustomHeader": "your-custom-header",
+                  }
+              }
         }
     }
 }
 
 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
@@ -31,4 +54,4 @@ Here are the parameters available for configuring Azure OpenAI embedder:
 | --- | --- | --- |
 | `model` | The name of the embedding model to use | `text-embedding-3-small` |
 | `embedding_dims` | Dimensions of the embedding model | `1536` |
-| `api_key` | The Azure OpenAI API key | `None` |
+| `azure_kwargs` | The Azure OpenAI configs | `config_keys` |

docs/components/embedders/models/gemini.mdx

@@ -0,0 +1,43 @@
+---
+title: Gemini
+---
+
+To use Gemini embedding models, set the `GOOGLE_API_KEY` environment variables. You can obtain the Gemini API key from [here](https://aistudio.google.com/app/apikey).
+
+### Usage
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["GOOGLE_API_KEY"] = "key"
+os.environ["OPENAI_API_KEY"] = "your_api_key" # For LLM
+
+config = {
+    "embedder": {
+        "provider": "gemini",
+        "config": {
+            "model": "models/text-embedding-004",
+        }
+    }
+}
+
+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="john")
+```
+
+### Config
+
+Here are the parameters available for configuring Gemini embedder:
+
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `model` | The name of the embedding model to use | `models/text-embedding-004` |
+| `embedding_dims` | Dimensions of the embedding model | `768` |
+| `api_key` | The Gemini API key | `None` |

docs/components/embedders/models/huggingface.mdx

@@ -1,3 +1,7 @@
+---
+title: Hugging Face
+---
+
 You can use embedding models from Huggingface to run Mem0 locally.
 
 ### Usage
@@ -6,7 +10,7 @@ You can use embedding models from Huggingface to run Mem0 locally.
 import os
 from mem0 import Memory
 
-os.environ["OPENAI_API_KEY"] = "your_api_key"
+os.environ["OPENAI_API_KEY"] = "your_api_key" # For LLM
 
 config = {
     "embedder": {
@@ -18,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

@@ -6,7 +6,7 @@ You can use embedding models from Ollama to run Mem0 locally.
 import os
 from mem0 import Memory
 
-os.environ["OPENAI_API_KEY"] = "your_api_key"
+os.environ["OPENAI_API_KEY"] = "your_api_key" # For LLM
 
 config = {
     "embedder": {
@@ -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

@@ -1,8 +1,13 @@
+---
+title: OpenAI
+---
+
 To use OpenAI embedding models, set the `OPENAI_API_KEY` environment variable. You can obtain the OpenAI API key from the [OpenAI Platform](https://platform.openai.com/account/api-keys).
 
 ### Usage
 
-```python
+<CodeGroup>
+```python Python
 import os
 from mem0 import Memory
 
@@ -18,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

@@ -0,0 +1,45 @@
+---
+title: Together
+---
+
+To use Together embedding models, set the `TOGETHER_API_KEY` environment variable. You can obtain the Together API key from the [Together Platform](https://api.together.xyz/settings/api-keys).
+
+### Usage
+
+<Note> The `embedding_model_dims` parameter for `vector_store` should be set to `768` for Together embedder. </Note>
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["TOGETHER_API_KEY"] = "your_api_key"
+os.environ["OPENAI_API_KEY"] = "your_api_key" # For LLM
+
+config = {
+    "embedder": {
+        "provider": "together",
+        "config": {
+            "model": "togethercomputer/m2-bert-80M-8k-retrieval"
+        }
+    }
+}
+
+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="john")
+```
+
+### Config
+
+Here are the parameters available for configuring Together embedder:
+
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `model` | The name of the embedding model to use | `togethercomputer/m2-bert-80M-8k-retrieval` |
+| `embedding_dims` | Dimensions of the embedding model | `768` |
+| `api_key` | The Together API key | `None` |

docs/components/embedders/models/vertexai.mdx

@@ -0,0 +1,55 @@
+### Vertex AI
+
+To use Google Cloud's Vertex AI for text embedding models, set the `GOOGLE_APPLICATION_CREDENTIALS` environment variable to point to the path of your service account's credentials JSON file. These credentials can be created in the [Google Cloud Console](https://console.cloud.google.com/).
+
+### Usage
+
+```python
+import os
+from mem0 import Memory
+
+# Set the path to your Google Cloud credentials JSON file
+os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = "/path/to/your/credentials.json"
+os.environ["OPENAI_API_KEY"] = "your_api_key" # For LLM
+
+config = {
+    "embedder": {
+        "provider": "vertexai",
+        "config": {
+            "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)
+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:
+
+| Parameter                 | Description                                      | Default Value        |
+| ------------------------- | ------------------------------------------------ | -------------------- |
+| `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,15 +1,31 @@
 ---
 title: Overview
+icon: "info"
+iconType: "solid"
 ---
 
 Mem0 offers support for various embedding models, allowing users to choose the one that best suits their needs.
 
+## Supported Embedders
+
+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>
+  <Card title="Ollama" href="/components/embedders/models/ollama"></Card>
+  <Card title="Hugging Face" href="/components/embedders/models/huggingface"></Card>
+  <Card title="Gemini" href="/components/embedders/models/gemini"></Card>
+  <Card title="Vertex AI" href="/components/embedders/models/vertexai"></Card>
+  <Card title="Together" href="/components/embedders/models/together"></Card>
+</CardGroup>
+
 ## Usage
 
 To utilize a embedder, you must provide a configuration to customize its usage. If no configuration is supplied, a default configuration will be applied, and `OpenAI` will be used as the embedder.
 
 For a comprehensive list of available parameters for embedder configuration, please refer to [Config](./config).
-
-To view all supported embedders, visit the [Supported embedders](./models).
-
-

docs/components/llms/config.mdx

@@ -1,19 +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
+<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>
 
-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
+### Config Values Precedence
+
+Config values are applied in the following order of precedence (from highest to lowest):
+
+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` 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
 
@@ -32,35 +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               |
-| `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            |
+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
 
@@ -11,9 +16,9 @@ os.environ["ANTHROPIC_API_KEY"] = "your-api-key"
 
 config = {
     "llm": {
-        "provider": "litellm",
+        "provider": "anthropic",
         "config": {
-            "model": "claude-3-opus-20240229",
+            "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

@@ -1,3 +1,7 @@
+---
+title: AWS Bedrock
+---
+
 ### Setup
 - Before using the AWS Bedrock LLM, make sure you have the appropriate model access from [Bedrock Console](https://us-east-1.console.aws.amazon.com/bedrock/home?region=us-east-1#/modelaccess).
 - You will also need to authenticate the `boto3` client by using a method in the [AWS documentation](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html#configuring-credentials)
@@ -20,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

@@ -1,4 +1,8 @@
-To use Azure OpenAI models, you have to set the `AZURE_OPENAI_API_KEY`, `AZURE_OPENAI_ENDPOINT`, and `OPENAI_API_VERSION` environment variables. You can obtain the Azure API key from the [Azure](https://azure.microsoft.com/).
+---
+title: Azure OpenAI
+---
+
+To use Azure OpenAI models, you have to set the `LLM_AZURE_OPENAI_API_KEY`, `LLM_AZURE_ENDPOINT`, `LLM_AZURE_DEPLOYMENT` and `LLM_AZURE_API_VERSION` environment variables. You can obtain the Azure API key from the [Azure](https://azure.microsoft.com/).
 
 ## Usage
 
@@ -6,9 +10,10 @@ To use Azure OpenAI models, you have to set the `AZURE_OPENAI_API_KEY`, `AZURE_O
 import os
 from mem0 import Memory
 
-os.environ["AZURE_OPENAI_API_KEY"] = "your-api-key"
-os.environ["AZURE_OPENAI_ENDPOINT"] = "your-api-base-url"
-os.environ["OPENAI_API_VERSION"] = "version-to-use"
+os.environ["LLM_AZURE_OPENAI_API_KEY"] = "your-api-key"
+os.environ["LLM_AZURE_DEPLOYMENT"] = "your-deployment-name"
+os.environ["LLM_AZURE_ENDPOINT"] = "your-api-base-url"
+os.environ["LLM_AZURE_API_VERSION"] = "version-to-use"
 
 config = {
     "llm": {
@@ -17,14 +22,61 @@ config = {
             "model": "your-deployment-name",
             "temperature": 0.1,
             "max_tokens": 2000,
+            "azure_kwargs": {
+                  "azure_deployment": "",
+                  "api_version": "",
+                  "azure_endpoint": "",
+                  "api_key": "",
+                  "default_headers": {
+                    "CustomHeader": "your-custom-header",
+                  }
+              }
         }
     }
 }
 
 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.
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["LLM_AZURE_OPENAI_API_KEY"] = "your-api-key"
+os.environ["LLM_AZURE_DEPLOYMENT"] = "your-deployment-name"
+os.environ["LLM_AZURE_ENDPOINT"] = "your-api-base-url"
+os.environ["LLM_AZURE_API_VERSION"] = "version-to-use"
+
+config = {
+    "llm": {
+        "provider": "azure_openai_structured",
+        "config": {
+            "model": "your-deployment-name",
+            "temperature": 0.1,
+            "max_tokens": 2000,
+            "azure_kwargs": {
+                  "azure_deployment": "",
+                  "api_version": "",
+                  "azure_endpoint": "",
+                  "api_key": "",
+                  "default_headers": {
+                    "CustomHeader": "your-custom-header",
+                  }
+              }
+        }
+    }
+}
 ```
 
 ## Config
 
-All available parameters for the `azure_openai` config are present in [Master List of All Params in Config](../config).
+All available parameters for the `azure_openai` config are present in [Master List of All Params in Config](../config).

docs/components/llms/models/deepseek.mdx

@@ -0,0 +1,55 @@
+---
+title: DeepSeek
+---
+
+To use DeepSeek LLM models, you have to set the `DEEPSEEK_API_KEY` environment variable. You can also optionally set `DEEPSEEK_API_BASE` if you need to use a different API endpoint (defaults to "https://api.deepseek.com").
+
+## Usage
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["DEEPSEEK_API_KEY"] = "your-api-key"
+os.environ["OPENAI_API_KEY"] = "your-api-key" # for embedder model
+
+config = {
+    "llm": {
+        "provider": "deepseek",
+        "config": {
+            "model": "deepseek-chat",  # default model
+            "temperature": 0.2,
+            "max_tokens": 2000,
+            "top_p": 1.0
+        }
+    }
+}
+
+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"})
+```
+
+You can also configure the API base URL in the config:
+
+```python
+config = {
+    "llm": {
+        "provider": "deepseek",
+        "config": {
+            "model": "deepseek-chat",
+            "deepseek_base_url": "https://your-custom-endpoint.com",
+            "api_key": "your-api-key"  # alternatively to using environment variable
+        }
+    }
+}
+```
+
+## Config
+
+All available parameters for the `deepseek` config are present in [Master List of All Params in Config](../config).

docs/components/llms/models/gemini.mdx

@@ -0,0 +1,39 @@
+---
+title: Gemini
+---
+
+To use Gemini model, you have to set the `GEMINI_API_KEY` environment variable. You can obtain the Gemini API key from the [Google AI Studio](https://aistudio.google.com/app/apikey)
+
+## Usage
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "your-api-key" # used for embedding model
+os.environ["GEMINI_API_KEY"] = "your-api-key"
+
+config = {
+    "llm": {
+        "provider": "gemini",
+        "config": {
+            "model": "gemini-1.5-flash-latest",
+            "temperature": 0.2,
+            "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 `Gemini` config are present in [Master List of All Params in Config](../config).

docs/components/llms/models/google_AI.mdx

@@ -1,3 +1,7 @@
+---
+title: Google AI
+---
+
 To use Google AI model, you have to set the `GOOGLE_API_KEY` environment variable. You can obtain the Google API key from the [Google Maker Suite](https://makersuite.google.com/app/apikey)
 
 ## Usage
@@ -15,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

@@ -12,15 +12,21 @@ config = {
     "llm": {
         "provider": "litellm",
         "config": {
-            "model": "gpt-3.5-turbo",
+            "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

@@ -1,3 +1,7 @@
+---
+title: Mistral AI
+---
+
 To use mistral's models, please Obtain the Mistral AI api key from their [console](https://console.mistral.ai/). Set the `MISTRAL_API_KEY` environment variable to use the model as given below in the example.
 
 ## Usage
@@ -21,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

@@ -1,8 +1,13 @@
+---
+title: OpenAI
+---
+
 To use OpenAI LLM models, you have to set the `OPENAI_API_KEY` environment variable. You can obtain the OpenAI API key from the [OpenAI Platform](https://platform.openai.com/account/api-keys).
 
 ## Usage
 
-```python
+<CodeGroup>
+```python Python
 import os
 from mem0 import Memory
 
@@ -14,7 +19,7 @@ config = {
         "config": {
             "model": "gpt-4o",
             "temperature": 0.2,
-            "max_tokens": 1500,
+            "max_tokens": 2000,
         }
     }
 }
@@ -31,9 +36,66 @@ 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
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "your-api-key"
+
+config = {
+    "llm": {
+        "provider": "openai_structured",
+        "config": {
+            "model": "gpt-4o-2024-08-06",
+            "temperature": 0.0,
+        }
+    }
+}
+
+m = Memory.from_config(config)
+```
+
+<Note>
+  OpenAI structured-outputs is currently only available in the Python implementation.
+</Note>
+
 ## Config
 
 All available parameters for the `openai` config are present in [Master List of All Params in Config](../config).

docs/components/llms/models/together.mdx

@@ -11,17 +11,23 @@ os.environ["TOGETHER_API_KEY"] = "your-api-key"
 
 config = {
     "llm": {
-        "provider": "togetherai",
+        "provider": "together",
         "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.
@@ -11,3 +13,47 @@ To use a llm, you must provide a configuration to customize its usage. If no con
 For a comprehensive list of available parameters for llm configuration, please refer to [Config](./config).
 
 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 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
+
+Mem0 supports two types of OpenAI LLM formats, each with its own strengths and use cases:
+
+### Structured Outputs
+
+Structured outputs are LLMs that align with OpenAI's structured outputs model:
+
+- **Optimized for:** Returning structured responses (e.g., JSON objects)
+- **Benefits:** Precise, easily parseable data
+- **Ideal for:** Data extraction, form filling, API responses
+- **Learn more:** [OpenAI Structured Outputs Guide](https://platform.openai.com/docs/guides/structured-outputs/introduction)
+
+### Unstructured Outputs
+
+Unstructured outputs correspond to OpenAI's standard, free-form text model:
+
+- **Flexibility:** Returns open-ended, natural language responses
+- **Customization:** Use the `response_format` parameter to guide output
+- **Trade-off:** Less efficient than structured outputs for specific data needs
+- **Best for:** Creative writing, explanations, general conversation
+
+Choose the format that best suits your application's requirements for optimal performance and usability.

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

@@ -0,0 +1,73 @@
+# Azure AI Search
+
+[Azure AI Search](https://learn.microsoft.com/azure/search/search-what-is-azure-search/) (formerly known as "Azure Cognitive Search") provides secure information retrieval at scale over user-owned content in traditional and generative AI search applications.
+
+## Usage
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "sk-xx"   # This key is used for embedding purpose
+
+config = {
+    "vector_store": {
+        "provider": "azure_ai_search",
+        "config": {
+            "service_name": "ai-search-test",
+            "api_key": "*****",
+            "collection_name": "mem0", 
+            "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"})
+```
+
+## Using binary compression for large vector collections
+
+```python
+config = {
+    "vector_store": {
+        "provider": "azure_ai_search",
+        "config": {
+            "service_name": "ai-search-test",
+            "api_key": "*****",
+            "collection_name": "mem0", 
+            "embedding_model_dims": 1536,
+            "compression_type": "binary",
+            "use_float16": True  # Use half precision for storage efficiency
+        }
+    }
+}
+```
+
+## Configuration Parameters
+
+| Parameter | Description | Default Value | Options |
+| --- | --- | --- | --- |
+| `service_name` | Azure AI Search service name | Required | - |
+| `api_key` | API key of the Azure AI Search service | Required | - |
+| `collection_name` | The name of the collection/index to store vectors | `mem0` | Any valid index name |
+| `embedding_model_dims` | Dimensions of the embedding model | `1536` | Any integer value |
+| `compression_type` | Type of vector compression to use | `none` | `none`, `scalar`, `binary` |
+| `use_float16` | Store vectors in half precision (Edm.Half) | `False` | `True`, `False` |
+
+## Notes on Configuration Options
+
+- **compression_type**: 
+  - `none`: No compression, uses full vector precision
+  - `scalar`: Scalar quantization with reasonable balance of speed and accuracy
+  - `binary`: Binary quantization for maximum compression with some accuracy trade-off
+
+- **use_float16**: Using half precision (float16) reduces storage requirements but may slightly impact accuracy. Useful for very large vector collections.
+
+- **Filterable Fields**: The implementation automatically extracts `user_id`, `run_id`, and `agent_id` fields from payloads for filtering.

docs/components/vectordbs/dbs/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

@@ -0,0 +1,108 @@
+[Elasticsearch](https://www.elastic.co/) is a distributed, RESTful search and analytics engine that can efficiently store and search vector data using dense vectors and k-NN search.
+
+### Installation
+
+Elasticsearch support requires additional dependencies. Install them with:
+
+```bash
+pip install elasticsearch>=8.0.0
+```
+
+### Usage
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "sk-xx"
+
+config = {
+    "vector_store": {
+        "provider": "elasticsearch",
+        "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 `elasticsearch` 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 Elasticsearch server is running | `localhost`   |
+| `port`                 | The port where the Elasticsearch server is running | `9200`        |
+| `cloud_id`             | Cloud ID for Elastic Cloud deployment              | `None`        |
+| `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                 | `True`        |
+| `auto_create_index`    | Whether to automatically create the index          | `True`        |
+| `custom_search_query`  | Function returning a custom search query            | `None`        |
+
+### Features
+
+- Efficient vector search using Elasticsearch's native k-NN search
+- Support for both local and cloud deployments (Elastic Cloud)
+- Multiple authentication methods (Basic Auth, API Key)
+- Automatic index creation with optimized mappings for vector search
+- Memory isolation through payload filtering
+- Custom search query function to customize the search query
+
+### Custom Search Query
+
+The `custom_search_query` parameter allows you to customize the search query when `Memory.search` is called.  
+  
+__Example__  
+```python
+import os
+from typing import List, Optional, Dict
+from mem0 import Memory
+
+def custom_search_query(query: List[float], limit: int, filters: Optional[Dict]) -> Dict:
+    return {
+        "knn": {
+            "field": "vector", 
+            "query_vector": query, 
+            "k": limit, 
+            "num_candidates": limit * 2
+        }
+    }
+
+os.environ["OPENAI_API_KEY"] = "sk-xx"
+
+config = {
+    "vector_store": {
+        "provider": "elasticsearch",
+        "config": {
+            "collection_name": "mem0",
+            "host": "localhost",
+            "port": 9200,
+            "embedding_model_dims": 1536,
+            "custom_search_query": custom_search_query
+        }
+    }
+}
+```
+It should be a function that takes the following parameters:
+- `query`: a query vector used in `Memory.search`
+- `limit`: a number of results used in `Memory.search`
+- `filters`: a dictionary of key-value pairs used in `Memory.search`. You can add custom pairs for the custom search query.  
+  
+The function should return a query body for the Elasticsearch search API.

docs/components/vectordbs/dbs/milvus.mdx

@@ -0,0 +1,41 @@
+[Milvus](https://milvus.io/) Milvus is an open-source vector database that suits AI applications of every size from running a demo chatbot in Jupyter notebook to building web-scale search that serves billions of users.
+
+### Usage
+
+```python
+import os
+from mem0 import Memory
+
+config = {
+    "vector_store": {
+        "provider": "milvus",
+        "config": {
+            "collection_name": "test",
+            "embedding_model_dims": "123",
+            "url": "127.0.0.1",
+            "token": "8e4b8ca8cf2c67",
+        }
+    }
+}
+
+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's the parameters available for configuring Milvus Database:
+
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `url` | Full URL/Uri for Milvus/Zilliz server | `http://localhost:19530` |
+| `token` | Token for Zilliz server / for local setup defaults to None. | `None` |
+| `collection_name` | The name of the collection | `mem0` |
+| `embedding_model_dims` | Dimensions of the embedding model | `1536` |
+| `metric_type` | Metric type for similarity search | `L2` |

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
@@ -30,10 +36,12 @@ Here's the parameters available for configuring pgvector:
 
 | Parameter | Description | Default Value |
 | --- | --- | --- |
-| `dbname` | The name of the database | `postgres` |
+| `dbname` | The name of the  | `postgres` |
 | `collection_name` | The name of the collection | `mem0` |
 | `embedding_model_dims` | Dimensions of the embedding model | `1536` |
 | `user` | User name to connect to the database | `None` |
 | `password` | Password to connect to the database | `None` |
 | `host` | The host where the Postgres server is running | `None` |
-| `port` | The port where the Postgres server is running | `None` |
+| `port` | The port where the Postgres server is running | `None` |
+| `diskann` | Whether to use diskann for vector similarity search (requires pgvectorscale) | `True` |
+| `hnsw` | Whether to use hnsw for vector similarity search | `False` |

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

@@ -0,0 +1,92 @@
+[Redis](https://redis.io/) is a scalable, real-time database that can store, search, and analyze vector data.
+
+### Installation
+```bash
+pip install redis redisvl
+```
+
+Redis Stack using Docker:
+```bash
+docker run -d --name redis-stack -p 6379:6379 -p 8001:8001 redis/redis-stack:latest
+```
+
+### Usage
+
+<CodeGroup>
+```python Python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "sk-xx"
+
+config = {
+    "vector_store": {
+        "provider": "redis",
+        "config": {
+            "collection_name": "mem0",
+            "embedding_model_dims": 1536,
+            "redis_url": "redis://localhost:6379"
+        }
+    },
+    "version": "v1.1"
+}
+
+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"})
+```
+
+```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` |
+</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/dbs/weaviate.mdx

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

docs/components/vectordbs/overview.mdx

@@ -1,17 +1,39 @@
 ---
 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.
 
+## Supported Vector Databases
+
+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>
+  <Card title="Pgvector" href="/components/vectordbs/dbs/pgvector"></Card>
+  <Card title="Milvus" href="/components/vectordbs/dbs/milvus"></Card>
+  <Card title="Azure AI Search" href="/components/vectordbs/dbs/azure_ai_search"></Card>
+  <Card title="Redis" href="/components/vectordbs/dbs/redis"></Card>
+  <Card title="Elasticsearch" href="/components/vectordbs/dbs/elasticsearch"></Card>
+  <Card title="OpenSearch" href="/components/vectordbs/dbs/opensearch"></Card>
+  <Card title="Supabase" href="/components/vectordbs/dbs/supabase"></Card>
+  <Card title="Vertex AI Vector Search" href="/components/vectordbs/dbs/vertex_ai_vector_search"></Card>
+  <Card title="Weaviate" href="/components/vectordbs/dbs/weaviate"></Card>
+</CardGroup>
+
 ## Usage
 
 To utilize a vector database, you must provide a configuration to customize its usage. If no configuration is supplied, a default configuration will be applied, and `Qdrant` will be used as the vector database.
 
 For a comprehensive list of available parameters for vector database configuration, please refer to [Config](./config).
 
-To view all supported vector databases, visit the [Supported Vector Databases](./dbs).
-
 ## Common issues
 
 ### Using model with different dimensions
@@ -22,3 +44,4 @@ for example 768, you may encounter below error:
 `ValueError: shapes (0,1536) and (768,) not aligned: 1536 (dim 1) != 768 (dim 0)`
 
 you could add `"embedding_model_dims": 768,` to the config of the vector_store to overcome this issue.
+

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,348 @@
+{
+  "$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/contextual-add",
+                      "features/multimodal-support",
+                      "features/selective-memory",
+                      "features/custom-categories",
+                      "features/custom-instructions",
+                      "features/direct-import",
+                      "features/async-client",
+                      "features/memory-export",
+                      "features/webhooks",
+                      "features/graph-memory",
+                      "features/feedback-mechanism"
+                    ]
+                  }
+                ]
+              },
+              {
+                "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-fact-extraction-prompt",
+                      "features/custom-update-memory-prompt",
+                      "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",
+                          "components/vectordbs/dbs/weaviate"
+                        ]
+                      }
+                    ]
+                  },
+                  {
+                    "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",
+                  "examples/mem0-agentic-tool",
+                  "examples/openai-inbuilt-tools"
+                ]
+              }
+            ]
+          },
+          {
+            "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"
+    },
+    "intercom": {
+      "appId": "jjv2r0tt"
+    }
+  }
+}

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

@@ -1,123 +0,0 @@
----
-title: LangGraph with Mem0
----
-
-This guide demonstrates how to create a personalized Customer Support AI Agent using LangGraph and Mem0. The agent retains information across interactions, enabling a personalized and efficient support experience.
-
-## Overview
-The Customer Support AI Agent leverages LangGraph for conversational flow and Mem0 for memory retention, creating a more context-aware and personalized support experience.
-
-## Setup
-Install the necessary packages using pip:
-
-```bash
-pip install langgraph langchain-openai mem0ai
-```
-
-## Full Code Example
-Below is the complete code to create and interact with a Customer Support AI Agent using LangGraph and Mem0:
-
-```python
-from typing import Annotated, TypedDict, List
-from langgraph.graph import StateGraph, START
-from langgraph.graph.message import add_messages
-from langchain_openai import ChatOpenAI
-from mem0 import Memory
-from langchain_core.messages import SystemMessage, HumanMessage, AIMessage
-
-llm = ChatOpenAI(model="gpt-4o")
-mem0 = Memory()
-
-# Define the State
-class State(TypedDict):
-    messages: Annotated[List[HumanMessage | AIMessage], add_messages]
-    mem0_user_id: str
-
-graph = StateGraph(State)
-
-
-def chatbot(state: State):
-    messages = state["messages"]
-    user_id = state["mem0_user_id"]
-    
-    # Retrieve relevant memories
-    memories = mem0.search(messages[-1].content, user_id=user_id)
-    
-    context = "Relevant information from previous conversations:\n"
-    for memory in memories:
-        context += f"- {memory['memory']}\n"
-    
-    system_message = SystemMessage(content=f"""You are a helpful customer support assistant. Use the provided context to personalize your responses and remember user preferences and past interactions.
-{context}""")
-    
-    full_messages = [system_message] + messages
-    response = llm.invoke(full_messages)
-    
-    # Store the interaction in Mem0
-    mem0.add(f"User: {messages[-1].content}\nAssistant: {response.content}", user_id=user_id)
-    return {"messages": [response]}
-
-# Add nodes to the graph
-graph.add_node("chatbot", chatbot)
-
-# Add edge from START to chatbot
-graph.add_edge(START, "chatbot")
-
-# Add edge from chatbot back to itself
-graph.add_edge("chatbot", "chatbot")
-
-compiled_graph = graph.compile()
-
-def run_conversation(user_input: str, mem0_user_id: str):
-    config = {"configurable": {"thread_id": mem0_user_id}}
-    state = {"messages": [HumanMessage(content=user_input)], "mem0_user_id": mem0_user_id}
-    
-    for event in compiled_graph.stream(state, config):
-        for value in event.values():
-            if value.get("messages"):
-                print("Customer Support:", value["messages"][-1].content)
-                return  # Exit after printing the response
-
-
-if __name__ == "__main__":
-    print("Welcome to Customer Support! How can I assist you today?")
-    mem0_user_id = "test123"
-    while True:
-        user_input = input("You: ")
-        if user_input.lower() in ['quit', 'exit', 'bye']:
-            print("Customer Support: Thank you for contacting us. Have a great day!")
-            break
-        run_conversation(user_input, mem0_user_id)
-```
-
-## Key Components
-
-1. **State Definition**: The `State` class defines the structure of the conversation state, including messages and user ID.
-
-2. **Chatbot Node**: The `chatbot` function handles the core logic, including:
-   - Retrieving relevant memories
-   - Preparing context and system message
-   - Generating responses
-   - Storing interactions in Mem0
-
-3. **Graph Setup**: The code sets up a `StateGraph` with the chatbot node and necessary edges.
-
-4. **Conversation Runner**: The `run_conversation` function manages the flow of the conversation, processing user input and displaying responses.
-
-## Usage
-
-To use the Customer Support AI Agent:
-
-1. Run the script.
-2. Enter your queries when prompted.
-3. Type 'quit', 'exit', or 'bye' to end the conversation.
-
-## Key Points
-
-- **Memory Integration**: Mem0 is used to store and retrieve relevant information from past interactions.
-- **Personalization**: The agent uses past interactions to provide more contextual and personalized responses.
-- **Flexible Architecture**: The LangGraph structure allows for easy expansion and modification of the conversation flow.
-
-## Conclusion
-
-This Customer Support AI Agent demonstrates the power of combining LangGraph for conversation management and Mem0 for memory retention. As the conversation progresses, the agent's responses become increasingly personalized, providing an improved support experience.