Remove unnecessary dependencies from base package (#2613)

Co-authored-by: Deshraj Yadav <deshraj@gatech.edu>

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,41 @@
+name: 🐛 Bug Report
+description: Create a report to help us reproduce and fix the bug
+
+body:
+- type: markdown
+  attributes:
+    value: >
+      #### Before submitting a bug, please make sure the issue hasn't been already addressed by searching through [the existing and past issues](https://github.com/embedchain/embedchain/issues?q=is%3Aissue+sort%3Acreated-desc+).
+- type: textarea
+  attributes:
+    label: 🐛 Describe the bug
+    description: |
+      Please provide a clear and concise description of what the bug is.
+
+      If relevant, add a minimal example so that we can reproduce the error by running the code. It is very important for the snippet to be as succinct (minimal) as possible, so please take time to trim down any irrelevant code to help us debug efficiently. We are going to copy-paste your code and we expect to get the same result as you did: avoid any external data, and include the relevant imports, etc. For example:
+
+      ```python
+      # All necessary imports at the beginning
+      import embedchain as ec
+      # Your code goes here
+
+
+      ```
+
+      Please also paste or describe the results you observe instead of the expected results. If you observe an error, please paste the error message including the **full** traceback of the exception. It may be relevant to wrap error messages in ```` ```triple quotes blocks``` ````.
+    placeholder: |
+      A clear and concise description of what the bug is.
+
+      ```python
+      Sample code to reproduce the problem
+      ```
+
+      ```
+      The error message you got, with the full traceback.
+      ````
+  validations:
+    required: true
+- type: markdown
+  attributes:
+    value: >
+      Thanks for contributing 🎉!

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,8 @@
+blank_issues_enabled: true
+contact_links:
+  - name: 1-on-1 Session
+    url: https://cal.com/taranjeetio/ec
+    about: Speak directly with Taranjeet, the founder, to discuss issues, share feedback, or explore improvements for Embedchain
+  - name: Discord
+    url: https://discord.gg/6PzXDgEjG5
+    about: General community discussions

.github/ISSUE_TEMPLATE/documentation_issue.yml

@@ -0,0 +1,11 @@
+name: Documentation
+description: Report an issue related to the Embedchain docs.
+title: "DOC: <Please write a comprehensive title after the 'DOC: ' prefix>"
+
+body:
+- type: textarea
+  attributes:
+    label: "Issue with current documentation:"
+    description: >
+      Please make sure to leave a reference to the document/code you're
+      referring to.

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,23 @@
+name: 🚀 Feature request
+description: Submit a proposal/request for a new Embedchain feature
+
+body:
+- type: textarea
+  id: feature-request
+  attributes:
+    label: 🚀 The feature
+    description: >
+      A clear and concise description of the feature proposal
+  validations:
+    required: true
+- type: textarea
+  attributes:
+    label: Motivation, pitch
+    description: >
+      Please outline the motivation for the proposal. Is your feature request related to a specific problem? e.g., *"I'm working on X and would like Y to be possible"*. If this is related to another GitHub issue, please link here too.
+  validations:
+    required: true
+- type: markdown
+  attributes:
+    value: >
+      Thanks for contributing 🎉!

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,41 @@
+## Description
+
+Please include a summary of the change and which issue is fixed. Please also include relevant motivation and context. List any dependencies that are required for this change.
+
+Fixes # (issue)
+
+## Type of change
+
+Please delete options that are not relevant.
+
+- [ ] Bug fix (non-breaking change which fixes an issue)
+- [ ] New feature (non-breaking change which adds functionality)
+- [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected)
+- [ ] Refactor (does not change functionality, e.g. code style improvements, linting)
+- [ ] Documentation update
+
+## How Has This Been Tested?
+
+Please describe the tests that you ran to verify your changes. Provide instructions so we can reproduce. Please also list any relevant details for your test configuration
+
+Please delete options that are not relevant.
+
+- [ ] Unit Test
+- [ ] Test Script (please provide)
+
+## Checklist:
+
+- [ ] My code follows the style guidelines of this project
+- [ ] I have performed a self-review of my own code
+- [ ] I have commented my code, particularly in hard-to-understand areas
+- [ ] I have made corresponding changes to the documentation
+- [ ] My changes generate no new warnings
+- [ ] I have added tests that prove my fix is effective or that my feature works
+- [ ] New and existing unit tests pass locally with my changes
+- [ ] Any dependent changes have been merged and published in downstream modules
+- [ ] I have checked my code and corrected any misspellings
+
+## Maintainer Checklist
+
+- [ ] closes #xxxx (Replace xxxx with the GitHub issue number)
+- [ ] Made sure Checks passed

.github/workflows/cd.yml

@@ -0,0 +1,47 @@
+name: Publish Python 🐍 distributions 📦 to PyPI and TestPyPI
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  build-n-publish:
+    name: Build and publish Python 🐍 distributions 📦 to PyPI and TestPyPI
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Set up Python
+        uses: actions/setup-python@v2
+        with:
+          python-version: '3.11'
+
+      - name: Install Poetry
+        run: |
+          curl -sSL https://install.python-poetry.org | python3 -
+          echo "$HOME/.local/bin" >> $GITHUB_PATH
+
+      - name: Install dependencies
+        run: |
+          cd mem0
+          poetry install
+
+      - name: Build a binary wheel and a source tarball
+        run: |
+          cd mem0
+          poetry build
+
+      # TODO: Needs to setup mem0 repo on Test PyPI
+      # - name: Publish distribution 📦 to Test PyPI
+      #   uses: pypa/gh-action-pypi-publish@release/v1
+      #   with:
+      #     repository_url: https://test.pypi.org/legacy/
+      #     packages_dir: dist/
+
+      - name: Publish distribution 📦 to PyPI
+        if: startsWith(github.ref, 'refs/tags')
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          packages_dir: dist/

.github/workflows/ci.yml

@@ -0,0 +1,102 @@
+name: ci
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - 'mem0/**'
+      - 'tests/**'
+      - 'embedchain/**'
+  pull_request:
+    paths:
+      - 'mem0/**'
+      - 'tests/**'
+      - 'embedchain/**'
+
+jobs:
+  check_changes:
+    runs-on: ubuntu-latest
+    outputs:
+      mem0_changed: ${{ steps.filter.outputs.mem0 }}
+      embedchain_changed: ${{ steps.filter.outputs.embedchain }}
+    steps:
+    - uses: actions/checkout@v3
+    - uses: dorny/paths-filter@v2
+      id: filter
+      with:
+        filters: |
+          mem0:
+            - 'mem0/**'
+            - 'tests/**'
+          embedchain:
+            - 'embedchain/**'
+
+  build_mem0:
+    needs: check_changes
+    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 }}
+        uses: actions/setup-python@v4
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install poetry
+        uses: snok/install-poetry@v1
+        with:
+          version: 1.4.2
+          virtualenvs-create: true
+          virtualenvs-in-project: true
+      - name: Load cached venv
+        id: cached-poetry-dependencies
+        uses: actions/cache@v3
+        with:
+          path: .venv
+          key: venv-mem0-${{ runner.os }}-${{ hashFiles('**/poetry.lock') }}
+      - name: Install dependencies
+        run: make install_all
+        if: steps.cached-poetry-dependencies.outputs.cache-hit != 'true'
+      - name: Run tests and generate coverage report
+        run: make test
+
+  build_embedchain:
+    needs: check_changes
+    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 }}
+        uses: actions/setup-python@v4
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install poetry
+        uses: snok/install-poetry@v1
+        with:
+          version: 1.4.2
+          virtualenvs-create: true
+          virtualenvs-in-project: true
+      - name: Load cached venv
+        id: cached-poetry-dependencies
+        uses: actions/cache@v3
+        with:
+          path: .venv
+          key: venv-embedchain-${{ runner.os }}-${{ hashFiles('**/poetry.lock') }}
+      - name: Install dependencies
+        run: cd embedchain && make install_all
+        if: steps.cached-poetry-dependencies.outputs.cache-hit != 'true'
+      - name: Lint with ruff
+        run: cd embedchain && make lint
+      - name: Run tests and generate coverage report
+        run: cd embedchain && make coverage
+      - name: Upload coverage reports to Codecov
+        uses: codecov/codecov-action@v3
+        with:
+          file: coverage.xml
+        env:
+          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}

.gitignore

@@ -2,6 +2,7 @@
 __pycache__/
 *.py[cod]
 *$py.class
+**/node_modules/
 
 # C extensions
 *.so
@@ -76,7 +77,6 @@ docs/_build/
 target/
 
 # Jupyter Notebook
-.ipynb_checkpoints
 
 # IPython
 profile_default/
@@ -104,7 +104,7 @@ ipython_config.py
 # pdm
 #   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
 #pdm.lock
-#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended not to include it
 #   in version control.
 #   https://pdm.fming.dev/#use-with-ide
 .pdm.toml
@@ -165,5 +165,24 @@ cython_debug/
 
 # Database
 db
+test-db
+!embedchain/embedchain/core/db/
 
-.vscode
+.vscode
+.idea/
+
+.DS_Store
+
+notebooks/*.yaml
+.ipynb_checkpoints/
+
+!configs/*.yaml
+
+# cache db
+*.db
+
+# local directories for testing
+eval/
+qdrant_storage/
+.crossnote
+testing.ipynb

.pre-commit-config.yaml

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

CONTRIBUTING.md

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

Makefile

@@ -1,24 +1,44 @@
-# Variables
-PYTHON := python3
-PIP := $(PYTHON) -m pip
-PROJECT_NAME := embedchain
+.PHONY: format sort lint
 
-# Targets
-.PHONY: install format lint clean test
+# Variables
+ISORT_OPTIONS = --profile black
+PROJECT_NAME := mem0ai
+
+# Default target
+all: format sort lint
 
 install:
-	$(PIP) install --upgrade pip
-	$(PIP) install -e .[dev]
+	poetry install
 
+install_all:
+	poetry install
+	poetry run pip install groq together boto3 litellm ollama chromadb weaviate weaviate-client sentence_transformers vertexai \
+	                        google-generativeai elasticsearch opensearch-py vecs pinecone pinecone-text faiss-cpu langchain-community \
+							upstash-vector azure-search-documents langchain-memgraph
+
+# Format code with ruff
 format:
-	$(PYTHON) -m black .
-	$(PYTHON) -m isort .
+	poetry run ruff format mem0/
 
+# Sort imports with isort
+sort:
+	poetry run isort mem0/
+
+# Lint code with ruff
 lint:
-	$(PYTHON) -m ruff .
+	poetry run ruff check mem0/
+
+docs:
+	cd docs && mintlify dev
+
+build:
+	poetry build
+
+publish:
+	poetry publish
 
 clean:
-	rm -rf dist build *.egg-info
+	poetry run rm -rf dist
 
 test:
-	$(PYTHON) -m pytest
+	poetry run pytest tests

README.md

@@ -1,635 +1,167 @@
-# embedchain
+<p align="center">
+  <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>
+<p align="center" style="display: flex; justify-content: center; gap: 20px; align-items: center;">
+  <a href="https://trendshift.io/repositories/11194" target="blank">
+    <img src="https://trendshift.io/api/badge/repositories/11194" alt="mem0ai%2Fmem0 | Trendshift" width="250" height="55"/>
+  </a>
+</p>
 
-[![PyPI](https://img.shields.io/pypi/v/embedchain)](https://pypi.org/project/embedchain/)
-[![Discord](https://dcbadge.vercel.app/api/server/nhvCbCtKV?style=flat)](https://discord.gg/6PzXDgEjG5)
-[![Twitter](https://img.shields.io/twitter/follow/embedchain)](https://twitter.com/embedchain)
-[![Substack](https://img.shields.io/badge/Substack-%23006f5c.svg?logo=substack)](https://embedchain.substack.com/)
+<p align="center">
+  <a href="https://mem0.ai">Learn more</a>
+  ·
+  <a href="https://mem0.dev/DiG">Join Discord</a>
+  ·
+  <a href="https://mem0.dev/demo">Demo</a>
+</p>
 
-embedchain is a framework to easily create LLM powered bots over any dataset. If you want a javascript version, check out [embedchain-js](https://github.com/embedchain/embedchainjs)
+<p align="center">
+  <a href="https://mem0.dev/DiG">
+    <img src="https://dcbadge.vercel.app/api/server/6PzXDgEjG5?style=flat" alt="Mem0 Discord">
+  </a>
+  <a href="https://pepy.tech/project/mem0ai">
+    <img src="https://img.shields.io/pypi/dm/mem0ai" alt="Mem0 PyPI - Downloads">
+  </a>
+  <a href="https://github.com/mem0ai/mem0">
+    <img src="https://img.shields.io/github/commit-activity/m/mem0ai/mem0?style=flat-square" alt="GitHub commit activity">
+  </a>
+  <a href="https://pypi.org/project/mem0ai" target="blank">
+    <img src="https://img.shields.io/pypi/v/mem0ai?color=%2334D058&label=pypi%20package" alt="Package version">
+  </a>
+  <a href="https://www.npmjs.com/package/mem0ai" target="blank">
+    <img src="https://img.shields.io/npm/v/mem0ai" alt="Npm package">
+  </a>
+  <a href="https://www.ycombinator.com/companies/mem0">
+    <img src="https://img.shields.io/badge/Y%20Combinator-S24-orange?style=flat-square" alt="Y Combinator S24">
+  </a>
+</p>
 
-# Table of Contents
+<p align="center">
+  <a href="https://mem0.ai/research"><strong>📄 Building Production-Ready AI Agents with Scalable Long-Term Memory →</strong></a>
+</p>
+<p align="center">
+  <strong>⚡ +26% Accuracy vs. OpenAI Memory • 🚀 91% Faster • 💰 90% Fewer Tokens</strong>
+</p>
 
-- [Latest Updates](#latest-updates)
-- [What is embedchain?](#what-is-embedchain)
-- [Getting Started](#getting-started)
-  - [Installation](#installation)
-  - [Usage](#usage)
-    - [App Types](#app-types)
-      - [1. App (uses OpenAI models, paid)](#1-app-uses-openai-models-paid)
-      - [2. OpenSourceApp (uses opensource models, free)](#2-opensourceapp-uses-opensource-models-free)
-      - [3. PersonApp (uses OpenAI models, paid)](#3-personapp-uses-openai-models-paid)
-    - [Add Dataset](#add-dataset)
-  - [Interface Types](#interface-types)
-    - [Query Interface](#query-interface)
-    - [Chat Interface](#chat-interface)
-  - [Format supported](#format-supported)
-    - [Youtube Video](#youtube-video)
-    - [PDF File](#pdf-file)
-    - [Web Page](#web-page)
-    - [Doc File](#doc-file)
-    - [Text](#text)
-    - [QnA Pair](#qna-pair)
-    - [Reusing a Vector DB](#reusing-a-vector-db)
-    - [More Formats coming soon](#more-formats-coming-soon)
-  - [Testing](#testing)
-- [Advanced](#advanced)
-  - [Configuration](#configuration)
-    - [Example](#example)
-    - [Configs](#configs)
-      - [InitConfig](#initconfig)
-      - [Add Config](#add-config)
-      - [Query Config](#query-config)
-      - [Chat Config](#chat-config)
-  - [Other methods](#other-methods)
-    - [Reset](#reset)
-    - [Count](#count)
-- [How does it work?](#how-does-it-work)
-- [Contribution Guidelines](#contribution-guidelines)
-- [Tech Stack](#tech-stack)
-- [Team](#team)
-  - [Author](#author)
-  - [Maintainer](#maintainer)
-  - [Citation](#citation)
+##  🔥 Research Highlights
+- **+26% Accuracy** over OpenAI Memory on the LOCOMO benchmark
+- **91% Faster Responses** than full-context, ensuring low-latency at scale
+- **90% Lower Token Usage** than full-context, cutting costs without compromise
+- [Read the full paper](https://mem0.ai/research)
 
-# Latest Updates
+# Introduction
 
-- Introduce a new interface called `chat`. It remembers the history (last 5 messages) and can be used to powerful stateful bots. You can use it by calling `.chat` on any app instance. Works for both OpenAI and OpenSourceApp.
+[Mem0](https://mem0.ai) ("mem-zero") enhances AI assistants and agents with an intelligent memory layer, enabling personalized AI interactions. It remembers user preferences, adapts to individual needs, and continuously learns over time—ideal for customer support chatbots, AI assistants, and autonomous systems.
 
-- Introduce a new app type called `OpenSourceApp`. It uses `gpt4all` as the LLM and `sentence transformers` all-MiniLM-L6-v2 as the embedding model. If you use this app, you dont have to pay for anything.
+### Key Features & Use Cases
 
-# What is embedchain?
+**Core Capabilities:**
+- **Multi-Level Memory**: Seamlessly retains User, Session, and Agent state with adaptive personalization
+- **Developer-Friendly**: Intuitive API, cross-platform SDKs, and a fully managed service option
 
-Embedchain abstracts the entire process of loading a dataset, chunking it, creating embeddings and then storing in a vector database.
+**Applications:**
+- **AI Assistants**: Consistent, context-rich conversations
+- **Customer Support**: Recall past tickets and user history for tailored help
+- **Healthcare**: Track patient preferences and history for personalized care
+- **Productivity & Gaming**: Adaptive workflows and environments based on user behavior
 
-You can add a single or multiple dataset using `.add` and `.add_local` function and then use `.query` function to find an answer from the added datasets.
+## 🚀 Quickstart Guide <a name="quickstart"></a>
 
-If you want to create a Naval Ravikant bot which has 1 youtube video, 1 book as pdf and 2 of his blog posts, as well as a question and answer pair you supply, all you need to do is add the links to the videos, pdf and blog posts and the QnA pair and embedchain will create a bot for you.
+Choose between our hosted platform or self-hosted package:
 
-```python
+### Hosted Platform
 
-from embedchain import App
+Get up and running in minutes with automatic updates, analytics, and enterprise security.
 
-naval_chat_bot = App()
+1. Sign up on [Mem0 Platform](https://app.mem0.ai)
+2. Embed the memory layer via SDK or API keys
 
-# Embed Online Resources
-naval_chat_bot.add("youtube_video", "https://www.youtube.com/watch?v=3qHkcs3kG44")
-naval_chat_bot.add("pdf_file", "https://navalmanack.s3.amazonaws.com/Eric-Jorgenson_The-Almanack-of-Naval-Ravikant_Final.pdf")
-naval_chat_bot.add("web_page", "https://nav.al/feedback")
-naval_chat_bot.add("web_page", "https://nav.al/agi")
+### Self-Hosted (Open Source)
 
-# Embed Local Resources
-naval_chat_bot.add_local("qna_pair", ("Who is Naval Ravikant?", "Naval Ravikant is an Indian-American entrepreneur and investor."))
-
-naval_chat_bot.query("What unique capacity does Naval argue humans possess when it comes to understanding explanations or concepts?")
-# answer: Naval argues that humans possess the unique capacity to understand explanations or concepts to the maximum extent possible in this physical reality.
-```
-
-# Getting Started
-
-## Installation
-
-First make sure that you have the package installed. If not, then install it using `pip`
+Install the sdk via pip:
 
 ```bash
-pip install embedchain
+pip install mem0ai
 ```
 
-## Usage
-
-Creating a chatbot involves 3 steps:
-
-- Import the App instance (App Types)
-- Add Dataset (Add Dataset)
-- Query or Chat on the dataset and get answers (Interface Types)
-
-### App Types
-
-We have three types of App.
-
-#### 1. App (uses OpenAI models, paid)
-
-```python
-from embedchain import App
-
-naval_chat_bot = App()
-```
-
-- `App` uses OpenAI's model, so these are paid models. You will be charged for embedding model usage and LLM usage.
-
-- `App` uses OpenAI's embedding model to create embeddings for chunks and ChatGPT API as LLM to get answer given the relevant docs. Make sure that you have an OpenAI account and an API key. If you have don't have an API key, you can create one by visiting [this link](https://platform.openai.com/account/api-keys).
-
-- Once you have the API key, set it in an environment variable called `OPENAI_API_KEY`
-
-```python
-import os
-os.environ["OPENAI_API_KEY"] = "sk-xxxx"
-```
-
-#### 2. OpenSourceApp (uses opensource models, free)
-
-```python
-from embedchain import OpenSourceApp
-
-naval_chat_bot = OpenSourceApp()
-```
-
-- `OpenSourceApp` uses open source embedding and LLM model. It uses `all-MiniLM-L6-v2` from Sentence Transformers library as the embedding model and `gpt4all` as the LLM.
-
-- Here there is no need to setup any api keys. You just need to install embedchain package and these will get automatically installed.
-
-- Once you have imported and instantiated the app, every functionality from here onwards is the same for either type of app.
-
-#### 3. PersonApp (uses OpenAI models, paid)
-
-```python
-from embedchain import PersonApp
-
-naval_chat_bot = PersonApp("name_of_person_or_character") #Like "Yoda"
-```
-
-- `PersonApp` uses OpenAI's model, so these are paid models. You will be charged for embedding model usage and LLM usage.
-
-- `PersonApp` uses OpenAI's embedding model to create embeddings for chunks and ChatGPT API as LLM to get answer given the relevant docs. Make sure that you have an OpenAI account and an API key. If you have don't have an API key, you can create one by visiting [this link](https://platform.openai.com/account/api-keys).
-
-- Once you have the API key, set it in an environment variable called `OPENAI_API_KEY`
-
-```python
-import os
-os.environ["OPENAI_API_KEY"] = "sk-xxxx"
-```
-
-### Add Dataset
-
-- This step assumes that you have already created an `app` instance by either using `App` or `OpenSourceApp`. We are calling our app instance as `naval_chat_bot`
-
-- Now use `.add` function to add any dataset.
-
-```python
-
-# naval_chat_bot = App() or
-# naval_chat_bot = OpenSourceApp()
-
-# Embed Online Resources
-naval_chat_bot.add("youtube_video", "https://www.youtube.com/watch?v=3qHkcs3kG44")
-naval_chat_bot.add("pdf_file", "https://navalmanack.s3.amazonaws.com/Eric-Jorgenson_The-Almanack-of-Naval-Ravikant_Final.pdf")
-naval_chat_bot.add("web_page", "https://nav.al/feedback")
-naval_chat_bot.add("web_page", "https://nav.al/agi")
-
-# Embed Local Resources
-naval_chat_bot.add_local("qna_pair", ("Who is Naval Ravikant?", "Naval Ravikant is an Indian-American entrepreneur and investor."))
-```
-
-- If there is any other app instance in your script or app, you can change the import as
-
-```python
-from embedchain import App as EmbedChainApp
-from embedchain import OpenSourceApp as EmbedChainOSApp
-from embedchain import PersonApp as EmbedChainPersonApp
-
-# or
-
-from embedchain import App as ECApp
-from embedchain import OpenSourceApp as ECOSApp
-from embedchain import PersonApp as ECPApp
-```
-
-## Interface Types
-
-### Query Interface
-
-- This interface is like a question answering bot. It takes a question and gets the answer. It does not maintain context about the previous chats.
-
-- To use this, call `.query` function to get the answer for any query.
-
-```python
-print(naval_chat_bot.query("What unique capacity does Naval argue humans possess when it comes to understanding explanations or concepts?"))
-# answer: Naval argues that humans possess the unique capacity to understand explanations or concepts to the maximum extent possible in this physical reality.
-```
-
-### Chat Interface
-
-- This interface is chat interface where it remembers previous conversation. Right now it remembers 5 conversation by default.
-
-- To use this, call `.chat` function to get the answer for any query.
-
-```python
-print(naval_chat_bot.chat("How to be happy in life?"))
-# answer: The most important trick to being happy is to realize happiness is a skill you develop and a choice you make. You choose to be happy, and then you work at it. It's just like building muscles or succeeding at your job. It's about recognizing the abundance and gifts around you at all times.
-
-print(naval_chat_bot.chat("who is naval ravikant?"))
-# answer: Naval Ravikant is an Indian-American entrepreneur and investor.
-
-print(naval_chat_bot.chat("what did the author say about happiness?"))
-# answer: The author, Naval Ravikant, believes that happiness is a choice you make and a skill you develop. He compares the mind to the body, stating that just as the body can be molded and changed, so can the mind. He emphasizes the importance of being present in the moment and not getting caught up in regrets of the past or worries about the future. By being present and grateful for where you are, you can experience true happiness.
-```
-
-### Stream Response
-
-- You can add config to your query method to stream responses like ChatGPT does. You would require a downstream handler to render the chunk in your desirable format. Supports both OpenAI model and OpenSourceApp.
-
-- To use this, instantiate a `QueryConfig` or `ChatConfig` object with `stream=True`. Then pass it to the `.chat()` or `.query()` method. The following example iterates through the chunks and prints them as they appear.
-
-```python
-app = App()
-query_config = QueryConfig(stream = True)
-resp = app.query("What unique capacity does Naval argue humans possess when it comes to understanding explanations or concepts?", query_config)
-
-for chunk in resp:
-    print(chunk, end="", flush=True)
-# answer: Naval argues that humans possess the unique capacity to understand explanations or concepts to the maximum extent possible in this physical reality.
-```
-
-## Format supported
-
-We support the following formats:
-
-### Youtube Video
-
-To add any youtube video to your app, use the data_type (first argument to `.add`) as `youtube_video`. Eg:
-
-```python
-app.add('youtube_video', 'a_valid_youtube_url_here')
-```
-
-### PDF File
-
-To add any pdf file, use the data_type as `pdf_file`. Eg:
-
-```python
-app.add('pdf_file', 'a_valid_url_where_pdf_file_can_be_accessed')
-```
-
-Note that we do not support password protected pdfs.
-
-### Web Page
-
-To add any web page, use the data_type as `web_page`. Eg:
-
-```python
-app.add('web_page', 'a_valid_web_page_url')
-```
-
-### Doc File
-
-To add any doc/docx file, use the data_type as `docx`. Eg:
-
-```python
-app.add('docx', 'a_local_docx_file_path')
-```
-
-### Text
-
-To supply your own text, use the data_type as `text` and enter a string. The text is not processed, this can be very versatile. Eg:
-
-```python
-app.add_local('text', 'Seek wealth, not money or status. Wealth is having assets that earn while you sleep. Money is how we transfer time and wealth. Status is your place in the social hierarchy.')
-```
-
-Note: This is not used in the examples because in most cases you will supply a whole paragraph or file, which did not fit.
-
-### QnA Pair
-
-To supply your own QnA pair, use the data_type as `qna_pair` and enter a tuple. Eg:
-
-```python
-app.add_local('qna_pair', ("Question", "Answer"))
-```
-### Sitemap
-
-To add a XML site map containing list of all urls, use the data_type as `sitemap` and enter the sitemap url. Eg:
-
-```python
-app.add('sitemap', 'a_valid_sitemap_url/sitemap.xml')
-```
-
-### Reusing a Vector DB
-
-Default behavior is to create a persistent vector DB in the directory **./db**. You can split your application into two Python scripts: one to create a local vector DB and the other to reuse this local persistent vector DB. This is useful when you want to index hundreds of documents and separately implement a chat interface.
-
-Create a local index:
-
-```python
-
-from embedchain import App
-
-naval_chat_bot = App()
-naval_chat_bot.add("youtube_video", "https://www.youtube.com/watch?v=3qHkcs3kG44")
-naval_chat_bot.add("pdf_file", "https://navalmanack.s3.amazonaws.com/Eric-Jorgenson_The-Almanack-of-Naval-Ravikant_Final.pdf")
-```
-
-You can reuse the local index with the same code, but without adding new documents:
-
-```python
-
-from embedchain import App
-
-naval_chat_bot = App()
-print(naval_chat_bot.query("What unique capacity does Naval argue humans possess when it comes to understanding explanations or concepts?"))
-```
-
-### More Formats coming soon
-
-- If you want to add any other format, please create an [issue](https://github.com/embedchain/embedchain/issues) and we will add it to the list of supported formats.
-
-## Testing
-
-Before you consume valueable tokens, you should make sure that the embedding you have done works and that it's receiving the correct document from the database.
-
-For this you can use the `dry_run` method.
-
-Following the example above, add this to your script:
-
-```python
-print(naval_chat_bot.dry_run('Can you tell me who Naval Ravikant is?'))
-
-'''
-Use the following pieces of context to answer the query at the end. If you don't know the answer, just say that you don't know, don't try to make up an answer.
-        Q: Who is Naval Ravikant?
-A: Naval Ravikant is an Indian-American entrepreneur and investor.
-        Query: Can you tell me who Naval Ravikant is?
-        Helpful Answer:
-'''
-```
-
-_The embedding is confirmed to work as expected. It returns the right document, even if the question is asked slightly different. No prompt tokens have been consumed._
-
-**The dry run will still consume tokens to embed your query, but it is only ~1/15 of the prompt.**
-
-## Colab Notebook and Video Tutorials
-
-Chinese Colab Tutorial:https://colab.research.google.com/drive/10_7Y0x4YXWVjuhhYwVraGQLpKAatTQTm?usp=sharing
-
-Chinese Video Tutorial:https://www.bilibili.com/video/BV1YX4y1H7oN
-
-# Advanced
-
-## Configuration
-
-Embedchain is made to work out of the box. However, for advanced users we're also offering configuration options. All of these configuration options are optional and have sane defaults.
-
-### Example
-
-Here's the readme example with configuration options.
-
-```python
-import os
-from embedchain import App
-from embedchain.config import InitConfig, AddConfig, QueryConfig
-from chromadb.utils import embedding_functions
-
-# Example: use your own embedding function
-config = InitConfig(ef=embedding_functions.OpenAIEmbeddingFunction(
-                api_key=os.getenv("OPENAI_API_KEY"),
-                organization_id=os.getenv("OPENAI_ORGANIZATION"),
-                model_name="text-embedding-ada-002"
-            ))
-naval_chat_bot = App(config)
-
-# Example: define your own chunker config for `youtube_video`
-youtube_add_config = {
-        "chunker": {
-                "chunk_size": 1000,
-                "chunk_overlap": 100,
-                "length_function": len,
-        }
-}
-naval_chat_bot.add("youtube_video", "https://www.youtube.com/watch?v=3qHkcs3kG44", AddConfig(**youtube_add_config))
-
-add_config = AddConfig()
-naval_chat_bot.add("pdf_file", "https://navalmanack.s3.amazonaws.com/Eric-Jorgenson_The-Almanack-of-Naval-Ravikant_Final.pdf", add_config)
-naval_chat_bot.add("web_page", "https://nav.al/feedback", add_config)
-naval_chat_bot.add("web_page", "https://nav.al/agi", add_config)
-
-naval_chat_bot.add_local("qna_pair", ("Who is Naval Ravikant?", "Naval Ravikant is an Indian-American entrepreneur and investor."), add_config)
-
-query_config = QueryConfig() # Currently no options
-print(naval_chat_bot.query("What unique capacity does Naval argue humans possess when it comes to understanding explanations or concepts?", query_config))
-```
-
-Here's the example of using custom prompt template with `.query`
-
-```python
-from embedchain.config import QueryConfig
-from embedchain.embedchain import App
-from string import Template
-import wikipedia
-
-einstein_chat_bot = App()
-
-# Embed Wikipedia page
-page = wikipedia.page("Albert Einstein")
-einstein_chat_bot.add("text", page.content)
-
-# Example: use your own custom template with `$context` and `$query`
-einstein_chat_template = Template("""
-        You are Albert Einstein, a German-born theoretical physicist,
-        widely ranked among the greatest and most influential scientists of all time.
-
-        Use the following information about Albert Einstein to respond to 
-        the human's query acting as Albert Einstein.
-        Context: $context                                
-
-        Keep the response brief. If you don't know the answer, just say that you don't know, don't try to make up an answer.
-
-        Human: $query
-        Albert Einstein:""")
-query_config = QueryConfig(einstein_chat_template)
-queries = [
-        "Where did you complete your studies?",
-        "Why did you win nobel prize?",
-        "Why did you divorce your first wife?",
-]
-for query in queries:
-        response = einstein_chat_bot.query(query, query_config)
-        print("Query: ", query)
-        print("Response: ", response)
-
-# Output
-# Query:  Where did you complete your studies?
-# Response:  I completed my secondary education at the Argovian cantonal school in Aarau, Switzerland.
-# Query:  Why did you win nobel prize?
-# Response:  I won the Nobel Prize in Physics in 1921 for my services to Theoretical Physics, particularly for my discovery of the law of the photoelectric effect.
-# Query:  Why did you divorce your first wife?
-# Response:  We divorced due to living apart for five years.
-```
-
-**Client Mode**. By defining a (ChromaDB) server, you can run EmbedChain as a client only.
-
-```python
-from embedchain import App
-config = InitConfig(host="localhost", port="8080")
-app = App(config)
-```
-This is useful for scalability. Say you have EmbedChain behind an API with multiple workers. If you separate clients and server, all clients can connect to the server, which only has to keep one instance of the database in memory. You also don't have to worry about replication.
-
-To run a chroma db server, run `git clone https://github.com/chroma-core/chroma.git`, navigate to the directory (`cd chroma`) and then start the server with `docker-compose up -d --build`.
-
-### Configs
-
-This section describes all possible config options.
-
-#### **InitConfig**
-
-|option|description|type|default|
-|---|---|---|---|
-|log_level|log level|string|WARNING|
-|ef|embedding function|chromadb.utils.embedding_functions|{text-embedding-ada-002}|
-|db|vector database (experimental)|BaseVectorDB|ChromaDB|
-|host|hostname for (Chroma) DB server|string|None|
-|port|port number for (Chroma) DB server|string, int|None|
-
-#### **Add Config**
-
-|option|description|type|default|
-|---|---|---|---|
-|chunker|chunker config|ChunkerConfig|Default values for chunker depends on the `data_type`. Please refer [ChunkerConfig](#chunker-config)|
-|loader|loader config|LoaderConfig|None|
-
-##### **Chunker Config**
-
-|option|description|type|default|
-|---|---|---|---|
-|chunk_size|Maximum size of chunks to return|int|Default value for various `data_type` mentioned below|
-|chunk_overlap|Overlap in characters between chunks|int|Default value for various `data_type` mentioned below|
-|length_function|Function that measures the length of given chunks|typing.Callable|Default value for various `data_type` mentioned below|
-
-Default values of chunker config parameters for different `data_type`:
-
-|data_type|chunk_size|chunk_overlap|length_function|
-|---|---|---|---|
-|docx|1000|0|len|
-|text|300|0|len|
-|qna_pair|300|0|len|
-|web_page|500|0|len|
-|pdf_file|1000|0|len|
-|youtube_video|2000|0|len|
-
-##### **Loader Config**
-
-_coming soon_
-
-#### **Query Config**
-
-|option|description|type|default|
-|---|---|---|---|
-|number_documents|number of documents to be retrieved as context|int|1|
-|template|custom template for prompt|Template|Template("Use the following pieces of context to answer the query at the end. If you don't know the answer, just say that you don't know, don't try to make up an answer. \$context Query: $query Helpful Answer:")|
-|history|include conversation history from your client or database|any (recommendation: list[str])|None
-|stream|control if response is streamed back to the user|bool|False|
-|model|OpenAI model|string|gpt-3.5-turbo-0613|
-|temperature|creativity of the model (0-1)|float|0|
-|max_tokens|limit maximum tokens used|int|1000|
-|top_p|diversity of words used by the model (0-1)|float|1|
-
-#### **Chat Config**
-
-All options for query and...
-
-_coming soon_
-
-history is handled automatically, the config option is not supported.
-
-## Other methods
-
-### Reset
-
-Resets the database and deletes all embeddings. Irreversible. Requires reinitialization afterwards.
-
-```python
-app.reset()
-```
-
-### Count
-
-Counts the number of embeddings (chunks) in the database.
-
-```python
-print(app.count())
-# returns: 481
-```
-
-# How does it work?
-
-Creating a chat bot over any dataset needs the following steps to happen
-
-- load the data
-- create meaningful chunks
-- create embeddings for each chunk
-- store the chunks in vector database
-
-Whenever a user asks any query, following process happens to find the answer for the query
-
-- create the embedding for query
-- find similar documents for this query from vector database
-- pass similar documents as context to LLM to get the final answer.
-
-The process of loading the dataset and then querying involves multiple steps and each steps has nuances of it is own.
-
-- How should I chunk the data? What is a meaningful chunk size?
-- How should I create embeddings for each chunk? Which embedding model should I use?
-- How should I store the chunks in vector database? Which vector database should I use?
-- Should I store meta data along with the embeddings?
-- How should I find similar documents for a query? Which ranking model should I use?
-
-These questions may be trivial for some but for a lot of us, it needs research, experimentation and time to find out the accurate answers.
-
-embedchain is a framework which takes care of all these nuances and provides a simple interface to create bots over any dataset.
-
-In the first release, we are making it easier for anyone to get a chatbot over any dataset up and running in less than a minute. All you need to do is create an app instance, add the data sets using `.add` function and then use `.query` function to get the relevant answer.
-
-# Contribution Guidelines
-
-Thank you for your interest in contributing to the EmbedChain project! We welcome your ideas and contributions to help improve the project. Please follow the instructions below to get started:
-
-1. **Fork the repository**: Click on the "Fork" button at the top right corner of this repository page. This will create a copy of the repository in your own GitHub account.
-
-2. **Install the required dependencies**: Ensure that you have the necessary dependencies installed in your Python environment. You can do this by running the following command:
-
+Install sdk via npm:
 ```bash
-make install
+npm install mem0ai
 ```
 
-3. **Make changes in the code**: Create a new branch in your forked repository and make your desired changes in the codebase.
-4. **Format code**: Before creating a pull request, it's important to ensure that your code follows our formatting guidelines. Run the following commands to format the code:
+### Basic Usage
 
-```bash
-make lint format
+Mem0 requires an LLM to function, with `gpt-4o-mini` from OpenAI as the default. However, it supports a variety of LLMs; for details, refer to our [Supported LLMs documentation](https://docs.mem0.ai/components/llms/overview).
+
+First step is to instantiate the memory:
+
+```python
+from openai import OpenAI
+from mem0 import Memory
+
+openai_client = OpenAI()
+memory = Memory()
+
+def chat_with_memories(message: str, user_id: str = "default_user") -> str:
+    # Retrieve relevant memories
+    relevant_memories = memory.search(query=message, user_id=user_id, limit=3)
+    memories_str = "\n".join(f"- {entry['memory']}" for entry in relevant_memories["results"])
+
+    # Generate Assistant response
+    system_prompt = f"You are a helpful AI. Answer the question based on query and memories.\nUser Memories:\n{memories_str}"
+    messages = [{"role": "system", "content": system_prompt}, {"role": "user", "content": message}]
+    response = openai_client.chat.completions.create(model="gpt-4o-mini", messages=messages)
+    assistant_response = response.choices[0].message.content
+
+    # Create new memories from the conversation
+    messages.append({"role": "assistant", "content": assistant_response})
+    memory.add(messages, user_id=user_id)
+
+    return assistant_response
+
+def main():
+    print("Chat with AI (type 'exit' to quit)")
+    while True:
+        user_input = input("You: ").strip()
+        if user_input.lower() == 'exit':
+            print("Goodbye!")
+            break
+        print(f"AI: {chat_with_memories(user_input)}")
+
+if __name__ == "__main__":
+    main()
 ```
 
-5. **Create a pull request**: When you are ready to contribute your changes, submit a pull request to the EmbedChain repository. Provide a clear and descriptive title for your pull request, along with a detailed description of the changes you have made.
+For detailed integration steps, see the [Quickstart](https://docs.mem0.ai/quickstart) and [API Reference](https://docs.mem0.ai/api-reference).
 
-# Tech Stack
+## 🔗 Integrations & Demos
 
-embedchain is built on the following stack:
+- **ChatGPT with Memory**: Personalized chat powered by Mem0 ([Live Demo](https://mem0.dev/demo))
+- **Browser Extension**: Store memories across ChatGPT, Perplexity, and Claude ([Chrome Extension](https://chromewebstore.google.com/detail/onihkkbipkfeijkadecaafbgagkhglop?utm_source=item-share-cb))
+- **Langgraph Support**: Build a customer bot with Langgraph + Mem0 ([Guide](https://docs.mem0.ai/integrations/langgraph))
+- **CrewAI Integration**: Tailor CrewAI outputs with Mem0 ([Example](https://docs.mem0.ai/integrations/crewai))
 
-- [Langchain](https://github.com/hwchase17/langchain) as an LLM framework to load, chunk and index data
-- [OpenAI's Ada embedding model](https://platform.openai.com/docs/guides/embeddings) to create embeddings
-- [OpenAI's ChatGPT API](https://platform.openai.com/docs/guides/gpt/chat-completions-api) as LLM to get answers given the context
-- [Chroma](https://github.com/chroma-core/chroma) as the vector database to store embeddings
-- [gpt4all](https://github.com/nomic-ai/gpt4all) as an open source LLM
-- [sentence-transformers](https://huggingface.co/sentence-transformers) as open source embedding model
+## 📚 Documentation & Support
 
-# Team
-
-## Author
-
-- Taranjeet Singh ([@taranjeetio](https://twitter.com/taranjeetio))
-
-## Maintainer
-
-- [cachho](https://github.com/cachho)
+- Full docs: https://docs.mem0.ai
+- Community: [Discord](https://mem0.dev/DiG) · [Twitter](https://x.com/mem0ai)
+- Contact: founders@mem0.ai
 
 ## Citation
 
-If you utilize this repository, please consider citing it with:
+We now have a paper you can cite:
 
-```
-@misc{embedchain,
-  author = {Taranjeet Singh},
-  title = {Embechain: Framework to easily create LLM powered bots over any dataset},
-  year = {2023},
-  publisher = {GitHub},
-  journal = {GitHub repository},
-  howpublished = {\url{https://github.com/embedchain/embedchain}},
+```bibtex
+@article{mem0,
+  title={Mem0: Building Production-Ready AI Agents with Scalable Long-Term Memory},
+  author={Chhikara, Prateek and Khant, Dev and Aryan, Saket and Singh, Taranjeet and Yadav, Deshraj},
+  journal={arXiv preprint arXiv:2504.19413},
+  year={2025}
 }
 ```
+
+## ⚖️ License
+
+Apache 2.0 — see the [LICENSE](LICENSE) file for details.

cookbooks/customer-support-chatbot.ipynb

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

cookbooks/helper/mem0_teachability.py

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

docs/README.md

@@ -0,0 +1,32 @@
+# Mintlify Starter Kit
+
+Click on `Use this template` to copy the Mintlify starter kit. The starter kit contains examples including
+
+- Guide pages
+- Navigation
+- Customizations
+- API Reference pages
+- Use of popular components
+
+### Development
+
+Install the [Mintlify CLI](https://www.npmjs.com/package/mintlify) to preview the documentation changes locally. To install, use the following command
+
+```
+npm i -g mintlify
+```
+
+Run the following command at the root of your documentation (where mint.json is)
+
+```
+mintlify dev
+```
+
+### Publishing Changes
+
+Install our Github App to auto propagate changes from your repo to your deployment. Changes will be deployed to production automatically after pushing to the default branch. Find the link to install on your dashboard. 
+
+#### Troubleshooting
+
+- Mintlify dev isn't running - Run `mintlify install` it'll re-install dependencies.
+- Page loads as a 404 - Make sure you are running in a folder with `mint.json`

docs/_snippets/get-help.mdx

@@ -0,0 +1,11 @@
+<CardGroup cols={3}>
+  <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>
+</CardGroup>

docs/_snippets/paper-release.mdx

@@ -0,0 +1,3 @@
+<Note type="info">
+  📢 Announcing our research paper: Mem0 achieves <strong>26%</strong> higher accuracy than OpenAI Memory, <strong>91%</strong> lower latency, and <strong>90%</strong> token savings! [Read the paper](https://mem0.ai/research) to learn how we're revolutionizing AI agent memory.
+</Note>

docs/api-reference.mdx

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

docs/api-reference/memory/feedback.mdx

@@ -0,0 +1,4 @@
+---
+title: 'Feedback'
+openapi: post /v1/feedback/
+---

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,43 @@
+---
+title: 'Get Memories (v2)'
+openapi: post /v2/memories/
+---
+
+The v2 get memories API is powerful and flexible, allowing for more precise memory listing without the need for a search query. It supports complex logical operations (AND, OR) and comparison operators for advanced filtering capabilities. The comparison operators include:
+- `in`: Matches any of the values specified
+- `gte`: Greater than or equal to
+- `lte`: Less than or equal to
+- `gt`: Greater than
+- `lt`: Less than
+
+<CodeGroup>
+```python Code
+memories = m.get_all(
+    filters={
+        "AND": [
+            {
+                "user_id": "alex"
+            },
+            {
+                "created_at": {"gte": "2024-07-01", "lte": "2024-07-31"}
+            }
+        ]
+    },
+    version="v2"
+)
+```
+
+```json Output
+[
+{
+    "id":"f38b689d-6b24-45b7-bced-17fbb4d8bac7",
+    "memory":"Name: Alex. Vegetarian. Allergic to nuts.",
+    "user_id":"alex",
+    "hash":"62bc074f56d1f909f1b4c2b639f56f6a",
+    "metadata":null,
+    "created_at":"2024-07-25T23:57:00.108347-07:00",
+    "updated_at":"2024-07-25T23:57:00.108367-07:00"
+}
+]
+```
+</CodeGroup>

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

@@ -0,0 +1,51 @@
+---
+title: 'Search Memories (v2)'
+openapi: post /v2/memories/search/
+---
+
+The v2 search API is powerful and flexible, allowing for more precise memory retrieval. It supports complex logical operations (AND, OR) and comparison operators for advanced filtering capabilities. The comparison operators include:
+- `in`: Matches any of the values specified
+- `gte`: Greater than or equal to
+- `lte`: Less than or equal to
+- `gt`: Greater than
+- `lt`: Less than
+- `ne`: Not equal to
+- `icontains`: Case-insensitive containment check
+
+  <CodeGroup>
+  ```python Code
+  related_memories = m.search(
+      query="What are Alice's hobbies?",
+      version="v2",
+      filters={
+          "AND": [
+              {
+                "user_id": "alice"
+              },
+              {
+                "agent_id": {"in": ["travel-agent", "sports-agent"]}
+              }
+          ]
+      },
+  )
+  ```
+
+  ```json Output
+  {
+    "memories": [
+      {
+        "id": "ea925981-272f-40dd-b576-be64e4871429",
+        "memory": "Likes to play cricket and plays cricket on weekends.",
+        "metadata": {
+          "category": "hobbies"
+        },
+        "score": 0.32116443111457704,
+        "created_at": "2024-07-26T10:29:36.630547-07:00",
+        "updated_at": null,
+        "user_id": "alice",
+        "agent_id": "sports-agent"
+      }
+    ],
+  }
+  ```
+  </CodeGroup>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

docs/changelog.mdx

@@ -0,0 +1,481 @@
+---
+title: "Product Updates"
+mode: "wide"
+---
+
+<Snippet file="paper-release.mdx" />
+
+<Tabs>
+<Tab title="Python">
+
+<Update label="2025-04-26" description="v0.1.94">
+
+**New Features:**
+- **Integrations:** Added Memgraph integration
+- **Memory:** Added timestamp support
+- **Vector Stores:** Added reset function for VectorDBs
+
+**Improvements:**
+- **Documentation:** 
+  - Updated timestamp and expiration_date documentation
+  - Fixed v2 search documentation
+  - Added "memory" in EC "Custom config" section
+  - Fixed typos in the json config sample
+
+</Update>
+
+<Update label="2025-04-21" description="v0.1.93">
+
+**Improvements:**
+- **Vector Stores:** Initialized embedding_model_dims in all vectordbs
+
+**Bug Fixes:**
+- **Documentation:** Fixed agno link
+
+</Update>
+
+<Update label="2025-04-18" description="v0.1.92">
+
+**New Features:**
+- **Memory:** Added Memory Reset functionality
+- **Client:** Added support for Custom Instructions
+- **Examples:** Added Fitness Checker powered by memory
+
+**Improvements:**
+- **Core:** Updated capture_event
+- **Documentation:** Fixed curl for v2 get_all
+
+**Bug Fixes:**
+- **Vector Store:** Fixed user_id functionality
+- **Client:** Various client improvements
+
+</Update>
+
+<Update label="2025-04-16" description="v0.1.91">
+
+**New Features:**
+- **LLM Integrations:** Added Azure OpenAI Embedding Model
+- **Examples:** 
+  - Added movie recommendation using grok3
+  - Added Voice Assistant using Elevenlabs
+
+**Improvements:**
+- **Documentation:** 
+  - Added keywords AI
+  - Reformatted navbar page URLs
+  - Updated changelog
+  - Updated openai.mdx
+- **FAISS:** Silenced FAISS info logs
+
+</Update>
+
+<Update label="2025-04-11" description="v0.1.90">
+
+**New Features:**
+- **LLM Integrations:** Added Mistral AI as LLM provider
+
+**Improvements:**
+- **Documentation:** 
+  - Updated changelog
+  - Fixed memory exclusion example
+  - Updated xAI documentation
+  - Updated YouTube Chrome extension example documentation
+
+**Bug Fixes:**
+- **Core:** Fixed EmbedderFactory.create() in GraphMemory
+- **Azure OpenAI:** Added patch to fix Azure OpenAI
+- **Telemetry:** Fixed telemetry issue
+
+</Update>
+
+<Update label="2025-04-11" description="v0.1.89">
+
+**New Features:**
+- **Langchain Integration:** Added support for Langchain VectorStores
+- **Examples:** 
+  - Added personal assistant example
+  - Added personal study buddy example
+  - Added YouTube assistant Chrome extension example
+  - Added agno example
+  - Updated OpenAI Responses API examples
+- **Vector Store:** Added capability to store user_id in vector database
+- **Async Memory:** Added async support for OSS
+
+**Improvements:**
+- **Documentation:** Updated formatting and examples
+
+</Update>
+
+<Update label="2025-04-09" description="v0.1.87">
+
+**New Features:**
+- **Upstash Vector:** Added support for Upstash Vector store
+
+**Improvements:**
+- **Code Quality:** Removed redundant code lines
+- **Build:** Updated MAKEFILE
+- **Documentation:** Updated memory export documentation
+
+</Update>
+
+<Update label="2025-04-07" description="v0.1.86">
+
+**Improvements:**
+- **FAISS:** Added embedding_dims parameter to FAISS vector store
+
+</Update>
+
+<Update label="2025-04-07" description="v0.1.84">
+
+**New Features:**
+- **Langchain Embedder:** Added Langchain embedder integration
+
+**Improvements:**
+- **Langchain LLM:** Updated Langchain LLM integration to directly pass the Langchain object LLM
+</Update>
+
+<Update label="2025-04-07" description="v0.1.83">
+
+**Bug Fixes:**
+- **Langchain LLM:** Fixed issues with Langchain LLM integration
+</Update>
+
+<Update label="2025-04-07" description="v0.1.82">
+
+**New Features:**
+- **LLM Integrations:** Added support for Langchain LLMs, Google as new LLM and embedder
+- **Development:** Added development docker compose
+
+**Improvements:**
+- **Output Format:** Set output_format='v1.1' and updated documentation
+
+**Documentation:**
+- **Integrations:** Added LMStudio and Together.ai documentation
+- **API Reference:** Updated output_format documentation
+- **Integrations:** Added PipeCat integration documentation
+- **Integrations:** Added Flowise integration documentation for Mem0 memory setup
+
+**Bug Fixes:**
+- **Tests:** Fixed failing unit tests
+</Update>
+
+<Update label="2025-04-02" description="v0.1.79">
+
+**New Features:**
+- **FAISS Support:** Added FAISS vector store support
+
+</Update>
+
+<Update label="2025-04-02" description="v0.1.78">
+
+**New Features:**
+- **Livekit Integration:** Added Mem0 livekit example
+- **Evaluation:** Added evaluation framework and tools
+
+**Documentation:**
+- **Multimodal:** Updated multimodal documentation
+- **Examples:** Added examples for email processing
+- **API Reference:** Updated API reference section
+- **Elevenlabs:** Added Elevenlabs integration example
+
+**Bug Fixes:**
+- **OpenAI Environment Variables:** Fixed issues with OpenAI environment variables
+- **Deployment Errors:** Added `package.json` file to fix deployment errors
+- **Tools:** Fixed tools issues and improved formatting
+- **Docs:** Updated API reference section for `expiration date`
+</Update>
+
+<Update label="2025-03-26" description="v0.1.77">
+
+**Bug Fixes:**
+- **OpenAI Environment Variables:** Fixed issues with OpenAI environment variables
+- **Deployment Errors:** Added `package.json` file to fix deployment errors
+- **Tools:** Fixed tools issues and improved formatting
+- **Docs:** Updated API reference section for `expiration date`
+</Update>
+
+<Update label="2025-03-19" description="v0.1.76">
+**New Features:**
+- **Supabase Vector Store:** Added support for Supabase Vector Store
+- **Supabase History DB:** Added Supabase History DB to run Mem0 OSS on Serverless
+- **Feedback Method:** Added feedback method to client
+
+**Bug Fixes:**
+- **Azure OpenAI:** Fixed issues with Azure OpenAI
+- **Azure AI Search:** Fixed test cases for Azure AI Search
+</Update>
+
+</Tab>
+
+<Tab title="TypeScript">
+
+<Update label="2025-05-02" description="v2.1.22">
+**New Features:**
+- **Client:** Updated `deleteUser` to use `entity_id` and `entity_type`
+</Update>
+
+<Update label="2025-05-01" description="v2.1.21">
+**Improvements:**
+- **OSS SDK:** Bumped version of `@anthropic-ai/sdk` to `0.40.1`
+</Update>
+
+<Update label="2025-04-28" description="v2.1.20">
+**Improvements:**
+- **Client:** Fixed `organizationId` and `projectId` being asssigned to default in `ping` method
+</Update>
+
+<Update label="2025-04-22" description="v2.1.19">
+**Improvements:**
+- **Client:** Added support for `timestamps`
+</Update>
+
+<Update label="2025-04-17" description="v2.1.18">
+**Improvements:**
+- **Client:** Added support for custom instructions
+</Update>
+
+<Update label="2025-04-15" description="v2.1.17">
+**New Features:**
+- **OSS SDK:** Added support for Langchain LLM
+- **OSS SDK:** Added support for Langchain Embedder
+- **OSS SDK:** Added support for Langchain Vector Store
+- **OSS SDK:** Added support for Azure OpenAI Embedder
+
+
+**Improvements:**
+- **OSS SDK:** Changed `model` in LLM and Embedder to use type any from `string` to use langchain llm models
+- **OSS SDK:** Added client to vector store config for langchain vector store
+- **OSS SDK:** - Updated Azure OpenAI to use new OpenAI SDK
+</Update>
+
+<Update label="2025-04-11" description="v2.1.16-patch.1">
+**Bug Fixes:**
+- **Azure OpenAI:** Fixed issues with Azure OpenAI
+</Update>
+
+<Update label="2025-04-11" description="v2.1.16">
+**New Features:**
+- **Azure OpenAI:** Added support for Azure OpenAI
+- **Mistral LLM:** Added Mistral LLM integration in OSS
+
+**Improvements:**
+- **Zod:** Updated Zod to 3.24.1 to avoid conflicts with other packages
+</Update>
+
+<Update label="2025-04-09" description="v2.1.15">
+**Improvements:**
+- **Client:** Added support for Mem0 to work with Chrome Extensions
+</Update>
+
+<Update label="2025-04-01" description="v2.1.14">
+**New Features:**
+- **Mastra Example:** Added Mastra example
+- **Integrations:** Added Flowise integration documentation for Mem0 memory setup
+
+**Improvements:**
+- **Demo:** Updated Demo Mem0AI
+- **Client:** Enhanced Ping method in Mem0 Client
+- **AI SDK:** Updated AI SDK implementation
+</Update>
+
+<Update label="2025-03-29" description="v2.1.13">
+**Improvements:**
+- **Introuced `ping` method to check if API key is valid and populate org/project id**
+</Update>
+
+<Update label="2025-03-29" description="AI SDK v1.0.0">
+**New Features:**
+- **Vercel AI SDK Update:** Support threshold and rerank
+
+**Improvements:**
+- **Made add calls async to avoid blocking**
+- **Bump `mem0ai` to use `2.1.12`**
+
+</Update>
+
+<Update label="2025-03-26" description="v2.1.12">
+**New Features:**
+- **Mem0 OSS:** Support infer param
+
+**Improvements:**
+- **Updated Supabase TS Docs**
+- **Made package size smaller**
+
+</Update>
+
+<Update label="2025-03-19" description="v2.1.11">
+**New Features:**
+- **Supabase Vector Store Integration**
+- **Feedback Method**
+</Update>
+
+</Tab>
+
+<Tab title="Platform">
+
+<Update label="2025-04-26" description="">
+
+**Improvements:**
+- **Performance:** Parallelized embedding calls
+- **Monitoring:** Added timing for LLM calls
+- **Search:** Added category checking in Search V2
+- **Bug Fixes:** Fixed issues with ADD filters
+- **Graph:** Implemented new graph updates
+
+</Update>
+
+<Update label="2025-04-25" description="">
+
+**Improvements:**
+- **Memory:** Fixed memory export functionality
+- **Analytics:** Added logging for project
+
+</Update>
+
+<Update label="2025-04-24" description="">
+
+**Improvements:**
+- **Output:** Added memory_type display for ADD output
+
+</Update>
+
+<Update label="2025-04-23" description="">
+
+**New Features:**
+- **UI:** Added new Pricing Component
+- **Memory:** Implemented Long/Short term memory categorization
+- **Output:** Modified serializer to hide memory_type
+
+**Documentation:**
+- Updated README for deployment
+
+</Update>
+
+<Update label="2025-04-22" description="">
+
+**New Features:**
+- **Memory:** Added timestamp to ADD call
+
+**Bug Fixes:**
+- Fixed issues with coreV2
+
+</Update>
+
+<Update label="2025-04-21" description="">
+
+**New Features:**
+- **Memory:** Implemented backdating with migrations and backfilling script
+
+</Update>
+
+<Update label="2025-04-17" description="">
+
+**New Features:**
+- **Billing:** Integrated Stripe Billing Dashboard
+- **Admin:** Added webhook creation functionality
+
+**Bug Fixes:**
+- Fixed Users Page issues
+- Fixed Custom Categories
+- Fixed Table components
+- Updated Stripe configuration
+
+</Update>
+
+<Update label="2025-04-16" description="">
+
+**Improvements:**
+- **Performance:** Made Admin panel and Memory Page faster
+- **Security:** Implemented active session cancellation
+- **Analytics:** Added Stripe customer ID capture
+
+</Update>
+
+<Update label="2025-04-12" description="">
+
+**New Features:**
+- **Memory Management:** 
+  - Added ability to delete memories from Project level with filters
+  - Added delete memories capability on Memories Page
+- **Memory Visualization:** Released V1 Graph Memory Visualization
+- **Graph Playground:** Enabled for @mem0.ai users
+- **Notifications:** Added email alerts to organization owners when new members join
+- **Memory Export:** Added date support for filtering memory exports
+
+**Improvements:**
+- **Performance:** 
+  - Optimized graph for better performance
+  - Optimized database calls in ADD method
+- **Analytics:** Added flagging of paid users in Posthog
+- **CI/CD:** Improved CI pipeline and fixed lint issues
+
+</Update>
+
+<Update label="2025-04-10" description="">
+
+**New Features:**
+- **Notifications:** Implemented email notifications for organization owners when new members join
+
+**Improvements:**
+- **CI/CD:** Fixed Dockerfile for CI tests
+
+</Update>
+
+<Update label="2025-04-09" description="">
+
+**Improvements:**
+- **Integrations:** Updated chat model for Together Qwen
+- **Platform:** Removed older platforms
+- **Bug Fixes:** Fixed FILTER_MAPPING
+
+</Update>
+
+<Update label="2025-04-03" description="">
+
+**New Features:**
+- **Memory:** Added implicit memory capabilities
+- **API:** Improved implicit lambda and get_all v2 functionality
+
+</Update>
+
+<Update label="2025-04-02" description="">
+
+**New Features:**
+- **Integrations:** Added Clay integration
+
+**Improvements:**
+- **Integrations:** Removed deepseek coder from Together
+- **API:** Added custom instructions for add v2
+
+</Update>
+
+<Update label="2025-03-31" description="">
+
+**Security:**
+- **Validation:** Added key validation in messages
+
+</Update>
+
+<Update label="2025-03-28" description="">
+- **Updated Playground Prompt**
+- **Send Email on User Addition to Org/Proj**
+- **Fix Search Entity**
+</Update>
+
+<Update label="2025-03-19" description="">
+- **General Stability & Performance Improvements**
+</Update>
+
+</Tab>
+
+<Tab title="Vercel AI SDK">
+
+<Update label="2025-05-01" description="v1.0.1">
+**New Features:**
+- **Vercel AI SDK:** Added support for graph memories
+</Update>
+
+</Tab>
+
+</Tabs>
+

docs/components/embedders/config.mdx

@@ -0,0 +1,102 @@
+---
+title: Configurations
+icon: "gear"
+iconType: "solid"
+---
+
+<Snippet file="paper-release.mdx" />
+
+Config in mem0 is a dictionary that specifies the settings for your embedding models. It allows you to customize the behavior and connection details of your chosen embedder.
+
+## How to define configurations?
+
+The config is defined as an object (or dictionary) with two main keys:
+- `embedder`: Specifies the embedder provider and its configuration
+  - `provider`: The name of the embedder (e.g., "openai", "ollama")
+  - `config`: A nested object or dictionary containing provider-specific settings
+
+
+## How to use configurations?
+
+Here's a general example of how to use the config with mem0:
+
+<CodeGroup>
+```python Python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "sk-xx"
+
+config = {
+    "embedder": {
+        "provider": "your_chosen_provider",
+        "config": {
+            # Provider-specific settings go here
+        }
+    }
+}
+
+m = Memory.from_config(config)
+m.add("Your text here", user_id="user", metadata={"category": "example"})
+```
+
+```typescript TypeScript
+import { Memory } from 'mem0ai/oss';
+
+const config = {
+  embedder: {
+    provider: 'openai',
+    config: {
+      apiKey: process.env.OPENAI_API_KEY || '',
+      model: 'text-embedding-3-small',
+      // Provider-specific settings go here
+    },
+  },
+};
+
+const memory = new Memory(config);
+await memory.add("Your text here", { userId: "user", metadata: { category: "example" } });
+```
+</CodeGroup>
+
+## Why is Config Needed?
+
+Config is essential for:
+1. Specifying which embedding model to use.
+2. Providing necessary connection details (e.g., model, api_key, embedding_dims).
+3. Ensuring proper initialization and connection to your chosen embedder.
+
+## Master List of All Params in Config
+
+Here's a comprehensive list of all parameters that can be used across different embedders:
+
+<Tabs>
+<Tab title="Python">
+| Parameter | Description | Provider |
+|-----------|-------------|----------|
+| `model` | Embedding model to use | All |
+| `api_key` | API key of the provider | All |
+| `embedding_dims` | Dimensions of the embedding model | All |
+| `http_client_proxies` | Allow proxy server settings | All |
+| `ollama_base_url` | Base URL for the Ollama embedding model | Ollama |
+| `model_kwargs` | Key-Value arguments for the Huggingface embedding model | Huggingface |
+| `azure_kwargs` | Key-Value arguments for the AzureOpenAI embedding model | Azure OpenAI |
+| `openai_base_url`    | Base URL for OpenAI API                       | OpenAI            |
+| `vertex_credentials_json` | Path to the Google Cloud credentials JSON file for VertexAI                       | VertexAI            |
+| `memory_add_embedding_type` | The type of embedding to use for the add memory action                       | VertexAI            |
+| `memory_update_embedding_type` | The type of embedding to use for the update memory action                       | VertexAI            |
+| `memory_search_embedding_type` | The type of embedding to use for the search memory action                       | VertexAI            |
+| `lmstudio_base_url` | Base URL for LM Studio API                    | LM Studio         |
+</Tab>
+<Tab title="TypeScript">
+| Parameter | Description | Provider |
+|-----------|-------------|----------|
+| `model` | Embedding model to use | All |
+| `apiKey` | API key of the provider | All |
+| `embeddingDims` | Dimensions of the embedding model | All |
+</Tab>
+</Tabs>
+
+## Supported Embedding Models
+
+For detailed information on configuring specific embedders, please visit the [Embedding Models](./models) section. There you'll find information for each supported embedder with provider-specific usage examples and configuration details.

docs/components/embedders/models/azure_openai.mdx

@@ -0,0 +1,88 @@
+---
+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
+
+<CodeGroup>
+```python Python
+import os
+from mem0 import Memory
+
+os.environ["EMBEDDING_AZURE_OPENAI_API_KEY"] = "your-api-key"
+os.environ["EMBEDDING_AZURE_DEPLOYMENT"] = "your-deployment-name"
+os.environ["EMBEDDING_AZURE_ENDPOINT"] = "your-api-base-url"
+os.environ["EMBEDDING_AZURE_API_VERSION"] = "version-to-use"
+
+os.environ["OPENAI_API_KEY"] = "your_api_key" # For LLM
+
+
+config = {
+    "embedder": {
+        "provider": "azure_openai",
+        "config": {
+            "model": "text-embedding-3-large"
+            "azure_kwargs": {
+                  "api_version": "",
+                  "azure_deployment": "",
+                  "azure_endpoint": "",
+                  "api_key": "",
+                  "default_headers": {
+                    "CustomHeader": "your-custom-header",
+                  }
+              }
+        }
+    }
+}
+
+m = Memory.from_config(config)
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+m.add(messages, user_id="john")
+```
+
+```typescript TypeScript
+import { Memory } from 'mem0ai/oss';
+
+const config = {
+    embedder: {
+        provider: "azure_openai",
+        config: {
+            model: "text-embedding-3-large",
+            modelProperties: {
+                endpoint: "your-api-base-url",
+                deployment: "your-deployment-name",
+                apiVersion: "version-to-use",
+            }
+        }
+    }
+}
+
+const memory = new Memory(config);
+
+const messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+
+await memory.add(messages, { userId: "john" });
+```
+</CodeGroup>
+
+### Config
+
+Here are the parameters available for configuring Azure OpenAI embedder:
+
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `model` | The name of the embedding model to use | `text-embedding-3-small` |
+| `embedding_dims` | Dimensions of the embedding model | `1536` |
+| `azure_kwargs` | The Azure OpenAI configs | `config_keys` |

docs/components/embedders/models/gemini.mdx

@@ -0,0 +1,43 @@
+---
+title: Gemini
+---
+
+To use Gemini embedding models, set the `GOOGLE_API_KEY` environment variables. You can obtain the Gemini API key from [here](https://aistudio.google.com/app/apikey).
+
+### Usage
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["GOOGLE_API_KEY"] = "key"
+os.environ["OPENAI_API_KEY"] = "your_api_key" # For LLM
+
+config = {
+    "embedder": {
+        "provider": "gemini",
+        "config": {
+            "model": "models/text-embedding-004",
+        }
+    }
+}
+
+m = Memory.from_config(config)
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+m.add(messages, user_id="john")
+```
+
+### Config
+
+Here are the parameters available for configuring Gemini embedder:
+
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `model` | The name of the embedding model to use | `models/text-embedding-004` |
+| `embedding_dims` | Dimensions of the embedding model | `768` |
+| `api_key` | The Gemini API key | `None` |

docs/components/embedders/models/huggingface.mdx

@@ -0,0 +1,42 @@
+---
+title: Hugging Face
+---
+
+You can use embedding models from Huggingface to run Mem0 locally.
+
+### Usage
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "your_api_key" # For LLM
+
+config = {
+    "embedder": {
+        "provider": "huggingface",
+        "config": {
+            "model": "multi-qa-MiniLM-L6-cos-v1"
+        }
+    }
+}
+
+m = Memory.from_config(config)
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+m.add(messages, user_id="john")
+```
+
+### Config
+
+Here are the parameters available for configuring Huggingface embedder:
+
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `model` | The name of the model to use | `multi-qa-MiniLM-L6-cos-v1` |
+| `embedding_dims` | Dimensions of the embedding model | `selected_model_dimensions` |
+| `model_kwargs` | Additional arguments for the model | `None` |

docs/components/embedders/models/langchain.mdx

@@ -0,0 +1,146 @@
+---
+title: LangChain
+---
+
+Mem0 supports LangChain as a provider to access a wide range of embedding models. LangChain is a framework for developing applications powered by language models, making it easy to integrate various embedding providers through a consistent interface.
+
+For a complete list of available embedding models supported by LangChain, refer to the [LangChain Text Embedding documentation](https://python.langchain.com/docs/integrations/text_embedding/).
+
+## Usage
+
+<CodeGroup>
+```python Python
+import os
+from mem0 import Memory
+from langchain_openai import OpenAIEmbeddings
+
+# Set necessary environment variables for your chosen LangChain provider
+os.environ["OPENAI_API_KEY"] = "your-api-key"
+
+# Initialize a LangChain embeddings model directly
+openai_embeddings = OpenAIEmbeddings(
+    model="text-embedding-3-small",
+    dimensions=1536
+)
+
+# Pass the initialized model to the config
+config = {
+    "embedder": {
+        "provider": "langchain",
+        "config": {
+            "model": openai_embeddings
+        }
+    }
+}
+
+m = Memory.from_config(config)
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
+```
+
+```typescript TypeScript
+import { Memory } from "mem0ai";
+import { OpenAIEmbeddings } from "@langchain/openai";
+
+const embeddings = new OpenAIEmbeddings();
+const config = {
+    "embedder": {
+        "provider": "langchain",
+        "config": {
+            "model": embeddings
+        }
+    }
+}
+
+const memory = new Memory(config);
+
+const messages = [
+    { role: "user", content: "I'm planning to watch a movie tonight. Any recommendations?" },
+    { role: "assistant", content: "How about a thriller movies? They can be quite engaging." },
+    { role: "user", content: "I'm not a big fan of thriller movies but I love sci-fi movies." },
+    { role: "assistant", content: "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future." }
+]
+
+memory.add(messages, user_id="alice", metadata={"category": "movies"})
+```
+</CodeGroup>
+
+## Supported LangChain Embedding Providers
+
+LangChain supports a wide range of embedding providers, including:
+
+- OpenAI (`OpenAIEmbeddings`)
+- Cohere (`CohereEmbeddings`)
+- Google (`VertexAIEmbeddings`)
+- Hugging Face (`HuggingFaceEmbeddings`)
+- Sentence Transformers (`HuggingFaceEmbeddings`)
+- Azure OpenAI (`AzureOpenAIEmbeddings`)
+- Ollama (`OllamaEmbeddings`)
+- Together (`TogetherEmbeddings`)
+- And many more
+
+You can use any of these model instances directly in your configuration. For a complete and up-to-date list of available embedding providers, refer to the [LangChain Text Embedding documentation](https://python.langchain.com/docs/integrations/text_embedding/).
+
+## Provider-Specific Configuration
+
+When using LangChain as an embedder provider, you'll need to:
+
+1. Set the appropriate environment variables for your chosen embedding provider
+2. Import and initialize the specific model class you want to use
+3. Pass the initialized model instance to the config
+
+### Examples with Different Providers
+
+#### HuggingFace Embeddings
+
+```python
+from langchain_huggingface import HuggingFaceEmbeddings
+
+# Initialize a HuggingFace embeddings model
+hf_embeddings = HuggingFaceEmbeddings(
+    model_name="BAAI/bge-small-en-v1.5",
+    encode_kwargs={"normalize_embeddings": True}
+)
+
+config = {
+    "embedder": {
+        "provider": "langchain",
+        "config": {
+            "model": hf_embeddings
+        }
+    }
+}
+```
+
+#### Ollama Embeddings
+
+```python
+from langchain_ollama import OllamaEmbeddings
+
+# Initialize an Ollama embeddings model
+ollama_embeddings = OllamaEmbeddings(
+    model="nomic-embed-text"
+)
+
+config = {
+    "embedder": {
+        "provider": "langchain",
+        "config": {
+            "model": ollama_embeddings
+        }
+    }
+}
+```
+
+<Note>
+  Make sure to install the necessary LangChain packages and any provider-specific dependencies.
+</Note>
+
+## Config
+
+All available parameters for the `langchain` embedder config are present in [Master List of All Params in Config](../config).

docs/components/embedders/models/lmstudio.mdx

@@ -0,0 +1,38 @@
+You can use embedding models from LM Studio to run Mem0 locally.
+
+### Usage
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "your_api_key" # For LLM
+
+config = {
+    "embedder": {
+        "provider": "lmstudio",
+        "config": {
+            "model": "nomic-embed-text-v1.5-GGUF/nomic-embed-text-v1.5.f16.gguf"
+        }
+    }
+}
+
+m = Memory.from_config(config)
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+m.add(messages, user_id="john")
+```
+
+### Config
+
+Here are the parameters available for configuring Ollama embedder:
+
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `model` | The name of the OpenAI model to use | `nomic-embed-text-v1.5-GGUF/nomic-embed-text-v1.5.f16.gguf` |
+| `embedding_dims` | Dimensions of the embedding model | `1536` |
+| `lmstudio_base_url` | Base URL for LM Studio connection | `http://localhost:1234/v1` |

docs/components/embedders/models/ollama.mdx

@@ -0,0 +1,38 @@
+You can use embedding models from Ollama to run Mem0 locally.
+
+### Usage
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "your_api_key" # For LLM
+
+config = {
+    "embedder": {
+        "provider": "ollama",
+        "config": {
+            "model": "mxbai-embed-large"
+        }
+    }
+}
+
+m = Memory.from_config(config)
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+m.add(messages, user_id="john")
+```
+
+### Config
+
+Here are the parameters available for configuring Ollama embedder:
+
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `model` | The name of the OpenAI model to use | `nomic-embed-text` |
+| `embedding_dims` | Dimensions of the embedding model | `512` |
+| `ollama_base_url` | Base URL for ollama connection | `None` |

docs/components/embedders/models/openai.mdx

@@ -0,0 +1,72 @@
+---
+title: OpenAI
+---
+
+To use OpenAI embedding models, set the `OPENAI_API_KEY` environment variable. You can obtain the OpenAI API key from the [OpenAI Platform](https://platform.openai.com/account/api-keys).
+
+### Usage
+
+<CodeGroup>
+```python Python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "your_api_key"
+
+config = {
+    "embedder": {
+        "provider": "openai",
+        "config": {
+            "model": "text-embedding-3-large"
+        }
+    }
+}
+
+m = Memory.from_config(config)
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+m.add(messages, user_id="john")
+```
+
+```typescript TypeScript
+import { Memory } from 'mem0ai/oss';
+
+const config = {
+  embedder: {
+    provider: 'openai',
+    config: {
+      apiKey: 'your-openai-api-key',
+      model: 'text-embedding-3-large',
+    },
+  },
+};
+
+const memory = new Memory(config);
+await memory.add("I'm visiting Paris", { userId: "john" });
+```
+</CodeGroup>
+
+### Config
+
+Here are the parameters available for configuring OpenAI embedder:
+
+<Tabs>
+<Tab title="Python">
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `model` | The name of the embedding model to use | `text-embedding-3-small` |
+| `embedding_dims` | Dimensions of the embedding model | `1536` |
+| `api_key` | The OpenAI API key | `None` |
+</Tab>
+<Tab title="TypeScript">
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `model` | The name of the embedding model to use | `text-embedding-3-small` |
+| `embeddingDims` | Dimensions of the embedding model | `1536` |
+| `apiKey` | The OpenAI API key | `None` |
+</Tab>
+</Tabs>

docs/components/embedders/models/together.mdx

@@ -0,0 +1,45 @@
+---
+title: Together
+---
+
+To use Together embedding models, set the `TOGETHER_API_KEY` environment variable. You can obtain the Together API key from the [Together Platform](https://api.together.xyz/settings/api-keys).
+
+### Usage
+
+<Note> The `embedding_model_dims` parameter for `vector_store` should be set to `768` for Together embedder. </Note>
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["TOGETHER_API_KEY"] = "your_api_key"
+os.environ["OPENAI_API_KEY"] = "your_api_key" # For LLM
+
+config = {
+    "embedder": {
+        "provider": "together",
+        "config": {
+            "model": "togethercomputer/m2-bert-80M-8k-retrieval"
+        }
+    }
+}
+
+m = Memory.from_config(config)
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+m.add(messages, user_id="john")
+```
+
+### Config
+
+Here are the parameters available for configuring Together embedder:
+
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `model` | The name of the embedding model to use | `togethercomputer/m2-bert-80M-8k-retrieval` |
+| `embedding_dims` | Dimensions of the embedding model | `768` |
+| `api_key` | The Together API key | `None` |

docs/components/embedders/models/vertexai.mdx

@@ -0,0 +1,55 @@
+### Vertex AI
+
+To use Google Cloud's Vertex AI for text embedding models, set the `GOOGLE_APPLICATION_CREDENTIALS` environment variable to point to the path of your service account's credentials JSON file. These credentials can be created in the [Google Cloud Console](https://console.cloud.google.com/).
+
+### Usage
+
+```python
+import os
+from mem0 import Memory
+
+# Set the path to your Google Cloud credentials JSON file
+os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = "/path/to/your/credentials.json"
+os.environ["OPENAI_API_KEY"] = "your_api_key" # For LLM
+
+config = {
+    "embedder": {
+        "provider": "vertexai",
+        "config": {
+            "model": "text-embedding-004",
+            "memory_add_embedding_type": "RETRIEVAL_DOCUMENT",
+            "memory_update_embedding_type": "RETRIEVAL_DOCUMENT",
+            "memory_search_embedding_type": "RETRIEVAL_QUERY"
+        }
+    }
+}
+
+m = Memory.from_config(config)
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+m.add(messages, user_id="john")
+```
+The embedding types can be one of the following:
+- SEMANTIC_SIMILARITY
+- CLASSIFICATION
+- CLUSTERING
+- RETRIEVAL_DOCUMENT, RETRIEVAL_QUERY, QUESTION_ANSWERING, FACT_VERIFICATION
+- CODE_RETRIEVAL_QUERY  
+Check out the [Vertex AI documentation](https://cloud.google.com/vertex-ai/generative-ai/docs/embeddings/task-types#supported_task_types) for more information.  
+  
+### Config
+
+Here are the parameters available for configuring the Vertex AI embedder:
+
+| Parameter                 | Description                                      | Default Value        |
+| ------------------------- | ------------------------------------------------ | -------------------- |
+| `model`                   | The name of the Vertex AI embedding model to use | `text-embedding-004` |
+| `vertex_credentials_json` | Path to the Google Cloud credentials JSON file   | `None`               |
+| `embedding_dims`          | Dimensions of the embedding model                | `256`                |
+| `memory_add_embedding_type` | The type of embedding to use for the add memory action | `RETRIEVAL_DOCUMENT` |
+| `memory_update_embedding_type` | The type of embedding to use for the update memory action | `RETRIEVAL_DOCUMENT` |
+| `memory_search_embedding_type` | The type of embedding to use for the search memory action | `RETRIEVAL_QUERY` |

docs/components/embedders/overview.mdx

@@ -0,0 +1,35 @@
+---
+title: Overview
+icon: "info"
+iconType: "solid"
+---
+
+<Snippet file="paper-release.mdx" />
+
+Mem0 offers support for various embedding models, allowing users to choose the one that best suits their needs.
+
+## Supported Embedders
+
+See the list of supported embedders below.
+
+<Note>
+  The following embedders are supported in the Python implementation. The TypeScript implementation currently only supports OpenAI.
+</Note>
+
+<CardGroup cols={4}>
+  <Card title="OpenAI" href="/components/embedders/models/openai"></Card>
+  <Card title="Azure OpenAI" href="/components/embedders/models/azure_openai"></Card>
+  <Card title="Ollama" href="/components/embedders/models/ollama"></Card>
+  <Card title="Hugging Face" href="/components/embedders/models/huggingface"></Card>
+  <Card title="Gemini" href="/components/embedders/models/gemini"></Card>
+  <Card title="Vertex AI" href="/components/embedders/models/vertexai"></Card>
+  <Card title="Together" href="/components/embedders/models/together"></Card>
+  <Card title="LM Studio" href="/components/embedders/models/lmstudio"></Card>
+  <Card title="Langchain" href="/components/embedders/models/langchain"></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,130 @@
+---
+title: Configurations
+icon: "gear"
+iconType: "solid"
+---
+
+<Snippet file="paper-release.mdx" />
+
+## How to define configurations?
+
+<Tabs>
+  <Tab title="Python">
+    The `config` is defined as a Python dictionary with two main keys:
+    - `llm`: Specifies the llm provider and its configuration
+      - `provider`: The name of the llm (e.g., "openai", "groq")
+      - `config`: A nested dictionary containing provider-specific settings
+  </Tab>
+  <Tab title="TypeScript">
+    The `config` is defined as a TypeScript object with these keys:
+    - `llm`: Specifies the LLM provider and its configuration (required)
+      - `provider`: The name of the LLM (e.g., "openai", "groq")
+      - `config`: A nested object containing provider-specific settings
+    - `embedder`: Specifies the embedder provider and its configuration (optional)
+    - `vectorStore`: Specifies the vector store provider and its configuration (optional)
+    - `historyDbPath`: Path to the history database file (optional)
+  </Tab>
+</Tabs>
+
+### Config Values Precedence
+
+Config values are applied in the following order of precedence (from highest to lowest):
+
+1. Values explicitly set in the `config` object/dictionary
+2. Environment variables (e.g., `OPENAI_API_KEY`, `OPENAI_BASE_URL`)
+3. Default values defined in the LLM implementation
+
+This means that values specified in the `config` will override corresponding environment variables, which in turn override default values.
+
+## How to Use Config
+
+Here's a general example of how to use the config with Mem0:
+
+<CodeGroup>
+```python Python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "sk-xx" # for embedder
+
+config = {
+    "llm": {
+        "provider": "your_chosen_provider",
+        "config": {
+            # Provider-specific settings go here
+        }
+    }
+}
+
+m = Memory.from_config(config)
+m.add("Your text here", user_id="user", metadata={"category": "example"})
+```
+
+```typescript TypeScript
+import { Memory } from 'mem0ai/oss';
+
+// Minimal configuration with just the LLM settings
+const config = {
+  llm: {
+    provider: 'your_chosen_provider',
+    config: {
+      // Provider-specific settings go here
+    }
+  }
+};
+
+const memory = new Memory(config);
+await memory.add("Your text here", { userId: "user123", metadata: { category: "example" } });
+```
+</CodeGroup>
+
+## Why is Config Needed?
+
+Config is essential for:
+1. Specifying which LLM to use.
+2. Providing necessary connection details (e.g., model, api_key, temperature).
+3. Ensuring proper initialization and connection to your chosen LLM.
+
+## Master List of All Params in Config
+
+Here's a comprehensive list of all parameters that can be used across different LLMs:
+
+<Tabs>
+  <Tab title="Python">
+    | Parameter            | Description                                   | Provider          |
+    |----------------------|-----------------------------------------------|-------------------|
+    | `model`              | Embedding model to use                        | All               |
+    | `temperature`        | Temperature of the model                      | All               |
+    | `api_key`            | API key to use                                | All               |
+    | `max_tokens`         | Tokens to generate                            | All               |
+    | `top_p`              | Probability threshold for nucleus sampling    | All               |
+    | `top_k`              | Number of highest probability tokens to keep  | All               |
+    | `http_client_proxies`| Allow proxy server settings                   | AzureOpenAI       |
+    | `models`             | List of models                                | Openrouter        |
+    | `route`              | Routing strategy                              | Openrouter        |
+    | `openrouter_base_url`| Base URL for Openrouter API                   | Openrouter        |
+    | `site_url`           | Site URL                                      | Openrouter        |
+    | `app_name`           | Application name                              | Openrouter        |
+    | `ollama_base_url`    | Base URL for Ollama API                       | Ollama            |
+    | `openai_base_url`    | Base URL for OpenAI API                       | OpenAI            |
+    | `azure_kwargs`       | Azure LLM args for initialization             | AzureOpenAI       |
+    | `deepseek_base_url`  | Base URL for DeepSeek API                     | DeepSeek          |
+    | `xai_base_url`       | Base URL for XAI API                          | XAI               |
+    | `lmstudio_base_url`  | Base URL for LM Studio API                    | LM Studio         |
+  </Tab>
+  <Tab title="TypeScript">
+    | Parameter            | Description                                   | Provider          |
+    |----------------------|-----------------------------------------------|-------------------|
+    | `model`              | Embedding model to use                        | All               |
+    | `temperature`        | Temperature of the model                      | All               |
+    | `apiKey`             | API key to use                                | All               |
+    | `maxTokens`          | Tokens to generate                            | All               |
+    | `topP`               | Probability threshold for nucleus sampling    | All               |
+    | `topK`               | Number of highest probability tokens to keep  | All               |
+    | `openaiBaseUrl`      | Base URL for OpenAI API                       | OpenAI            |
+  </Tab>
+</Tabs>
+
+## Supported LLMs
+
+For detailed information on configuring specific LLMs, please visit the [LLMs](./models) section. There you'll find information for each supported LLM with provider-specific usage examples and configuration details.

docs/components/llms/models/anthropic.mdx

@@ -0,0 +1,68 @@
+---
+title: Anthropic
+---
+
+<Snippet file="paper-release.mdx" />
+
+To use anthropic's models, please set the `ANTHROPIC_API_KEY` which you find on their [Account Settings Page](https://console.anthropic.com/account/keys).
+
+## Usage
+
+<CodeGroup>
+```python Python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "your-api-key" # used for embedding model
+os.environ["ANTHROPIC_API_KEY"] = "your-api-key"
+
+config = {
+    "llm": {
+        "provider": "anthropic",
+        "config": {
+            "model": "claude-3-7-sonnet-latest",
+            "temperature": 0.1,
+            "max_tokens": 2000,
+        }
+    }
+}
+
+m = Memory.from_config(config)
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
+```
+
+```typescript TypeScript
+import { Memory } from 'mem0ai/oss';
+
+const config = {
+  llm: {
+    provider: 'anthropic',
+    config: {
+      apiKey: process.env.ANTHROPIC_API_KEY || '',
+      model: 'claude-3-7-sonnet-latest',
+      temperature: 0.1,
+      maxTokens: 2000,
+    },
+  },
+};
+
+const memory = new Memory(config);
+const messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+await memory.add(messages, { userId: "alice", metadata: { category: "movies" } });
+```
+</CodeGroup>
+
+## Config
+
+All available parameters for the `anthropic` config are present in [Master List of All Params in Config](../config).

docs/components/llms/models/aws_bedrock.mdx

@@ -0,0 +1,46 @@
+---
+title: AWS Bedrock
+---
+
+<Snippet file="paper-release.mdx" />
+
+### Setup
+- Before using the AWS Bedrock LLM, make sure you have the appropriate model access from [Bedrock Console](https://us-east-1.console.aws.amazon.com/bedrock/home?region=us-east-1#/modelaccess).
+- You will also need to authenticate the `boto3` client by using a method in the [AWS documentation](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html#configuring-credentials)
+- You will have to export `AWS_REGION`, `AWS_ACCESS_KEY`, and `AWS_SECRET_ACCESS_KEY` to set environment variables.
+
+### Usage
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "your-api-key" # used for embedding model
+os.environ['AWS_REGION'] = 'us-east-1'
+os.environ["AWS_ACCESS_KEY"] = "xx"
+os.environ["AWS_SECRET_ACCESS_KEY"] = "xx"
+
+config = {
+    "llm": {
+        "provider": "aws_bedrock",
+        "config": {
+            "model": "arn:aws:bedrock:us-east-1:123456789012:model/your-model-name",
+            "temperature": 0.2,
+            "max_tokens": 2000,
+        }
+    }
+}
+
+m = Memory.from_config(config)
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
+```
+
+### Config
+
+All available parameters for the `aws_bedrock` config are present in [Master List of All Params in Config](../config).

docs/components/llms/models/azure_openai.mdx

@@ -0,0 +1,121 @@
+---
+title: Azure OpenAI
+---
+
+<Snippet file="paper-release.mdx" />
+
+<Note> Mem0 Now Supports Azure OpenAI Models in TypeScript SDK </Note>
+
+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/).
+
+> **Note**: The following are currently unsupported with reasoning models `Parallel tool calling`,`temperature`, `top_p`, `presence_penalty`, `frequency_penalty`, `logprobs`, `top_logprobs`, `logit_bias`, `max_tokens`
+
+
+## Usage
+
+<CodeGroup>
+```python Python
+import os
+from mem0 import Memory
+
+os.environ["LLM_AZURE_OPENAI_API_KEY"] = "your-api-key"
+os.environ["LLM_AZURE_DEPLOYMENT"] = "your-deployment-name"
+os.environ["LLM_AZURE_ENDPOINT"] = "your-api-base-url"
+os.environ["LLM_AZURE_API_VERSION"] = "version-to-use"
+
+config = {
+    "llm": {
+        "provider": "azure_openai",
+        "config": {
+            "model": "your-deployment-name",
+            "temperature": 0.1,
+            "max_tokens": 2000,
+            "azure_kwargs": {
+                  "azure_deployment": "",
+                  "api_version": "",
+                  "azure_endpoint": "",
+                  "api_key": "",
+                  "default_headers": {
+                    "CustomHeader": "your-custom-header",
+                  }
+              }
+        }
+    }
+}
+
+m = Memory.from_config(config)
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
+```
+
+```typescript TypeScript
+import { Memory } from 'mem0ai/oss';
+
+const config = {
+  llm: {
+    provider: 'azure_openai',
+    config: {
+      apiKey: process.env.AZURE_OPENAI_API_KEY || '',
+      modelProperties: {
+        endpoint: 'https://your-api-base-url',
+        deployment: 'your-deployment-name',
+        modelName: 'your-model-name',
+        apiVersion: 'version-to-use',
+        // Any other parameters you want to pass to the Azure OpenAI API
+      },
+    },
+  },
+};
+
+const memory = new Memory(config);
+const messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+await memory.add(messages, { userId: "alice", metadata: { category: "movies" } });
+```
+</CodeGroup>
+
+
+We also support the new [OpenAI structured-outputs](https://platform.openai.com/docs/guides/structured-outputs/introduction) model. Typescript SDK does not support the `azure_openai_structured` model yet.
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["LLM_AZURE_OPENAI_API_KEY"] = "your-api-key"
+os.environ["LLM_AZURE_DEPLOYMENT"] = "your-deployment-name"
+os.environ["LLM_AZURE_ENDPOINT"] = "your-api-base-url"
+os.environ["LLM_AZURE_API_VERSION"] = "version-to-use"
+
+config = {
+    "llm": {
+        "provider": "azure_openai_structured",
+        "config": {
+            "model": "your-deployment-name",
+            "temperature": 0.1,
+            "max_tokens": 2000,
+            "azure_kwargs": {
+                  "azure_deployment": "",
+                  "api_version": "",
+                  "azure_endpoint": "",
+                  "api_key": "",
+                  "default_headers": {
+                    "CustomHeader": "your-custom-header",
+                  }
+              }
+        }
+    }
+}
+```
+
+## Config
+
+All available parameters for the `azure_openai` config are present in [Master List of All Params in Config](../config).

docs/components/llms/models/deepseek.mdx

@@ -0,0 +1,57 @@
+---
+title: DeepSeek
+---
+
+<Snippet file="paper-release.mdx" />
+
+To use DeepSeek LLM models, you have to set the `DEEPSEEK_API_KEY` environment variable. You can also optionally set `DEEPSEEK_API_BASE` if you need to use a different API endpoint (defaults to "https://api.deepseek.com").
+
+## Usage
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["DEEPSEEK_API_KEY"] = "your-api-key"
+os.environ["OPENAI_API_KEY"] = "your-api-key" # for embedder model
+
+config = {
+    "llm": {
+        "provider": "deepseek",
+        "config": {
+            "model": "deepseek-chat",  # default model
+            "temperature": 0.2,
+            "max_tokens": 2000,
+            "top_p": 1.0
+        }
+    }
+}
+
+m = Memory.from_config(config)
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
+```
+
+You can also configure the API base URL in the config:
+
+```python
+config = {
+    "llm": {
+        "provider": "deepseek",
+        "config": {
+            "model": "deepseek-chat",
+            "deepseek_base_url": "https://your-custom-endpoint.com",
+            "api_key": "your-api-key"  # alternatively to using environment variable
+        }
+    }
+}
+```
+
+## Config
+
+All available parameters for the `deepseek` config are present in [Master List of All Params in Config](../config).

docs/components/llms/models/gemini.mdx

@@ -0,0 +1,41 @@
+---
+title: Gemini
+---
+
+<Snippet file="paper-release.mdx" />
+
+To use Gemini model, you have to set the `GEMINI_API_KEY` environment variable. You can obtain the Gemini API key from the [Google AI Studio](https://aistudio.google.com/app/apikey)
+
+## Usage
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "your-api-key" # used for embedding model
+os.environ["GEMINI_API_KEY"] = "your-api-key"
+
+config = {
+    "llm": {
+        "provider": "gemini",
+        "config": {
+            "model": "gemini-1.5-flash-latest",
+            "temperature": 0.2,
+            "max_tokens": 2000,
+        }
+    }
+}
+
+m = Memory.from_config(config)
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
+```
+
+## Config
+
+All available parameters for the `Gemini` config are present in [Master List of All Params in Config](../config).

docs/components/llms/models/google_AI.mdx

@@ -0,0 +1,41 @@
+---
+title: Google AI
+---
+
+<Snippet file="paper-release.mdx" />
+
+To use Google AI model, you have to set the `GOOGLE_API_KEY` environment variable. You can obtain the Google API key from the [Google Maker Suite](https://makersuite.google.com/app/apikey)
+
+## Usage
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "your-api-key" # used for embedding model
+os.environ["GEMINI_API_KEY"] = "your-api-key"
+
+config = {
+    "llm": {
+        "provider": "litellm",
+        "config": {
+            "model": "gemini/gemini-pro",
+            "temperature": 0.2,
+            "max_tokens": 2000,
+        }
+    }
+}
+
+m = Memory.from_config(config)
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
+```
+
+## Config
+
+All available parameters for the `litellm` config are present in [Master List of All Params in Config](../config).

docs/components/llms/models/groq.mdx

@@ -0,0 +1,70 @@
+---
+title: Groq
+---
+
+<Snippet file="paper-release.mdx" />
+
+[Groq](https://groq.com/) is the creator of the world's first Language Processing Unit (LPU), providing exceptional speed performance for AI workloads running on their LPU Inference Engine.
+
+In order to use LLMs from Groq, go to their [platform](https://console.groq.com/keys) and get the API key. Set the API key as `GROQ_API_KEY` environment variable to use the model as given below in the example.
+
+## Usage
+
+<CodeGroup>
+```python Python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "your-api-key" # used for embedding model
+os.environ["GROQ_API_KEY"] = "your-api-key"
+
+config = {
+    "llm": {
+        "provider": "groq",
+        "config": {
+            "model": "mixtral-8x7b-32768",
+            "temperature": 0.1,
+            "max_tokens": 2000,
+        }
+    }
+}
+
+m = Memory.from_config(config)
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
+```
+
+```typescript TypeScript
+import { Memory } from 'mem0ai/oss';
+
+const config = {
+  llm: {
+    provider: 'groq',
+    config: {
+      apiKey: process.env.GROQ_API_KEY || '',
+      model: 'mixtral-8x7b-32768',
+      temperature: 0.1,
+      maxTokens: 1000,
+    },
+  },
+};
+
+const memory = new Memory(config);
+const messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+await memory.add(messages, { userId: "alice", metadata: { category: "movies" } });
+```
+</CodeGroup>
+
+## Config
+
+All available parameters for the `groq` config are present in [Master List of All Params in Config](../config).

docs/components/llms/models/langchain.mdx

@@ -0,0 +1,110 @@
+---
+title: LangChain
+---
+
+<Snippet file="paper-release.mdx" />
+
+Mem0 supports LangChain as a provider to access a wide range of LLM models. LangChain is a framework for developing applications powered by language models, making it easy to integrate various LLM providers through a consistent interface.
+
+For a complete list of available chat models supported by LangChain, refer to the [LangChain Chat Models documentation](https://python.langchain.com/docs/integrations/chat).
+
+## Usage
+
+<CodeGroup>
+```python Python
+import os
+from mem0 import Memory
+from langchain_openai import ChatOpenAI
+
+# Set necessary environment variables for your chosen LangChain provider
+os.environ["OPENAI_API_KEY"] = "your-api-key"
+
+# Initialize a LangChain model directly
+openai_model = ChatOpenAI(
+    model="gpt-4o",
+    temperature=0.2,
+    max_tokens=2000
+)
+
+# Pass the initialized model to the config
+config = {
+    "llm": {
+        "provider": "langchain",
+        "config": {
+            "model": openai_model
+        }
+    }
+}
+
+m = Memory.from_config(config)
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
+```
+
+```typescript TypeScript
+import { Memory } from "mem0ai";
+import { ChatOpenAI } from "@langchain/openai";
+
+const openai_model = new ChatOpenAI({
+    model: "gpt-4o",
+    temperature: 0.2,
+    max_tokens: 2000
+})
+
+const config = {
+    "llm": {
+        "provider": "langchain",
+        "config": {
+            "model": openai_model
+        }
+    }
+}
+
+const memory = new Memory(config);
+
+const messages = [
+    { role: "user", content: "I'm planning to watch a movie tonight. Any recommendations?" },
+    { role: "assistant", content: "How about a thriller movies? They can be quite engaging." },
+    { role: "user", content: "I'm not a big fan of thriller movies but I love sci-fi movies." },
+    { role: "assistant", content: "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future." }
+]
+
+memory.add(messages, user_id="alice", metadata={"category": "movies"})
+```
+</CodeGroup>
+
+## Supported LangChain Providers
+
+LangChain supports a wide range of LLM providers, including:
+
+- OpenAI (`ChatOpenAI`)
+- Anthropic (`ChatAnthropic`)
+- Google (`ChatGoogleGenerativeAI`, `ChatGooglePalm`)
+- Mistral (`ChatMistralAI`)
+- Ollama (`ChatOllama`)
+- Azure OpenAI (`AzureChatOpenAI`)
+- HuggingFace (`HuggingFaceChatEndpoint`)
+- And many more
+
+You can use any of these model instances directly in your configuration. For a complete and up-to-date list of available providers, refer to the [LangChain Chat Models documentation](https://python.langchain.com/docs/integrations/chat).
+
+## Provider-Specific Configuration
+
+When using LangChain as a provider, you'll need to:
+
+1. Set the appropriate environment variables for your chosen LLM provider
+2. Import and initialize the specific model class you want to use
+3. Pass the initialized model instance to the config
+
+<Note>
+  Make sure to install the necessary LangChain packages and any provider-specific dependencies.
+</Note>
+
+## Config
+
+All available parameters for the `langchain` config are present in [Master List of All Params in Config](../config).

docs/components/llms/models/litellm.mdx

@@ -0,0 +1,36 @@
+<Snippet file="paper-release.mdx" />
+
+[Litellm](https://litellm.vercel.app/docs/) is compatible with over 100 large language models (LLMs), all using a standardized input/output format. You can explore the [available models](https://litellm.vercel.app/docs/providers) to use with Litellm. Ensure you set the `API_KEY` for the model you choose to use.
+
+## Usage
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "your-api-key"
+
+config = {
+    "llm": {
+        "provider": "litellm",
+        "config": {
+            "model": "gpt-4o-mini",
+            "temperature": 0.2,
+            "max_tokens": 2000,
+        }
+    }
+}
+
+m = Memory.from_config(config)
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
+```
+
+## Config
+
+All available parameters for the `litellm` config are present in [Master List of All Params in Config](../config).

docs/components/llms/models/lmstudio.mdx

@@ -0,0 +1,84 @@
+---
+title: LM Studio
+---
+
+<Snippet file="paper-release.mdx" />
+
+To use LM Studio with Mem0, you'll need to have LM Studio running locally with its server enabled. LM Studio provides a way to run local LLMs with an OpenAI-compatible API.
+
+## Usage
+
+<CodeGroup>
+```python Python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "your-api-key" # used for embedding model
+
+config = {
+    "llm": {
+        "provider": "lmstudio",
+        "config": {
+            "model": "lmstudio-community/Meta-Llama-3.1-70B-Instruct-GGUF/Meta-Llama-3.1-70B-Instruct-IQ2_M.gguf",
+            "temperature": 0.2,
+            "max_tokens": 2000,
+            "lmstudio_base_url": "http://localhost:1234/v1", # default LM Studio API URL
+        }
+    }
+}
+
+m = Memory.from_config(config)
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
+```
+</CodeGroup>
+
+### Running Completely Locally
+
+You can also use LM Studio for both LLM and embedding to run Mem0 entirely locally:
+
+```python
+from mem0 import Memory
+
+# No external API keys needed!
+config = {
+    "llm": {
+        "provider": "lmstudio"
+    },
+    "embedder": {
+        "provider": "lmstudio"
+    }
+}
+
+m = Memory.from_config(config)
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+m.add(messages, user_id="alice123", metadata={"category": "movies"})
+```
+
+<Note>
+  When using LM Studio for both LLM and embedding, make sure you have:
+  1. An LLM model loaded for generating responses
+  2. An embedding model loaded for vector embeddings
+  3. The server enabled with the correct endpoints accessible
+</Note>
+
+<Note>
+  To use LM Studio, you need to:
+  1. Download and install [LM Studio](https://lmstudio.ai/)
+  2. Start a local server from the "Server" tab
+  3. Set the appropriate `lmstudio_base_url` in your configuration (default is usually http://localhost:1234/v1)
+</Note>
+
+## Config
+
+All available parameters for the `lmstudio` config are present in [Master List of All Params in Config](../config).

docs/components/llms/models/mistral_AI.mdx

@@ -0,0 +1,68 @@
+---
+title: Mistral AI
+---
+
+<Snippet file="paper-release.mdx" />
+
+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
+
+<CodeGroup>
+```python Python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "your-api-key" # used for embedding model
+os.environ["MISTRAL_API_KEY"] = "your-api-key"
+
+config = {
+    "llm": {
+        "provider": "litellm",
+        "config": {
+            "model": "open-mixtral-8x7b",
+            "temperature": 0.1,
+            "max_tokens": 2000,
+        }
+    }
+}
+
+m = Memory.from_config(config)
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
+```
+
+```typescript TypeScript
+import { Memory } from 'mem0ai/oss';
+
+const config = {
+  llm: {
+    provider: 'mistral',
+    config: {
+      apiKey: process.env.MISTRAL_API_KEY || '',
+      model: 'mistral-tiny-latest', // Or 'mistral-small-latest', 'mistral-medium-latest', etc.
+      temperature: 0.1,
+      maxTokens: 2000,
+    },
+  },
+};
+
+const memory = new Memory(config);
+const messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+await memory.add(messages, { userId: "alice", metadata: { category: "movies" } });
+```
+</CodeGroup>
+
+## Config
+
+All available parameters for the `litellm` config are present in [Master List of All Params in Config](../config).

docs/components/llms/models/ollama.mdx

@@ -0,0 +1,36 @@
+<Snippet file="paper-release.mdx" />
+
+You can use LLMs from Ollama to run Mem0 locally. These [models](https://ollama.com/search?c=tools) support tool support.
+
+## Usage
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "your-api-key" # for embedder
+
+config = {
+    "llm": {
+        "provider": "ollama",
+        "config": {
+            "model": "mixtral:8x7b",
+            "temperature": 0.1,
+            "max_tokens": 2000,
+        }
+    }
+}
+
+m = Memory.from_config(config)
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
+```
+
+## Config
+
+All available parameters for the `ollama` config are present in [Master List of All Params in Config](../config).

docs/components/llms/models/openai.mdx

@@ -0,0 +1,99 @@
+---
+title: OpenAI
+---
+
+<Snippet file="paper-release.mdx" />
+
+To use OpenAI LLM models, you have to set the `OPENAI_API_KEY` environment variable. You can obtain the OpenAI API key from the [OpenAI Platform](https://platform.openai.com/account/api-keys).
+
+## Usage
+
+<CodeGroup>
+```python Python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "your-api-key"
+
+config = {
+    "llm": {
+        "provider": "openai",
+        "config": {
+            "model": "gpt-4o",
+            "temperature": 0.2,
+            "max_tokens": 2000,
+        }
+    }
+}
+
+# Use Openrouter by passing it's api key
+# os.environ["OPENROUTER_API_KEY"] = "your-api-key"
+# config = {
+#    "llm": {
+#        "provider": "openai",
+#        "config": {
+#            "model": "meta-llama/llama-3.1-70b-instruct",
+#        }
+#    }
+# }
+
+m = Memory.from_config(config)
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
+```
+
+```typescript TypeScript
+import { Memory } from 'mem0ai/oss';
+
+const config = {
+  llm: {
+    provider: 'openai',
+    config: {
+      apiKey: process.env.OPENAI_API_KEY || '',
+      model: 'gpt-4-turbo-preview',
+      temperature: 0.2,
+      maxTokens: 1500,
+    },
+  },
+};
+
+const memory = new Memory(config);
+const messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+await memory.add(messages, { userId: "alice", metadata: { category: "movies" } });
+```
+</CodeGroup>
+
+We also support the new [OpenAI structured-outputs](https://platform.openai.com/docs/guides/structured-outputs/introduction) model.
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "your-api-key"
+
+config = {
+    "llm": {
+        "provider": "openai_structured",
+        "config": {
+            "model": "gpt-4o-2024-08-06",
+            "temperature": 0.0,
+        }
+    }
+}
+
+m = Memory.from_config(config)
+```
+
+## 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,37 @@
+<Snippet file="paper-release.mdx" />
+
+To use TogetherAI LLM models, you have to set the `TOGETHER_API_KEY` environment variable. You can obtain the TogetherAI API key from their [Account settings page](https://api.together.xyz/settings/api-keys).
+
+## Usage
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "your-api-key" # used for embedding model
+os.environ["TOGETHER_API_KEY"] = "your-api-key"
+
+config = {
+    "llm": {
+        "provider": "together",
+        "config": {
+            "model": "mistralai/Mixtral-8x7B-Instruct-v0.1",
+            "temperature": 0.2,
+            "max_tokens": 2000,
+        }
+    }
+}
+
+m = Memory.from_config(config)
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
+```
+
+## Config
+
+All available parameters for the `togetherai` config are present in [Master List of All Params in Config](../config).

docs/components/llms/models/xAI.mdx

@@ -0,0 +1,43 @@
+---
+title: xAI
+---
+
+<Snippet file="paper-release.mdx" />
+
+[xAI](https://x.ai/) is a new AI company founded by Elon Musk that develops large language models, including Grok. Grok is trained on real-time data from X (formerly Twitter) and aims to provide accurate, up-to-date responses with a touch of wit and humor.
+
+In order to use LLMs from xAI, go to their [platform](https://console.x.ai) and get the API key. Set the API key as `XAI_API_KEY` environment variable to use the model as given below in the example.
+
+## Usage
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "your-api-key" # used for embedding model
+os.environ["XAI_API_KEY"] = "your-api-key"
+
+config = {
+    "llm": {
+        "provider": "xai",
+        "config": {
+            "model": "grok-3-beta",
+            "temperature": 0.1,
+            "max_tokens": 2000,
+        }
+    }
+}
+
+m = Memory.from_config(config)
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
+```
+
+## Config
+
+All available parameters for the `xai` config are present in [Master List of All Params in Config](../config).

docs/components/llms/overview.mdx

@@ -0,0 +1,63 @@
+---
+title: Overview
+icon: "info"
+iconType: "solid"
+---
+
+<Snippet file="paper-release.mdx" />
+
+Mem0 includes built-in support for various popular large language models. Memory can utilize the LLM provided by the user, ensuring efficient use for specific needs.
+
+## Usage
+
+To use a llm, you must provide a configuration to customize its usage. If no configuration is supplied, a default configuration will be applied, and `OpenAI` will be used as the llm.
+
+For a comprehensive list of available parameters for llm configuration, please refer to [Config](./config).
+
+To view all supported llms, visit the [Supported LLMs](./models).
+
+<Note>
+  All LLMs are supported in Python. The following LLMs are also supported in TypeScript: **OpenAI**, **Anthropic**, and **Groq**.
+</Note>
+
+<CardGroup cols={4}>
+  <Card title="OpenAI" href="/components/llms/models/openai" />
+  <Card title="Ollama" href="/components/llms/models/ollama" />
+  <Card title="Azure OpenAI" href="/components/llms/models/azure_openai" />
+  <Card title="Anthropic" href="/components/llms/models/anthropic" />
+  <Card title="Together" href="/components/llms/models/together" />
+  <Card title="Groq" href="/components/llms/models/groq" />
+  <Card title="Litellm" href="/components/llms/models/litellm" />
+  <Card title="Mistral AI" href="/components/llms/models/mistral_ai" />
+  <Card title="Google AI" href="/components/llms/models/google_ai" />
+  <Card title="AWS bedrock" href="/components/llms/models/aws_bedrock" />
+  <Card title="Gemini" href="/components/llms/models/gemini" />
+  <Card title="DeepSeek" href="/components/llms/models/deepseek" />
+  <Card title="xAI" href="/components/llms/models/xAI" />
+  <Card title="LM Studio" href="/components/llms/models/lmstudio" />
+  <Card title="Langchain" href="/components/llms/models/langchain" />
+</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,130 @@
+---
+title: Configurations
+icon: "gear"
+iconType: "solid"
+---
+
+<Snippet file="paper-release.mdx" />
+
+## How to define configurations?
+
+The `config` is defined as an object with two main keys:
+- `vector_store`: Specifies the vector database provider and its configuration
+  - `provider`: The name of the vector database (e.g., "chroma", "pgvector", "qdrant", "milvus", "upstash_vector", "azure_ai_search", "vertex_ai_vector_search")
+  - `config`: A nested dictionary containing provider-specific settings
+
+
+## How to Use Config
+
+Here's a general example of how to use the config with mem0:
+
+<CodeGroup>
+```python Python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "sk-xx"
+
+config = {
+    "vector_store": {
+        "provider": "your_chosen_provider",
+        "config": {
+            # Provider-specific settings go here
+        }
+    }
+}
+
+m = Memory.from_config(config)
+m.add("Your text here", user_id="user", metadata={"category": "example"})
+```
+
+```typescript TypeScript
+// Example for in-memory vector database (Only supported in TypeScript)
+import { Memory } from 'mem0ai/oss';
+
+const configMemory = {
+  vector_store: {
+    provider: 'memory',
+    config: {
+      collectionName: 'memories',
+      dimension: 1536,
+    },
+  },
+};
+
+const memory = new Memory(configMemory);
+await memory.add("Your text here", { userId: "user", metadata: { category: "example" } });
+```
+</CodeGroup>
+
+<Note>
+  The in-memory vector database is only supported in the TypeScript implementation.
+</Note>
+
+## Why is Config Needed?
+
+Config is essential for:
+1. Specifying which vector database to use.
+2. Providing necessary connection details (e.g., host, port, credentials).
+3. Customizing database-specific settings (e.g., collection name, path).
+4. Ensuring proper initialization and connection to your chosen vector store.
+
+## Master List of All Params in Config
+
+Here's a comprehensive list of all parameters that can be used across different vector databases:
+
+<Tabs>
+<Tab title="Python">
+| Parameter | Description |
+|-----------|-------------|
+| `collection_name` | Name of the collection |
+| `embedding_model_dims` | Dimensions of the embedding model |
+| `client` | Custom client for the database |
+| `path` | Path for the database |
+| `host` | Host where the server is running |
+| `port` | Port where the server is running |
+| `user` | Username for database connection |
+| `password` | Password for database connection |
+| `dbname` | Name of the database |
+| `url` | Full URL for the server |
+| `api_key` | API key for the server |
+| `on_disk` | Enable persistent storage |
+| `endpoint_id` | Endpoint ID (vertex_ai_vector_search) |
+| `index_id` | Index ID (vertex_ai_vector_search) |
+| `deployment_index_id` | Deployment index ID (vertex_ai_vector_search) |
+| `project_id` | Project ID (vertex_ai_vector_search) |
+| `project_number` | Project number (vertex_ai_vector_search) |
+| `vector_search_api_endpoint` | Vector search API endpoint (vertex_ai_vector_search) |
+| `connection_string` | PostgreSQL connection string (for Supabase/PGVector) |
+| `index_method` | Vector index method (for Supabase) |
+| `index_measure` | Distance measure for similarity search (for Supabase) |
+</Tab>
+<Tab title="TypeScript">
+| Parameter | Description |
+|-----------|-------------|
+| `collectionName` | Name of the collection |
+| `embeddingModelDims` | Dimensions of the embedding model |
+| `dimension` | Dimensions of the embedding model (for memory provider) |
+| `host` | Host where the server is running |
+| `port` | Port where the server is running |
+| `url` | URL for the server |
+| `apiKey` | API key for the server |
+| `path` | Path for the database |
+| `onDisk` | Enable persistent storage |
+| `redisUrl` | URL for the Redis server |
+| `username` | Username for database connection |
+| `password` | Password for database connection |
+</Tab>
+</Tabs>
+
+## Customizing Config
+
+Each vector database has its own specific configuration requirements. To customize the config for your chosen vector store:
+
+1. Identify the vector database you want to use from [supported vector databases](./dbs).
+2. Refer to the `Config` section in the respective vector database's documentation.
+3. Include only the relevant parameters for your chosen database in the `config` dictionary.
+
+## Supported Vector Databases
+
+For detailed information on configuring specific vector databases, please visit the [Supported Vector Databases](./dbs) section. There you'll find individual pages for each supported vector store with provider-specific usage examples and configuration details.

docs/components/vectordbs/dbs/azure.mdx

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

docs/components/vectordbs/dbs/chroma.mdx

@@ -0,0 +1,41 @@
+[Chroma](https://www.trychroma.com/) is an AI-native open-source vector database that simplifies building LLM apps by providing tools for storing, embedding, and searching embeddings with a focus on simplicity and speed.
+
+### Usage
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "sk-xx"
+
+config = {
+    "vector_store": {
+        "provider": "chroma",
+        "config": {
+            "collection_name": "test",
+            "path": "db",
+        }
+    }
+}
+
+m = Memory.from_config(config)
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
+```
+
+### Config
+
+Here are the parameters available for configuring Chroma:
+
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `collection_name` | The name of the collection | `mem0` |
+| `client` | Custom client for Chroma | `None` |
+| `path` | Path for the Chroma database | `db` |
+| `host` | The host where the Chroma server is running | `None` |
+| `port` | The port where the Chroma server is running | `None` |

docs/components/vectordbs/dbs/elasticsearch.mdx

@@ -0,0 +1,108 @@
+[Elasticsearch](https://www.elastic.co/) is a distributed, RESTful search and analytics engine that can efficiently store and search vector data using dense vectors and k-NN search.
+
+### Installation
+
+Elasticsearch support requires additional dependencies. Install them with:
+
+```bash
+pip install elasticsearch>=8.0.0
+```
+
+### Usage
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "sk-xx"
+
+config = {
+    "vector_store": {
+        "provider": "elasticsearch",
+        "config": {
+            "collection_name": "mem0",
+            "host": "localhost",
+            "port": 9200,
+            "embedding_model_dims": 1536
+        }
+    }
+}
+
+m = Memory.from_config(config)
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
+```
+
+### Config
+
+Let's see the available parameters for the `elasticsearch` config:
+
+| Parameter              | Description                                        | Default Value |
+| ---------------------- | -------------------------------------------------- | ------------- |
+| `collection_name`      | The name of the index to store the vectors         | `mem0`        |
+| `embedding_model_dims` | Dimensions of the embedding model                  | `1536`        |
+| `host`                 | The host where the Elasticsearch server is running | `localhost`   |
+| `port`                 | The port where the Elasticsearch server is running | `9200`        |
+| `cloud_id`             | Cloud ID for Elastic Cloud deployment              | `None`        |
+| `api_key`              | API key for authentication                         | `None`        |
+| `user`                 | Username for basic authentication                  | `None`        |
+| `password`             | Password for basic authentication                  | `None`        |
+| `verify_certs`         | Whether to verify SSL certificates                 | `True`        |
+| `auto_create_index`    | Whether to automatically create the index          | `True`        |
+| `custom_search_query`  | Function returning a custom search query            | `None`        |
+
+### Features
+
+- Efficient vector search using Elasticsearch's native k-NN search
+- Support for both local and cloud deployments (Elastic Cloud)
+- Multiple authentication methods (Basic Auth, API Key)
+- Automatic index creation with optimized mappings for vector search
+- Memory isolation through payload filtering
+- Custom search query function to customize the search query
+
+### Custom Search Query
+
+The `custom_search_query` parameter allows you to customize the search query when `Memory.search` is called.  
+  
+__Example__  
+```python
+import os
+from typing import List, Optional, Dict
+from mem0 import Memory
+
+def custom_search_query(query: List[float], limit: int, filters: Optional[Dict]) -> Dict:
+    return {
+        "knn": {
+            "field": "vector", 
+            "query_vector": query, 
+            "k": limit, 
+            "num_candidates": limit * 2
+        }
+    }
+
+os.environ["OPENAI_API_KEY"] = "sk-xx"
+
+config = {
+    "vector_store": {
+        "provider": "elasticsearch",
+        "config": {
+            "collection_name": "mem0",
+            "host": "localhost",
+            "port": 9200,
+            "embedding_model_dims": 1536,
+            "custom_search_query": custom_search_query
+        }
+    }
+}
+```
+It should be a function that takes the following parameters:
+- `query`: a query vector used in `Memory.search`
+- `limit`: a number of results used in `Memory.search`
+- `filters`: a dictionary of key-value pairs used in `Memory.search`. You can add custom pairs for the custom search query.  
+  
+The function should return a query body for the Elasticsearch search API.

docs/components/vectordbs/dbs/faiss.mdx

@@ -0,0 +1,72 @@
+[FAISS](https://github.com/facebookresearch/faiss) is a library for efficient similarity search and clustering of dense vectors. It is designed to work with large-scale datasets and provides a high-performance search engine for vector data. FAISS is optimized for memory usage and search speed, making it an excellent choice for production environments.
+
+### Usage
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "sk-xx"
+
+config = {
+    "vector_store": {
+        "provider": "faiss",
+        "config": {
+            "collection_name": "test",
+            "path": "/tmp/faiss_memories",
+            "distance_strategy": "euclidean"
+        }
+    }
+}
+
+m = Memory.from_config(config)
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
+```
+
+### Installation
+
+To use FAISS in your mem0 project, you need to install the appropriate FAISS package for your environment:
+
+```bash
+# For CPU version
+pip install faiss-cpu
+
+# For GPU version (requires CUDA)
+pip install faiss-gpu
+```
+
+### Config
+
+Here are the parameters available for configuring FAISS:
+
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `collection_name` | The name of the collection | `mem0` |
+| `path` | Path to store FAISS index and metadata | `/tmp/faiss/<collection_name>` |
+| `distance_strategy` | Distance metric strategy to use (options: 'euclidean', 'inner_product', 'cosine') | `euclidean` |
+| `normalize_L2` | Whether to normalize L2 vectors (only applicable for euclidean distance) | `False` |
+
+### Performance Considerations
+
+FAISS offers several advantages for vector search:
+
+1. **Efficiency**: FAISS is optimized for memory usage and speed, making it suitable for large-scale applications.
+2. **Offline Support**: FAISS works entirely locally, with no need for external servers or API calls.
+3. **Storage Options**: Vectors can be stored in-memory for maximum speed or persisted to disk.
+4. **Multiple Index Types**: FAISS supports different index types optimized for various use cases (though mem0 currently uses the basic flat index).
+
+### Distance Strategies
+
+FAISS in mem0 supports three distance strategies:
+
+- **euclidean**: L2 distance, suitable for most embedding models
+- **inner_product**: Dot product similarity, useful for some specialized embeddings
+- **cosine**: Cosine similarity, best for comparing semantic similarity regardless of vector magnitude
+
+When using `cosine` or `inner_product` with normalized vectors, you may want to set `normalize_L2=True` for better results.

docs/components/vectordbs/dbs/langchain.mdx

@@ -0,0 +1,112 @@
+---
+title: LangChain
+---
+
+Mem0 supports LangChain as a provider for vector store integration. LangChain provides a unified interface to various vector databases, making it easy to integrate different vector store providers through a consistent API.
+
+<Note>
+  When using LangChain as your vector store provider, you must set the collection name to "mem0". This is a required configuration for proper integration with Mem0.
+</Note>
+
+## Usage
+
+<CodeGroup>
+```python Python
+import os
+from mem0 import Memory
+from langchain_community.vectorstores import Chroma
+from langchain_openai import OpenAIEmbeddings
+
+# Initialize a LangChain vector store
+embeddings = OpenAIEmbeddings()
+vector_store = Chroma(
+    persist_directory="./chroma_db",
+    embedding_function=embeddings,
+    collection_name="mem0"  # Required collection name
+)
+
+# Pass the initialized vector store to the config
+config = {
+    "vector_store": {
+        "provider": "langchain",
+        "config": {
+            "client": vector_store
+        }
+    }
+}
+
+m = Memory.from_config(config)
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
+```
+
+```typescript TypeScript
+import { Memory } from "mem0ai";
+import { OpenAIEmbeddings } from "@langchain/openai";
+import { MemoryVectorStore as LangchainMemoryStore } from "langchain/vectorstores/memory";
+
+const embeddings = new OpenAIEmbeddings();
+const vectorStore = new LangchainVectorStore(embeddings);
+
+const config = {
+    "vector_store": {
+        "provider": "langchain",
+        "config": { "client": vectorStore }
+    }
+}
+
+const memory = new Memory(config);
+
+const messages = [
+    { role: "user", content: "I'm planning to watch a movie tonight. Any recommendations?" },
+    { role: "assistant", content: "How about a thriller movies? They can be quite engaging." },
+    { role: "user", content: "I'm not a big fan of thriller movies but I love sci-fi movies." },
+    { role: "assistant", content: "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future." }
+]
+
+memory.add(messages, user_id="alice", metadata={"category": "movies"})
+```
+</CodeGroup>
+
+## Supported LangChain Vector Stores
+
+LangChain supports a wide range of vector store providers, including:
+
+- Chroma
+- FAISS
+- Pinecone
+- Weaviate
+- Milvus
+- Qdrant
+- And many more
+
+You can use any of these vector store instances directly in your configuration. For a complete and up-to-date list of available providers, refer to the [LangChain Vector Stores documentation](https://python.langchain.com/docs/integrations/vectorstores).
+
+## Limitations
+
+When using LangChain as a vector store provider, there are some limitations to be aware of:
+
+1. **Bulk Operations**: The `get_all` and `delete_all` operations are not supported when using LangChain as the vector store provider. This is because LangChain's vector store interface doesn't provide standardized methods for these bulk operations across all providers.
+
+2. **Provider-Specific Features**: Some advanced features may not be available depending on the specific vector store implementation you're using through LangChain.
+
+## Provider-Specific Configuration
+
+When using LangChain as a vector store provider, you'll need to:
+
+1. Set the appropriate environment variables for your chosen vector store provider
+2. Import and initialize the specific vector store class you want to use
+3. Pass the initialized vector store instance to the config
+
+<Note>
+  Make sure to install the necessary LangChain packages and any provider-specific dependencies.
+</Note>
+
+## Config
+
+All available parameters for the `langchain` vector store config are present in [Master List of All Params in Config](../config).

docs/components/vectordbs/dbs/milvus.mdx

@@ -0,0 +1,41 @@
+[Milvus](https://milvus.io/) Milvus is an open-source vector database that suits AI applications of every size from running a demo chatbot in Jupyter notebook to building web-scale search that serves billions of users.
+
+### Usage
+
+```python
+import os
+from mem0 import Memory
+
+config = {
+    "vector_store": {
+        "provider": "milvus",
+        "config": {
+            "collection_name": "test",
+            "embedding_model_dims": "123",
+            "url": "127.0.0.1",
+            "token": "8e4b8ca8cf2c67",
+        }
+    }
+}
+
+m = Memory.from_config(config)
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
+```
+
+### Config
+
+Here's the parameters available for configuring Milvus Database:
+
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `url` | Full URL/Uri for Milvus/Zilliz server | `http://localhost:19530` |
+| `token` | Token for Zilliz server / for local setup defaults to None. | `None` |
+| `collection_name` | The name of the collection | `mem0` |
+| `embedding_model_dims` | Dimensions of the embedding model | `1536` |
+| `metric_type` | Metric type for similarity search | `L2` |

docs/components/vectordbs/dbs/opensearch.mdx

@@ -0,0 +1,65 @@
+[OpenSearch](https://opensearch.org/) is an open-source, enterprise-grade search and observability suite that brings order to unstructured data at scale. OpenSearch supports k-NN (k-Nearest Neighbors) and allows you to store and retrieve high-dimensional vector embeddings efficiently.
+
+### Installation
+
+OpenSearch support requires additional dependencies. Install them with:
+
+```bash
+pip install opensearch>=2.8.0
+```
+
+### Usage
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "sk-xx"
+
+config = {
+    "vector_store": {
+        "provider": "opensearch",
+        "config": {
+            "collection_name": "mem0",
+            "host": "localhost",
+            "port": 9200,
+            "embedding_model_dims": 1536
+        }
+    }
+}
+
+m = Memory.from_config(config)
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
+```
+
+### Config
+
+Let's see the available parameters for the `opensearch` config:
+
+| Parameter              | Description                                        | Default Value |
+| ---------------------- | -------------------------------------------------- | ------------- |
+| `collection_name`      | The name of the index to store the vectors         | `mem0`        |
+| `embedding_model_dims` | Dimensions of the embedding model                  | `1536`        |
+| `host`                 | The host where the OpenSearch server is running    | `localhost`   |
+| `port`                 | The port where the OpenSearch server is running    | `9200`        |
+| `api_key`              | API key for authentication                         | `None`        |
+| `user`                 | Username for basic authentication                  | `None`        |
+| `password`             | Password for basic authentication                  | `None`        |
+| `verify_certs`         | Whether to verify SSL certificates                 | `False`        |
+| `auto_create_index`    | Whether to automatically create the index          | `True`        |
+| `use_ssl`              | Whether to use SSL for connection                  | `False`        |
+
+### Features
+
+- Fast and Efficient Vector Search
+- Can be deployed on-premises, in containers, or on cloud platforms like AWS OpenSearch Service.
+- Multiple Authentication and Security Methods (Basic Authentication, API Keys, LDAP, SAML, and OpenID Connect)
+- Automatic index creation with optimized mappings for vector search
+- Memory Optimization through Disk-Based Vector Search and Quantization
+- Real-Time Analytics and Observability

docs/components/vectordbs/dbs/pgvector.mdx

@@ -0,0 +1,47 @@
+[pgvector](https://github.com/pgvector/pgvector) is open-source vector similarity search for Postgres. After connecting with postgres run `CREATE EXTENSION IF NOT EXISTS vector;` to create the vector extension.
+
+### Usage
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "sk-xx"
+
+config = {
+    "vector_store": {
+        "provider": "pgvector",
+        "config": {
+            "user": "test",
+            "password": "123",
+            "host": "127.0.0.1",
+            "port": "5432",
+        }
+    }
+}
+
+m = Memory.from_config(config)
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
+```
+
+### Config
+
+Here's the parameters available for configuring pgvector:
+
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `dbname` | The name of the  | `postgres` |
+| `collection_name` | The name of the collection | `mem0` |
+| `embedding_model_dims` | Dimensions of the embedding model | `1536` |
+| `user` | User name to connect to the database | `None` |
+| `password` | Password to connect to the database | `None` |
+| `host` | The host where the Postgres server is running | `None` |
+| `port` | The port where the Postgres server is running | `None` |
+| `diskann` | Whether to use diskann for vector similarity search (requires pgvectorscale) | `True` |
+| `hnsw` | Whether to use hnsw for vector similarity search | `False` |

docs/components/vectordbs/dbs/pinecone.mdx

@@ -0,0 +1,92 @@
+[Pinecone](https://www.pinecone.io/) is a fully managed vector database designed for machine learning applications, offering high performance vector search with low latency at scale. It's particularly well-suited for semantic search, recommendation systems, and other AI-powered applications.
+
+> **Note**: Before configuring Pinecone, you need to select an embedding model (e.g., OpenAI, Cohere, or custom models) and ensure the `embedding_model_dims` in your config matches your chosen model's dimensions. For example, OpenAI's text-embedding-3-small uses 1536 dimensions.
+
+### Usage
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "sk-xx"
+os.environ["PINECONE_API_KEY"] = "your-api-key"
+
+# Example using serverless configuration
+config = {
+    "vector_store": {
+        "provider": "pinecone",
+        "config": {
+            "collection_name": "testing",
+            "embedding_model_dims": 1536,  # Matches OpenAI's text-embedding-3-small
+            "serverless_config": {
+                "cloud": "aws",  # Choose between 'aws' or 'gcp' or 'azure'
+                "region": "us-east-1"
+            },
+            "metric": "cosine"
+        }
+    }
+}
+
+m = Memory.from_config(config)
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
+```
+
+### Config
+
+Here are the parameters available for configuring Pinecone:
+
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `collection_name` | Name of the index/collection | Required |
+| `embedding_model_dims` | Dimensions of the embedding model (must match your chosen embedding model) | Required |
+| `client` | Existing Pinecone client instance | `None` |
+| `api_key` | API key for Pinecone | Environment variable: `PINECONE_API_KEY` |
+| `environment` | Pinecone environment | `None` |
+| `serverless_config` | Configuration for serverless deployment (AWS or GCP or Azure) | `None` |
+| `pod_config` | Configuration for pod-based deployment | `None` |
+| `hybrid_search` | Whether to enable hybrid search | `False` |
+| `metric` | Distance metric for vector similarity | `"cosine"` |
+| `batch_size` | Batch size for operations | `100` |
+
+> **Important**: You must choose either `serverless_config` or `pod_config` for your deployment, but not both.
+
+#### Serverless Config Example
+```python
+config = {
+    "vector_store": {
+        "provider": "pinecone",
+        "config": {
+            "collection_name": "memory_index",
+            "embedding_model_dims": 1536,  # For OpenAI's text-embedding-3-small
+            "serverless_config": {
+                "cloud": "aws",  # or "gcp" or "azure"
+                "region": "us-east-1"  # Choose appropriate region
+            }
+        }
+    }
+}
+```
+
+#### Pod Config Example
+```python
+config = {
+    "vector_store": {
+        "provider": "pinecone",
+        "config": {
+            "collection_name": "memory_index",
+            "embedding_model_dims": 1536,  # For OpenAI's text-embedding-ada-002
+            "pod_config": {
+                "environment": "gcp-starter",
+                "replicas": 1,
+                "pod_type": "starter"
+            }
+        }
+    }
+}
+```

docs/components/vectordbs/dbs/qdrant.mdx

@@ -0,0 +1,89 @@
+[Qdrant](https://qdrant.tech/) is an open-source vector search engine. It is designed to work with large-scale datasets and provides a high-performance search engine for vector data.
+
+### Usage
+
+<CodeGroup>
+```python Python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "sk-xx"
+
+config = {
+    "vector_store": {
+        "provider": "qdrant",
+        "config": {
+            "collection_name": "test",
+            "host": "localhost",
+            "port": 6333,
+        }
+    }
+}
+
+m = Memory.from_config(config)
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
+```
+
+```typescript TypeScript
+import { Memory } from 'mem0ai/oss';
+
+const config = {
+  vectorStore: {
+    provider: 'qdrant',
+    config: {
+      collectionName: 'memories',
+      embeddingModelDims: 1536,
+      host: 'localhost',
+      port: 6333,
+    },
+  },
+};
+
+const memory = new Memory(config);
+const messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+await memory.add(messages, { userId: "alice", metadata: { category: "movies" } });
+```
+</CodeGroup>
+
+### Config
+
+Let's see the available parameters for the `qdrant` config:
+
+<Tabs>
+<Tab title="Python">
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `collection_name` | The name of the collection to store the vectors | `mem0` |
+| `embedding_model_dims` | Dimensions of the embedding model | `1536` |
+| `client` | Custom client for qdrant | `None` |
+| `host` | The host where the qdrant server is running | `None` |
+| `port` | The port where the qdrant server is running | `None` |
+| `path` | Path for the qdrant database | `/tmp/qdrant` |
+| `url` | Full URL for the qdrant server | `None` |
+| `api_key` | API key for the qdrant server | `None` |
+| `on_disk` | For enabling persistent storage | `False` |
+</Tab>
+<Tab title="TypeScript">
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `collectionName` | The name of the collection to store the vectors | `mem0` |
+| `embeddingModelDims` | Dimensions of the embedding model | `1536` |
+| `host` | The host where the Qdrant server is running | `None` |
+| `port` | The port where the Qdrant server is running | `None` |
+| `path` | Path for the Qdrant database | `/tmp/qdrant` |
+| `url` | Full URL for the Qdrant server | `None` |
+| `apiKey` | API key for the Qdrant server | `None` |
+| `onDisk` | For enabling persistent storage | `False` |
+</Tab>
+</Tabs>

docs/components/vectordbs/dbs/redis.mdx

@@ -0,0 +1,92 @@
+[Redis](https://redis.io/) is a scalable, real-time database that can store, search, and analyze vector data.
+
+### Installation
+```bash
+pip install redis redisvl
+```
+
+Redis Stack using Docker:
+```bash
+docker run -d --name redis-stack -p 6379:6379 -p 8001:8001 redis/redis-stack:latest
+```
+
+### Usage
+
+<CodeGroup>
+```python Python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "sk-xx"
+
+config = {
+    "vector_store": {
+        "provider": "redis",
+        "config": {
+            "collection_name": "mem0",
+            "embedding_model_dims": 1536,
+            "redis_url": "redis://localhost:6379"
+        }
+    },
+    "version": "v1.1"
+}
+
+m = Memory.from_config(config)
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
+```
+
+```typescript TypeScript
+import { Memory } from 'mem0ai/oss';
+
+const config = {
+  vectorStore: {
+    provider: 'redis',
+    config: {
+      collectionName: 'memories',
+      embeddingModelDims: 1536,
+      redisUrl: 'redis://localhost:6379',
+      username: 'your-redis-username',
+      password: 'your-redis-password',
+    },
+  },
+};
+
+const memory = new Memory(config);
+const messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+await memory.add(messages, { userId: "alice", metadata: { category: "movies" } });
+```
+</CodeGroup>
+
+### Config
+
+Let's see the available parameters for the `redis` config:
+
+<Tabs>
+<Tab title="Python">
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `collection_name` | The name of the collection to store the vectors | `mem0` |
+| `embedding_model_dims` | Dimensions of the embedding model | `1536` |
+| `redis_url` | The URL of the Redis server | `None` |
+</Tab>
+<Tab title="TypeScript">
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `collectionName` | The name of the collection to store the vectors | `mem0` |
+| `embeddingModelDims` | Dimensions of the embedding model | `1536` |
+| `redisUrl` | The URL of the Redis server | `None` |
+| `username` | Username for Redis connection | `None` |
+| `password` | Password for Redis connection | `None` |
+</Tab>
+</Tabs>

docs/components/vectordbs/dbs/supabase.mdx

@@ -0,0 +1,170 @@
+[Supabase](https://supabase.com/) is an open-source Firebase alternative that provides a PostgreSQL database with pgvector extension for vector similarity search. It offers a powerful and scalable solution for storing and querying vector embeddings.
+
+Create a [Supabase](https://supabase.com/dashboard/projects) account and project, then get your connection string from Project Settings > Database. See the [docs](https://supabase.github.io/vecs/hosting/) for details.
+
+### Usage
+
+<CodeGroup>
+```python Python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "sk-xx"
+
+config = {
+    "vector_store": {
+        "provider": "supabase",
+        "config": {
+            "connection_string": "postgresql://user:password@host:port/database",
+            "collection_name": "memories",
+            "index_method": "hnsw",  # Optional: defaults to "auto"
+            "index_measure": "cosine_distance"  # Optional: defaults to "cosine_distance"
+        }
+    }
+}
+
+m = Memory.from_config(config)
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
+```
+
+```typescript Typescript
+import { Memory } from "mem0ai/oss";
+
+const config = {
+    vectorStore: {
+      provider: "supabase",
+      config: {
+        collectionName: "memories",
+        embeddingModelDims: 1536,
+        supabaseUrl: process.env.SUPABASE_URL || "",
+        supabaseKey: process.env.SUPABASE_KEY || "",
+        tableName: "memories",
+      },
+    },
+}
+
+const memory = new Memory(config);
+
+const messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+
+await memory.add(messages, { userId: "alice", metadata: { category: "movies" } });
+```
+</CodeGroup>
+
+### SQL Migrations for TypeScript Implementation
+
+The following SQL migrations are required to enable the vector extension and create the memories table:
+
+```sql
+-- Enable the vector extension
+create extension if not exists vector;
+
+-- Create the memories table
+create table if not exists memories (
+  id text primary key,
+  embedding vector(1536),
+  metadata jsonb,
+  created_at timestamp with time zone default timezone('utc', now()),
+  updated_at timestamp with time zone default timezone('utc', now())
+);
+
+-- Create the vector similarity search function
+create or replace function match_vectors(
+  query_embedding vector(1536),
+  match_count int,
+  filter jsonb default '{}'::jsonb
+)
+returns table (
+  id text,
+  similarity float,
+  metadata jsonb
+)
+language plpgsql
+as $$
+begin
+  return query
+  select
+    t.id::text,
+    1 - (t.embedding <=> query_embedding) as similarity,
+    t.metadata
+  from memories t
+  where case
+    when filter::text = '{}'::text then true
+    else t.metadata @> filter
+  end
+  order by t.embedding <=> query_embedding
+  limit match_count;
+end;
+$$;
+```
+
+Goto [Supabase](https://supabase.com/dashboard/projects) and run the above SQL migrations inside the SQL Editor.
+
+### Config
+
+Here are the parameters available for configuring Supabase:
+
+<Tabs>
+<Tab title="Python">
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `connection_string` | PostgreSQL connection string (required) | None |
+| `collection_name` | Name for the vector collection | `mem0` |
+| `embedding_model_dims` | Dimensions of the embedding model | `1536` |
+| `index_method` | Vector index method to use | `auto` |
+| `index_measure` | Distance measure for similarity search | `cosine_distance` |
+</Tab>
+<Tab title="TypeScript">
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `collectionName` | Name for the vector collection | `mem0` |
+| `embeddingModelDims` | Dimensions of the embedding model | `1536` |
+| `supabaseUrl` | Supabase URL | None |
+| `supabaseKey` | Supabase key | None |
+| `tableName` | Name for the vector table | `memories` |
+</Tab>
+</Tabs>
+
+### Index Methods
+
+The following index methods are supported:
+
+- `auto`: Automatically selects the best available index method
+- `hnsw`: Hierarchical Navigable Small World graph index (faster search, more memory usage)
+- `ivfflat`: Inverted File Flat index (good balance of speed and memory)
+
+### Distance Measures
+
+Available distance measures for similarity search:
+
+- `cosine_distance`: Cosine similarity (recommended for most embedding models)
+- `l2_distance`: Euclidean distance
+- `l1_distance`: Manhattan distance
+- `max_inner_product`: Maximum inner product similarity
+
+### Best Practices
+
+1. **Index Method Selection**:
+   - Use `hnsw` for fastest search performance when memory is not a constraint
+   - Use `ivfflat` for a good balance of search speed and memory usage
+   - Use `auto` if unsure, it will select the best method based on your data
+
+2. **Distance Measure Selection**:
+   - Use `cosine_distance` for most embedding models (OpenAI, Hugging Face, etc.)
+   - Use `max_inner_product` if your vectors are normalized
+   - Use `l2_distance` or `l1_distance` if working with raw feature vectors
+
+3. **Connection String**:
+   - Always use environment variables for sensitive information in the connection string
+   - Format: `postgresql://user:password@host:port/database`