Update pyproject.toml (#2301)

Co-authored-by: Deshraj Yadav <deshrajdry@gmail.com>

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

@@ -1,212 +1,185 @@
 <p align="center">
-  <img src="docs/images/banner.png" width="800px" alt="Mem0 Logo">
+  <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.dev/DiG">Join Discord</a>
+  </p>
 </p>
 
 <p align="center">
-  <a href="https://mem0.ai/slack">
-    <img src="https://img.shields.io/badge/slack-mem0-brightgreen.svg?logo=slack" alt="Mem0 Slack">
-  </a>
-  <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://x.com/mem0ai">
-    <img src="https://img.shields.io/twitter/follow/mem0ai" alt="Mem0 Twitter">
+  <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>
-  <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>
-  <a href="https://www.npmjs.com/package/mem0ai"><img src="https://img.shields.io/npm/v/mem0ai?style=flat-square&label=npm+mem0ai" alt="mem0ai npm package"></a>
-  <a href="https://pypi.python.org/pypi/mem0ai"><img src="https://img.shields.io/pypi/v/mem0ai.svg?style=flat-square&label=pypi+mem0ai" alt="mem0ai Python package on PyPi"></a>
-  <a href="https://mem0.ai/email"><img src="https://img.shields.io/badge/substack-mem0-brightgreen.svg?logo=substack&label=mem0+substack" alt="Mem0 newsletter"></a>
 </p>
 
-# Mem0: The Memory Layer for Personalized AI
 
-Mem0 provides an intelligent, adaptive memory layer for Large Language Models (LLMs), enhancing personalized AI experiences by retaining and utilizing contextual information across diverse applications. This enhanced memory capability is crucial for applications ranging from customer support and healthcare diagnostics to autonomous systems and personalized content recommendations, allowing AI to remember user preferences, adapt to individual needs, and continuously improve over time.
+# Introduction
 
-## 🚀 Quickstart
+[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.
 
-### Installation
+### Features & Use Cases
 
-The Mem0 package can be installed directly from pip command in the terminal.
+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
+
+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
+
+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.
+
+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.
+
+## Quickstart Guide <a name="quickstart"></a>
+
+Install the Mem0 package via pip:
 
 ```bash
 pip install mem0ai
 ```
 
-### Basic Usage (Open Source)
+Install the Mem0 package via npm:
 
-Mem0 supports various LLMs, details of which can be found in our docs, checkout [Supported LLMs](https://docs.mem0.ai/llms). By default, Mem0 is equipped with ```gpt-4o```, and to use it, you need to set the keys in the environment variable.
-
-```python
-import os
-os.environ["OPENAI_API_KEY"] = "sk-xxx"
+```bash
+npm install mem0ai
 ```
 
-Now, you can simply initialize the memory.
+### 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).
+
+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)
+    
+    # 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()
 ```
 
-You can perform the following task on the memory.
-1. Add: adds memory
-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: describes how a memory has changed over time for a specific memory ID
+See the example for [Node.js](https://docs.mem0.ai/examples/ai_companion_js).
 
-```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' }
-```
-
-### Mem0 Platform
-
-```python
-from mem0 import MemoryClient
-client = MemoryClient(api_key="your-api-key") # get api_key from https://app.mem0.ai/
-
-# Store messages 
-messages = [
-    {"role": "user", "content": "Hi, I'm Alex. I'm a vegetarian and I'm allergic to nuts."},
-    {"role": "assistant", "content": "Hello Alex! I've noted that you're a vegetarian and have a nut allergy. I'll keep this in mind for any food-related recommendations or discussions."}
-]
-result = client.add(messages, user_id="alex")
-print(result)
-
-# Retrieve memories
-all_memories = client.get_all(user_id="alex")
-print(all_memories)
-
-# Search memories
-query = "What do you know about me?"
-related_memories = client.search(query, user_id="alex")
-
-# Get memory history
-history = client.history(memory_id="m1")
-print(history)
-```
+For more advanced usage and API documentation, visit our [documentation](https://docs.mem0.ai).
 
 > [!TIP]
-> If you are looking for a hosted version and don't want to setup the infrastucture yourself, checkout [Mem0 Platform Docs](https://docs.mem0.ai/platform/quickstart) to get started in minutes.
+> For a hassle-free experience, try our [hosted platform](https://app.mem0.ai) with automatic updates and enterprise features.
 
-## 🔑 Core Features
+## Demos
 
-- **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
+- AI Companion: Experience personalized conversations with an AI that remembers your preferences and past interactions
 
-## 📖 Documentation
+[AI Companion Demo](https://github.com/user-attachments/assets/3fc72023-a72c-4593-8be0-3cee3ba744da)
 
-For detailed usage instructions and API reference, visit our documentation at [docs.mem0.ai](https://docs.mem0.ai).
+<br/><br/>
 
-## 🔧 Advanced Usage
+- Mem0 Demo: A personalized AI chat app powered by Mem0 that remembers your preferences, facts, and memories.
 
-For production environments, you can use Qdrant as a vector store:
+[Mem0 Demo](https://github.com/user-attachments/assets/cebc4f8e-bdb9-4837-868d-13c5ab7bb433)
 
-```python
-from mem0 import Memory
+<br/><br/>
 
-config = {
-    "vector_store": {
-        "provider": "qdrant",
-        "config": {
-            "host": "localhost",
-            "port": 6333,
-        }
-    },
-}
+- 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).
 
-m = Memory.from_config(config)
-```
 
-## 🗺️ Roadmap
+[Chrome Extension Demo](https://github.com/user-attachments/assets/ca92e40b-c453-4ff6-b25e-739fb18a8650)
 
-- Integration with various LLM providers
-- Support for LLM frameworks
-- Integration with AI Agents frameworks
-- Customizable memory creation/update rules
-- Hosted platform support
+<br/><br/>
 
-## 💰 Pricing
+- Customer support bot using <strong>Langgraph and Mem0</strong>. Get the complete code from [here](https://docs.mem0.ai/integrations/langgraph)
 
-Choose the Mem0 plan that best fits your needs:
 
-### Open Source (Self-hosted)
-Perfect for developers and small teams who want full control over their infrastructure.
+[Langgraph: Customer Bot](https://github.com/user-attachments/assets/ca6b482e-7f46-42c8-aa08-f88d1d93a5f4)
 
-### Pro (Hosted)
-Ideal for growing businesses that need a reliable, managed solution with generous free usage. Try the platform [here](https://app.mem0.ai)
+<br/><br/>
 
-### Enterprise (Hosted)
-Designed for large organizations with advanced security, compliance, and scalability needs.
+- Use Mem0 with CrewAI to get personalized results. Full example [here](https://docs.mem0.ai/integrations/crewai)
 
-| Feature | Open Source | Pro | Enterprise |
-|---------|-------------|-----|------------|
-| Hosting | Self-hosted | Hosted | Hosted |
-| API Calls | Unlimited | 100K free/month | Custom limits |
-| Support | Community | Email | Dedicated support |
-| Updates | Manual | Automatic | Automatic |
-| SSO | ❌ | ❌ | ✅ |
-| Audit Logs | ❌ | ❌ | ✅ |
-| Custom Integrations | ❌ | ❌ | ✅ |
-| SLA | ❌ | ❌ | ✅ |
-| Advanced Analytics | ❌ | Basic | Advanced |
-| Multi-region Deployment | ❌ | ❌ | ✅ |
+[CrewAI Demo](https://github.com/user-attachments/assets/69172a79-ccb9-4340-91f1-caa7d2dd4213)
 
-[Contact us](mailto:taranjeet@mem0.ai) for Enterprise pricing and custom solutions.
 
-## Star History
 
-[![Star History Chart](https://api.star-history.com/svg?repos=mem0ai/mem0&type=Date)](https://star-history.com/#mem0ai/mem0&Date)
+## Documentation
 
-## 🙋‍♂️ Support
-Join our Slack or Discord community for support and discussions.
-If you have any questions, feel free to reach out to us using one of the following methods:
+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)
 
-- [Join our Discord](https://mem0.ai/discord)
-- [Join our Slack](https://mem0.ai/slack)
-- [Join our newsletter](https://mem0.ai/email)
+## 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.dev/DiG)
 - [Follow us on Twitter](https://x.com/mem0ai)
-- [Email us](mailto:founders@mem0.ai)
+- [Email founders](mailto:founders@mem0.ai)
 
-## 📝 License
+## License
 
 This project is licensed under the Apache 2.0 License - see the [LICENSE](LICENSE) file for details.
-
-> [!NOTE]
-> The Mem0 repository now also includes the Embedchain project. We continue to maintain and support Embedchain ❤️. You can find the Embedchain codebase in the [embedchain](https://github.com/mem0ai/mem0/tree/main/embedchain) directory.

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

@@ -0,0 +1,99 @@
+---
+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 configurations?
+
+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 object or dictionary containing provider-specific settings
+
+
+## How to use configurations?
+
+Here's a general example of how to use the config with mem0:
+
+<CodeGroup>
+```python Python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "sk-xx"
+
+config = {
+    "embedder": {
+        "provider": "your_chosen_provider",
+        "config": {
+            # Provider-specific settings go here
+        }
+    }
+}
+
+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:
+1. Specifying which embedding model to use.
+2. Providing necessary connection details (e.g., model, api_key, embedding_dims).
+3. Ensuring proper initialization and connection to your chosen embedder.
+
+## Master List of All Params in Config
+
+Here's a comprehensive list of all parameters that can be used across different embedders:
+
+<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
+
+For detailed information on configuring specific embedders, please visit the [Embedding Models](./models) section. There you'll find information for each supported embedder with provider-specific usage examples and configuration details.

docs/components/embedders/models/azure_openai.mdx

@@ -0,0 +1,57 @@
+---
+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
+
+```python
+import os
+from mem0 import Memory
+
+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 = {
+    "embedder": {
+        "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)
+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 Azure OpenAI embedder:
+
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `model` | The name of the embedding model to use | `text-embedding-3-small` |
+| `embedding_dims` | Dimensions of the embedding model | `1536` |
+| `azure_kwargs` | The Azure OpenAI configs | `config_keys` |

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

@@ -0,0 +1,42 @@
+---
+title: Hugging Face
+---
+
+You can use embedding models from Huggingface to run Mem0 locally.
+
+### Usage
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "your_api_key" # For LLM
+
+config = {
+    "embedder": {
+        "provider": "huggingface",
+        "config": {
+            "model": "multi-qa-MiniLM-L6-cos-v1"
+        }
+    }
+}
+
+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 Huggingface embedder:
+
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `model` | The name of the model to use | `multi-qa-MiniLM-L6-cos-v1` |
+| `embedding_dims` | Dimensions of the embedding model | `selected_model_dimensions` |
+| `model_kwargs` | Additional arguments for the model | `None` |

docs/components/embedders/models/ollama.mdx

@@ -0,0 +1,38 @@
+You can use embedding models from Ollama to run Mem0 locally.
+
+### Usage
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "your_api_key" # For LLM
+
+config = {
+    "embedder": {
+        "provider": "ollama",
+        "config": {
+            "model": "mxbai-embed-large"
+        }
+    }
+}
+
+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 Ollama embedder:
+
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `model` | The name of the OpenAI model to use | `nomic-embed-text` |
+| `embedding_dims` | Dimensions of the embedding model | `512` |
+| `ollama_base_url` | Base URL for ollama connection | `None` |

docs/components/embedders/models/openai.mdx

@@ -0,0 +1,72 @@
+---
+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
+
+<CodeGroup>
+```python Python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "your_api_key"
+
+config = {
+    "embedder": {
+        "provider": "openai",
+        "config": {
+            "model": "text-embedding-3-large"
+        }
+    }
+}
+
+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")
+```
+
+```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

@@ -0,0 +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).

docs/components/llms.mdx

@@ -1,294 +0,0 @@
----
-title: 🤖 LLMs
----
-
-## Overview
-
-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.
-
-<CardGroup cols={4}>
-  <Card title="OpenAI" href="#openai"></Card>
-  <Card title="Ollama" href="#ollama"></Card>
-  <Card title="Groq" href="#groq"></Card>
-  <Card title="Together" href="#together"></Card>
-  <Card title="AWS Bedrock" href="#aws-bedrock"></Card>
-  <Card title="Litellm" href="#litellm"></Card>
-  <Card title="Google AI" href="#google-ai"></Card>
-  <Card title="Anthropic" href="#anthropic"></Card>
-  <Card title="Mistral AI" href="#mistral-ai"></Card>
-  <Card title="OpenAI Azure" href="#openai-azure"></Card>
-</CardGroup>
-
-## 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).
-
-Once you have obtained the key, you can use it like this:
-
-```python
-import os
-from mem0 import Memory
-
-os.environ["OPENAI_API_KEY"] = "your-api-key"
-
-config = {
-    "llm": {
-        "provider": "openai",
-        "config": {
-            "model": "gpt-4o",
-            "temperature": 0.2,
-            "max_tokens": 1500,
-        }
-    }
-}
-
-m = Memory.from_config(config)
-m.add("Likes to play cricket on weekends", user_id="alice", metadata={"category": "hobbies"})
-```
-
-## Ollama
-
-You can use LLMs from Ollama to run Mem0 locally. These [models](https://ollama.com/search?c=tools) support tool support.
-
-```python
-import os
-from mem0 import Memory
-
-os.environ["OPENAI_API_KEY"] = "your-api-key" # for embedder
-
-config = {
-    "llm": {
-        "provider": "ollama",
-        "config": {
-            "model": "mixtral:8x7b",
-            "temperature": 0.1,
-            "max_tokens": 2000,
-        }
-    }
-}
-
-m = Memory.from_config(config)
-m.add("Likes to play cricket on weekends", user_id="alice", metadata={"category": "hobbies"})
-```
-
-## 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.
-
-```python
-import os
-from mem0 import Memory
-
-os.environ["OPENAI_API_KEY"] = "your-api-key" # used for embedding model
-os.environ["GROQ_API_KEY"] = "your-api-key"
-
-config = {
-    "llm": {
-        "provider": "groq",
-        "config": {
-            "model": "mixtral-8x7b-32768",
-            "temperature": 0.1,
-            "max_tokens": 1000,
-        }
-    }
-}
-
-m = Memory.from_config(config)
-m.add("Likes to play cricket on weekends", user_id="alice", metadata={"category": "hobbies"})
-```
-
-## Together
-
-To use TogetherAI LLM models, you have to set the `TOGETHER_API_KEY` environment variable. You can obtain the TogetherAI API key from their [Account settings page](https://api.together.xyz/settings/api-keys).
-
-Once you have obtained the key, you can use it like this:
-
-```python
-import os
-from mem0 import Memory
-
-os.environ["OPENAI_API_KEY"] = "your-api-key" # used for embedding model
-os.environ["TOGETHER_API_KEY"] = "your-api-key"
-
-config = {
-    "llm": {
-        "provider": "togetherai",
-        "config": {
-            "model": "mistralai/Mixtral-8x7B-Instruct-v0.1",
-            "temperature": 0.2,
-            "max_tokens": 1500,
-        }
-    }
-}
-
-m = Memory.from_config(config)
-m.add("Likes to play cricket on weekends", user_id="alice", metadata={"category": "hobbies"})
-```
-
-## 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)
-- You will have to export `AWS_REGION`, `AWS_ACCESS_KEY`, and `AWS_SECRET_ACCESS_KEY` to set environment variables.
-
-```python
-import os
-from mem0 import Memory
-
-os.environ["OPENAI_API_KEY"] = "your-api-key" # used for embedding model
-os.environ['AWS_REGION'] = 'us-east-1'
-os.environ["AWS_ACCESS_KEY"] = "xx"
-os.environ["AWS_SECRET_ACCESS_KEY"] = "xx"
-
-config = {
-    "llm": {
-        "provider": "aws_bedrock",
-        "config": {
-            "model": "arn:aws:bedrock:us-east-1:123456789012:model/your-model-name",
-            "temperature": 0.2,
-            "max_tokens": 1500,
-        }
-    }
-}
-
-m = Memory.from_config(config)
-m.add("Likes to play cricket on weekends", user_id="alice", metadata={"category": "hobbies"})
-```
-
-## Litellm
-
-[Litellm](https://litellm.vercel.app/docs/) is compatible with over 100 large language models (LLMs), all using a standardized input/output format. You can explore the [available models]((https://litellm.vercel.app/docs/providers)) to use with Litellm. Ensure you set the `API_KEY` for the model you choose to use.
-
-```python
-import os
-from mem0 import Memory
-
-os.environ["OPENAI_API_KEY"] = "your-api-key"
-
-config = {
-    "llm": {
-        "provider": "litellm",
-        "config": {
-            "model": "gpt-3.5-turbo",
-            "temperature": 0.2,
-            "max_tokens": 1500,
-        }
-    }
-}
-
-m = Memory.from_config(config)
-m.add("Likes to play cricket on weekends", user_id="alice", metadata={"category": "hobbies"})
-```
-
-## 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)
-
-Once you have obtained the key, you can use it like this:
-
-```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": "litellm",
-        "config": {
-            "model": "gemini/gemini-pro",
-            "temperature": 0.2,
-            "max_tokens": 1500,
-        }
-    }
-}
-
-m = Memory.from_config(config)
-m.add("Likes to play cricket on weekends", user_id="alice", metadata={"category": "hobbies"})
-```
-
-## 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).
-
-```python
-import os
-from mem0 import Memory
-
-os.environ["OPENAI_API_KEY"] = "your-api-key" # used for embedding model
-os.environ["ANTHROPIC_API_KEY"] = "your-api-key"
-
-config = {
-    "llm": {
-        "provider": "litellm",
-        "config": {
-            "model": "claude-3-opus-20240229",
-            "temperature": 0.1,
-            "max_tokens": 2000,
-        }
-    }
-}
-
-m = Memory.from_config(config)
-m.add("Likes to play cricket on weekends", user_id="alice", metadata={"category": "hobbies"})
-```
-
-## 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.
-
-```python
-import os
-from mem0 import Memory
-
-os.environ["OPENAI_API_KEY"] = "your-api-key" # used for embedding model
-os.environ["MISTRAL_API_KEY"] = "your-api-key"
-
-config = {
-    "llm": {
-        "provider": "litellm",
-        "config": {
-            "model": "open-mixtral-8x7b",
-            "temperature": 0.1,
-            "max_tokens": 2000,
-        }
-    }
-}
-
-m = Memory.from_config(config)
-m.add("Likes to play cricket on weekends", user_id="alice", metadata={"category": "hobbies"})
-```
-
-## OpenAI Azure
-
-To use Azure AI models, you have to set the `AZURE_API_KEY`, `AZURE_API_BASE`, and `AZURE_API_VERSION` environment variables. You can obtain the Azure API key from the [Azure](https://azure.microsoft.com/).
-
-```python
-import os
-from mem0 import Memory
-
-
-os.environ["AZURE_API_KEY"] = "your-api-key"
-
-# Needed to use custom models
-os.environ["AZURE_API_BASE"] = "your-api-base-url"
-os.environ["AZURE_API_VERSION"] = "version-to-use"
-
-config = {
-    "llm": {
-        "provider": "litellm",
-        "config": {
-            "model": "azure_ai/command-r-plus",
-            "temperature": 0.1,
-            "max_tokens": 2000,
-        }
-    }
-}
-
-m = Memory.from_config(config)
-m.add("Likes to play cricket on weekends", user_id="alice", metadata={"category": "hobbies"})
-```

docs/components/llms/config.mdx

@@ -0,0 +1,127 @@
+---
+title: Configurations
+icon: "gear"
+iconType: "solid"
+---
+
+## How to define configurations?
+
+<Tabs>
+  <Tab title="Python">
+    The `config` is defined as a Python dictionary with two main keys:
+    - `llm`: Specifies the llm provider and its configuration
+      - `provider`: The name of the llm (e.g., "openai", "groq")
+      - `config`: A nested dictionary containing provider-specific settings
+  </Tab>
+  <Tab title="TypeScript">
+    The `config` is defined as a TypeScript object with these keys:
+    - `llm`: Specifies the LLM provider and its configuration (required)
+      - `provider`: The name of the LLM (e.g., "openai", "groq")
+      - `config`: A nested object containing provider-specific settings
+    - `embedder`: Specifies the embedder provider and its configuration (optional)
+    - `vectorStore`: Specifies the vector store provider and its configuration (optional)
+    - `historyDbPath`: Path to the history database file (optional)
+  </Tab>
+</Tabs>
+
+### Config Values Precedence
+
+Config values are applied in the following order of precedence (from highest to lowest):
+
+1. Values explicitly set in the `config` 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:
+
+<CodeGroup>
+```python Python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "sk-xx" # for embedder
+
+config = {
+    "llm": {
+        "provider": "your_chosen_provider",
+        "config": {
+            # Provider-specific settings go here
+        }
+    }
+}
+
+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.
+2. Providing necessary connection details (e.g., model, api_key, temperature).
+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:
+
+<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.

docs/components/llms/models/anthropic.mdx

@@ -0,0 +1,66 @@
+---
+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
+
+<CodeGroup>
+```python Python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "your-api-key" # used for embedding model
+os.environ["ANTHROPIC_API_KEY"] = "your-api-key"
+
+config = {
+    "llm": {
+        "provider": "anthropic",
+        "config": {
+            "model": "claude-3-7-sonnet-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"})
+```
+
+```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

@@ -0,0 +1,44 @@
+---
+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)
+- You will have to export `AWS_REGION`, `AWS_ACCESS_KEY`, and `AWS_SECRET_ACCESS_KEY` to set environment variables.
+
+### Usage
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "your-api-key" # used for embedding model
+os.environ['AWS_REGION'] = 'us-east-1'
+os.environ["AWS_ACCESS_KEY"] = "xx"
+os.environ["AWS_SECRET_ACCESS_KEY"] = "xx"
+
+config = {
+    "llm": {
+        "provider": "aws_bedrock",
+        "config": {
+            "model": "arn:aws:bedrock:us-east-1:123456789012:model/your-model-name",
+            "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 `aws_bedrock` config are present in [Master List of All Params in Config](../config).

docs/components/llms/models/azure_openai.mdx

@@ -0,0 +1,82 @@
+---
+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
+
+```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",
+        "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)
+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).

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

@@ -0,0 +1,39 @@
+---
+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
+
+```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": "litellm",
+        "config": {
+            "model": "gemini/gemini-pro",
+            "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 `litellm` config are present in [Master List of All Params in Config](../config).

docs/components/llms/models/groq.mdx

@@ -0,0 +1,68 @@
+---
+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
+
+<CodeGroup>
+```python Python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "your-api-key" # used for embedding model
+os.environ["GROQ_API_KEY"] = "your-api-key"
+
+config = {
+    "llm": {
+        "provider": "groq",
+        "config": {
+            "model": "mixtral-8x7b-32768",
+            "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"})
+```
+
+```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

@@ -0,0 +1,34 @@
+[Litellm](https://litellm.vercel.app/docs/) is compatible with over 100 large language models (LLMs), all using a standardized input/output format. You can explore the [available models](https://litellm.vercel.app/docs/providers) to use with Litellm. Ensure you set the `API_KEY` for the model you choose to use.
+
+## Usage
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "your-api-key"
+
+config = {
+    "llm": {
+        "provider": "litellm",
+        "config": {
+            "model": "gpt-4o-mini",
+            "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 `litellm` config are present in [Master List of All Params in Config](../config).

docs/components/llms/models/mistral_AI.mdx

@@ -0,0 +1,39 @@
+---
+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
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "your-api-key" # used for embedding model
+os.environ["MISTRAL_API_KEY"] = "your-api-key"
+
+config = {
+    "llm": {
+        "provider": "litellm",
+        "config": {
+            "model": "open-mixtral-8x7b",
+            "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 `litellm` config are present in [Master List of All Params in Config](../config).

docs/components/llms/models/ollama.mdx

@@ -0,0 +1,34 @@
+You can use LLMs from Ollama to run Mem0 locally. These [models](https://ollama.com/search?c=tools) support tool support.
+
+## Usage
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "your-api-key" # for embedder
+
+config = {
+    "llm": {
+        "provider": "ollama",
+        "config": {
+            "model": "mixtral:8x7b",
+            "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 `ollama` config are present in [Master List of All Params in Config](../config).

docs/components/llms/models/openai.mdx

@@ -0,0 +1,101 @@
+---
+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
+
+<CodeGroup>
+```python Python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "your-api-key"
+
+config = {
+    "llm": {
+        "provider": "openai",
+        "config": {
+            "model": "gpt-4o",
+            "temperature": 0.2,
+            "max_tokens": 2000,
+        }
+    }
+}
+
+# Use Openrouter by passing it's api key
+# os.environ["OPENROUTER_API_KEY"] = "your-api-key"
+# config = {
+#    "llm": {
+#        "provider": "openai",
+#        "config": {
+#            "model": "meta-llama/llama-3.1-70b-instruct",
+#        }
+#    }
+# }
+
+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 = {
+  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

@@ -0,0 +1,35 @@
+To use TogetherAI LLM models, you have to set the `TOGETHER_API_KEY` environment variable. You can obtain the TogetherAI API key from their [Account settings page](https://api.together.xyz/settings/api-keys).
+
+## Usage
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "your-api-key" # used for embedding model
+os.environ["TOGETHER_API_KEY"] = "your-api-key"
+
+config = {
+    "llm": {
+        "provider": "together",
+        "config": {
+            "model": "mistralai/Mixtral-8x7B-Instruct-v0.1",
+            "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 `togetherai` config are present in [Master List of All Params in Config](../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

@@ -0,0 +1,59 @@
+---
+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.
+
+## Usage
+
+To use a llm, 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 llm.
+
+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/vectordb.mdx

@@ -1,64 +0,0 @@
----
-title: 🗄 Vector Databases
----
-
-## Overview
-
-Mem0 includes built-in support for various popular databases. Memory can utilize the database provided by the user, ensuring efficient use for specific needs.
-
-<CardGroup>
-    <Card title="Qdrant" href="#qdrant"></Card>
-    <Card title="Chroma" href="#chroma"></Card>
-</CardGroup>
-
-
-## Qdrant
-
-[Qdrant](https://qdrant.tech/) is an open-source vector search engine. It is designed to work with large-scale datasets and provides a high-performance search engine for vector data.
-
-To use Qdrant you can do like this:
-
-```python
-import os
-from mem0 import Memory
-
-
-config = {
-    "vectordb": {
-        "provider": "qdrant",
-        "config": {
-            "collection_name": "test",
-            "host": "localhost",
-            "port": 6333,
-        }
-    }
-}
-
-m = Memory.from_config(config)
-m.add("Likes to play cricket on weekends", user_id="alice", metadata={"category": "hobbies"})
-```
-
-## Chroma
-
-[Chroma](https://www.trychroma.com/) is an AI-native open-source vector database that simplifies building LLM apps by providing tools for storing, embedding, and searching embeddings with a focus on simplicity and speed.
-
-To use ChromaDB you can do like this:
-
-```python
-import os
-from mem0 import Memory
-
-
-config = {
-    "vectordb": {
-        "provider": "chromadb",
-        "config": {
-            "collection_name": "test",
-            "path": "db",
-        }
-    }
-}
-
-m = Memory.from_config(config)
-m.add("Likes to play cricket on weekends", user_id="alice", metadata={"category": "hobbies"})
-```

docs/components/vectordbs/config.mdx

@@ -0,0 +1,121 @@
+---
+title: Configurations
+icon: "gear"
+iconType: "solid"
+---
+
+## How to define configurations?
+
+The `config` is defined as an object with two main keys:
+- `vector_store`: Specifies the vector database provider and its configuration
+  - `provider`: The name of the vector database (e.g., "chroma", "pgvector", "qdrant", "milvus", "azure_ai_search")
+  - `config`: A nested object containing provider-specific settings
+
+## How to Use Config
+
+Here's a general example of how to use the config with mem0:
+
+<CodeGroup>
+```python Python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "sk-xx"
+
+config = {
+    "vector_store": {
+        "provider": "your_chosen_provider",
+        "config": {
+            # Provider-specific settings go here
+        }
+    }
+}
+
+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:
+1. Specifying which vector database to use.
+2. Providing necessary connection details (e.g., host, port, credentials).
+3. Customizing database-specific settings (e.g., collection name, path).
+4. Ensuring proper initialization and connection to your chosen vector store.
+
+## Master List of All Params in Config
+
+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 |
+| `embedding_model_dims` | Dimensions of the embedding model |
+| `client` | Custom client for the database |
+| `path` | Path for the database |
+| `host` | Host where the server is running |
+| `port` | Port where the server is running |
+| `user` | Username for database connection |
+| `password` | Password for database connection |
+| `dbname` | Name of the database |
+| `url` | Full URL for the server |
+| `api_key` | API key for the server |
+| `on_disk` | Enable persistent storage |
+| `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
+
+Each vector database has its own specific configuration requirements. To customize the config for your chosen vector store:
+
+1. Identify the vector database you want to use from [supported vector databases](./dbs).
+2. Refer to the `Config` section in the respective vector database's documentation.
+3. Include only the relevant parameters for your chosen database in the `config` dictionary.
+
+## Supported Vector Databases
+
+For detailed information on configuring specific vector databases, please visit the [Supported Vector Databases](./dbs) section. There you'll find individual pages for each supported vector store with provider-specific usage examples and configuration details.

docs/components/vectordbs/dbs/azure_ai_search.mdx

@@ -0,0 +1,44 @@
+[Azure AI Search](https://learn.microsoft.com/en-us/azure/search/search-what-is-azure-search/) (formerly known as "Azure Cognitive Search") provides secure information retrieval at scale over user-owned content in traditional and generative AI search applications.
+
+### 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 ,
+            "use_compression": False
+        }
+    }
+}
+
+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 `qdrant` config:
+service_name (str): Azure Cognitive Search service name.  
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `service_name` | Azure AI Search service name | `None` |
+| `api_key` | API key of the Azure AI Search service | `None` |
+| `collection_name` | The name of the collection/index to store the vectors, it will be created automatically if not exist | `mem0` |
+| `embedding_model_dims` | Dimensions of the embedding model | `1536` |
+| `use_compression` | Use scalar quantization vector compression | False |

docs/components/vectordbs/dbs/chroma.mdx

@@ -0,0 +1,41 @@
+[Chroma](https://www.trychroma.com/) is an AI-native open-source vector database that simplifies building LLM apps by providing tools for storing, embedding, and searching embeddings with a focus on simplicity and speed.
+
+### Usage
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "sk-xx"
+
+config = {
+    "vector_store": {
+        "provider": "chroma",
+        "config": {
+            "collection_name": "test",
+            "path": "db",
+        }
+    }
+}
+
+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 Chroma:
+
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `collection_name` | The name of the collection | `mem0` |
+| `client` | Custom client for Chroma | `None` |
+| `path` | Path for the Chroma database | `db` |
+| `host` | The host where the Chroma server is running | `None` |
+| `port` | The port where the Chroma server is running | `None` |

docs/components/vectordbs/dbs/elasticsearch.mdx

@@ -0,0 +1,64 @@
+[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`        |
+
+### 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

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

@@ -0,0 +1,47 @@
+[pgvector](https://github.com/pgvector/pgvector) is open-source vector similarity search for Postgres. After connecting with postgres run `CREATE EXTENSION IF NOT EXISTS vector;` to create the vector extension.
+
+### Usage
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "sk-xx"
+
+config = {
+    "vector_store": {
+        "provider": "pgvector",
+        "config": {
+            "user": "test",
+            "password": "123",
+            "host": "127.0.0.1",
+            "port": "5432",
+        }
+    }
+}
+
+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 pgvector:
+
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `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` |
+| `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

@@ -0,0 +1,89 @@
+[Qdrant](https://qdrant.tech/) is an open-source vector search engine. It is designed to work with large-scale datasets and provides a high-performance search engine for vector data.
+
+### Usage
+
+<CodeGroup>
+```python Python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "sk-xx"
+
+config = {
+    "vector_store": {
+        "provider": "qdrant",
+        "config": {
+            "collection_name": "test",
+            "host": "localhost",
+            "port": 6333,
+        }
+    }
+}
+
+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: '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` |
+| `embedding_model_dims` | Dimensions of the embedding model | `1536` |
+| `client` | Custom client for qdrant | `None` |
+| `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` |
+| `api_key` | API key for the qdrant server | `None` |
+| `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/overview.mdx

@@ -0,0 +1,45 @@
+---
+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>
+</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).
+
+## Common issues
+
+### Using model with different dimensions
+
+If you are using customized model, which is having different dimensions other than 1536
+for example 768, you may encounter below error:
+
+`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,332 @@
+{
+  "$schema": "https://mintlify.com/docs.json",
+  "theme": "maple",
+  "name": "Mem0",
+  "description": "Mem0 is a self-improving memory layer for LLM applications, enabling personalized AI experiences that save costs and delight users.",
+  "colors": {
+    "primary": "#6c60f0",
+    "light": "#E6FFA2",
+    "dark": "#a3df02"
+  },
+  "favicon": "/logo/favicon.png",
+  "navigation": {
+    "anchors": [
+      {
+        "anchor": "Documentation",
+        "icon": "book-open",
+        "tabs": [
+          {
+            "tab": "Documentation",
+            "groups": [
+              {
+                "group": "Get Started",
+                "icon": "rocket",
+                "pages": [
+                  "overview",
+                  "quickstart",
+                  "faqs"
+                ]
+              },
+              {
+                "group": "Core Concepts",
+                "icon": "brain",
+                "pages": [
+                  "core-concepts/memory-types",
+                  "core-concepts/memory-operations"
+                ]
+              },
+              {
+                "group": "Platform",
+                "icon": "cogs",
+                "pages": [
+                  "platform/overview",
+                  "platform/quickstart",
+                  {
+                    "group": "Features",
+                    "icon": "star",
+                    "pages": [
+                      "features/platform-overview",
+                      "features/advanced-retrieval",
+                      "features/multimodal-support",
+                      "features/selective-memory",
+                      "features/custom-categories",
+                      "features/custom-instructions",
+                      "features/direct-import",
+                      "features/async-client",
+                      "features/memory-export",
+                      "features/webhooks"
+                    ]
+                  }
+                ]
+              },
+              {
+                "group": "Open Source",
+                "icon": "code-branch",
+                "pages": [
+                  "open-source/quickstart",
+                  "open-source/python-quickstart",
+                  "open-source/node-quickstart",
+                  {
+                    "group": "Features",
+                    "icon": "wrench",
+                    "pages": [
+                      "features/openai_compatibility",
+                      "features/custom-prompts",
+                      "open-source/multimodal-support",
+                      "open-source/features/rest-api"
+                    ]
+                  },
+                  {
+                    "group": "Graph Memory",
+                    "icon": "spider-web",
+                    "pages": [
+                      "open-source/graph_memory/overview",
+                      "open-source/graph_memory/features"
+                    ]
+                  },
+                  {
+                    "group": "LLMs",
+                    "icon": "brain",
+                    "pages": [
+                      "components/llms/overview",
+                      "components/llms/config",
+                      {
+                        "group": "Supported LLMs",
+                        "icon": "list",
+                        "pages": [
+                          "components/llms/models/openai",
+                          "components/llms/models/anthropic",
+                          "components/llms/models/azure_openai",
+                          "components/llms/models/ollama",
+                          "components/llms/models/together",
+                          "components/llms/models/groq",
+                          "components/llms/models/litellm",
+                          "components/llms/models/mistral_AI",
+                          "components/llms/models/google_AI",
+                          "components/llms/models/aws_bedrock",
+                          "components/llms/models/gemini",
+                          "components/llms/models/deepseek",
+                          "components/llms/models/xAI"
+                        ]
+                      }
+                    ]
+                  },
+                  {
+                    "group": "Vector Databases",
+                    "icon": "database",
+                    "pages": [
+                      "components/vectordbs/overview",
+                      "components/vectordbs/config",
+                      {
+                        "group": "Supported Vector Databases",
+                        "icon": "server",
+                        "pages": [
+                          "components/vectordbs/dbs/qdrant",
+                          "components/vectordbs/dbs/chroma",
+                          "components/vectordbs/dbs/pgvector",
+                          "components/vectordbs/dbs/milvus",
+                          "components/vectordbs/dbs/azure_ai_search",
+                          "components/vectordbs/dbs/redis",
+                          "components/vectordbs/dbs/elasticsearch",
+                          "components/vectordbs/dbs/opensearch",
+                          "components/vectordbs/dbs/supabase"
+                        ]
+                      }
+                    ]
+                  },
+                  {
+                    "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"
+                ]
+              }
+            ]
+          },
+          {
+            "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"
+                ]
+              }
+            ]
+          },
+          {
+            "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://demo.mem0.ai",
+        "icon": "play"
+      },
+      {
+        "anchor": "Discord",
+        "href": "https://mem0.dev/DiD",
+        "icon": "discord"
+      },
+      {
+        "anchor": "GitHub",
+        "href": "https://github.com/mem0ai/mem0",
+        "icon": "github"
+      },
+      {
+        "anchor": "Support",
+        "href": "mailto:founders@mem0.ai",
+        "icon": "envelope"
+      }
+    ]
+  },
+  "logo": {
+    "light": "/logo/light.svg",
+    "dark": "/logo/dark.svg",
+    "href": "https://github.com/mem0ai/mem0"
+  },
+  "background": {
+    "color": {
+      "light": "#fff",
+      "dark": "#0f1117"
+    }
+  },
+  "navbar": {
+    "primary": {
+      "type": "button",
+      "label": "Your Dashboard",
+      "href": "https://app.mem0.ai"
+    }
+  },
+  "footer": {
+    "socials": {
+      "discord": "https://mem0.dev/DiD",
+      "x": "https://x.com/mem0ai",
+      "github": "https://github.com/mem0ai",
+      "linkedin": "https://www.linkedin.com/company/mem0/"
+    }
+  },
+  "integrations": {
+    "posthog": {
+      "apiKey": "phc_hgJkUVJFYtmaJqrvf6CYN67TIQ8yhXAkWzUn9AMU4yX",
+      "apiHost": "https://mango.mem0.ai"
+    }
+  }
+}

docs/examples/ai_companion.mdx

@@ -0,0 +1,166 @@
+---
+title: AI Companion
+---
+
+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 separate memories for both the user and the companion. By integrating with OpenAI's GPT-4 model, the companion can provide detailed and context-aware responses to user queries.
+
+## Setup
+Before you begin, ensure you have the required dependencies installed. You can install the necessary packages using pip:
+
+```bash
+pip install openai mem0ai
+```
+
+## Full Code Example
+
+Below is the complete code to create and interact with an AI Companion using Mem0:
+
+```python
+from openai import OpenAI
+from mem0 import Memory
+import os
+
+# Set the OpenAI API key
+os.environ['OPENAI_API_KEY'] = 'sk-xxx'
+
+# Initialize the OpenAI client
+client = OpenAI()
+
+class Companion:
+    def __init__(self, user_id, companion_id):
+        """
+        Initialize the Companion with memory configuration, OpenAI client, and user IDs.
+        :param user_id: ID for storing user-related memories
+        :param companion_id: ID for storing companion-related memories
+        """
+        config = {
+            "vector_store": {
+                "provider": "qdrant",
+                "config": {
+                    "host": "localhost",
+                    "port": 6333,
+                }
+            },
+        }
+        self.memory = Memory.from_config(config)
+        self.client = client
+        self.app_id = "app-1"
+        self.USER_ID = user_id
+        self.companion_id = companion_id
+
+    def analyze_question(self, question):
+        """
+        Analyze the question to determine whether it's about the user or the companion.
+        """
+        check_prompt = f"""
+        Analyze the given input and determine whether the user is primarily:
+        1) Talking about themselves or asking for personal advice. They may use words like "I" for this. 
+        2) Inquiring about the AI companions's capabilities or characteristics They may use words like "you" for this. 
+
+        Respond with a single word:
+        - 'user' if the input is focused on the user
+        - 'companion' if the input is focused on the AI companion
+
+        If the input is ambiguous or doesn't clearly fit either category, respond with 'user'.
+
+        Input: {question}
+        """
+        response = self.client.chat.completions.create(
+            model="gpt-4",
+            messages=[{"role": "user", "content": check_prompt}]
+        )
+        return response.choices[0].message.content
+
+    def ask(self, question):
+        """
+        Ask a question to the AI and store the relevant facts in memory
+        :param question: The question to ask the AI.
+        """
+        check_answer = self.analyze_question(question)
+        user_id_to_use = self.USER_ID if check_answer == "user" else self.companion_id
+
+        previous_memories = self.memory.search(question, user_id=user_id_to_use)
+        relevant_memories_text = ""
+        if previous_memories:
+            relevant_memories_text = '\n'.join(mem["memory"] for mem in previous_memories)
+
+        prompt = f"User input: {question}\nPrevious {check_answer} memories: {relevant_memories_text}"
+
+        messages = [
+            {
+                "role": "system",
+                "content": "You are the user's romantic companion. Use the user's input and previous memories to respond. Answer based on the context provided."
+            },
+            {
+                "role": "user",
+                "content": prompt
+            }
+        ]
+
+        stream = self.client.chat.completions.create(
+            model="gpt-4",
+            stream=True,
+            messages=messages
+        )
+
+        answer = ""
+        for chunk in stream:
+            if chunk.choices[0].delta.content is not None:
+                content = chunk.choices[0].delta.content
+                print(content, end="")
+                answer += content
+        # Store the question and answer in memory
+        self.memory.add(question, user_id=self.USER_ID, metadata={"app_id": self.app_id})
+        self.memory.add(answer, user_id=self.companion_id, metadata={"app_id": self.app_id})
+
+    def get_memories(self, user_id=None):
+        """
+        Retrieve all memories associated with the given user ID.
+        :param user_id: Optional user ID to filter memories.
+        :return: List of memories.
+        """
+        return self.memory.get_all(user_id=user_id)
+
+# Example usage:
+user_id = "user"
+companion_id = "companion"
+ai_companion = Companion(user_id, companion_id)
+
+# Ask a question
+ai_companion.ask("Ive been missing you. What have you been up to off late?")
+```
+
+### Fetching Memories
+
+You can fetch all the memories at any point in time using the following code:
+
+```python
+def print_memories(user_id, label):
+    print(f"\n{label} Memories:")
+    memories = ai_companion.get_memories(user_id=user_id)
+    if memories:
+        for m in memories:
+            print(f"- {m['text']}")
+    else:
+        print("No memories found.")
+
+# Print user memories
+print_memories(user_id, "User")
+
+# Print companion memories
+print_memories(companion_id, "Companion")
+```
+
+### Key Points
+
+- **Initialization**: The Companion class is initialized with the necessary memory configuration and OpenAI client setup.
+- **Asking Questions**: The ask method sends a question to the AI and stores the relevant information in memory.
+- **Retrieving Memories**: The get_memories method fetches all stored memories associated with a user.
+
+### Conclusion
+
+As the conversation progresses, Mem0's memory automatically updates based on the interactions, providing a continuously improving personalized experience. This setup ensures that the AI Companion can offer contextually relevant and accurate responses, enhancing the user's experience.

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/llama-index-mem0.mdx

@@ -0,0 +1,172 @@
+---
+title: LlamaIndex ReAct Agent
+---
+Create a ReAct Agent with LlamaIndex which uses Mem0 as the memory store.
+
+### Overview
+A ReAct agent combines reasoning and action capabilities, making it versatile for tasks requiring both thought processes (reasoning) and interaction with tools or APIs (acting). Mem0 as memory enhances these capabilities by allowing the agent to store and retrieve contextual information from past interactions.
+
+### Setup
+```bash
+pip install llama-index-core llama-index-memory-mem0
+```
+
+Initialize the LLM.
+```python
+import os
+from llama_index.llms.openai import OpenAI
+
+os.environ["OPENAI_API_KEY"] = "<your-openai-api-key>"
+llm = OpenAI(model="gpt-4o")
+```
+
+Initialize the Mem0 client. You can find your API key [here](https://app.mem0.ai/dashboard/). Read about Mem0 [Open Source](https://docs.mem0.ai/open-source/quickstart).
+```python
+os.environ["MEM0_API_KEY"] = "<your-mem0-api-key>"
+
+from llama_index.memory.mem0 import Mem0Memory
+
+context = {"user_id": "david"}
+memory_from_client = Mem0Memory.from_client(
+    context=context,
+    api_key=os.environ["MEM0_API_KEY"],
+    search_msg_limit=4,  # optional, default is 5
+)
+```
+
+Create the tools. These tools will be used by the agent to perform actions.
+```python
+from llama_index.core.tools import FunctionTool
+
+def call_fn(name: str):
+    """Call the provided name.
+    Args:
+        name: str (Name of the person)
+    """
+    return f"Calling... {name}"
+
+def email_fn(name: str):
+    """Email the provided name.
+    Args:
+        name: str (Name of the person)
+    """
+    return f"Emailing... {name}"
+
+def order_food(name: str, dish: str):
+    """Order food for the provided name.
+    Args:
+        name: str (Name of the person)
+        dish: str (Name of the dish)
+    """
+    return f"Ordering {dish} for {name}"
+
+call_tool = FunctionTool.from_defaults(fn=call_fn)
+email_tool = FunctionTool.from_defaults(fn=email_fn)
+order_food_tool = FunctionTool.from_defaults(fn=order_food)
+```
+
+Initialize the agent with tools and memory.
+```python
+from llama_index.core.agent import FunctionCallingAgent
+
+agent = FunctionCallingAgent.from_tools(
+    [call_tool, email_tool, order_food_tool],
+    llm=llm,
+    memory=memory_from_client,  # or memory_from_config
+    verbose=True,
+)
+```
+
+Start the chat.
+<Note> The agent will use the Mem0 to store the relavant memories from the chat. </Note>
+
+Input
+```python
+response = agent.chat("Hi, My name is David")
+print(response)
+```
+Output
+```text
+> Running step bf44a75a-a920-4cf3-944e-b6e6b5695043. Step input: Hi, My name is David
+Added user message to memory: Hi, My name is David
+=== LLM Response ===
+Hello, David! How can I assist you today?
+```
+
+Input
+```python
+response = agent.chat("I love to eat pizza on weekends")
+print(response)
+```
+Output
+```text
+> Running step 845783b0-b85b-487c-baee-8460ebe8b38d. Step input: I love to eat pizza on weekends
+Added user message to memory: I love to eat pizza on weekends
+=== LLM Response ===
+Pizza is a great choice for the weekend! If you'd like, I can help you order some. Just let me know what kind of pizza you prefer!
+```
+Input
+```python
+response = agent.chat("My preferred way of communication is email")
+print(response)
+```
+Output
+```text
+> Running step 345842f0-f8a0-42ea-a1b7-612265d72a92. Step input: My preferred way of communication is email
+Added user message to memory: My preferred way of communication is email
+=== LLM Response ===
+Got it! If you need any assistance or have any requests, feel free to let me know, and I can communicate with you via email.
+```
+
+### Using the agent WITHOUT memory
+Input
+```python
+agent = FunctionCallingAgent.from_tools(
+    [call_tool, email_tool, order_food_tool],
+    # memory is not provided
+    llm=llm,
+    verbose=True,
+)
+response = agent.chat("I am feeling hungry, order me something and send me the bill")
+print(response)
+```
+Output
+```text
+> Running step e89eb75d-75e1-4dea-a8c8-5c3d4b77882d. Step input: I am feeling hungry, order me something and send me the bill
+Added user message to memory: I am feeling hungry, order me something and send me the bill
+=== LLM Response ===
+Please let me know your name and the dish you'd like to order, and I'll take care of it for you!
+```
+<Note> The agent is not able to remember the past prefernces that user shared in previous chats. </Note>
+
+### Using the agent WITH memory
+Input
+```python
+agent = FunctionCallingAgent.from_tools(
+    [call_tool, email_tool, order_food_tool],
+    llm=llm,
+    # memory is provided
+    memory=memory_from_client,  # or memory_from_config
+    verbose=True,
+)
+response = agent.chat("I am feeling hungry, order me something and send me the bill")
+print(response)
+```
+
+Output
+```text
+> Running step 5e473db9-3973-4cb1-a5fd-860be0ab0006. Step input: I am feeling hungry, order me something and send me the bill
+Added user message to memory: I am feeling hungry, order me something and send me the bill
+=== Calling Function ===
+Calling function: order_food with args: {"name": "David", "dish": "pizza"}
+=== Function Output ===
+Ordering pizza for David
+=== Calling Function ===
+Calling function: email_fn with args: {"name": "David"}
+=== Function Output ===
+Emailing... David
+> Running step 38080544-6b37-4bb2-aab2-7670100d926e. Step input: None
+=== LLM Response ===
+I've ordered a pizza for you, and the bill has been sent to your email. Enjoy your meal! If there's anything else you need, feel free to let me know.
+```
+<Note> The agent is able to remember the past prefernces that user shared and use them to perform actions. </Note>

docs/examples/mem0-demo.mdx

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

docs/examples/mem0-with-ollama.mdx

@@ -0,0 +1,73 @@
+---
+title: Mem0 with Ollama
+---
+
+## Running Mem0 Locally with Ollama
+
+Mem0 can be utilized entirely locally by leveraging Ollama for both the embedding model and the language model (LLM). This guide will walk you through the necessary steps and provide the complete code to get you started.
+
+### Overview
+
+By using Ollama, you can run Mem0 locally, which allows for greater control over your data and models. This setup uses Ollama for both the embedding model and the language model, providing a fully local solution.
+
+### Setup
+
+Before you begin, ensure you have Mem0 and Ollama installed and properly configured on your local machine.
+
+### Full Code Example
+
+Below is the complete code to set up and use Mem0 locally with Ollama:
+
+```python
+import os
+from mem0 import Memory
+
+config = {
+    "vector_store": {
+        "provider": "qdrant",
+        "config": {
+            "collection_name": "test",
+            "host": "localhost",
+            "port": 6333,
+            "embedding_model_dims": 768,  # Change this according to your local model's dimensions
+        },
+    },
+    "llm": {
+        "provider": "ollama",
+        "config": {
+            "model": "llama3.1:latest",
+            "temperature": 0,
+            "max_tokens": 2000,
+            "ollama_base_url": "http://localhost:11434",  # Ensure this URL is correct
+        },
+    },
+    "embedder": {
+        "provider": "ollama",
+        "config": {
+            "model": "nomic-embed-text:latest",
+            # Alternatively, you can use "snowflake-arctic-embed:latest"
+            "ollama_base_url": "http://localhost:11434",
+        },
+    },
+}
+
+# Initialize Memory with the configuration
+m = Memory.from_config(config)
+
+# Add a memory
+m.add("I'm visiting Paris", user_id="john")
+
+# Retrieve memories
+memories = m.get_all(user_id="john")
+```
+
+### Key Points
+
+- **Configuration**: The setup involves configuring the vector store, language model, and embedding model to use local resources.
+- **Vector Store**: Qdrant is used as the vector store, running on localhost.
+- **Language Model**: Ollama is used as the LLM provider, with the "llama3.1:latest" model.
+- **Embedding Model**: Ollama is also used for embeddings, with the "nomic-embed-text:latest" model.
+
+### Conclusion
+
+This local setup of Mem0 using Ollama provides a fully self-contained solution for memory management and AI interactions. It allows for greater control over your data and models while still leveraging the powerful capabilities of Mem0.

docs/examples/overview.mdx

@@ -14,19 +14,25 @@ With Mem0, you can create stateful LLM-based applications such as chatbots, virt
 
 Here are some examples of how Mem0 can be integrated into various applications:
 
-## Example Use Cases
+## Examples
 
-<CardGroup cols={1}>
-  <Card title="Personal AI Tutor" icon="square-1" href="/examples/personal-ai-tutor">
-    <img width="100%" src="/images/ai-tutor.png" />
+<CardGroup cols={2}>
+  <Card title="AI Companion in Node.js" icon="square-6" href="/examples/ai_companion_js">
+    Create a Personalized AI Companion using Mem0 in Node.js.
+  </Card>
+  <Card title="Mem0 with Ollama" icon="square-1" href="/examples/mem0-with-ollama">
+    Run Mem0 locally with Ollama.
+  </Card>
+  <Card title="Personal AI Tutor" icon="square-2" href="/examples/personal-ai-tutor">
     Create a Personalized AI Tutor that adapts to student progress and learning preferences.
   </Card>
-  <Card title="Personal Travel Assistant" icon="square-2" href="/examples/personal-travel-assistant">
-    <img src="/images/personal-travel-agent.png" />
+  <Card title="Personal Travel Assistant" icon="square-3" href="/examples/personal-travel-assistant">
     Build a Personalized AI Travel Assistant that understands your travel preferences and past itineraries.
   </Card>
-  <Card title="Customer Support Agent" icon="square-3" href="/examples/customer-support-agent">
-    <img width="100%" src="/images/customer-support-agent.png" />
+  <Card title="Customer Support Agent" icon="square-4" href="/examples/customer-support-agent">
     Develop a Personal AI Assistant that remembers user preferences, past interactions, and context to provide personalized and efficient assistance.
   </Card>
-</CardGroup>
+  <Card title="LlamaIndex Mem0" icon="square-5" href="/examples/llama-index-mem0">
+    Create a ReAct Agent with LlamaIndex which uses Mem0 as the memory store.
+  </Card>
+</CardGroup>

docs/examples/personal-travel-assistant.mdx

@@ -19,7 +19,99 @@ pip install openai mem0ai
 
 Here's the complete code to create and interact with a Personalized AI Travel Assistant using Mem0:
 
-```python
+<CodeGroup>
+
+```python After v1.1
+import os
+from openai import OpenAI
+from mem0 import Memory
+
+# Set the OpenAI API key
+os.environ['OPENAI_API_KEY'] = "sk-xxx"
+
+config = {
+    "llm": {
+        "provider": "openai",
+        "config": {
+            "model": "gpt-4o",
+            "temperature": 0.1,
+            "max_tokens": 2000,
+        }
+    },
+    "embedder": {
+        "provider": "openai",
+        "config": {
+            "model": "text-embedding-3-large"
+        }
+    },
+    "vector_store": {
+        "provider": "qdrant",
+        "config": {
+            "collection_name": "test",
+            "embedding_model_dims": 3072,
+        }
+    },
+    "version": "v1.1",
+}
+
+class PersonalTravelAssistant:
+    def __init__(self):
+        self.client = OpenAI()
+        self.memory = Memory.from_config(config)
+        self.messages = [{"role": "system", "content": "You are a personal AI Assistant."}]
+
+    def ask_question(self, question, user_id):
+        # Fetch previous related memories
+        previous_memories = self.search_memories(question, user_id=user_id)
+        prompt = question
+        if previous_memories:
+            prompt = f"User input: {question}\n Previous memories: {previous_memories}"
+        self.messages.append({"role": "user", "content": prompt})
+
+        # Generate response using GPT-4o
+        response = self.client.chat.completions.create(
+            model="gpt-4o",
+            messages=self.messages
+        )
+        answer = response.choices[0].message.content
+        self.messages.append({"role": "assistant", "content": answer})
+
+        # Store the question in memory
+        self.memory.add(question, user_id=user_id)
+        return answer
+
+    def get_memories(self, user_id):
+        memories = self.memory.get_all(user_id=user_id)
+        return [m['memory'] for m in memories['memories']]
+
+    def search_memories(self, query, user_id):
+        memories = self.memory.search(query, user_id=user_id)
+        return [m['memory'] for m in memories['memories']]
+
+# Usage example
+user_id = "traveler_123"
+ai_assistant = PersonalTravelAssistant()
+
+def main():
+    while True:
+        question = input("Question: ")
+        if question.lower() in ['q', 'exit']:
+            print("Exiting...")
+            break
+
+        answer = ai_assistant.ask_question(question, user_id=user_id)
+        print(f"Answer: {answer}")
+        memories = ai_assistant.get_memories(user_id=user_id)
+        print("Memories:")
+        for memory in memories:
+            print(f"- {memory}")
+        print("-----")
+
+if __name__ == "__main__":
+    main()
+```
+
+```python Before v1.1
 import os
 from openai import OpenAI
 from mem0 import Memory
@@ -55,11 +147,11 @@ class PersonalTravelAssistant:
 
     def get_memories(self, user_id):
         memories = self.memory.get_all(user_id=user_id)
-        return [m['text'] for m in memories]
+        return [m['memory'] for m in memories['memories']]
 
     def search_memories(self, query, user_id):
         memories = self.memory.search(query, user_id=user_id)
-        return [m['text'] for m in memories]
+        return [m['memory'] for m in memories['memories']]
 
 # Usage example
 user_id = "traveler_123"
@@ -83,6 +175,8 @@ def main():
 if __name__ == "__main__":
     main()
 ```
+</CodeGroup>
+
 
 ## Key Components