Update langchain dependencies and version bump for embedchain (#1935)

Co-authored-by: parshvadaftari <parshva@192.168.1.5>

.github/workflows/ci.yml

@@ -7,15 +7,11 @@ on:
       - 'mem0/**'
       - 'tests/**'
       - 'embedchain/**'
-      - 'embedchain/tests/**'
-      - 'embedchain/examples/**'
   pull_request:
     paths:
       - 'mem0/**'
       - 'tests/**'
       - 'embedchain/**'
-      - 'embedchain/tests/**'
-      - 'embedchain/examples/**'
 
 jobs:
   check_changes:
@@ -34,17 +30,14 @@ jobs:
             - 'tests/**'
           embedchain:
             - 'embedchain/**'
-            - 'embedchain/tests/**'
-            - 'embedchain/examples/**'
 
   build_mem0:
     needs: check_changes
-    if: ${{ needs.check_changes.outputs.mem0_changed == 'true' || (needs.check_changes.outputs.mem0_changed == 'false' && needs.check_changes.outputs.embedchain_changed == 'false') }}
+    if: needs.check_changes.outputs.mem0_changed == 'true'
     runs-on: ubuntu-latest
     strategy:
       matrix:
         python-version: ["3.10", "3.11"]
-
     steps:
       - uses: actions/checkout@v3
       - name: Set up Python ${{ matrix.python-version }}
@@ -71,12 +64,11 @@ jobs:
 
   build_embedchain:
     needs: check_changes
-    if: ${{ needs.check_changes.outputs.embedchain_changed == 'true' || (needs.check_changes.outputs.mem0_changed == 'false' && needs.check_changes.outputs.embedchain_changed == 'false') }}
+    if: needs.check_changes.outputs.embedchain_changed == 'true'
     runs-on: ubuntu-latest
     strategy:
       matrix:
         python-version: ["3.9", "3.10", "3.11"]
-
     steps:
       - uses: actions/checkout@v3
       - name: Set up Python ${{ matrix.python-version }}

.gitignore

@@ -184,3 +184,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!

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [2023] [Taranjeet Singh]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

Makefile

@@ -12,18 +12,20 @@ install:
 
 install_all:
 	poetry install
+	poetry run pip install groq together boto3 litellm ollama chromadb sentence_transformers vertexai \
+	                        google-generativeai
 
 # 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
@@ -38,4 +40,4 @@ clean:
 	poetry run rm -rf dist
 
 test:
-	poetry run pytest
+	poetry run pytest tests

README.md

@@ -1,63 +1,48 @@
 <p align="center">
-  <img src="docs/images/mem0-bg.png" width="500px" 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"><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://embedchain.ai/slack">
-    <img src="https://img.shields.io/badge/slack-embedchain-brightgreen.svg?logo=slack" alt="Slack">
+  <a href="https://mem0.dev/DiG">
+    <img src="https://dcbadge.vercel.app/api/server/6PzXDgEjG5?style=flat" alt="Mem0 Discord">
   </a>
-  <a href="https://embedchain.ai/discord">
-    <img src="https://dcbadge.vercel.app/api/server/6PzXDgEjG5?style=flat" alt="Discord">
+  <a href="https://pepy.tech/project/mem0ai">
+    <img src="https://img.shields.io/pypi/dm/mem0ai" alt="Mem0 PyPI - Downloads" >
   </a>
-  <a href="https://twitter.com/mem0ai">
-    <img src="https://img.shields.io/twitter/follow/mem0ai" alt="Twitter">
+  <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://pypi.org/project/mem0ai" target="_blank">
+        <img src="https://img.shields.io/pypi/pyversions/mem0ai.svg?color=%2334D058" alt="Supported Python versions">
+    </a>
+  <a href="https://www.ycombinator.com/companies/mem0">
+    <img src="https://img.shields.io/badge/Y%20Combinator-S24-orange?style=flat-square" alt="Y Combinator S24">
   </a>
 </p>
 
-# Mem0: The Memory Layer for Personalized AI
 
-Mem0 provides a smart, self-improving memory layer for Large Language Models, enabling personalized AI experiences across applications.
+# Introduction
 
-> 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.
-## 🚀 Quick Start
+[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
+<!-- Start of Selection -->
+<p style="display: flex;">
+  <span style="font-size: 1.2em;">New Feature: Introducing Graph Memory. Check out our <a href="https://docs.mem0.ai/open-source/graph-memory" target="_blank">documentation</a>.</span>
+</p>
+<!-- End of Selection -->
 
-```bash
-pip install mem0ai
-```
 
-### Basic Usage
-
-```python
-from mem0 import Memory
-
-# Initialize Mem0
-m = Memory()
-
-# 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"})
-print(result)
-# Created memory: Improving her tennis skills. Looking for online suggestions.
-
-# Retrieve memories
-all_memories = m.get_all()
-print(all_memories)
-
-# Search memories
-related_memories = m.search(query="What are Alice's hobbies?", user_id="alice")
-print(related_memories)
-
-# Update a memory
-result = m.update(memory_id="m1", data="Likes to play tennis on weekends")
-print(result)
-
-# Get memory history
-history = m.history(memory_id="m1")
-print(history)
-```
-
-## 🔑 Core Features
+### Core Features
 
 - **Multi-Level Memory**: User, Session, and AI Agent memory retention
 - **Adaptive Personalization**: Continuous improvement based on interactions
@@ -65,43 +50,165 @@ print(history)
 - **Cross-Platform Consistency**: Uniform behavior across devices
 - **Managed Service**: Hassle-free hosted solution
 
-## 📖 Documentation
+### How Mem0 works?
 
-For detailed usage instructions and API reference, visit our documentation at [docs.mem0.ai](https://docs.mem0.ai).
+Mem0 leverages a hybrid database approach to manage and retrieve long-term memories for AI agents and assistants. Each memory is associated with a unique identifier, such as a user ID or agent ID, allowing Mem0 to organize and access memories specific to an individual or context.
 
-## 🔧 Advanced Usage
+When a message is added to the Mem0 using add()  method, the system extracts relevant facts and preferences and stores it across data stores: a vector database, a key-value database, and a graph database. This hybrid approach ensures that different types of information are stored in the most efficient manner, making subsequent searches quick and effective.
 
-For production environments, you can use Qdrant as a vector store:
+When an AI agent or LLM needs to recall memories, it uses the search() method. Mem0 then performs search across these data stores, retrieving relevant information from each source. This information is then passed through a scoring layer, which evaluates their importance based on relevance, importance, and recency. This ensures that only the most personalized and useful context is surfaced.
+
+The retrieved memories can then be appended to the LLM's prompt as needed, enhancing the personalization and relevance of its responses.
+
+### Use Cases
+
+Mem0 empowers organizations and individuals to enhance:
+
+- **AI Assistants and agents**: Seamless conversations with a touch of déjà vu
+- **Personalized Learning**: Tailored content recommendations and progress tracking
+- **Customer Support**: Context-aware assistance with user preference memory
+- **Healthcare**: Patient history and treatment plan management
+- **Virtual Companions**: Deeper user relationships through conversation memory
+- **Productivity**: Streamlined workflows based on user habits and task history
+- **Gaming**: Adaptive environments reflecting player choices and progress
+
+## Get Started
+
+The easiest way to set up Mem0 is through the managed [Mem0 Platform](https://app.mem0.ai). This hosted solution offers automatic updates, advanced analytics, and dedicated support. [Sign up](https://app.mem0.ai) to get started.
+
+If you prefer to self-host, use the open-source Mem0 package. Follow the [installation instructions](#install) to get started.
+
+## Installation Instructions <a name="install"></a>
+
+Install the Mem0 package via pip:
+
+```bash
+pip install mem0ai
+```
+
+Alternatively, you can use Mem0 with one click on the hosted platform [here](https://app.mem0.ai/).
+
+### 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 mem0 import Memory
+
+m = Memory()
+```
+
+<details>
+<summary>How to set OPENAI_API_KEY</summary>
+
+```python
+import os
+os.environ["OPENAI_API_KEY"] = "sk-xxx"
+```
+</details>
+
+
+You can perform the following task on the memory:
+
+1. Add: Store a memory from any unstructured text
+2. Update: Update memory of a given memory_id
+3. Search: Fetch memories based on a query
+4. Get: Return memories for a certain user/agent/session
+5. History: Describe how a memory has changed over time for a specific memory ID
+
+```python
+# 1. Add: Store a memory from any unstructured text
+result = m.add("I am working on improving my tennis skills. Suggest some online courses.", user_id="alice", metadata={"category": "hobbies"})
+
+# Created memory --> 'Improving her tennis skills.' and 'Looking for online suggestions.'
+```
+
+```python
+# 2. Update: update the memory
+result = m.update(memory_id=<memory_id_1>, data="Likes to play tennis on weekends")
+
+# Updated memory --> 'Likes to play tennis on weekends.' and 'Looking for online suggestions.'
+```
+
+```python
+# 3. Search: search related memories
+related_memories = m.search(query="What are Alice's hobbies?", user_id="alice")
+
+# Retrieved memory --> 'Likes to play tennis on weekends'
+```
+
+```python
+# 4. Get all memories
+all_memories = m.get_all()
+memory_id = all_memories["memories"][0] ["id"] # get a memory_id
+
+# All memory items --> 'Likes to play tennis on weekends.' and 'Looking for online suggestions.'
+```
+
+```python
+# 5. Get memory history for a particular memory_id
+history = m.history(memory_id=<memory_id_1>)
+
+# Logs corresponding to memory_id_1 --> {'prev_value': 'Working on improving tennis skills and interested in online courses for tennis.', 'new_value': 'Likes to play tennis on weekends' }
+```
+
+> [!TIP]
+> If you prefer a hosted version without the need to set up infrastructure yourself, check out the [Mem0 Platform](https://app.mem0.ai/) to get started in minutes.
+
+
+### Graph Memory
+To initialize Graph Memory you'll need to set up your configuration with graph store providers.
+Currently, we support Neo4j as a graph store provider. You can setup [Neo4j](https://neo4j.com/) locally or use the hosted [Neo4j AuraDB](https://neo4j.com/product/auradb/). 
+Moreover, you also need to set the version to `v1.1` (*prior versions are not supported*). 
+Here's how you can do it:
 
 ```python
 from mem0 import Memory
 
 config = {
-    "vector_store": {
-        "provider": "qdrant",
+    "graph_store": {
+        "provider": "neo4j",
         "config": {
-            "host": "localhost",
-            "port": 6333,
+            "url": "neo4j+s://xxx",
+            "username": "neo4j",
+            "password": "xxx"
         }
     },
+    "version": "v1.1"
 }
 
-m = Memory.from_config(config)
+m = Memory.from_config(config_dict=config)
+
 ```
 
-## 🗺️ Roadmap
+## Documentation
 
-- Integration with various LLM providers
-- Support for LLM frameworks
-- Integration with AI Agents frameworks
-- Customizable memory creation/update rules
-- Hosted platform support
+For detailed usage instructions and API reference, visit our documentation at [docs.mem0.ai](https://docs.mem0.ai). Here, you can find more information on both the open-source version and the hosted [Mem0 Platform](https://app.mem0.ai).
 
-## 🙋‍♂️ 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:
+## Star History
 
-- [Join our Discord](https://embedchain.ai/discord)
-- [Join our Slack](https://embedchain.ai/slack)
-- [Follow us on Twitter](https://twitter.com/mem0ai)
-- [Email us](mailto:founders@mem0.ai)
+[![Star History Chart](https://api.star-history.com/svg?repos=mem0ai/mem0&type=Date)](https://star-history.com/#mem0ai/mem0&Date)
+
+## 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 founders](mailto:founders@mem0.ai)
+
+## Contributors
+
+Join our [Discord community](https://mem0.dev/DiG) to learn about memory management for AI agents and LLMs, and connect with Mem0 users and contributors. Share your ideas, questions, or feedback in our [GitHub Issues](https://github.com/mem0ai/mem0/issues).
+
+We value and appreciate the contributions of our community. Special thanks to our contributors for helping us improve Mem0.
+
+<a href="https://github.com/mem0ai/mem0/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=mem0ai/mem0" />
+</a>
+
+## License
+
+This project is licensed under the Apache 2.0 License - see the [LICENSE](LICENSE) file for details.

cookbooks/add_memory_using_qdrant_cloud.py

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

cookbooks/multion_travel_agent.ipynb

@@ -0,0 +1,296 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "fu3euPKZsbaC"
+   },
+   "outputs": [],
+   "source": [
+    "!pip install mem0ai"
+   ]
+  },
+  {
+   "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",
+    "    {\"role\": \"user\", \"content\": \"What are the best travel destinations in the world?\"},\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",
+    "    {\"role\": \"user\", \"content\": \"Sure, I want to travel to San Francisco.\"},\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",
+    "    {\"role\": \"user\", \"content\": \"Show me hotels around Golden Gate Bridge.\"},\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)"
+   ]
+  },
+  {
+   "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",
+    "    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": {
+  "colab": {
+   "provenance": []
+  },
+  "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"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}

docs/_snippets/get-help.mdx

@@ -1,11 +1,11 @@
 <CardGroup cols={3}>
-  <Card title="Talk to founders" icon="calendar" href="https://cal.com/taranjeetio/meet">
+  <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/discussions/new?category=q-a">
+    Ask questions on GitHub
+  </Card>
+  <Card title="Support" icon="calendar" href="https://cal.com/taranjeetio/meet">
   Talk to founders
   </Card>
-  <Card title="Slack" icon="slack" href="https://embedchain.ai/slack" color="#4A154B">
-    Join our slack community
-  </Card>
-  <Card title="Discord" icon="discord" href="https://discord.gg/6PzXDgEjG5" color="#7289DA">
-    Join our discord community
-  </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/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-memories.mdx

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

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-search-memories.mdx

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

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

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

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

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

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,4 @@
+---
+title: 'Update Member'
+openapi: put /api/v1/orgs/organizations/{org_id}/members/
+---

docs/api-reference/overview.mdx

@@ -0,0 +1,60 @@
+# Mem0 API Overview
+
+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)
+
+For users who belong to multiple organizations or are working on multiple projects, you can specify the organization and project for an API request. This is done by initializing the Mem0 client with the appropriate parameters. Usage from these API requests will be attributed to the specified organization and project.
+
+Example with the mem0 Python package:
+
+```python
+from mem0 import MemoryClient
+
+client = MemoryClient(
+  organization='YOUR_ORG_NAME',
+  project='YOUR_PROJECT_NAME',
+)
+```
+
+Example with the mem0 Node.js package:
+
+```javascript
+import { MemoryClient } from "mem0ai";
+
+const client = new MemoryClient({
+    organization: "YOUR_ORG_NAME",
+    project: "YOUR_PROJECT_NAME"
+});
+```
+
+## 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,4 @@
+---
+title: 'Add Member'
+openapi: post /api/v1/orgs/organizations/{org_id}/projects/{project_id}/members/
+---

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,4 @@
+---
+title: 'Update Member'
+openapi: put /api/v1/orgs/organizations/{org_id}/projects/{project_id}/members/
+---

docs/components/embedders/config.mdx

@@ -0,0 +1,61 @@
+## What is Config?
+
+Config in mem0 is a dictionary that specifies the settings for your embedding models. It allows you to customize the behavior and connection details of your chosen embedder.
+
+## How to Define Config
+
+The config is defined as a Python dictionary with two main keys:
+- `embedder`: Specifies the embedder provider and its configuration
+  - `provider`: The name of the embedder (e.g., "openai", "ollama")
+  - `config`: A nested dictionary containing provider-specific settings
+
+## How to Use Config
+
+Here's a general example of how to use the config with mem0:
+
+```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"})
+```
+
+## 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:
+
+| Parameter | Description |
+|-----------|-------------|
+| `model` | Embedding model to use |
+| `api_key` | API key of the provider |
+| `embedding_dims` | Dimensions of the embedding model |
+| `http_client_proxies` | Allow proxy server settings |
+| `ollama_base_url` | Base URL for the Ollama embedding model |
+| `model_kwargs` | Key-Value arguments for the Huggingface embedding model |
+| `azure_kwargs` | Key-Value arguments for the AzureOpenAI embedding model |
+| `openai_base_url`    | Base URL for OpenAI API                       | OpenAI            |
+| `vertex_credentials_json` | Path to the Google Cloud credentials JSON file for VertexAI |
+
+
+## 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,46 @@
+---
+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"
+
+
+config = {
+    "embedder": {
+        "provider": "azure_openai",
+        "config": {
+            "model": "text-embedding-3-large"
+            "azure_kwargs" : {
+                  "api_version" : "",
+                  "azure_deployment" : "",
+                  "azure_endpoint" : "",
+                  "api_key": ""
+              }
+        }
+    }
+}
+
+m = Memory.from_config(config)
+m.add("I'm visiting Paris", 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,41 @@
+---
+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"
+
+config = {
+    "embedder": {
+        "provider": "gemini",
+        "config": {
+            "model": "models/text-embedding-004"
+        }
+    },
+    "vector_store": {
+        "provider": "qdrant",
+        "config": {
+            "collection_name": "test",
+            "embedding_model_dims": 768,
+        }
+    },
+}
+
+m = Memory.from_config(config)
+m.add("I'm visiting Paris", 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` |

docs/components/embedders/models/huggingface.mdx

@@ -0,0 +1,36 @@
+---
+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"
+
+config = {
+    "embedder": {
+        "provider": "huggingface",
+        "config": {
+            "model": "multi-qa-MiniLM-L6-cos-v1"
+        }
+    }
+}
+
+m = Memory.from_config(config)
+m.add("I'm visiting Paris", 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,32 @@
+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"
+
+config = {
+    "embedder": {
+        "provider": "ollama",
+        "config": {
+            "model": "mxbai-embed-large"
+        }
+    }
+}
+
+m = Memory.from_config(config)
+m.add("I'm visiting Paris", 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,36 @@
+---
+title: OpenAI
+---
+
+To use OpenAI embedding models, set the `OPENAI_API_KEY` environment variable. You can obtain the OpenAI API key from the [OpenAI Platform](https://platform.openai.com/account/api-keys).
+
+### Usage
+
+```python
+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)
+m.add("I'm visiting Paris", user_id="john")
+```
+
+### Config
+
+Here are the parameters available for configuring 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` |
+| `api_key` | The OpenAI API key | `None` |

docs/components/embedders/models/vertexai.mdx

@@ -0,0 +1,35 @@
+### 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"
+
+config = {
+    "embedder": {
+        "provider": "vertexai",
+        "config": {
+            "model": "text-embedding-004"
+        }
+    }
+}
+
+m = Memory.from_config(config)
+m.add("I'm visiting Paris", user_id="john")
+```
+
+### 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`                |

docs/components/embedders/overview.mdx

@@ -0,0 +1,24 @@
+---
+title: Overview
+---
+
+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.
+
+<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>
+</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/config.mdx

@@ -0,0 +1,79 @@
+## What is Config?
+
+Config in mem0 is a dictionary that specifies the settings for your llms. It allows you to customize the behavior and connection details of your chosen llm.
+
+## How to Define Config
+
+The config is defined as a Python dictionary with two main keys:
+- `llm`: Specifies the llm provider and its configuration
+  - `provider`: The name of the llm (e.g., "openai", "groq")
+  - `config`: A nested dictionary containing provider-specific settings
+
+### Config Values Precedence
+
+Config values are applied in the following order of precedence (from highest to lowest):
+
+1. Values explicitly set in the `config` dictionary
+2. Environment variables (e.g., `OPENAI_API_KEY`, `OPENAI_API_BASE`)
+3. Default values defined in the LLM implementation
+
+This means that values specified in the `config` dictionary will override corresponding environment variables, which in turn override default values.
+
+## How to Use Config
+
+Here's a general example of how to use the config with mem0:
+
+```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"})
+```
+
+## 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:
+
+Here's the table based on the provided parameters:
+
+| Parameter            | Description                                   | Provider          |
+|----------------------|-----------------------------------------------|-------------------|
+| `model`              | Embedding model to use                        | All               |
+| `temperature`        | Temperature of the model                      | All               |
+| `api_key`            | API key to use                                | All               |
+| `max_tokens`         | Tokens to generate                            | All               |
+| `top_p`              | Probability threshold for nucleus sampling    | All               |
+| `top_k`              | Number of highest probability tokens to keep  | All               |
+| `http_client_proxies`| Allow proxy server settings                   | AzureOpenAI       |
+| `models`             | List of models                                | Openrouter        |
+| `route`              | Routing strategy                              | Openrouter        |
+| `openrouter_base_url`| Base URL for Openrouter API                   | Openrouter        |
+| `site_url`           | Site URL                                      | Openrouter        |
+| `app_name`           | Application name                              | Openrouter        |
+| `ollama_base_url`    | Base URL for Ollama API                       | Ollama            |
+| `openai_base_url`    | Base URL for OpenAI API                       | OpenAI            |
+| `azure_kwargs`       | Azure LLM args for initialization             | AzureOpenAI       |
+
+
+## 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,29 @@
+To use anthropic's models, please set the `ANTHROPIC_API_KEY` which you find on their [Account Settings Page](https://console.anthropic.com/account/keys).
+
+## Usage
+
+```python
+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-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"})
+```
+
+## 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,38 @@
+---
+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": 1500,
+        }
+    }
+}
+
+m = Memory.from_config(config)
+m.add("Likes to play cricket on weekends", user_id="alice", metadata={"category": "hobbies"})
+```
+
+### 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,70 @@
+---
+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" : ""
+              }
+        }
+    }
+}
+
+m = Memory.from_config(config)
+m.add("Likes to play cricket on weekends", user_id="alice", metadata={"category": "hobbies"})
+```
+
+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" : ""
+              }
+        }
+    }
+}
+```
+
+## Config
+
+All available parameters for the `azure_openai` config are present in [Master List of All Params in Config](../config).

docs/components/llms/models/google_AI.mdx

@@ -0,0 +1,33 @@
+---
+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": 1500,
+        }
+    }
+}
+
+m = Memory.from_config(config)
+m.add("Likes to play cricket on weekends", user_id="alice", metadata={"category": "hobbies"})
+```
+
+## 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,31 @@
+[Groq](https://groq.com/) is the creator of the world's first Language Processing Unit (LPU), providing exceptional speed performance for AI workloads running on their LPU Inference Engine.
+
+In order to use LLMs from Groq, go to their [platform](https://console.groq.com/keys) and get the API key. Set the API key as `GROQ_API_KEY` environment variable to use the model as given below in the example.
+
+## Usage
+
+```python
+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"})
+```
+
+## 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,28 @@
+[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": 1500,
+        }
+    }
+}
+
+m = Memory.from_config(config)
+m.add("Likes to play cricket on weekends", user_id="alice", metadata={"category": "hobbies"})
+```
+
+## 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,33 @@
+---
+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)
+m.add("Likes to play cricket on weekends", user_id="alice", metadata={"category": "hobbies"})
+```
+
+## 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,28 @@
+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)
+m.add("Likes to play cricket on weekends", user_id="alice", metadata={"category": "hobbies"})
+```
+
+## 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,66 @@
+---
+title: OpenAI
+---
+
+To use OpenAI LLM models, you have to set the `OPENAI_API_KEY` environment variable. You can obtain the OpenAI API key from the [OpenAI Platform](https://platform.openai.com/account/api-keys).
+
+## Usage
+
+```python
+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,
+        }
+    }
+}
+
+# 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)
+m.add("Likes to play cricket on weekends", user_id="alice", metadata={"category": "hobbies"})
+```
+
+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)
+```
+
+
+
+## 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,29 @@
+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": 1500,
+        }
+    }
+}
+
+m = Memory.from_config(config)
+m.add("Likes to play cricket on weekends", user_id="alice", metadata={"category": "hobbies"})
+```
+
+## Config
+
+All available parameters for the `togetherai` config are present in [Master List of All Params in Config](../config).

docs/components/llms/overview.mdx

@@ -0,0 +1,50 @@
+---
+title: 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.
+
+## 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).
+
+<CardGroup cols={4}>
+  <Card title="OpenAI" href="/components/llms/models/openai"></Card>
+    <Card title="Ollama" href="/components/llms/models/ollama"></Card>
+    <Card title="Azure OpenAI" href="/components/llms/models/azure_openai"></Card>
+    <Card title="Anthropic" href="/components/llms/models/anthropic"></Card>
+    <Card title="Together" href="/components/llms/models/together"></Card>
+    <Card title="Groq" href="/components/llms/models/groq"></Card>
+    <Card title="Litellm" href="/components/llms/models/litellm"></Card>
+    <Card title="Mistral AI" href="/components/llms/models/mistral_ai"></Card>
+    <Card title="Google AI" href="/components/llms/models/google_ai"></Card>
+    <Card title="AWS bedrock" href="/components/llms/models/aws_bedrock"></Card>
+</CardGroup>
+
+## Structured vs Unstructured Outputs
+
+Mem0 supports two types of OpenAI LLM formats, each with its own strengths and use cases:
+
+### Structured Outputs
+
+Structured outputs are LLMs that align with OpenAI's structured outputs model:
+
+- **Optimized for:** Returning structured responses (e.g., JSON objects)
+- **Benefits:** Precise, easily parseable data
+- **Ideal for:** Data extraction, form filling, API responses
+- **Learn more:** [OpenAI Structured Outputs Guide](https://platform.openai.com/docs/guides/structured-outputs/introduction)
+
+### Unstructured Outputs
+
+Unstructured outputs correspond to OpenAI's standard, free-form text model:
+
+- **Flexibility:** Returns open-ended, natural language responses
+- **Customization:** Use the `response_format` parameter to guide output
+- **Trade-off:** Less efficient than structured outputs for specific data needs
+- **Best for:** Creative writing, explanations, general conversation
+
+Choose the format that best suits your application's requirements for optimal performance and usability.

docs/components/vectordbs/config.mdx

@@ -0,0 +1,72 @@
+## What is Config?
+
+Config in mem0 is a dictionary that specifies the settings for your vector database. It allows you to customize the behavior and connection details of your chosen vector store.
+
+## How to Define Config
+
+The config is defined as a Python dictionary 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")
+  - `config`: A nested dictionary containing provider-specific settings
+
+## How to Use Config
+
+Here's a general example of how to use the config with mem0:
+
+```python
+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"})
+```
+
+## 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:
+
+| 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 |
+
+## 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/chroma.mdx

@@ -0,0 +1,35 @@
+[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)
+m.add("Likes to play cricket on weekends", user_id="alice", metadata={"category": "hobbies"})
+```
+
+### 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/milvus.mdx

@@ -0,0 +1,35 @@
+[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)
+m.add("Likes to play cricket on weekends", user_id="alice", metadata={"category": "hobbies"})
+```
+
+### 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/pgvector.mdx

@@ -0,0 +1,40 @@
+[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)
+m.add("Likes to play cricket on weekends", user_id="alice", metadata={"category": "hobbies"})
+```
+
+### Config
+
+Here's the parameters available for configuring pgvector:
+
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `dbname` | The name of the database | `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` |

docs/components/vectordbs/dbs/qdrant.mdx

@@ -0,0 +1,40 @@
+[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
+
+```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)
+m.add("Likes to play cricket on weekends", user_id="alice", metadata={"category": "hobbies"})
+```
+
+### Config
+
+Let's see the available parameters for the `qdrant` config:
+
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `collection_name` | The name of the collection to store the vectors | `mem0` |
+| `embedding_model_dims` | Dimensions of the embedding model | `1536` |
+| `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` |

docs/components/vectordbs/overview.mdx

@@ -0,0 +1,33 @@
+---
+title: 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.
+
+## Supported Vector Databases
+
+See the list of supported vector databases below.
+
+<CardGroup cols={3}>
+  <Card title="Qdrant" href="/components/vectordbs/dbs/qdrant"></Card>
+  <Card title="Chroma" href="/components/vectordbs/dbs/chroma"></Card>
+  <Card title="Pgvector" href="/components/vectordbs/dbs/pgvector"></Card>
+</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/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/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": 8000,
+            "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,19 @@ 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="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>

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
 

docs/features.mdx

@@ -0,0 +1,59 @@
+---
+title: Features
+---
+
+## Core features
+
+- **User, Session, and AI Agent Memory**: Retains information across sessions and interactions for users and AI agents, ensuring continuity and context.
+- **Adaptive Personalization**: Continuously updates memories based on user interactions and feedback.
+- **Developer-Friendly API**: Offers a straightforward API for seamless integration into various applications.
+- **Platform Consistency**: Ensures consistent behavior and data across different platforms and devices.
+- **Managed Service**: Provides a hosted solution for easy deployment and maintenance.
+- **Save Costs**: Saves costs by adding relevent memories instead of complete transcripts to context window
+
+
+
+## How does Mem0 work?
+
+Mem0 leverages a hybrid database approach to manage and retrieve long-term memories for AI agents and assistants. Each memory is associated with a unique identifier, such as a user ID or agent ID, allowing Mem0 to organize and access memories specific to an individual or context.
+
+When a message is added to the Mem0 using add()  method, the system extracts relevant facts and preferences and stores it across data stores: a vector database, a key-value database, and a graph database. This hybrid approach ensures that different types of information are stored in the most efficient manner, making subsequent searches quick and effective.
+
+When an AI agent or LLM needs to recall memories, it uses the search() method. Mem0 then performs search across these data stores, retrieving relevant information from each source. This information is then passed through a scoring layer, which evaluates their importance based on relevance, importance, and recency. This ensures that only the most personalized and useful context is surfaced.
+
+The retrieved memories can then be appended to the LLM's prompt as needed, making responses personalized and relevant.
+
+
+## Common Use Cases
+
+- **Personalized Learning Assistants**: Long-term memory allows learning assistants to remember user preferences, strengths and weaknesses, and progress, providing a more tailored and effective learning experience.
+
+- **Customer Support AI Agents**: By retaining information from previous interactions, customer support bots can offer more accurate and context-aware assistance, improving customer satisfaction and reducing resolution times.
+
+- **Healthcare Assistants**: Long-term memory enables healthcare assistants to keep track of patient history, medication schedules, and treatment plans, ensuring personalized and consistent care.
+
+- **Virtual Companions**: Virtual companions can use long-term memory to build deeper relationships with users by remembering personal details, preferences, and past conversations, making interactions more delightful.
+
+- **Productivity Tools**: Long-term memory helps productivity tools remember user habits, frequently used documents, and task history, streamlining workflows and enhancing efficiency.
+
+- **Gaming AI**: In gaming, AI with long-term memory can create more immersive experiences by remembering player choices, strategies, and progress, adapting the game environment accordingly.
+
+## How is Mem0 different from RAG?
+
+Mem0's memory implementation for Large Language Models (LLMs) offers several advantages over Retrieval-Augmented Generation (RAG):
+
+- **Entity Relationships**: Mem0 can understand and relate entities across different interactions, unlike RAG which retrieves information from static documents. This leads to a deeper understanding of context and relationships.
+
+- **Recency, Relevancy, and Decay**: Mem0 uses custom search algorithms to prioritize recent interactions and gradually forgets outdated information, ensuring the memory remains relevant and up-to-date for more accurate responses.
+
+- **Contextual Continuity**: Mem0 retains information across sessions, maintaining continuity in conversations and interactions, which is essential for long-term engagement applications like virtual companions or personalized learning assistants.
+
+- **Adaptive Learning**: Mem0 improves its personalization based on user interactions and feedback, making the memory more accurate and tailored to individual users over time.
+
+- **Dynamic Updates**: Mem0 can dynamically update its memory with new information and interactions, unlike RAG which relies on static data. This allows for real-time adjustments and improvements, enhancing the user experience.
+
+These advanced memory capabilities make Mem0 a powerful tool for developers aiming to create personalized and context-aware AI applications.
+
+If you have any questions, please feel free to reach out to us using one of the following methods:
+
+<Snippet file="get-help.mdx" />

docs/features/custom-categories.mdx

@@ -0,0 +1,71 @@
+---
+title: Custom Categories
+description: 'Enhance your product experience by adding custom categories tailored to your needs'
+---
+
+## How to set custom categories?
+
+Users can now create custom categories tailored to their specific needs, in addition to the default categories such as travel, sports, music, and more.
+To setup the custom categories, user has to specify the category name and a description of what that category signifies.
+Here’s how you can do it:
+
+```python
+from mem0 import MemoryClient
+
+m = MemoryClient(api_key="xxx")
+
+custom_categories = [
+    {"cooking": "For users interested in cooking, including recipes, cooking tips, and culinary experiences."},
+    {"fitness": "Includes content related to fitness, such as workouts, exercises, and fitness tips."}
+]
+
+messages = [
+    {"role" : "user", "content" : "Hi, my name is Alice. I love to play badminton."},
+    {"role" : "assistant", "content" : "Hello Alice! It's nice to meet you. Badminton is such an amazing sport. How can I assist you today?"},
+    {"role" : "user", "content" : "I am a fitness freak, I go to gym daily."},
+    {"role" : "assistant", "content" : "That's great! Regular exercise is very beneficial for health."},
+    {"role" : "user", "content" : "Because of my gym plan, I mostly cook at home."},
+    {"role" : "assistant", "content" : "Cooking at home is a good way to ensure you have a balanced diet."}
+]
+```
+
+<CodeGroup>
+```python Code
+client.add(messages, user_id="alice", custom_categories=custom_categories)
+```
+
+```markdown Memories with categories
+User's name is Alice (personal_details)
+Loves playing badminton (sports)
+User is a fitness freak. (fitness)
+Likes to go to gym daily. (fitness)
+Mostly cook at home because of gym plan. (fitness, cooking)
+```
+</CodeGroup>
+
+> Note: The more detailed the description of categories is, the better output the user will receive.
+
+## Default Categories
+Here is the list of **default categories**. Ensure you review these before creating custom categories to prevent duplication.
+
+```
+- personal_details
+- family
+- professional_details
+- sports
+- travel 
+- food
+- music
+- health
+- technology
+- hobbies
+- fashion
+- entertainment
+- milestones
+- user_preferences
+- misc
+```
+
+If you have any questions, please feel free to reach out to us using one of the following methods:
+
+<Snippet file="get-help.mdx" />

docs/features/custom-prompts.mdx

@@ -0,0 +1,109 @@
+---
+title: Custom Prompts
+description: 'Enhance your product experience by adding custom prompts tailored to your needs'
+---
+
+## Introduction to Custom Prompts
+
+Custom prompts allow you to tailor the behavior of your Mem0 instance to specific use cases or domains. 
+By defining a custom prompt, you can control how information is extracted, processed, and stored in your memory system.
+
+To create an effective custom prompt:
+1. Be specific about the information to extract.
+2. Provide few-shot examples to guide the LLM.
+3. Ensure examples follow the format shown below.
+
+Example of a custom prompt:
+
+```python
+custom_prompt = """
+Please only extract entities containing customer support information, order details, and user information. 
+Here are some few shot examples:
+
+Input: Hi.
+Output: {{"facts" : []}}
+
+Input: The weather is nice today.
+Output: {{"facts" : []}}
+
+Input: My order #12345 hasn't arrived yet.
+Output: {{"facts" : ["Order #12345 not received"]}}
+
+Input: I'm John Doe, and I'd like to return the shoes I bought last week.
+Output: {{"facts" : ["Customer name: John Doe", "Wants to return shoes", "Purchase made last week"]}}
+
+Input: I ordered a red shirt, size medium, but received a blue one instead.
+Output: {{"facts" : ["Ordered red shirt, size medium", "Received blue shirt instead"]}}
+
+Return the facts and customer information in a json format as shown above.
+"""
+
+```
+
+Here we initialize the custom prompt in the config.
+
+```python
+from mem0 import Memory
+
+config = {
+    "llm": {
+        "provider": "openai",
+        "config": {
+            "model": "gpt-4o",
+            "temperature": 0.2,
+            "max_tokens": 1500,
+        }
+    },
+    "custom_prompt": custom_prompt,
+    "version": "v1.1"
+}
+
+m = Memory.from_config(config_dict=config, user_id="alice")
+```
+
+### Example 1
+
+In this example, we are adding a memory of a user ordering a laptop. As seen in the output, the custom prompt is used to extract the relevant information from the user's message.
+
+<CodeGroup>
+```python Code
+m.add("Yesterday, I ordered a laptop, the order id is 12345", user_id="alice")
+```
+
+```json Output
+{
+  "results": [
+    {
+      "memory": "Ordered a laptop",
+      "event": "ADD"
+    },
+    {
+      "memory": "Order ID: 12345",
+      "event": "ADD"
+    },
+    {
+      "memory": "Order placed yesterday",
+      "event": "ADD"
+    }
+  ],
+  "relations": []
+}
+```
+</CodeGroup>
+
+### Example 2
+
+In this example, we are adding a memory of a user liking to go on hikes. This add message is not specific to the use-case mentioned in the custom prompt. 
+Hence, the memory is not added.
+<CodeGroup>
+```python Code
+m.add("I like going to hikes", user_id="alice")
+```
+
+```json Output
+{
+  "results": [],
+  "relations": []
+}
+```
+</CodeGroup>

docs/features/openai_compatibility.mdx

@@ -0,0 +1,93 @@
+---
+title: OpenAI Compatibility
+---
+
+Mem0 can be easily integrate into chat applications to enhance conversational agents with structured memory. Mem0's APIs are designed to be compatible with OpenAI's, with the goal of making it easy to leverage Mem0 in applications you may have already built.
+
+If you have a `Mem0 API key`, you can use it to initialize the client. Alternatively, you can initialize Mem0 without an API key if you're using it locally.
+
+Mem0 supports several language models (LLMs) through integration with various [providers](https://litellm.vercel.app/docs/providers).
+
+## Use Mem0 Platform
+
+```python
+from mem0.proxy.main import Mem0
+
+client = Mem0(api_key="m0-xxx")
+
+# First interaction: Storing user preferences
+messages = [
+    {
+        "role": "user",
+        "content": "I love indian food but I cannot eat pizza since allergic to cheese."
+    },
+]
+user_id = "alice"
+chat_completion = client.chat.completions.create(
+    messages=messages,
+    model="gpt-4o-mini",
+    user_id=user_id
+)
+# Memory saved after this will look like: "Loves Indian food. Allergic to cheese and cannot eat pizza."
+
+# Second interaction: Leveraging stored memory
+messages = [
+    {
+        "role": "user",
+        "content": "Suggest restaurants in San Francisco to eat.",
+    }
+]
+
+chat_completion = client.chat.completions.create(
+    messages=messages,
+    model="gpt-4o-mini",
+    user_id=user_id
+)
+print(chat_completion.choices[0].message.content)
+# Answer: You might enjoy Indian restaurants in San Francisco, such as Amber India, Dosa, or Curry Up Now, which offer delicious options without cheese.
+```
+
+In this example, you can see how the second response is tailored based on the information provided in the first interaction. Mem0 remembers the user's preference for Indian food and their cheese allergy, using this information to provide more relevant and personalized restaurant suggestions in San Francisco.
+
+### Use Mem0 OSS
+
+```python
+config = {
+    "vector_store": {
+        "provider": "qdrant",
+        "config": {
+            "host": "localhost",
+            "port": 6333,
+        }
+    },
+}
+
+client = Mem0(config=config)
+
+chat_completion = client.chat.completions.create(
+    messages=[
+        {
+            "role": "user",
+            "content": "What's the capital of France?",
+        }
+    ],
+    model="gpt-4o",
+)
+```
+
+## Mem0 Params for Chat Completion
+
+- `user_id` (Optional[str]): Identifier for the user.
+
+- `agent_id` (Optional[str]): Identifier for the agent.
+
+- `run_id` (Optional[str]): Identifier for the run.
+
+- `metadata` (Optional[dict]): Additional metadata to be stored with the memory.
+
+- `filters` (Optional[dict]): Filters to apply when searching for relevant memories.
+
+- `limit` (Optional[int]): Maximum number of relevant memories to retrieve. Default is 10.
+
+
+Other parameters are similar to OpenAI's API, making it easy to integrate Mem0 into your existing applications.

docs/features/selective-memory.mdx

@@ -0,0 +1,106 @@
+---
+title: Memory Customization
+description: 'Mem0 supports customizing the memories you store, allowing you to focus on pertinent information while omitting irrelevant data.'
+---
+
+## Benefits of Memory Customization
+
+Memory customization offers several key benefits:
+
+• **Focused Storage**: Store only relevant information for a streamlined system.
+
+• **Improved Accuracy**: Curate memories for more accurate and relevant retrieval.
+
+• **Enhanced Privacy**: Exclude sensitive information for better privacy control.
+
+• **Resource Efficiency**: Optimize storage and processing by keeping only pertinent data.
+
+• **Personalization**: Tailor the experience to individual user preferences.
+
+• **Contextual Relevance**: Improve effectiveness in specialized domains or applications.
+
+These benefits allow users to fine-tune their memory systems, creating a more powerful and personalized AI assistant experience.
+
+
+## Memory Inclusion
+Users can define specific kinds of memories to store. This feature enhances memory management by focusing on relevant information, resulting in a more efficient and personalized experience.
+Here’s how you can do it:
+
+```python
+from mem0 import MemoryClient
+
+m = MemoryClient(api_key="xxx")
+
+# Define what to include
+includes = "sports related things"
+
+messages = [
+    {"role": "user", "content": "Hi, my name is Alice and I love to play badminton"},
+    {"role": "assistant", "content": "Nice to meet you, Alice! Badminton is a great sport."},
+    {"role": "user", "content": "I love music festivals"},
+    {"role": "assistant", "content": "Music festivals are exciting! Do you have a favorite one?"},
+    {"role": "user", "content": "I love eating spicy food"},
+    {"role": "assistant", "content": "Spicy food is delicious! What's your favorite spicy dish?"},
+    {"role": "user", "content": "I love playing baseball with my friends"},
+    {"role": "assistant", "content": "Baseball with friends sounds fun!"},
+]
+```
+
+<CodeGroup>
+```python Code
+client.add(messages, user_id="alice", includes=includes)
+```
+
+```json Stored Memories
+User's name is Alice.
+Alice loves to play badminton.
+User loves playing baseball with friends.
+```
+</CodeGroup>
+
+
+
+
+## Memory Exclusion
+
+In addition to specifying what to include, users can also define exclusion rules for their memory management. This feature allows for fine-tuning the memory system by instructing it to omit certain types of information.
+Here’s how you can do it:
+
+```python
+from mem0 import MemoryClient
+
+m = MemoryClient(api_key="xxx")
+
+# Define what to exclude
+excludes = "food preferences"
+
+messages = [
+    {"role": "user", "content": "Hi, my name is Alice and I love to play badminton"},
+    {"role": "assistant", "content": "Nice to meet you, Alice! Badminton is a great sport."},
+    {"role": "user", "content": "I love music festivals"},
+    {"role": "assistant", "content": "Music festivals are exciting! Do you have a favorite one?"},
+    {"role": "user", "content": "I love eating spicy food"},
+    {"role": "assistant", "content": "Spicy food is delicious! What's your favorite spicy dish?"},
+    {"role": "user", "content": "I love playing baseball with my friends"},
+    {"role": "assistant", "content": "Baseball with friends sounds fun!"},
+]
+```
+
+<CodeGroup>
+```python Code
+client.add(messages, user_id="alice", includes=includes)
+```
+
+```json Stored Memories
+User's name is Alice.
+Alice loves to play badminton.
+Loves music festivals.
+User loves playing baseball with friends.
+```
+</CodeGroup>
+
+
+
+If you have any questions, please feel free to reach out to us using one of the following methods:
+
+<Snippet file="get-help.mdx" />

docs/integrations/autogen.mdx

@@ -0,0 +1,130 @@
+Build conversational AI agents with memory capabilities. This integration combines AutoGen for creating AI agents with Mem0 for memory management, enabling context-aware and personalized interactions.
+
+## Overview
+
+In this guide, we'll explore an example of creating a conversational AI system with memory:
+- A customer service bot that can recall previous interactions and provide personalized responses.
+
+## Setup and Configuration
+
+Install necessary libraries:
+
+```bash
+pip install pyautogen mem0ai openai
+```
+
+First, we'll import the necessary libraries and set up our configurations.
+
+<Note>Remember to get the Mem0 API key from [Mem0 Platform](https://app.mem0.ai).</Note>
+
+```python
+import os
+from autogen import ConversableAgent
+from mem0 import MemoryClient
+from openai import OpenAI
+
+# Configuration
+OPENAI_API_KEY = 'sk-xxx'  # Replace with your actual OpenAI API key
+MEM0_API_KEY = 'your-mem0-key'  # Replace with your actual Mem0 API key from https://app.mem0.ai
+USER_ID = "customer_service_bot"
+
+# Set up OpenAI API key
+os.environ['OPENAI_API_KEY'] = OPENAI_API_KEY
+
+# Initialize Mem0 and AutoGen agents
+memory_client = MemoryClient(api_key=MEM0_API_KEY)
+agent = ConversableAgent(
+    "chatbot",
+    llm_config={"config_list": [{"model": "gpt-4", "api_key": OPENAI_API_KEY}]},
+    code_execution_config=False,
+    human_input_mode="NEVER",
+)
+```
+
+## Storing Conversations in Memory
+
+Add conversation history to Mem0 for future reference:
+
+```python
+conversation = [
+    {"role": "assistant", "content": "Hi, I'm Best Buy's chatbot! How can I help you?"},
+    {"role": "user", "content": "I'm seeing horizontal lines on my TV."},
+    {"role": "assistant", "content": "I'm sorry to hear that. Can you provide your TV model?"},
+    {"role": "user", "content": "It's a Sony - 77\" Class BRAVIA XR A80K OLED 4K UHD Smart Google TV"},
+    {"role": "assistant", "content": "Thank you for the information. Let's troubleshoot this issue..."}
+]
+
+memory_client.add(messages=conversation, user_id=USER_ID)
+print("Conversation added to memory.")
+```
+
+## Retrieving and Using Memory
+
+Create a function to get context-aware responses based on user's question and previous interactions:
+
+```python
+def get_context_aware_response(question):
+    relevant_memories = memory_client.search(question, user_id=USER_ID)
+    context = "\n".join([m["memory"] for m in relevant_memories])
+
+    prompt = f"""Answer the user question considering the previous interactions:
+    Previous interactions:
+    {context}
+
+    Question: {question}
+    """
+
+    reply = agent.generate_reply(messages=[{"content": prompt, "role": "user"}])
+    return reply
+
+# Example usage
+question = "What was the issue with my TV?"
+answer = get_context_aware_response(question)
+print("Context-aware answer:", answer)
+```
+
+## Multi-Agent Conversation
+
+For more complex scenarios, you can create multiple agents:
+
+```python
+manager = ConversableAgent(
+    "manager",
+    system_message="You are a manager who helps in resolving complex customer issues.",
+    llm_config={"config_list": [{"model": "gpt-4", "api_key": OPENAI_API_KEY}]},
+    human_input_mode="NEVER"
+)
+
+def escalate_to_manager(question):
+    relevant_memories = memory_client.search(question, user_id=USER_ID)
+    context = "\n".join([m["memory"] for m in relevant_memories])
+
+    prompt = f"""
+    Context from previous interactions:
+    {context}
+
+    Customer question: {question}
+
+    As a manager, how would you address this issue?
+    """
+
+    manager_response = manager.generate_reply(messages=[{"content": prompt, "role": "user"}])
+    return manager_response
+
+# Example usage
+complex_question = "I'm not satisfied with the troubleshooting steps. What else can be done?"
+manager_answer = escalate_to_manager(complex_question)
+print("Manager's response:", manager_answer)
+```
+
+## Conclusion
+
+By integrating AutoGen with Mem0, you've created a conversational AI system with memory capabilities. This example demonstrates a customer service bot that can recall previous interactions and provide context-aware responses, with the ability to escalate complex issues to a manager agent.
+
+This integration enables the creation of more intelligent and personalized AI agents for various applications, such as customer support, virtual assistants, and interactive chatbots.
+
+## Help
+
+In case of any questions, please feel free to reach out to us using one of the following methods:
+
+<Snippet file="get-help.mdx" />

docs/integrations/langgraph.mdx

@@ -0,0 +1,144 @@
+---
+title: LangGraph
+---
+
+Build a personalized Customer Support AI Agent using LangGraph for conversation flow and Mem0 for memory retention. This integration enables context-aware and efficient support experiences.
+
+## Overview
+
+In this guide, we'll create a Customer Support AI Agent that:
+1. Uses LangGraph to manage conversation flow
+2. Leverages Mem0 to store and retrieve relevant information from past interactions
+3. Provides personalized responses based on user history
+
+## Setup and Configuration
+
+Install necessary libraries:
+
+```bash
+pip install langgraph langchain-openai mem0ai
+```
+
+
+Import required modules and set up configurations:
+
+<Note>Remember to get the Mem0 API key from [Mem0 Platform](https://app.mem0.ai).</Note>
+
+```python
+from typing import Annotated, TypedDict, List
+from langgraph.graph import StateGraph, START
+from langgraph.graph.message import add_messages
+from langchain_openai import ChatOpenAI
+from mem0 import MemoryClient
+from langchain_core.messages import SystemMessage, HumanMessage, AIMessage
+
+# Configuration
+OPENAI_API_KEY = 'sk-xxx'  # Replace with your actual OpenAI API key
+MEM0_API_KEY = 'your-mem0-key'  # Replace with your actual Mem0 API key
+
+# Initialize LangChain and Mem0
+llm = ChatOpenAI(model="gpt-4", api_key=OPENAI_API_KEY)
+mem0 = MemoryClient(api_key=MEM0_API_KEY)
+```
+
+## Define State and Graph
+
+Set up the conversation state and LangGraph structure:
+
+```python
+class State(TypedDict):
+    messages: Annotated[List[HumanMessage | AIMessage], add_messages]
+    mem0_user_id: str
+
+graph = StateGraph(State)
+```
+
+## Create Chatbot Function
+
+Define the core logic for the Customer Support AI Agent:
+
+```python
+def chatbot(state: State):
+    messages = state["messages"]
+    user_id = state["mem0_user_id"]
+
+    # Retrieve relevant memories
+    memories = mem0.search(messages[-1].content, user_id=user_id)
+
+    context = "Relevant information from previous conversations:\n"
+    for memory in memories:
+        context += f"- {memory['memory']}\n"
+
+    system_message = SystemMessage(content=f"""You are a helpful customer support assistant. Use the provided context to personalize your responses and remember user preferences and past interactions.
+{context}""")
+
+    full_messages = [system_message] + messages
+    response = llm.invoke(full_messages)
+
+    # Store the interaction in Mem0
+    mem0.add(f"User: {messages[-1].content}\nAssistant: {response.content}", user_id=user_id)
+    return {"messages": [response]}
+```
+
+## Set Up Graph Structure
+
+Configure the LangGraph with appropriate nodes and edges:
+
+```python
+graph.add_node("chatbot", chatbot)
+graph.add_edge(START, "chatbot")
+graph.add_edge("chatbot", "chatbot")
+
+compiled_graph = graph.compile()
+```
+
+## Create Conversation Runner
+
+Implement a function to manage the conversation flow:
+
+```python
+def run_conversation(user_input: str, mem0_user_id: str):
+    config = {"configurable": {"thread_id": mem0_user_id}}
+    state = {"messages": [HumanMessage(content=user_input)], "mem0_user_id": mem0_user_id}
+
+    for event in compiled_graph.stream(state, config):
+        for value in event.values():
+            if value.get("messages"):
+                print("Customer Support:", value["messages"][-1].content)
+                return
+```
+
+## Main Interaction Loop
+
+Set up the main program loop for user interaction:
+
+```python
+if __name__ == "__main__":
+    print("Welcome to Customer Support! How can I assist you today?")
+    mem0_user_id = "customer_123"  # You can generate or retrieve this based on your user management system
+    while True:
+        user_input = input("You: ")
+        if user_input.lower() in ['quit', 'exit', 'bye']:
+            print("Customer Support: Thank you for contacting us. Have a great day!")
+            break
+        run_conversation(user_input, mem0_user_id)
+```
+
+## Key Features
+
+1. **Memory Integration**: Uses Mem0 to store and retrieve relevant information from past interactions.
+2. **Personalization**: Provides context-aware responses based on user history.
+3. **Flexible Architecture**: LangGraph structure allows for easy expansion of the conversation flow.
+4. **Continuous Learning**: Each interaction is stored, improving future responses.
+
+## Conclusion
+
+By integrating LangGraph with Mem0, you can build a personalized Customer Support AI Agent that can maintain context across interactions and provide personalized assistance.
+
+## Help
+
+- For more details on LangGraph, visit the [LangChain documentation](https://python.langchain.com/docs/langgraph).
+- For Mem0 documentation, refer to the [Mem0 Platform](https://app.mem0.ai/).
+- If you need further assistance, please feel free to reach out to us through following methods:
+
+<Snippet file="get-help.mdx" />

docs/integrations/multion.mdx

@@ -6,42 +6,48 @@ Build personal browser agent remembers user preferences and automates web tasks.
 
 ## Overview
 
-In this example, we will create a Browser based AI Agent that searches [arxiv.org](https://arxiv.org) for research papers relevant to user's research interests.
+In this guide, we'll explore two examples of creating Browser-based AI Agents:
+1. An agent that searches [arxiv.org](https://arxiv.org) for research papers relevant to user's research interests.
+2. A travel agent that provides personalized travel information based on user preferences. Refer the [notebook](https://github.com/MULTI-ON/cookbook/blob/main/personalized-travel-agent/mem0_travel_agent.ipynb) for detailed code.
 
 ## Setup and Configuration
 
 Install necessary libraries:
 
 ```bash
-pip install mem0ai multion
+pip install mem0ai multion openai
 ```
 
 First, we'll import the necessary libraries and set up our configurations.
 
 ```python
 import os
-from mem0 import Memory
+from mem0 import Memory, MemoryClient
 from multion.client import MultiOn
+from openai import OpenAI
 
 # Configuration
 OPENAI_API_KEY = 'sk-xxx'  # Replace with your actual OpenAI API key
 MULTION_API_KEY = 'your-multion-key'  # Replace with your actual MultiOn API key
-USER_ID = "deshraj"
+MEM0_API_KEY = 'your-mem0-key'  # Replace with your actual Mem0 API key
+USER_ID = "your-user-id"
 
 # Set up OpenAI API key
 os.environ['OPENAI_API_KEY'] = OPENAI_API_KEY
 
 # Initialize Mem0 and MultiOn
-memory = Memory()
+memory = Memory()  # For local usage
+memory_client = MemoryClient(api_key=MEM0_API_KEY)  # For API usage
 multion = MultiOn(api_key=MULTION_API_KEY)
 ```
 
-## Add memories to Mem0
+## Example 1: Research Paper Search Agent
 
-Next, we'll define our user data and add it to Mem0.
+### Add memories to Mem0
+
+Define user data and add it to Mem0.
 
 ```python
-# Define user data
 USER_DATA = """
 About me
 - I'm Deshraj Yadav, Co-founder and CTO at Mem0, interested in AI and ML Infrastructure.
@@ -50,17 +56,15 @@ About me
 - Outside of work, I enjoy playing cricket in two leagues in the San Francisco.
 """
 
-# Add user data to memory
 memory.add(USER_DATA, user_id=USER_ID)
 print("User data added to memory.")
 ```
 
-## Retrieving Relevant Memories
+### Retrieving Relevant Memories
 
-Now, we'll define our search command and retrieve relevant memories from Mem0.
+Define search command and retrieve relevant memories from Mem0.
 
 ```python
-# Define search command and retrieve relevant memories
 command = "Find papers on arxiv that I should read based on my interests."
 
 relevant_memories = memory.search(command, user_id=USER_ID, limit=3)
@@ -69,17 +73,139 @@ print(f"Relevant memories:")
 print(relevant_memories_text)
 ```
 
-## Browsing arXiv
+### Browsing arXiv
 
-Finally, we'll use MultiOn to browse arXiv based on our command and relevant memories.
+Use MultiOn to browse arXiv based on the command and relevant memories.
 
 ```python
-# Create prompt and browse arXiv
 prompt = f"{command}\n My past memories: {relevant_memories_text}"
 browse_result = multion.browse(cmd=prompt, url="https://arxiv.org/")
 print(browse_result)
 ```
 
+## Example 2: Travel Agent
+
+### Get Travel Information
+
+Add conversation to Mem0 and create a function to get travel information based on user's question and optionally their preferences from memory.
+
+<CodeGroup>
+```python Code
+def get_travel_info(question, use_memory=True):
+    if use_memory:
+        previous_memories = memory_client.search(question, user_id=USER_ID)
+        relevant_memories_text = ""
+        if previous_memories:
+            print("Using previous memories to enhance the search...")
+            relevant_memories_text = '\n'.join(mem["memory"] for mem in previous_memories)
+        
+        command = "Find travel information based on my interests:"
+        prompt = f"{command}\n Question: {question} \n My preferences: {relevant_memories_text}"
+    else:
+        command = "Find travel information based on my interests:"
+        prompt = f"{command}\n Question: {question}"
+    
+    print("Searching for travel information...")    
+    browse_result = multion.browse(cmd=prompt)
+    return browse_result.message
+
+# Example usage
+question = "Show me flight details for it."
+answer_without_memory = get_travel_info(question, use_memory=False)
+answer_with_memory = get_travel_info(question, use_memory=True)
+
+print("Answer without memory:", answer_without_memory)
+print("Answer with memory:", answer_with_memory)
+
+# Another example
+question = "What is the best place to eat there?"
+answer_without_memory = get_travel_info(question, use_memory=False)
+answer_with_memory = get_travel_info(question, use_memory=True)
+
+print("Answer without memory:", answer_without_memory)
+print("Answer with memory:", answer_with_memory)
+```
+
+```json Conversation
+# Add conversation to Mem0
+conversation = [
+    {
+        "role": "user",
+        "content": "What are the best travel destinations in the world?"
+    },
+    {
+        "role": "assistant",
+        "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."
+    },
+    {
+        "role": "user",
+        "content": "Sure, I want to travel to San Francisco."
+    },
+    {
+        "role": "assistant",
+        "content": """
+        Based on the information gathered from TripAdvisor, here are some popular attractions, activities, and travel tips for San Francisco: \
+
+        1. **Golden Gate Bridge**: A must-see iconic landmark. \
+        2. **Alcatraz Island**: Famous former prison offering tours. \
+        3. **Fisherman's Wharf**: Popular tourist area with shops, restaurants, and sea lions. \
+        4. **Chinatown**: The largest Chinatown outside of Asia. \
+        5. **Golden Gate Park**: Large urban park with gardens, museums, and recreational activities. \
+        6. **Cable Cars**: Historic streetcars offering a unique way to see the city. \
+        7. **Exploratorium**: Interactive science museum. \
+        8. **San Francisco Museum of Modern Art (SFMOMA)**: Modern and contemporary art museum. \
+        9. **Lombard Street**: Known for its steep, one-block section with eight hairpin turns. \
+        10. **Union Square**: Major shopping and cultural hub. \
+
+        Travel Tips: \
+        - **Weather**: San Francisco has a mild climate, but it can be foggy and windy. Dress in layers. \
+        - **Transportation**: Use public transportation like BART, Muni, and cable cars to get around. \
+        - **Safety**: Be aware of your surroundings, especially in crowded tourist areas. \
+        - **Dining**: Try local specialties like sourdough bread, seafood, and Mission-style burritos. \
+        """
+    },
+    {
+        "role": "user",
+        "content": "Show me hotels around Golden Gate Bridge."
+    },
+    {
+        "role": "assistant",
+        "content": """The search results for hotels around Golden Gate Bridge in San Francisco include: \
+
+        1. Hilton Hotels In San Francisco - Hotel Near Fishermans Wharf (hilton.com) \
+        2. The 10 Closest Hotels to Golden Gate Bridge (tripadvisor.com) \
+        3. Hotels near Golden Gate Bridge (expedia.com) \
+        4. Hotels near Golden Gate Bridge (hotels.com) \
+        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 \
+        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 \
+        7. Hotel Zephyr San Francisco $159 (3.8K) 4-star hotel Golden Gate Bridge • 3.7 mi Nautical-themed lodging with bay views \
+        8. Lodge at the Presidio \
+        9. The Inn Above Tide \
+        10. Cavallo Point \
+        11. Casa Madrona Hotel and Spa \
+        12. Cow Hollow Inn and Suites \
+        13. Samesun San Francisco \
+        14. Inn on Broadway \
+        15. Coventry Motor Inn \
+        16. HI San Francisco Fisherman's Wharf Hostel \
+        17. Loews Regency San Francisco Hotel \
+        18. Fairmont Heritage Place Ghirardelli Square \
+        19. Hotel Drisco Pacific Heights \
+        20. Travelodge by Wyndham Presidio San Francisco \
+        """
+    }
+]
+```
+</CodeGroup>
+
 ## Conclusion
 
-By integrating Mem0 with MultiOn, you've created a personalized browser agent that remembers user preferences and automates web tasks. For more details and advanced usage, refer to the full [cookbook here](https://github.com/mem0ai/mem0/blob/main/cookbooks/mem0-multion.ipynb).
+By integrating Mem0 with MultiOn, you've created personalized browser agents that remember user preferences and automate web tasks. The first example demonstrates a research-focused agent, while the second example shows a travel agent capable of providing personalized recommendations.
+
+These examples illustrate how combining memory management with web browsing capabilities can create powerful, context-aware AI agents for various applications.
+
+## Help
+
+- For more details and advanced usage, refer to the full [cookbooks here](https://github.com/mem0ai/mem0/blob/main/cookbooks).
+- Feel free to visit our [Github](https://github.com/mem0ai/mem0) or [Mem0 Platform](https://app.mem0.ai/).
+- For any questions or assistance, please reach out to `taranjeetio` on [Discord](https://mem0.dev/DiD).

docs/knowledge-base/introduction.mdx

@@ -0,0 +1,6 @@
+---
+title: Introduction
+description: A collection of answers to Frequently asked questions about Mem0.
+---
+
+Coming soon.

docs/llms.mdx

@@ -1,206 +0,0 @@
----
-title: 🤖 Overview
----
-
-## 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="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>
-</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"})
-```
-
-## 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["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"})
-```
-
-## TogetherAI
-
-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["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['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["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 model, 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["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"})
-```
-

docs/mint.json

@@ -3,9 +3,9 @@
   "name": "Mem0.ai",
   "favicon": "/logo/favicon.png",
   "colors": {
-    "primary": "#3B2FC9",
-    "light": "#6673FF",
-    "dark": "#3B2FC9",
+    "primary": "#6c60f0",
+    "light": "#E6FFA2",
+    "dark": "#a3df02",
     "background": {
       "dark": "#0f1117",
       "light": "#fff"
@@ -14,39 +14,37 @@
   "logo": {
     "dark": "/logo/dark.svg",
     "light": "/logo/light.svg",
-    "href": "https://github.com/embedchain/embedchain"
+    "href": "https://github.com/mem0ai/mem0"
+  },
+  "topbarCtaButton": {
+    "name": "Your Dashboard",
+    "url": "https://app.mem0.ai"
   },
-  "tabs": [
-    {
-      "name": "💡 Examples",
-      "url": "examples"
-    },
-    {
-      "name": "🖥️  Platform",
-      "url": "platform"
-    }
-  ],
-  "topbarLinks": [
-    {
-      "name": "Support",
-      "url": "mailto:founders@mem0.ai"
-    }
-  ],
   "anchors": [
     {
-      "name": "Slack",
-      "icon": "slack",
-      "url": "https://mem0.ai/slack/"
+      "name": "Your Dashboard",
+      "icon": "chart-simple",
+      "url": "https://app.mem0.ai"
+    },
+    {
+      "name": "API Reference",
+      "url": "api-reference",
+      "icon": "square-terminal"
     },
     {
       "name": "Discord",
       "icon": "discord",
-      "url": "https://mem0.ai/discord/"
+      "url": "https://mem0.dev/DiD"
     },
     {
-      "name": "Talk to founders",
-      "icon": "calendar",
-      "url": "https://cal.com/taranjeetio/meet"
+      "name": "GitHub",
+      "icon": "github",
+      "url": "https://github.com/mem0ai/mem0"
+    },
+    {
+      "name": "Support",
+      "icon": "envelope",
+      "url": "mailto:taranjeet@mem0.ai"
     }
   ],
   "navigation": [
@@ -54,41 +52,183 @@
       "group": "Get Started",
       "pages": [
         "overview",
-        "quickstart"
+        "quickstart",
+        "playground",
+        "features"
       ]
     },
     {
-      "group": "LLMs",
+      "group": "Platform",
       "pages": [
-        "llms"
+        "platform/overview",
+        "platform/quickstart",
+        {
+          "group": "Features",
+          "pages": ["features/selective-memory", "features/custom-categories"]
+        }
+      ]
+    },
+    {
+      "group": "Open Source",
+      "pages": [
+        "open-source/quickstart",
+        {
+          "group": "Graph Memory",
+          "pages": ["open-source/graph_memory/overview", "open-source/graph_memory/features"]
+        },
+        {
+          "group": "LLMs",
+          "pages": [
+            "components/llms/overview",
+            "components/llms/config",
+            {
+              "group": "Supported LLMs",
+              "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"
+              ]
+            }
+          ]
+        },
+        {
+          "group": "Vector Databases",
+          "pages": [
+            "components/vectordbs/overview",
+            "components/vectordbs/config",
+            {
+              "group": "Supported Vector Databases",
+              "pages": [
+                "components/vectordbs/dbs/chroma",
+                "components/vectordbs/dbs/pgvector",
+                "components/vectordbs/dbs/qdrant",
+                "components/vectordbs/dbs/milvus"
+              ]
+            }
+          ]
+        },
+        {
+          "group": "Embedding Models",
+          "pages": [
+            "components/embedders/overview",
+            "components/embedders/config",
+            {
+              "group": "Supported Embedding Models",
+              "pages": [
+                "components/embedders/models/openai",
+                "components/embedders/models/azure_openai",
+                "components/embedders/models/ollama",
+                "components/embedders/models/huggingface",
+                "components/embedders/models/gemini"
+              ]
+            }
+          ]
+        },
+        {
+          "group": "Features",
+          "pages": ["features/openai_compatibility", "features/custom-prompts"]
+        }
+      ]
+    },
+    {
+      "group": "API Reference",
+      "pages": [
+        "api-reference/overview",
+        {
+          "group": "Memory APIs",
+          "pages": [
+            "api-reference/memory/get-memories",
+            "api-reference/memory/add-memories",
+            "api-reference/memory/delete-memories",
+            "api-reference/memory/get-memory",
+            "api-reference/memory/update-memory",
+            "api-reference/memory/delete-memory",
+            "api-reference/memory/v1-search-memories",
+            "api-reference/memory/v2-search-memories",
+            "api-reference/memory/history-memory"
+          ]
+        },
+        {
+          "group": "Entities APIs",
+          "pages": [
+            "api-reference/entities/get-users",
+            "api-reference/entities/delete-user"
+          ]
+        },
+        {
+          "group": "Organizations APIs",
+          "pages": [
+            "api-reference/organization/get-orgs",
+            "api-reference/organization/get-org",
+            "api-reference/organization/create-org",
+            "api-reference/organization/delete-org",
+            {
+              "group": "Members APIs",
+              "pages": [
+                "api-reference/organization/get-org-members",
+                "api-reference/organization/add-org-member",
+                "api-reference/organization/update-org-member",
+                "api-reference/organization/delete-org-member"
+              ]
+            }
+          ]
+        },
+        {
+          "group": "Projects APIs",
+          "pages": [
+            "api-reference/project/get-projects",
+            "api-reference/project/get-project",
+            "api-reference/project/create-project",
+            "api-reference/project/delete-project",
+            {
+              "group": "Members APIs",
+              "pages":[
+                "api-reference/project/get-project-members",
+                "api-reference/project/add-project-member",
+                "api-reference/project/update-project-member",
+                "api-reference/project/delete-project-member"
+              ]
+            }
+          ]
+        }
       ]
     },
     {
       "group": "Integrations",
       "pages": [
-        "integrations/multion"
+        "integrations/multion",
+        "integrations/autogen",
+        "integrations/langgraph"
       ]
     },
     {
       "group": "💡 Examples",
       "pages": [
         "examples/overview",
+        "examples/mem0-with-ollama",
         "examples/personal-ai-tutor",
         "examples/customer-support-agent",
         "examples/personal-travel-assistant"
       ]
-    },
-    {
-      "group": "🖥️  Platform",
-      "pages": [
-        "platform/overview",
-        "platform/quickstart"
-      ]
     }
   ],
   "footerSocials": {
+    "discord": "https://mem0.dev/DiD",
     "x": "https://x.com/mem0ai",
-    "github": "https://github.com/embedchain/embedchain/mem0",
+    "github": "https://github.com/mem0ai",
     "linkedin": "https://www.linkedin.com/company/mem0/"
+  },
+  "analytics": {
+    "posthog": {
+      "apiKey": "phc_hgJkUVJFYtmaJqrvf6CYN67TIQ8yhXAkWzUn9AMU4yX",
+      "apiHost": "https://us.i.posthog.com"
+    }
   }
 }

docs/open-source/graph_memory/features.mdx

@@ -0,0 +1,38 @@
+---
+title: Features
+description: 'Graph Memory features'
+---
+
+Graph Memory is a powerful feature that allows users to create and utilize complex relationships between pieces of information.
+
+## Graph Memory supports the following features:
+A list of features provided by Graph Memory.
+
+### Add Customize Prompt
+
+Users can add a customized prompt that will be used to extract specific entities from the given input text. 
+This allows for more targeted and relevant information extraction based on the user's needs. 
+Here's an example of how to add a customized prompt:
+
+```python
+from mem0 import Memory
+
+config = {
+    "graph_store": {
+        "provider": "neo4j",
+        "config": {
+            "url": "neo4j+s://xxx",
+            "username": "neo4j",
+            "password": "xxx"
+        },
+        "custom_prompt": "Please only extract entities containing sports related relationships and nothing else.",
+    },
+    "version": "v1.1"
+}
+
+m = Memory.from_config(config_dict=config)
+```
+
+If you want to use a managed version of Mem0, please check out [Mem0](https://mem0.dev/pd). If you have any questions, please feel free to reach out to us using one of the following methods:
+
+<Snippet file="get-help.mdx" />

docs/open-source/graph_memory/overview.mdx

@@ -0,0 +1,307 @@
+---
+title: Overview
+description: 'Enhance your memory system with graph-based knowledge representation and retrieval'
+---
+
+Mem0 now supports **Graph Memory**.
+With Graph Memory, users can now create and utilize complex relationships between pieces of information, allowing for more nuanced and context-aware responses. 
+This integration enables users to leverage the strengths of both vector-based and graph-based approaches, resulting in more accurate and comprehensive information retrieval and generation.
+
+Try Graph Memory on Google Colab.
+<a target="_blank" href="https://colab.research.google.com/drive/1PfIGVHnliIlG2v8cx0g45TF0US-jRPZ1?usp=sharing">
+  <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/>
+</a>
+
+
+<iframe
+width="100%"
+height="400"
+src="https://www.youtube.com/embed/u_ZAqNNVtXA"
+title="YouTube video player"
+frameborder="0"
+allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
+allowfullscreen
+></iframe>
+
+## Initialize Graph Memory
+
+To initialize Graph Memory you'll need to set up your configuration with graph store providers.
+Currently, we support Neo4j as a graph store provider. You can setup [Neo4j](https://neo4j.com/) locally or use the hosted [Neo4j AuraDB](https://neo4j.com/product/auradb/). 
+Moreover, you also need to set the version to `v1.1` (*prior versions are not supported*).
+
+<Note>If you are using Neo4j locally, then you need to install [APOC plugins](https://neo4j.com/labs/apoc/4.1/installation/).</Note>
+
+
+User can also customize the LLM for Graph Memory from the [Supported LLM list](https://docs.mem0.ai/components/llms/overview) with three levels of configuration:
+
+1. **Main Configuration**: If `llm` is set in the main config, it will be used for all graph operations.
+2. **Graph Store Configuration**: If `llm` is set in the graph_store config, it will override the main config `llm` and be used specifically for graph operations.
+3. **Default Configuration**: If no custom LLM is set, the default LLM (`gpt-4o-2024-08-06`) will be used for all graph operations.
+
+Here's how you can do it:
+
+
+<CodeGroup>
+```python Basic
+from mem0 import Memory
+
+config = {
+    "graph_store": {
+        "provider": "neo4j",
+        "config": {
+            "url": "neo4j+s://xxx",
+            "username": "neo4j",
+            "password": "xxx"
+        }
+    },
+    "version": "v1.1"
+}
+
+m = Memory.from_config(config_dict=config)
+```
+
+```python Advanced (Custom LLM)
+from mem0 import Memory
+
+config = {
+    "llm": {
+        "provider": "openai",
+        "config": {
+            "model": "gpt-4o",
+            "temperature": 0.2,
+            "max_tokens": 1500,
+        }
+    },
+    "graph_store": {
+        "provider": "neo4j",
+        "config": {
+            "url": "neo4j+s://xxx",
+            "username": "neo4j",
+            "password": "xxx"
+        },
+        "llm" : {
+            "provider": "openai",
+            "config": {
+                "model": "gpt-4o-mini",
+                "temperature": 0.0,
+            }
+        }
+    },
+    "version": "v1.1"
+}
+
+m = Memory.from_config(config_dict=config)
+```
+</CodeGroup>
+
+## Graph Operations
+The Mem0's graph supports the following operations:
+
+### Add Memories
+
+<CodeGroup>
+```python Code
+m.add("I like pizza", user_id="alice")
+```
+
+```json Output
+{'message': 'ok'}
+```
+</CodeGroup>
+
+
+### Get all memories
+
+<CodeGroup>
+```python Code
+m.get_all(user_id="alice")
+```
+
+```json Output
+{
+    'memories': [
+        {
+            'id': 'de69f426-0350-4101-9d0e-5055e34976a5',
+            'memory': 'Likes pizza',
+            'hash': '92128989705eef03ce31c462e198b47d',
+            'metadata': None,
+            'created_at': '2024-08-20T14:09:27.588719-07:00',
+            'updated_at': None,
+            'user_id': 'alice'
+        }
+    ],
+    'entities': [
+        {
+            'source': 'alice',
+            'relationship': 'likes',
+            'target': 'pizza'
+        }
+    ]
+}
+```
+</CodeGroup>
+
+### Search Memories
+
+<CodeGroup>
+```python Code
+m.search("tell me my name.", user_id="alice")
+```
+
+```json Output
+{
+    'memories': [
+        {
+            'id': 'de69f426-0350-4101-9d0e-5055e34976a5',
+            'memory': 'Likes pizza',
+            'hash': '92128989705eef03ce31c462e198b47d',
+            'metadata': None,
+            'created_at': '2024-08-20T14:09:27.588719-07:00',
+            'updated_at': None,
+            'user_id': 'alice'
+        }
+    ],
+    'entities': [
+        {
+            'source': 'alice',
+            'relationship': 'likes',
+            'target': 'pizza'
+        }
+    ]
+}
+```
+</CodeGroup>
+
+
+### Delete all Memories
+```python
+m.delete_all(user_id="alice")
+```
+
+
+# Example Usage
+Here's an example of how to use Mem0's graph operations:
+
+1. First, we'll add some memories for a user named Alice.
+2. Then, we'll visualize how the graph evolves as we add more memories.
+3. You'll see how entities and relationships are automatically extracted and connected in the graph.
+
+### Add Memories
+
+Below are the steps to add memories and visualize the graph:
+
+<Steps>
+  <Step title="Add memory 'I like going to hikes'">
+
+```python
+m.add("I like going to hikes", user_id="alice123")
+```
+![Graph Memory Visualization](/images/graph_memory/graph_example1.png)
+
+</Step>
+<Step title="Add memory 'I love to play badminton'">
+
+
+```python
+m.add("I love to play badminton", user_id="alice123")
+```
+![Graph Memory Visualization](/images/graph_memory/graph_example2.png)
+
+</Step>
+
+<Step title="Add memory 'I hate playing badminton'">
+
+```python
+m.add("I hate playing badminton", user_id="alice123")
+```
+![Graph Memory Visualization](/images/graph_memory/graph_example3.png)
+
+</Step>
+
+<Step title="Add memory 'My friend name is john and john has a dog named tommy'">
+
+```python
+m.add("My friend name is john and john has a dog named tommy", user_id="alice123")
+```
+![Graph Memory Visualization](/images/graph_memory/graph_example4.png)
+
+</Step>
+
+<Step title="Add memory 'My name is Alice'">
+
+```python
+m.add("My name is Alice", user_id="alice123")
+```
+![Graph Memory Visualization](/images/graph_memory/graph_example5.png)
+
+</Step>
+
+<Step title="Add memory 'John loves to hike and Harry loves to hike as well'">
+
+```python
+m.add("John loves to hike and Harry loves to hike as well", user_id="alice123")
+```
+![Graph Memory Visualization](/images/graph_memory/graph_example6.png)
+
+</Step>
+
+<Step title="Add memory 'My friend peter is the spiderman'">
+
+```python
+m.add("My friend peter is the spiderman", user_id="alice123")
+```
+
+![Graph Memory Visualization](/images/graph_memory/graph_example7.png)
+
+</Step>
+
+</Steps>
+
+
+### Search Memories
+
+<CodeGroup>
+```python Code
+m.search("What is my name?", user_id="alice123")
+```
+
+```json Output
+{
+    'memories': [...],
+    'entities': [
+        {'source': 'alice123', 'relation': 'dislikes_playing','destination': 'badminton'},
+        {'source': 'alice123', 'relation': 'friend', 'destination': 'peter'},
+        {'source': 'alice123', 'relation': 'friend', 'destination': 'john'},
+        {'source': 'alice123', 'relation': 'has_name', 'destination': 'alice'},
+        {'source': 'alice123', 'relation': 'likes', 'destination': 'hiking'}
+    ]
+}
+```
+</CodeGroup>
+
+Below graph visualization shows what nodes and relationships are fetched from the graph for the provided query.
+
+![Graph Memory Visualization](/images/graph_memory/graph_example8.png)
+
+<CodeGroup>
+```python Code
+m.search("Who is spiderman?", user_id="alice123")
+```
+
+```json Output
+{
+    'memories': [...],
+    'entities': [
+        {'source': 'peter', 'relation': 'identity','destination': 'spiderman'}
+    ]
+}
+```
+</CodeGroup>
+
+![Graph Memory Visualization](/images/graph_memory/graph_example9.png)
+
+> **Note:** The Graph Memory implementation is not standalone. You will be adding/retrieving memories to the vector store and the graph store simultaneously.
+
+If you want to use a managed version of Mem0, please check out [Mem0](https://mem0.dev/pd). If you have any questions, please feel free to reach out to us using one of the following methods:
+
+<Snippet file="get-help.mdx" />

docs/open-source/quickstart.mdx

@@ -0,0 +1,369 @@
+---
+title: Guide
+description: 'Get started with Mem0 quickly!'
+---
+
+> Welcome to the Mem0 quickstart guide. This guide will help you get up and running with Mem0 in no time.
+
+## Installation
+
+To install Mem0, you can use pip. Run the following command in your terminal:
+
+```bash
+pip install mem0ai
+```
+
+## Basic Usage
+
+### Initialize Mem0
+
+<Tabs>
+  <Tab title="Basic">
+```python
+from mem0 import Memory
+m = Memory()
+```
+  </Tab>
+  <Tab title="Advanced">
+If you want to run Mem0 in production, initialize using the following method:
+
+Run Qdrant first:
+
+```bash
+docker pull qdrant/qdrant
+
+docker run -p 6333:6333 -p 6334:6334 \
+    -v $(pwd)/qdrant_storage:/qdrant/storage:z \
+    qdrant/qdrant
+```
+
+Then, instantiate memory with qdrant server:
+
+```python
+from mem0 import Memory
+
+config = {
+    "vector_store": {
+        "provider": "qdrant",
+        "config": {
+            "host": "localhost",
+            "port": 6333,
+        }
+    },
+}
+
+m = Memory.from_config(config)
+```
+  </Tab>
+
+<Tab title="Advanced (Graph Memory)">
+
+```python
+from mem0 import Memory
+
+config = {
+    "graph_store": {
+        "provider": "neo4j",
+        "config": {
+            "url": "neo4j+s://---",
+            "username": "neo4j",
+            "password": "---"
+        }
+    },
+    "version": "v1.1"
+}
+
+m = Memory.from_config(config_dict=config)
+```
+
+</Tab>
+</Tabs>
+
+
+### Store a Memory
+
+<CodeGroup>
+```python Code
+# For a user
+result = m.add("Likes to play cricket on weekends", user_id="alice", metadata={"category": "hobbies"})
+
+# messages = [
+#    {"role": "user", "content": "Hi, I'm Alex. I like to play cricket on weekends."},
+#    {"role": "assistant", "content": "Hello Alex! It's great to know that you enjoy playing cricket on weekends. I'll remember that for future reference."}
+# ]
+# client.add(messages, user_id="alice")
+```
+
+```json Output
+{'message': 'ok'}
+```
+</CodeGroup>
+
+### Retrieve Memories
+
+<CodeGroup>
+```python Code
+# Get all memories
+all_memories = m.get_all()
+```
+
+```json Output
+[
+   {
+      "id":"13efe83b-a8df-4ec0-814e-428d6e8451eb",
+      "memory":"Likes to play cricket on weekends",
+      "hash":"87bcddeb-fe45-4353-bc22-15a841c50308",
+      "metadata":"None",
+      "created_at":"2024-07-26T08:44:41.039788-07:00",
+      "updated_at":"None",
+      "user_id":"alice"
+   }
+]
+```
+</CodeGroup>
+
+
+<br />
+
+<CodeGroup>
+```python Code
+# Get a single memory by ID
+specific_memory = m.get("m1")
+```
+
+```json Output
+{
+      "id":"13efe83b-a8df-4ec0-814e-428d6e8451eb",
+      "memory":"Likes to play cricket on weekends",
+      "hash":"87bcddeb-fe45-4353-bc22-15a841c50308",
+      "metadata":"None",
+      "created_at":"2024-07-26T08:44:41.039788-07:00",
+      "updated_at":"None",
+      "user_id":"alice"
+}
+```
+</CodeGroup>
+
+### Search Memories
+
+<CodeGroup>
+```python Code
+related_memories = m.search(query="What are Alice's hobbies?", user_id="alice")
+```
+
+```json Output
+[
+   {
+      "id":"ea925981-272f-40dd-b576-be64e4871429",
+      "memory":"Likes to play cricket and plays cricket on weekends.",
+      "hash":"c8809002-25c1-4c97-a3a2-227ce9c20c53",
+      "metadata":{
+         "category":"hobbies"
+      },
+      "score":0.32116443111457704,
+      "created_at":"2024-07-26T10:29:36.630547-07:00",
+      "updated_at":"None",
+      "user_id":"alice"
+   }
+]
+```
+</CodeGroup>
+
+### Update a Memory
+
+<CodeGroup>
+```python Code
+result = m.update(memory_id="m1", data="Likes to play tennis on weekends")
+```
+
+```json Output
+{'message': 'Memory updated successfully!'}
+```
+</CodeGroup>
+
+### Memory History
+
+<CodeGroup>
+```python Code
+history = m.history(memory_id="m1")
+```
+
+```json Output
+[
+   {
+      "id":"4e0e63d6-a9c6-43c0-b11c-a1bad3fc7abb",
+      "memory_id":"ea925981-272f-40dd-b576-be64e4871429",
+      "old_memory":"None",
+      "new_memory":"Likes to play cricket and plays cricket on weekends.",
+      "event":"ADD",
+      "created_at":"2024-07-26T10:29:36.630547-07:00",
+      "updated_at":"None"
+   },
+   {
+      "id":"548b75f0-f442-44b9-9ca1-772a105abb12",
+      "memory_id":"ea925981-272f-40dd-b576-be64e4871429",
+      "old_memory":"Likes to play cricket and plays cricket on weekends.",
+      "new_memory":"Likes to play tennis on weekends",
+      "event":"UPDATE",
+      "created_at":"2024-07-26T10:29:36.630547-07:00",
+      "updated_at":"2024-07-26T10:32:46.332336-07:00"
+   }
+]
+```
+</CodeGroup>
+
+### Delete Memory
+
+```python
+# Delete a memory by id
+m.delete(memory_id="m1")
+# Delete all memories for a user
+m.delete_all(user_id="alice")
+```
+
+### Reset Memory
+
+```python
+m.reset() # Reset all memories
+```
+
+## Run Mem0 Locally
+
+Please refer the example [Mem0 with Ollama](../examples/mem0-with-ollama) to run Mem0 locally.
+
+
+## Chat Completion
+
+Mem0 can be easily integrate into chat applications to enhance conversational agents with structured memory. Mem0's APIs are designed to be compatible with OpenAI's, with the goal of making it easy to leverage Mem0 in applications you may have already built.
+
+If you have a `Mem0 API key`, you can use it to initialize the client. Alternatively, you can initialize Mem0 without an API key if you're using it locally.
+
+Mem0 supports several language models (LLMs) through integration with various [providers](https://litellm.vercel.app/docs/providers).
+
+## Use Mem0 Platform
+
+```python
+from mem0.proxy.main import Mem0
+
+client = Mem0(api_key="m0-xxx")
+
+# First interaction: Storing user preferences
+messages = [
+  {
+    "role": "user",
+    "content": "I love indian food but I cannot eat pizza since allergic to cheese."
+  },
+]
+user_id = "alice"
+chat_completion = client.chat.completions.create(messages=messages, model="gpt-4o-mini", user_id=user_id)
+# Memory saved after this will look like: "Loves Indian food. Allergic to cheese and cannot eat pizza."
+
+# Second interaction: Leveraging stored memory
+messages = [
+  {
+    "role": "user",
+    "content": "Suggest restaurants in San Francisco to eat.",
+  }
+]
+
+chat_completion = client.chat.completions.create(messages=messages, model="gpt-4o-mini", user_id=user_id)
+print(chat_completion.choices[0].message.content)
+# Answer: You might enjoy Indian restaurants in San Francisco, such as Amber India, Dosa, or Curry Up Now, which offer delicious options without cheese.
+```
+
+In this example, you can see how the second response is tailored based on the information provided in the first interaction. Mem0 remembers the user's preference for Indian food and their cheese allergy, using this information to provide more relevant and personalized restaurant suggestions in San Francisco.
+
+### Use Mem0 OSS
+
+```python
+config = {
+    "vector_store": {
+        "provider": "qdrant",
+        "config": {
+            "host": "localhost",
+            "port": 6333,
+        }
+    },
+}
+
+client = Mem0(config=config)
+
+chat_completion = client.chat.completions.create(
+    messages=[
+        {
+            "role": "user",
+            "content": "What's the capital of France?",
+        }
+    ],
+    model="gpt-4o",
+)
+```
+
+## APIs
+
+Get started with using Mem0 APIs in your applications. For more details, refer to the [Platform](/platform/quickstart.mdx).
+
+Here is an example of how to use Mem0 APIs:
+
+```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)
+```
+
+
+## Contributing
+
+We welcome contributions to Mem0! Here's how you can contribute:
+
+1. Fork the repository and create your branch from `main`.
+2. Clone the forked repository to your local machine.
+3. Install the project dependencies:
+
+   ```bash
+   poetry install
+   ```
+
+4. Install pre-commit hooks:
+
+   ```bash
+   pip install pre-commit  # If pre-commit is not already installed
+   pre-commit install
+   ```
+
+5. Make your changes and ensure they adhere to the project's coding standards.
+
+6. Run the tests locally:
+
+   ```bash
+   poetry run pytest
+   ```
+
+7. If all tests pass, commit your changes and push to your fork.
+8. Open a pull request with a clear title and description.
+
+Please make sure your code follows our coding conventions and is well-documented. We appreciate your contributions to make Mem0 better!
+
+
+If you have any questions, please feel free to reach out to us using one of the following methods:
+
+<Snippet file="get-help.mdx" />

docs/overview.mdx

@@ -1,59 +1,31 @@
 ---
-title: 📚 Overview
-description: 'Welcome to the Mem0 docs!'
+title: Overview
 ---
 
-> Mem0 provides a smart, self-improving memory layer for Large Language Models, enabling personalized AI experiences across applications.
+[Mem0](https://mem0.dev/wd) (pronounced "mem-zero") enhances AI assistants and agents with an intelligent memory layer, enabling personalized AI interactions. Mem0 remembers user preferences and traits and continuously updates over time, making it ideal for applications like customer support chatbots and AI assistants.
 
-## Core features
+Mem0 offers two powerful ways to leverage our technology: our [managed platform](/platform/overview) and our [open source solution](/open-source/quickstart).
+## Getting Started 
 
-- **User, Session, and AI Agent Memory**: Retains information across user sessions, interactions, and AI agents, ensuring continuity and context.
-- **Adaptive Personalization**: Continuously improves personalization based on user interactions and feedback.
-- **Developer-Friendly API**: Offers a straightforward API for seamless integration into various applications.
-- **Platform Consistency**: Ensures consistent behavior and data across different platforms and devices.
-- **Managed Service**: Provides a hosted solution for easy deployment and maintenance.
-
-If you are looking to quick start, jump to one of the following links:
-
-<CardGroup cols={2}>
-  <Card title="Quickstart" icon="square-1" href="/quickstart/">
-    Jump to quickstart section to get started
+<CardGroup cols={3}>
+  <Card title="Quickstart" icon="rocket" href="/quickstart">
+    Integrate Mem0 in a few lines of code
   </Card>
-  <Card title="Examples" icon="square-2" href="/examples/overview/">
-    Checkout curated examples
+  <Card title="Playground" icon="play" href="playground">
+    Mem0 in action
+  </Card>
+  <Card title="Examples" icon="lightbulb" href="/open-source/quickstart">
+  See what you can build with Mem0
   </Card>
 </CardGroup>
+## Key Features
 
-## Common Use Cases
+- OpenAI-compatible API: Easily switch between OpenAI and Mem0
+- Advanced memory management: Save costs by efficiently handling long-term context
+- Flexible deployment: Choose between managed platform or self-hosted solution
+<Card title="All Mem0 Features" icon="list" href="/features" horizontal="false">
+    </Card>
 
-- **Personalized Learning Assistants**: Long-term memory allows learning assistants to remember user preferences, past interactions, and progress, providing a more tailored and effective learning experience.
+## Need help?
 
-- **Customer Support AI Agents**: By retaining information from previous interactions, customer support bots can offer more accurate and context-aware assistance, improving customer satisfaction and reducing resolution times.
-
-- **Healthcare Assistants**: Long-term memory enables healthcare assistants to keep track of patient history, medication schedules, and treatment plans, ensuring personalized and consistent care.
-
-- **Virtual Companions**: Virtual companions can use long-term memory to build deeper relationships with users by remembering personal details, preferences, and past conversations, making interactions more meaningful.
-
-- **Productivity Tools**: Long-term memory helps productivity tools remember user habits, frequently used documents, and task history, streamlining workflows and enhancing efficiency.
-
-- **Gaming AI**: In gaming, AI with long-term memory can create more immersive experiences by remembering player choices, strategies, and progress, adapting the game environment accordingly.
-
-## How is Mem0 different from RAG?
-
-Mem0's memory implementation for Large Language Models (LLMs) offers several advantages over Retrieval-Augmented Generation (RAG):
-
-- **Entity Relationships**: Mem0 can understand and relate entities across different interactions, unlike RAG which retrieves information from static documents. This leads to a deeper understanding of context and relationships.
-
-- **Recency, Relevancy, and Decay**: Mem0 prioritizes recent interactions and gradually forgets outdated information, ensuring the memory remains relevant and up-to-date for more accurate responses.
-
-- **Contextual Continuity**: Mem0 retains information across sessions, maintaining continuity in conversations and interactions, which is essential for long-term engagement applications like virtual companions or personalized learning assistants.
-
-- **Adaptive Learning**: Mem0 improves its personalization based on user interactions and feedback, making the memory more accurate and tailored to individual users over time.
-
-- **Dynamic Updates**: Mem0 can dynamically update its memory with new information and interactions, unlike RAG which relies on static data. This allows for real-time adjustments and improvements, enhancing the user experience.
-
-These advanced memory capabilities make Mem0 a powerful tool for developers aiming to create personalized and context-aware AI applications.
-
-If you have any questions, please feel free to reach out to us using one of the following methods:
-
-<Snippet file="get-help.mdx" />
+<Snippet file="get-help.mdx"/>

docs/platform/overview.mdx

@@ -5,41 +5,28 @@ description: 'Empower your AI applications with long-term memory and personaliza
 
 ## Welcome to Mem0 Platform
 
-Mem0 Platform is a managed service that revolutionizes the way AI applications handle memory. By providing a smart, self-improving memory layer for Large Language Models (LLMs), we enable developers to create personalized AI experiences that evolve with each user interaction.
+The Mem0 Platform is a managed service and the easiest way to add our powerful memory layer to your applications. 
 
 ## Why Choose Mem0 Platform?
 
-1. **Enhanced User Experience**: Deliver tailored interactions that make your AI applications truly stand out.
-2. **Simplified Development**: Our API-first approach streamlines integration, allowing you to focus on building great features.
-3. **Scalable Solution**: Designed to grow with your application, from prototypes to production-ready systems.
+Mem0 Platform offers a powerful, user-centric solution for AI memory management with a few key features:
 
-## Key Features
+1. **Simplified Development**: Integrate comprehensive memory capabilities with just 4 lines of code. Our API-first approach allows you to focus on building great features while we handle the complexities of memory management.
 
-- **Comprehensive Memory Management**: Easily manage long-term, short-term, semantic, and episodic memories for individual users, agents, and sessions through our robust APIs.
-- **Self-Improving Memory**: Our adaptive system continuously learns from user interactions, refining its understanding over time.
-- **Cross-Platform Consistency**: Ensure a unified user experience across various AI platforms and applications.
-- **Centralized Memory Control**: Store, update, and delete memories effortlessly, taking away the hassle of memory management.
+2. **Scalable Solution**: Whether you're working on a prototype or a production-ready system, Mem0 is designed to grow with your application. Our platform effortlessly scales to meet your evolving needs.
 
-## Common Use Cases
+3. **Enhanced Performance**: Experience lightning-fast response times with sub-50ms latency, ensuring smooth and responsive user interactions in your AI applications.
+
+4. **Insightful Dashboard**: Gain valuable insights and maintain full control over your AI's memory through our intuitive dashboard. Easily manage memories and access key user insights.
 
-- Personalized Learning Assistants
-- Customer Support AI Agents
-- Healthcare Assistants
-- Virtual Companions
-- Productivity Tools
-- Gaming AI
 
 ## Getting Started
-Ready to supercharge your AI application with Mem0? Follow these steps:
 
-1. **Sign Up**: Create your Mem0 account at our platform.
-2. **API Key**: Generate your API key in the dashboard.
-3. **Installation**: Install our Python SDK using pip: `pip install mem0ai`
-4. **Quick Implementation**: Check out our [Quickstart Guide](/platform/quickstart) to start using Mem0 quickly.
+Check out our [Platform Guide](/platform/guide) to start using Mem0 platform quickly.
 
 ## Next Steps
 
-- Explore our API Reference for detailed endpoint documentation.
-- Join our [slack](https://mem0.ai/slack) or [discord](https://mem0.ai/discord) with other developers and get support.
+- Sign up to the [Mem0 Platform](https://mem0.dev/pd)
+- Join our [Discord](https://mem0.dev/Did) or [Slack](https://mem0.ai/slack) with other developers and get support.
 
 We're excited to see what you'll build with Mem0 Platform. Let's create smarter, more personalized AI experiences together!

docs/playground.mdx

@@ -0,0 +1,25 @@
+---
+title: Interactive Playground
+---
+Watch Mem0 in action with our Playground tool.
+
+<Steps>
+  <Step title="Create Mem0 Account">
+    You'll need to create a free Mem0 account to use the playground – this helps ensure responses are more tailored to you by associating interactions with an individual profile.
+    <Card title="Sign up to Mem0" icon="right-to-bracket" href="https://mem0.dev/pd" horizontal="true">
+    </Card>
+  </Step>
+  <Step title="Go to Playground">
+    <Card title="Mem0 Playground" icon="play" href="https://mem0.dev/pd-pg" horizontal="true">
+    </Card>
+  </Step>
+  <Step title="Start adding memories">
+    Chat with the assistant to start adding memories.
+    ![Add memories to playground](/images/playground/pg-add-memory.png)
+  </Step>
+  <Step title="Experience the power of Mem0">
+    Memories are stored in context for all future conversations, creating truly personal AI. 
+    ![Retrieve memories in playground](/images/playground/pg-retrieve-memory.png)
+  </Step>
+</Steps>
+