test(ts-sdk): add backward compatibility tests for sqlite path changes

Verify that all existing usage patterns continue to work:
- empty config defaults, explicit historyStore workaround, disableHistory
- supabase/non-sqlite provider configs preserved
- embedder, llm, vectorStore, graphStore, customPrompt pass-through
- SQLiteManager with relative, absolute, and :memory: paths
- MemoryVectorStore full CRUD API, dimension checks, filters
- VectorStoreConfig with/without dbPath, client instance pass-through
- ensureSQLiteDirectory idempotency

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

.env.example

@@ -1 +0,0 @@
-OPENAI_API_KEY=

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -5,7 +5,7 @@ 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/gventuri/pandas-ai/issues?q=is%3Aissue+sort%3Acreated-desc+).
+      #### 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

.github/ISSUE_TEMPLATE/config.yml

@@ -1,5 +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
+    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/workflows/cd.yml

@@ -1,24 +1,44 @@
-name: cd
+name: Publish Python 🐍 distributions 📦 to PyPI and TestPyPI
 
 on:
   release:
-    types:
-      - published
-
-permissions:
-  id-token: write
-  contents: read
+    types: [published]
 
 jobs:
-  publish_to_pypi:
-    name: publish to pypi on new release
+  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@v3
-      - uses: JRubics/poetry-publish@v1.16
-        name: Build and publish to PyPI
+      - uses: actions/checkout@v2
+
+      - name: Set up Python
+        uses: actions/setup-python@v2
         with:
-          pypi_token: ${{ secrets.PYPI_TOKEN }}
-          ignore_dev_requirements: "yes"
-          repository_url: https://upload.pypi.org/legacy/
-          repository_name: embedchain
+          python-version: '3.11'
+
+      - name: Install Hatch
+        run: |
+          pip install hatch
+
+      - name: Install dependencies
+        run: |
+          hatch env create
+
+      - name: Build a binary wheel and a source tarball
+        run: |
+          hatch build --clean
+
+      # 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

@@ -3,26 +3,114 @@ name: ci
 on:
   push:
     branches: [main]
+    paths:
+      - 'mem0/**'
+      - 'tests/**'
+      - 'embedchain/**'
+      - '.github/workflows/**'
+      - 'pyproject.toml'
   pull_request:
+    paths:
+      - 'mem0/**'
+      - 'tests/**'
+      - 'embedchain/**'
 
 jobs:
-  build:
+  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/**'
+            - '.github/workflows/**'
+            - 'pyproject.toml'
+          embedchain:
+            - 'embedchain/**'
+
+  build_mem0:
+    needs: check_changes
+    if: needs.check_changes.outputs.mem0_changed == 'true'
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ["3.9", "3.10", "3.11"]
-
+        python-version: ["3.10", "3.11", "3.12"]
     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
-        run: pip install poetry==1.4.2
+      - name: Clean up disk space
+        run: |
+          df -h
+          sudo rm -rf /usr/share/dotnet /usr/local/lib/android /opt/ghc /opt/hostedtoolcache/CodeQL
+          sudo docker image prune --all --force
+          sudo docker builder prune -a
+          df -h
+      - name: Install Hatch
+        run: pip install hatch
+      - name: Load cached venv
+        id: cached-hatch-dependencies
+        uses: actions/cache@v3
+        with:
+          path: .venv
+          key: venv-mem0-${{ runner.os }}-${{ hashFiles('**/pyproject.toml') }}
+      - name: Install GEOS Libraries
+        run: sudo apt-get update && sudo apt-get install -y libgeos-dev
       - name: Install dependencies
-        run: poetry install --all-extras
+        run: |
+          pip install --upgrade pip
+          pip install -e ".[test,graph,vector_stores,llms,extras]"
+          pip install ruff
+        if: steps.cached-hatch-dependencies.outputs.cache-hit != 'true'
+      - name: Run Linting
+        run: make lint
+      - 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", "3.12"]
+    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 Hatch
+        run: pip install hatch
+      - name: Load cached venv
+        id: cached-hatch-dependencies
+        uses: actions/cache@v3
+        with:
+          path: .venv
+          key: venv-embedchain-${{ runner.os }}-${{ hashFiles('**/pyproject.toml') }}
+      - name: Install dependencies
+        run: cd embedchain && make install_all
+        if: steps.cached-hatch-dependencies.outputs.cache-hit != 'true'
+      - name: Run Formatting
+        run: |
+          mkdir -p embedchain/.ruff_cache && chmod -R 777 embedchain/.ruff_cache
+          cd embedchain && hatch run format
       - name: Lint with ruff
-        run: make ci_lint
-      - name: Test with pytest
-        run: make ci_test
+        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,9 +165,24 @@ cython_debug/
 
 # Database
 db
+test-db
+!embedchain/embedchain/core/db/
 
 .vscode
-/poetry.lock
 .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

@@ -1,20 +1,16 @@
 repos:
-  - repo: https://github.com/psf/black
-    rev: 23.3.0
-    hooks:
-      - id: black
-  - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: 'v0.0.220'
-    hooks:
-      - id: ruff
-        name: ruff
-        # Respect `exclude` and `extend-exclude` settings.
-        args: ["--force-exclude"]
   - repo: local
     hooks:
-      - id: pytest-check
-        name: pytest-check
-        entry: poetry run pytest
+      - id: ruff
+        name: Ruff
+        entry: ruff check
         language: system
-        pass_filenames: false
-        always_run: true
+        types: [python]
+        args: [--fix] 
+
+      - id: isort
+        name: isort
+        entry: isort
+        language: system
+        types: [python]
+        args: ["--profile", "black"]

CONTRIBUTING.md

@@ -1,74 +1,63 @@
-# Contributing to embedchain
+# Contributing to mem0
 
-Let us make contributing easy, collaborative and fun.
+Let us make contribution easy, collaborative and fun.
 
 ## Submit your Contribution through PR
 
-To make a contribution, follow the following steps:
+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. Check the linting
-6. Ensure that all tests pass
-7. Submit a pull request
+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
+### 📦 Development Environment
 
-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:
+We use `hatch` for managing development environments. To set up:
 
 ```bash
-poetry install --all-extras
-or
-poetry install --with dev
+# Activate environment for specific Python version:
+hatch shell dev_py_3_9   # Python 3.9
+hatch shell dev_py_3_10  # Python 3.10  
+hatch shell dev_py_3_11  # Python 3.11
+hatch shell dev_py_3_12  # Python 3.12
 
-#activate
-
-poetry shell
+# The environment will automatically install all dev dependencies
+# Run tests within the activated shell:
+make test
 ```
 
 ### 📌 Pre-commit
 
-To ensure our standards, make sure to install pre-commit before star to contribute.
+To ensure our standards, make sure to install pre-commit before starting to contribute.
 
 ```bash
 pre-commit install
 ```
 
-### 🧹 Linting
-
-We use `ruff` to lint our code. You can run the linter by running the following command:
-
-```bash
-make lint
-```
-
-Make sure that the linter does not report any errors or warnings before submitting a pull request.
-
-### Code Format with `black`
-
-We use `black` to reformat the code by running the following command:
-
-```bash
-make format
-```
-
 ### 🧪 Testing
 
-We use `pytest` to test our code. You can run the tests by running the following command:
+We use `pytest` to test our code across multiple Python versions. You can run tests using:
 
 ```bash
-poetry run pytest
+# Run tests with default Python version
+make test
+
+# Test specific Python versions:
+make test-py-3.9   # Python 3.9 environment
+make test-py-3.10  # Python 3.10 environment
+make test-py-3.11  # Python 3.11 environment
+make test-py-3.12  # Python 3.12 environment
+
+# When using hatch shells, run tests with:
+make test  # After activating a shell with hatch shell test_XX
 ```
 
-Make sure that all tests pass before submitting a pull request.
+Make sure that all tests pass across all supported Python versions before submitting a pull request.
 
-## 🚀 Release Process
-
-At the moment, the release process is manual. We try to make frequent releases. Usually, we release a new version when we have a new feature or bugfix. A developer with admin rights to the repository will create a new release on GitHub, and then publish the new version to PyPI.
+We look forward to your pull requests and can't wait to see your contributions!

MIGRATION_GUIDE_v1.0.md

@@ -0,0 +1,221 @@
+# Migration Guide: Upgrading to mem0 1.0.0
+
+## TL;DR
+
+**What changed?** We simplified the API by removing confusing version parameters. Now everything returns a consistent format: `{"results": [...]}`.
+
+**What you need to do:**
+1. Upgrade: `pip install mem0ai==1.0.0`
+2. Remove `version` and `output_format` parameters from your code
+3. Update response handling to use `result["results"]` instead of treating responses as lists
+
+**Time needed:** ~5-10 minutes for most projects
+
+---
+
+## Quick Migration Guide
+
+### 1. Install the Update
+
+```bash
+pip install mem0ai==1.0.0
+```
+
+### 2. Update Your Code
+
+**If you're using the Memory API:**
+
+```python
+# Before
+memory = Memory(config=MemoryConfig(version="v1.1"))
+result = memory.add("I like pizza")
+
+# After
+memory = Memory()  # That's it - version is automatic now
+result = memory.add("I like pizza")
+```
+
+**If you're using the Client API:**
+
+```python
+# Before
+client.add(messages, output_format="v1.1")
+client.search(query, version="v2", output_format="v1.1")
+
+# After
+client.add(messages)  # Just remove those extra parameters
+client.search(query)
+```
+
+### 3. Update How You Handle Responses
+
+All responses now use the same format: a dictionary with `"results"` key.
+
+```python
+# Before - you might have done this
+result = memory.add("I like pizza")
+for item in result:  # Treating it as a list
+    print(item)
+
+# After - do this instead
+result = memory.add("I like pizza")
+for item in result["results"]:  # Access the results key
+    print(item)
+
+# Graph relations (if you use them)
+if "relations" in result:
+    for relation in result["relations"]:
+        print(relation)
+```
+
+---
+
+## Enhanced Message Handling
+
+The platform client (MemoryClient) now supports the same flexible message formats as the OSS version:
+
+```python
+from mem0 import MemoryClient
+
+client = MemoryClient(api_key="your-key")
+
+# All three formats now work:
+
+# 1. Single string (automatically converted to user message)
+client.add("I like pizza", user_id="alice")
+
+# 2. Single message dictionary
+client.add({"role": "user", "content": "I like pizza"}, user_id="alice")
+
+# 3. List of messages (conversation)
+client.add([
+    {"role": "user", "content": "I like pizza"},
+    {"role": "assistant", "content": "I'll remember that!"}
+], user_id="alice")
+```
+
+### Async Mode Configuration
+
+The `async_mode` parameter now defaults to `True` but can be configured:
+
+```python
+# Default behavior (async_mode=True)
+client.add(messages, user_id="alice")
+
+# Explicitly set async mode
+client.add(messages, user_id="alice", async_mode=True)
+
+# Disable async mode if needed
+client.add(messages, user_id="alice", async_mode=False)
+```
+
+**Note:** `async_mode=True` provides better performance for most use cases. Only set it to `False` if you have specific synchronous processing requirements.
+
+---
+
+## That's It!
+
+For most users, that's all you need to know. The changes are:
+- ✅ No more `version` or `output_format` parameters
+- ✅ Consistent `{"results": [...]}` response format
+- ✅ Cleaner, simpler API
+
+---
+
+## Common Issues
+
+**Getting `KeyError: 'results'`?**
+
+Your code is still treating the response as a list. Update it:
+```python
+# Change this:
+for memory in response:
+
+# To this:
+for memory in response["results"]:
+```
+
+**Getting `TypeError: unexpected keyword argument`?**
+
+You're still passing old parameters. Remove them:
+```python
+# Change this:
+client.add(messages, output_format="v1.1")
+
+# To this:
+client.add(messages)
+```
+
+**Seeing deprecation warnings?**
+
+Remove any explicit `version="v1.0"` from your config:
+```python
+# Change this:
+memory = Memory(config=MemoryConfig(version="v1.0"))
+
+# To this:
+memory = Memory()
+```
+
+---
+
+## What's New in 1.0.0
+
+- **Better vector stores:** Fixed OpenSearch and improved reliability across all stores
+- **Cleaner API:** One way to do things, no more confusing options
+- **Enhanced GCP support:** Better Vertex AI configuration options
+- **Flexible message input:** Platform client now accepts strings, dicts, and lists (aligned with OSS)
+- **Configurable async_mode:** Now defaults to `True` but users can override if needed
+
+---
+
+## Need Help?
+
+- Check [GitHub Issues](https://github.com/mem0ai/mem0/issues)
+- Read the [documentation](https://docs.mem0.ai/)
+- Open a new issue if you're stuck
+
+---
+
+## Advanced: Configuration Changes
+
+**If you configured vector stores with version:**
+
+```python
+# Before
+config = MemoryConfig(
+    version="v1.1",
+    vector_store=VectorStoreConfig(...)
+)
+
+# After
+config = MemoryConfig(
+    vector_store=VectorStoreConfig(...)
+)
+```
+
+---
+
+## Testing Your Migration
+
+Quick sanity check:
+
+```python
+from mem0 import Memory
+
+memory = Memory()
+
+# Add should return a dict with "results"
+result = memory.add("I like pizza", user_id="test")
+assert "results" in result
+
+# Search should return a dict with "results"
+search = memory.search("food", user_id="test")
+assert "results" in search
+
+# Get all should return a dict with "results"
+all_memories = memory.get_all(user_id="test")
+assert "results" in all_memories
+
+print("✅ Migration successful!")
+```

Makefile

@@ -1,30 +1,55 @@
-# Variables
-PYTHON := python3
-PIP := $(PYTHON) -m pip
-PROJECT_NAME := embedchain
+.PHONY: format sort lint
 
-# Targets
-.PHONY: install format lint clean test ci_lint ci_test
+# Variables
+ISORT_OPTIONS = --profile black
+PROJECT_NAME := mem0ai
+
+# Default target
+all: format sort lint
 
 install:
-	$(PIP) install --upgrade pip
-	$(PIP) install -e .[dev]
+	hatch env create
 
+install_all:
+	pip install ruff==0.6.9 groq together boto3 litellm ollama chromadb weaviate weaviate-client sentence_transformers vertexai \
+	            google-generativeai elasticsearch opensearch-py vecs "pinecone<7.0.0" pinecone-text faiss-cpu langchain-community \
+							upstash-vector azure-search-documents langchain-memgraph langchain-neo4j langchain-aws rank-bm25 pymochow pymongo psycopg kuzu databricks-sdk valkey
+
+# Format code with ruff
 format:
-	$(PYTHON) -m black .
-	$(PYTHON) -m isort .
+	hatch run format
 
+# Sort imports with isort
+sort:
+	hatch run isort mem0/
+
+# Lint code with ruff
 lint:
-	$(PYTHON) -m ruff .
+	hatch run lint
+
+docs:
+	cd docs && mintlify dev
+
+build:
+	hatch build
+
+publish:
+	hatch publish
 
 clean:
-	rm -rf dist build *.egg-info
+	rm -rf dist
 
 test:
-	$(PYTHON) -m pytest
+	hatch run test
 
-ci_lint:
-	poetry run ruff .
+test-py-3.9:
+	hatch run dev_py_3_9:test
 
-ci_test:
-	poetry run pytest
+test-py-3.10:
+	hatch run dev_py_3_10:test
+
+test-py-3.11:
+	hatch run dev_py_3_11:test
+
+test-py-3.12:
+	hatch run dev_py_3_12:test

README.md

@@ -1,97 +1,171 @@
-# 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/6PzXDgEjG5?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/)
-[![Open in Colab](https://camo.githubusercontent.com/84f0493939e0c4de4e6dbe113251b4bfb5353e57134ffd9fcab6b8714514d4d1/68747470733a2f2f636f6c61622e72657365617263682e676f6f676c652e636f6d2f6173736574732f636f6c61622d62616467652e737667)](https://colab.research.google.com/drive/138lMWhENGeEu7Q1-6lNbNTHGLZXBBz_B?usp=sharing)
+<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>
+  ·
+  <a href="https://mem0.dev/openmemory">OpenMemory</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://img.shields.io/badge/Discord-%235865F2.svg?&logo=discord&logoColor=white" 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>
 
-## 🔧 Quick install
+<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>
+
+> **🎉 mem0ai v1.0.0 is now available!** This major release includes API modernization, improved vector store support, and enhanced GCP integration. [See migration guide →](MIGRATION_GUIDE_v1.0.md)
+
+##  🔥 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)
+
+# Introduction
+
+[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.
+
+### Key Features & Use Cases
+
+**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
+
+**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
+
+## 🚀 Quickstart Guide <a name="quickstart"></a>
+
+Choose between our hosted platform or self-hosted package:
+
+### Hosted Platform
+
+Get up and running in minutes with automatic updates, analytics, and enterprise security.
+
+1. Sign up on [Mem0 Platform](https://app.mem0.ai)
+2. Embed the memory layer via SDK or API keys
+
+### Self-Hosted (Open Source)
+
+Install the sdk via pip:
 
 ```bash
-pip install embedchain
+pip install mem0ai
 ```
 
-## 🔥 Latest
+Install sdk via npm:
+```bash
+npm install mem0ai
+```
 
-- **[2023/07/19]** Released support for 🦙 `llama2` model. Start creating your `llama2` based bots like this:
+### Basic Usage
 
-  ```python
-  import os
+Mem0 requires an LLM to function, with `gpt-4.1-nano-2025-04-14 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).
 
-  from embedchain import Llama2App
-
-  os.environ['REPLICATE_API_TOKEN'] = "REPLICATE API TOKEN"
-
-  zuck_bot = Llama2App()
-
-  # Embed your data
-  zuck_bot.add("https://www.youtube.com/watch?v=Ff4fRgnuFgQ")
-  zuck_bot.add("https://en.wikipedia.org/wiki/Mark_Zuckerberg")
-
-  # Nice, your bot is ready now. Start asking questions to your bot.
-  zuck_bot.query("Who is Mark Zuckerberg?")
-  # Answer: Mark Zuckerberg is an American internet entrepreneur and business magnate. He is the co-founder and CEO of Facebook.
-  ```
-
-
-## 🔍 Demo
-
-Try out embedchain in your browser:
-
-[![Open in Colab](https://camo.githubusercontent.com/84f0493939e0c4de4e6dbe113251b4bfb5353e57134ffd9fcab6b8714514d4d1/68747470733a2f2f636f6c61622e72657365617263682e676f6f676c652e636f6d2f6173736574732f636f6c61622d62616467652e737667)](https://colab.research.google.com/drive/138lMWhENGeEu7Q1-6lNbNTHGLZXBBz_B?usp=sharing)
-
-## 📖 Documentation
-
-The documentation for embedchain can be found at [docs.embedchain.ai](https://docs.embedchain.ai).
-
-## 💻 Usage
-
-Embedchain empowers you to create chatbot models similar to ChatGPT, using your own evolving dataset.
-
-### Queries
-
-For example, you can use Embedchain to create an Elon Musk bot using the following code:
+First step is to instantiate the memory:
 
 ```python
-import os
-from embedchain import App
+from openai import OpenAI
+from mem0 import Memory
 
-# Create a bot instance
-os.environ["OPENAI_API_KEY"] = "YOUR API KEY"
-elon_bot = App()
+openai_client = OpenAI()
+memory = Memory()
 
-# Embed online resources
-elon_bot.add("https://en.wikipedia.org/wiki/Elon_Musk")
-elon_bot.add("https://tesla.com/elon-musk")
-elon_bot.add("https://www.youtube.com/watch?v=MxZpaJK74Y4")
+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"])
 
-# Query the bot
-elon_bot.query("How many companies does Elon Musk run?")
-# Answer: Elon Musk runs four companies: Tesla, SpaceX, Neuralink, and The Boring Company
+    # 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-4.1-nano-2025-04-14", 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()
 ```
 
-## 🤝 Contributing
+For detailed integration steps, see the [Quickstart](https://docs.mem0.ai/quickstart) and [API Reference](https://docs.mem0.ai/api-reference).
 
-Contributions are welcome! Please check out the issues on the repository, and feel free to open a pull request.
-For more information, please see the [contributing guidelines](CONTRIBUTING.md).
+## 🔗 Integrations & Demos
 
-For more refrence, please go through [Development Guide](https://docs.embedchain.ai/contribution/dev) and [Documentation Guide](https://docs.embedchain.ai/contribution/docs).
+- **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))
 
+## 📚 Documentation & Support
+
+- 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 = {Embedchain: 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](https://github.com/mem0ai/mem0/blob/main/LICENSE) file for details.

cookbooks/customer-support-chatbot.ipynb

@@ -0,0 +1,225 @@
+{
+ "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, user_id: str, message: str, response: str, 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 = [{\"role\": \"user\", \"content\": message}, {\"role\": \"assistant\", \"content\": response}]\n",
+    "\n",
+    "        # Store in Mem0\n",
+    "        self.memory.add(conversation, user_id=user_id, metadata=metadata)\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, message=query, response=response, 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,172 @@
+# 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

@@ -1,7 +1,14 @@
-# Contributing to embedchain docs
+# Mintlify Starter Kit
 
+Click on `Use this template` to copy the Mintlify starter kit. The starter kit contains examples including
 
-### 👩‍💻 Development
+- 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
 
@@ -15,9 +22,9 @@ Run the following command at the root of your documentation (where mint.json is)
 mintlify dev
 ```
 
-### 😎 Publishing Changes
+### Publishing Changes
 
-Changes will be deployed to production automatically after your PR is merged to the main branch.
+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
 

docs/_snippets/async-memory-add.mdx

@@ -0,0 +1,5 @@
+<Note type="info">
+  📢 Heads up!
+  We're moving to async memory add for a faster experience.
+  If you signed up after July 1st, 2025, your add requests will work in the background and return right away.
+</Note> 

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">
+  <strong>🎉 Mem0 1.0.0 is here!</strong> Enhanced filtering, reranking, and smarter memory management.
+</Note>

docs/advanced/adding_data.mdx

@@ -1,25 +0,0 @@
----
-title: '➕ Adding Data'
----
-
-## Add Dataset
-
-- This step assumes that you have already created an `app` instance by either using `App`, `OpenSourceApp` or `CustomApp`. We are calling our app instance as `naval_chat_bot` 🤖
-
-- Now use `.add` method to add any dataset.
-
-```python
-# naval_chat_bot = App() or
-# naval_chat_bot = OpenSourceApp()
-
-# Embed Online Resources
-naval_chat_bot.add("https://www.youtube.com/watch?v=3qHkcs3kG44")
-naval_chat_bot.add("https://navalmanack.s3.amazonaws.com/Eric-Jorgenson_The-Almanack-of-Naval-Ravikant_Final.pdf")
-naval_chat_bot.add("https://nav.al/feedback")
-naval_chat_bot.add("https://nav.al/agi")
-
-# Embed Local Resources
-naval_chat_bot.add(("Who is Naval Ravikant?", "Naval Ravikant is an Indian-American entrepreneur and investor."))
-```
-
-The possible formats to add data can be found on the [Supported Data Formats](/advanced/data_types) page.

docs/advanced/app_types.mdx

@@ -1,127 +0,0 @@
----
-title: '📱 App types'
----
-
-## App Types
-
-We have three types of App.
-
-### App
-
-```python
-from embedchain import App
-app = 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).
-- `App` is opinionated. It uses the best embedding model and LLM on the market.
-- 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"
-```
-
-### Llama2App
-
-```python
-import os
-
-from embedchain import Llama2App
-
-os.environ['REPLICATE_API_TOKEN'] = "REPLICATE API TOKEN"
-
-zuck_bot = Llama2App()
-
-# Embed your data
-zuck_bot.add("https://www.youtube.com/watch?v=Ff4fRgnuFgQ")
-zuck_bot.add("https://en.wikipedia.org/wiki/Mark_Zuckerberg")
-
-# Nice, your bot is ready now. Start asking questions to your bot.
-zuck_bot.query("Who is Mark Zuckerberg?")
-# Answer: Mark Zuckerberg is an American internet entrepreneur and business magnate. He is the co-founder and CEO of Facebook. Born in 1984, he dropped out of Harvard University to focus on his social media platform, which has since grown to become one of the largest and most influential technology companies in the world.
-
-# Enable web search for your bot
-zuck_bot.online = True # enable internet access for the bot
-zuck_bot.query("Who owns the new threads app and when it was founded?")
-# Answer: Based on the context provided, the new Threads app is owned by Meta, the parent company of Facebook, Instagram, and WhatsApp.
-```
-
-- `Llama2App` uses Replicate's LLM model, so these are paid models. You can get the `REPLICATE_API_TOKEN` by registering on [their website](https://replicate.com/account).
-- `Llama2App` uses OpenAI's embedding model to create embeddings for chunks. 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).
-
-
-### OpenSourceApp
-
-```python
-from embedchain import OpenSourceApp
-app = 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. 📚
-- `OpenSourceApp` is opinionated. It uses the best open source embedding model and LLM on the market.
-
-### CustomApp
-
-```python
-from embedchain import CustomApp
-from embedchain.config import CustomAppConfig
-from embedchain.models import Providers, EmbeddingFunctions
-
-config = CustomAppConfig(embedding_fn=EmbeddingFunctions.OPENAI, provider=Providers.OPENAI)
-app = CustomApp(config)
-```
-
-- `CustomApp` is not opinionated.
-- Configuration required. It's for advanced users who want to mix and match different embedding models and LLMs. Configuration required.
-- while it's doing that, it's still providing abstractions through `Providers`.
-- paid and free/open source providers included.
-- Once you have imported and instantiated the app, every functionality from here onwards is the same for either type of app. 📚
-- Following providers are available for an LLM
-    - OPENAI
-    - ANTHPROPIC
-    - VERTEX_AI
-    - GPT4ALL
-    - AZURE_OPENAI
-- Following embedding functions are available for an embedding function
-    - OPENAI
-    - HUGGING_FACE
-    - VERTEX_AI
-    - GPT4ALL
-    - AZURE_OPENAI
-
-
-### PersonApp
-
-```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"
-```
-
-#### Compatibility with other apps
-
-- 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
-```

docs/advanced/configuration.mdx

@@ -1,89 +0,0 @@
----
-title: '⚙️ Custom configurations'
----
-
-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.
-
-## Examples
-
-### General
-
-Here's the readme example with configuration options.
-
-```python
-import os
-from embedchain import App
-from embedchain.config import AppConfig, AddConfig, QueryConfig, ChunkerConfig
-from chromadb.utils import embedding_functions
-
-# Example: set the log level for debugging
-config = AppConfig(log_level="DEBUG")
-naval_chat_bot = App(config)
-
-# Example: specify a custom collection name
-config = AppConfig(collection_name="naval_chat_bot")
-naval_chat_bot = App(config)
-
-# Example: define your own chunker config for `youtube_video`
-chunker_config = ChunkerConfig(chunk_size=1000, chunk_overlap=100, length_function=len)
-naval_chat_bot.add("https://www.youtube.com/watch?v=3qHkcs3kG44", AddConfig(chunker=chunker_config))
-
-add_config = AddConfig()
-naval_chat_bot.add("https://navalmanack.s3.amazonaws.com/Eric-Jorgenson_The-Almanack-of-Naval-Ravikant_Final.pdf", config=add_config)
-naval_chat_bot.add("https://nav.al/feedback", config=add_config)
-naval_chat_bot.add("https://nav.al/agi", config=add_config)
-
-naval_chat_bot.add(("Who is Naval Ravikant?", "Naval Ravikant is an Indian-American entrepreneur and investor."), config=add_config)
-
-query_config = QueryConfig()
-print(naval_chat_bot.query("What unique capacity does Naval argue humans possess when it comes to understanding explanations or concepts?", config=query_config))
-```
-
-### Custom prompt template
-
-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(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(template=einstein_chat_template, system_prompt="You are Albert Einstein.")
-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, config=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.
-```

docs/advanced/data_types.mdx

@@ -1,141 +0,0 @@
----
-title: '📋 Supported data formats'
----
-
-## Automatic data type detection
-The add method automatically tries to detect the data_type, based on your input for the source argument. So `app.add('https://www.youtube.com/watch?v=dQw4w9WgXcQ')` is enough to embed a YouTube video.
-
-This detection is implemented for all formats. It is based on factors such as whether it's a URL, a local file, the source data type, etc.
-
-### Debugging automatic detection
-
-
-Set `log_level=DEBUG` (in [AppConfig](http://localhost:3000/advanced/query_configuration#appconfig)) and make sure it's working as intended.
-
-Otherwise, you will not know when, for instance, an invalid filepath is interpreted as raw text instead.
-
-### Forcing a data type
-
-To omit any issues with the data type detection, you can **force** a data_type by adding it as a `add` method argument.
-The examples below show you the keyword to force the respective `data_type`.
-
-Forcing can also be used for edge cases, such as interpreting a sitemap as a web_page, for reading it's raw text instead of following links.
-
-## Remote Data Types
-
-<Tip>
-**Use local files in remote data types**
-
-Some data_types are meant for remote content and only work with URLs.
-You can pass local files by formatting the path using the `file:` [URI scheme](https://en.wikipedia.org/wiki/File_URI_scheme), e.g. `file:///info.pdf`.
-</Tip>
-
-### Youtube video
-
-To add any youtube video to your app, use the data_type (first argument to `.add()` method) as `youtube_video`. Eg:
-
-```python
-app.add('a_valid_youtube_url_here', data_type='youtube_video')
-```
-
-### PDF file
-
-To add any pdf file, use the data_type as `pdf_file`. Eg:
-
-```python
-app.add('a_valid_url_where_pdf_file_can_be_accessed', data_type='pdf_file')
-```
-
-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('a_valid_web_page_url', data_type='web_page')
-```
-
-### Sitemap
-
-Add all web pages from an xml-sitemap. Filters non-text files. Use the data_type as `sitemap`. Eg:
-
-```python
-app.add('https://example.com/sitemap.xml', data_type='sitemap')
-```
-
-### Doc file
-
-To add any doc/docx file, use the data_type as `docx`. `docx` allows remote urls and conventional file paths. Eg:
-
-```python
-app.add('https://example.com/content/intro.docx', data_type="docx")
-app.add('content/intro.docx', data_type="docx")
-```
-
-### Code documentation website loader
-
-To add any code documentation website as a loader, use the data_type as `docs_site`. Eg:
-
-```python
-app.add("https://docs.embedchain.ai/", data_type="docs_site")
-```
-
-### Notion
-To use notion you must install the extra dependencies with `pip install embedchain[notion]`.
-
-To load a notion page, use the data_type as `notion`. Since it is hard to automatically detect, forcing this is advised.
-The next argument must **end** with the `notion page id`. The id is a 32-character string. Eg:
-
-```python
-app.add("cfbc134ca6464fc980d0391613959196", "notion")
-app.add("my-page-cfbc134ca6464fc980d0391613959196", "notion")
-app.add("https://www.notion.so/my-page-cfbc134ca6464fc980d0391613959196", "notion")
-```
-
-## Local Data Types
-
-### 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('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.', data_type='text')
-```
-
-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(("Question", "Answer"), data_type="qna_pair")
-```
-
-## Reusing a vector database
-
-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("https://www.youtube.com/watch?v=3qHkcs3kG44")
-naval_chat_bot.add("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.

docs/advanced/interface_types.mdx

@@ -1,75 +0,0 @@
----
-title: '🤝 Interface types'
----
-
-## Interface Types
-
-The embedchain app exposes the following methods.
-
-### 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.
-```
-
-#### Dry Run
-
-Dry Run is an option in the `query` and `chat` methods that allows the user to not send their constructed prompt to the LLM, to save money. It's used for [testing](/advanced/testing#dry-run).
-
-
-### 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.
-```
-
-### 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
-```

docs/advanced/query_configuration.mdx

@@ -1,77 +0,0 @@
----
-title: '🔍 Query configurations'
----
-
-## AppConfig
-
-| option    | description           | type                            | default                |
-|-----------|-----------------------|---------------------------------|------------------------|
-| log_level | log level             | string                          | WARNING                |
-| embedding_fn| embedding function    | chromadb.utils.embedding_functions | \{text-embedding-ada-002\} |
-| db        | vector database (experimental) | BaseVectorDB               | ChromaDB               |
-| collection_name | initial collection name for the database | string             | embedchain_store |
-| collect_metrics | collect anonymous telemetry data to improve embedchain | boolean | true |
-
-
-## AddConfig
-
-|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|
-
-Yes, you are passing `ChunkerConfig` to `AddConfig`, like so:
-
-```python
-chunker_config = ChunkerConfig(chunk_size=100)
-add_config = AddConfig(chunker=chunker_config)
-app.add("lorem ipsum", config=add_config)
-```
-
-### ChunkerConfig
-
-|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|
-|docs_site|500|50|len|
-|notion|300|0|len|
-
-### LoaderConfig
-
-_coming soon_
-
-## QueryConfig
-
-|option|description|type|default|
-|---|---|---|---|
-|number_documents|Absolute number of documents to pull from the database as context.|int|1
-|template|custom template for prompt. If history is used with query, $history has to be included as well.|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:")|
-|model|name of the model used.|string|depends on app type|
-|temperature|Controls the randomness of the model's output. Higher values (closer to 1) make output more random, lower values make it more deterministic.|float|0|
-|max_tokens|Controls how many tokens are used. Exact implementation (whether it counts prompt and/or response) depends on the model.|int|1000|
-|top_p|Controls the diversity of words. Higher values (closer to 1) make word selection more diverse, lower values make words less diverse.|float|1|
-|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|
-|deployment_name|t.b.a.|str|None|
-|system_prompt|System prompt string. Unused if none.|str|None|
-
-## ChatConfig
-
-All options for query and...
-
-_coming soon_
-
-`history` is not supported, as that is handled is handled automatically, the config option is not supported.

docs/advanced/testing.mdx

@@ -1,29 +0,0 @@
----
-title: '🧪 Testing'
----
-
-## Methods for testing
-
-### Dry Run
-
-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` option in your `query` or `chat` method.
-
-Following the example above, add this to your script:
-
-```python
-print(naval_chat_bot.query('Can you tell me who Naval Ravikant is?', dry_run=True))
-
-'''
-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.**

docs/advanced/vector_database.mdx

@@ -1,34 +0,0 @@
----
-title: '💾 Vector Database'
----
-
-We support `Chroma` and `Elasticsearch` as two vector database. 
-`Chroma` is used as a default database.
-
-### Elasticsearch
-In order to use `Elasticsearch` as vector database we need to use App type `CustomApp`. 
-```python
-import os
-from embedchain import CustomApp
-from embedchain.config import CustomAppConfig, ElasticsearchDBConfig
-from embedchain.models import Providers, EmbeddingFunctions, VectorDatabases
-
-os.environ["OPENAI_API_KEY"] = 'OPENAI_API_KEY'
-
-es_config = ElasticsearchDBConfig(
-	# elasticsearch url or list of nodes url with different hosts and ports.
-	es_url='http://localhost:9200',
-	# pass named parameters supported by Python Elasticsearch client
-	ca_certs="/path/to/http_ca.crt",
-	basic_auth=("username", "password")
-)
-config = CustomAppConfig(
-	embedding_fn=EmbeddingFunctions.OPENAI, 
-	provider=Providers.OPENAI, 
-	db_type=VectorDatabases.ELASTICSEARCH, 
-	es_config=es_config,
-)
-es_app = CustomApp(config)
-```
-- Set `db_type=VectorDatabases.ELASTICSEARCH` and `es_config=ElasticsearchDBConfig(es_url='')` in `CustomAppConfig`.
-- `ElasticsearchDBConfig` accepts `es_url` as elasticsearch url or as list of nodes url with different hosts and ports. Additionally we can pass named paramaters supported by Python Elasticsearch client.

docs/api-reference.mdx

@@ -0,0 +1,108 @@
+---
+title: "Overview"
+icon: "terminal"
+iconType: "solid"
+description: "REST APIs for memory management, search, and entity operations"
+---
+
+## Mem0 REST API
+
+Mem0 provides a comprehensive REST API for integrating advanced memory capabilities into your applications. Create, search, update, and manage memories across users, agents, and custom entities with simple HTTP requests.
+
+<Info>
+**Quick start:** Get your API key from the [Mem0 Dashboard](https://app.mem0.ai/dashboard/api-keys) and make your first memory operation in minutes.
+</Info>
+
+---
+
+## Quick Start Guide
+
+Get started with Mem0 API in three simple steps:
+
+1. **[Add Memories](/api-reference/memory/add-memories)** - Store information and context from user conversations
+2. **[Search Memories](/api-reference/memory/v2-search-memories)** - Retrieve relevant memories using semantic search
+3. **[Get Memories](/api-reference/memory/v2-get-memories)** - Fetch all memories for a specific entity
+
+---
+
+## Core Operations
+
+<CardGroup cols={2}>
+  <Card title="Add Memories" icon="plus" href="/api-reference/memory/add-memories">
+    Store new memories from conversations and interactions
+  </Card>
+
+  <Card title="Search Memories" icon="magnifying-glass" href="/api-reference/memory/v2-search-memories">
+    Find relevant memories using semantic search with filters
+  </Card>
+
+  <Card title="Update Memory" icon="pen" href="/api-reference/memory/update-memory">
+    Modify existing memory content and metadata
+  </Card>
+
+  <Card title="Delete Memory" icon="trash" href="/api-reference/memory/delete-memory">
+    Remove specific memories or batch delete operations
+  </Card>
+</CardGroup>
+
+---
+
+## API Categories
+
+Explore the full API organized by functionality:
+
+<CardGroup cols={2}>
+  <Card title="Memory APIs" icon="microchip" href="/api-reference/memory/add-memories">
+    Core and advanced operations: CRUD, search, batch updates, history, and exports
+  </Card>
+
+  <Card title="Events APIs" icon="clock" href="/api-reference/events/get-events">
+    Track and monitor the status of asynchronous memory operations
+  </Card>
+
+  <Card title="Entities APIs" icon="users" href="/api-reference/entities/get-users">
+    Manage users, agents, and their associated memory data
+  </Card>
+
+  <Card title="Organizations & Projects" icon="building" href="/api-reference/organizations-projects">
+    Multi-tenant support, access control, and team collaboration
+  </Card>
+
+  <Card title="Webhooks" icon="webhook" href="/api-reference/webhook/create-webhook">
+    Real-time notifications for memory events and updates
+  </Card>
+</CardGroup>
+
+<Note>
+**Building multi-tenant apps?** Learn about [Organizations & Projects](/api-reference/organizations-projects) for team isolation and access control.
+</Note>
+
+---
+
+## Authentication
+
+All API requests require authentication using Token-based authentication. Include your API key in the Authorization header:
+
+```bash
+Authorization: Token <your-api-key>
+```
+
+Get your API key from the [Mem0 Dashboard](https://app.mem0.ai/dashboard/api-keys).
+
+<Warning>
+**Keep your API key secure.** Never expose it in client-side code or public repositories. Use environment variables and server-side requests only.
+</Warning>
+
+---
+
+## Next Steps
+
+<CardGroup cols={2}>
+  <Card title="Add Your First Memory" icon="rocket" href="/api-reference/memory/add-memories">
+    Start storing memories via the REST API
+  </Card>
+
+  <Card title="Search with Filters" icon="filter" href="/api-reference/memory/v2-search-memories">
+    Learn advanced search and filtering techniques
+  </Card>
+</CardGroup>

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

@@ -0,0 +1,4 @@
+---
+title: 'Delete User'
+openapi: delete /v2/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/events/get-event.mdx

@@ -0,0 +1,6 @@
+---
+title: 'Get Event'
+openapi: get /v1/event/{event_id}/
+---
+
+Retrieve details about a specific event by passing its `event_id`. This endpoint is particularly helpful for tracking the status, payload, and completion details of asynchronous memory operations.

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

@@ -0,0 +1,13 @@
+---
+title: 'Get Events'
+openapi: get /v1/events/
+---
+
+List recent events for your organization and project.
+
+## Use Cases
+
+- **Dashboards**: Summarize adds/searches over time by paging through events.
+- **Alerting**: Poll for `FAILED` events and trigger follow-up workflows.
+- **Audit**: Store the returned payload/metadata for compliance logs.
+

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

@@ -0,0 +1,97 @@
+---
+title: 'Add Memories'
+openapi: post /v1/memories/
+---
+
+Add new facts, messages, or metadata to a user’s memory store. The Add Memories endpoint accepts either raw text or conversational turns and commits them asynchronously so the memory is ready for later search, retrieval, and graph queries.
+
+## Endpoint
+
+- **Method**: `POST`
+- **URL**: `/v1/memories/`
+- **Content-Type**: `application/json`
+
+Memories are processed asynchronously by default. The response contains queued events you can track while the platform finalizes enrichment.
+
+## Required headers
+
+| Header | Required | Description |
+| --- | --- | --- |
+| `Authorization: Token <MEM0_API_KEY>` | Yes | API key scoped to your workspace. |
+| `Accept: application/json` | Yes | Ensures a JSON response. |
+
+## Request body
+
+Provide at least one message or direct memory string. Most callers supply `messages` so Mem0 can infer structured memories as part of ingestion.
+
+<CodeGroup>
+```json Basic request
+{
+  "user_id": "alice",
+  "messages": [
+    { "role": "user", "content": "I moved to Austin last month." }
+  ],
+  "metadata": {
+    "source": "onboarding_form"
+  }
+}
+```
+</CodeGroup>
+
+### Common fields
+
+| Field | Type | Required | Description |
+| --- | --- | --- | --- |
+| `user_id` | string | No* | Associates the memory with a user. Provide when you want the memory scoped to a specific identity. |
+| `messages` | array | No* | Conversation turns for Mem0 to infer memories from. Each object should include `role` and `content`. |
+| `metadata` | object | Optional | Custom key/value metadata (e.g., `{"topic": "preferences"}`). |
+| `infer` | boolean (default `true`) | Optional | Set to `false` to skip inference and store the provided text as-is. |
+| `async_mode` | boolean (default `true`) | Optional | Controls asynchronous processing. Most clients leave this enabled. |
+| `output_format` | string (default `v1.1`) | Optional | Response format. `v1.1` wraps results in a `results` array. |
+
+> \* Provide at least one `messages` entry to describe what you are storing. For scoped memories, include `user_id`. You can also attach `agent_id`, `app_id`, `run_id`, `project_id`, or `org_id` to refine ownership.
+
+## Response
+
+Successful requests return an array of events queued for processing. Each event includes the generated memory text and an identifier you can persist for auditing.
+
+<CodeGroup>
+```json 200 response
+[
+  {
+    "id": "mem_01JF8ZS4Y0R0SPM13R5R6H32CJ",
+    "event": "ADD",
+    "data": {
+      "memory": "The user moved to Austin in 2025."
+    }
+  }
+]
+```
+
+```json 400 response
+{
+  "error": "400 Bad Request",
+  "details": {
+    "message": "Invalid input data. Please refer to the memory creation documentation at https://docs.mem0.ai/platform/quickstart#4-1-create-memories for correct formatting and required fields."
+  }
+}
+```
+</CodeGroup>
+
+## Graph relationships
+
+Add Memories can enrich the knowledge graph on write. Set `enable_graph: true` to create entity nodes and relationships for the stored memory. Use this when you want downstream `get_all` or search calls to traverse connected entities.
+
+<CodeGroup>
+```json Graph-aware request
+{
+  "user_id": "alice",
+  "messages": [
+    { "role": "user", "content": "I met with Dr. Lee at General Hospital." }
+  ],
+  "enable_graph": true
+}
+```
+</CodeGroup>
+
+The response follows the same format, and related entities become available in [Graph Memory](/platform/features/graph-memory) queries.

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

@@ -0,0 +1,99 @@
+---
+title: "Get Memories"
+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, NOT) 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
+- `*`: Wildcard character that matches everything
+
+<CodeGroup>
+```python Code
+memories = client.get_all(
+    filters={
+        "AND": [
+            {
+                "user_id": "alex"
+            },
+            {
+                "created_at": {"gte": "2024-07-01", "lte": "2024-07-31"}
+            }
+        ]
+    }
+)
+```
+
+```python Output
+{
+    "results": [
+        {
+            "id": "f4cbdb08-7062-4f3e-8eb2-9f5c80dfe64c",
+            "memory": "Alex is planning a trip to San Francisco from July 1st to July 10th",
+            "created_at": "2024-07-01T12:00:00Z",
+            "updated_at": "2024-07-01T12:00:00Z"
+        },
+        {
+            "id": "a2b8c3d4-5e6f-7g8h-9i0j-1k2l3m4n5o6p",
+            "memory": "Alex prefers vegetarian restaurants",
+            "created_at": "2024-07-05T15:30:00Z",
+            "updated_at": "2024-07-05T15:30:00Z"
+        }
+    ],
+    "total": 2
+}
+```
+
+</CodeGroup>
+
+## Graph Memory
+
+To retrieve graph memory relationships between entities, pass `output_format="v1.1"` in your request. This will return memories with entity and relationship information from the knowledge graph.
+
+<CodeGroup>
+```python Code
+memories = client.get_all(
+    filters={
+        "user_id": "alex"
+    },
+    output_format="v1.1"
+)
+```
+
+```python Output
+{
+    "results": [
+        {
+            "id": "f4cbdb08-7062-4f3e-8eb2-9f5c80dfe64c",
+            "memory": "Alex is planning a trip to San Francisco",
+            "entities": [
+                {
+                    "id": "entity-1",
+                    "name": "Alex",
+                    "type": "person"
+                },
+                {
+                    "id": "entity-2",
+                    "name": "San Francisco",
+                    "type": "location"
+                }
+            ],
+            "relations": [
+                {
+                    "source": "entity-1",
+                    "target": "entity-2",
+                    "relationship": "traveling_to"
+                }
+            ]
+        }
+    ]
+}
+```
+
+</CodeGroup>

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

@@ -0,0 +1,104 @@
+---
+title: 'Search Memories'
+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, NOT) 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
+- `*`: Wildcard character that matches everything
+
+<CodeGroup>
+```python Platform API Example
+related_memories = client.search(
+    query="What are Alice's hobbies?",
+    filters={
+        "OR": [
+            {
+              "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>
+
+<CodeGroup>
+```python Wildcard Example
+# Using wildcard to match all run_ids for a specific user
+all_memories = client.search(
+    query="What are Alice's hobbies?",
+    filters={
+        "AND": [
+            {
+                "user_id": "alice"
+            },
+            {
+                "run_id": "*"
+            }
+        ]
+    },
+)
+```
+</CodeGroup>
+
+<CodeGroup>
+```python Categories Filter Examples
+# Example 1: Using 'contains' for partial matching
+finance_memories = client.search(
+    query="What are my financial goals?",
+    filters={
+        "AND": [
+            { "user_id": "alice" },
+            {
+                "categories": {
+                    "contains": "finance"
+                }
+            }
+        ]
+    },
+)
+
+# Example 2: Using 'in' for exact matching
+personal_memories = client.search(
+    query="What personal information do you have?",
+    filters={
+        "AND": [
+            { "user_id": "alice" },
+            {
+                "categories": {
+                    "in": ["personal_information"]
+                }
+            }
+        ]
+    },
+)
+```
+</CodeGroup>

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

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

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.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/organizations-projects.mdx

@@ -0,0 +1,197 @@
+---
+title: Organizations & Projects
+icon: "building"
+description: "Manage multi-tenant applications with organization and project APIs"
+---
+
+## Overview
+
+Organizations and projects provide multi-tenant support, access control, and team collaboration capabilities for Mem0 Platform. Use these APIs to build applications that support multiple teams, customers, or isolated environments.
+
+<Info>
+Organizations and projects are **optional** features. You can use Mem0 without them for single-user or simple multi-user applications.
+</Info>
+
+## Key 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
+
+---
+
+## Using Organizations & Projects
+
+### Initialize with Org/Project Context
+
+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>
+
+---
+
+## Project Management
+
+The Mem0 client provides comprehensive project management through the `client.project` interface:
+
+### Get Project Details
+
+Retrieve information about the current project:
+
+```python
+# Get all project details
+project_info = client.project.get()
+
+# Get specific fields only
+project_info = client.project.get(fields=["name", "description", "custom_categories"])
+```
+
+### Create a New Project
+
+Create a new project within your organization:
+
+```python
+# Create a project with name and description
+new_project = client.project.create(
+    name="My New Project",
+    description="A project for managing customer support memories"
+)
+```
+
+### Update Project Settings
+
+Modify project configuration including custom instructions, categories, and graph settings:
+
+```python
+# Update project with custom categories
+client.project.update(
+    custom_categories=[
+        {"customer_preferences": "Customer likes, dislikes, and preferences"},
+        {"support_history": "Previous support interactions and resolutions"}
+    ]
+)
+
+# Update project with custom instructions
+client.project.update(
+    custom_instructions="..."
+)
+
+# Enable graph memory for the project
+client.project.update(enable_graph=True)
+
+# Update multiple settings at once
+client.project.update(
+    custom_instructions="...",
+    custom_categories=[
+        {"personal_info": "User personal information and preferences"},
+        {"work_context": "Professional context and work-related information"}
+    ],
+    enable_graph=True
+)
+```
+
+### Delete Project
+
+<Warning>
+This action will remove all memories, messages, and other related data in the project. **This operation is irreversible.**
+</Warning>
+
+Remove a project and all its associated data:
+
+```python
+# Delete the current project (irreversible)
+result = client.project.delete()
+```
+
+---
+
+## Member Management
+
+Manage project members and their access levels:
+
+```python
+# Get all project members
+members = client.project.get_members()
+
+# Add a new member as a reader
+client.project.add_member(
+    email="colleague@company.com",
+    role="READER"  # or "OWNER"
+)
+
+# Update a member's role
+client.project.update_member(
+    email="colleague@company.com",
+    role="OWNER"
+)
+
+# Remove a member from the project
+client.project.remove_member(email="colleague@company.com")
+```
+
+### Member Roles
+
+| Role | Permissions |
+|------|-------------|
+| **READER** | Can view and search memories, but cannot modify project settings or manage members |
+| **OWNER** | Full access including project modification, member management, and all reader permissions |
+
+---
+
+## Async Support
+
+All project methods are available in async mode:
+
+```python
+from mem0 import AsyncMemoryClient
+
+async def manage_project():
+    client = AsyncMemoryClient(org_id='YOUR_ORG_ID', project_id='YOUR_PROJECT_ID')
+
+    # All methods support async/await
+    project_info = await client.project.get()
+    await client.project.update(enable_graph=True)
+    members = await client.project.get_members()
+
+# To call the async function properly
+import asyncio
+asyncio.run(manage_project())
+```
+
+---
+
+## API Reference
+
+For complete API specifications and additional endpoints, see:
+
+<CardGroup cols={2}>
+  <Card title="Organizations APIs" icon="building" href="/api-reference/organization/create-org">
+    Create, get, and manage organizations
+  </Card>
+
+  <Card title="Project APIs" icon="folder" href="/api-reference/project/create-project">
+    Full project CRUD and member management endpoints
+  </Card>
+</CardGroup>

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.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/webhook/create-webhook.mdx

@@ -0,0 +1,5 @@
+---
+title: 'Create Webhook'
+openapi: post /api/v1/webhooks/projects/{project_id}/
+---
+

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

@@ -0,0 +1,4 @@
+---
+title: 'Delete Webhook'
+openapi: delete /api/v1/webhooks/{webhook_id}/
+---

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

@@ -0,0 +1,5 @@
+---
+title: 'Get Webhook'
+openapi: get /api/v1/webhooks/projects/{project_id}/
+---
+

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

@@ -0,0 +1,5 @@
+---
+title: 'Update Webhook'
+openapi: put /api/v1/webhooks/{webhook_id}/
+---
+

docs/components/embedders/config.mdx

@@ -0,0 +1,99 @@
+---
+title: Configurations
+---
+
+
+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/aws_bedrock.mdx

@@ -0,0 +1,62 @@
+---
+title: AWS Bedrock
+---
+
+To use AWS Bedrock embedding models, you need to have the appropriate AWS credentials and permissions. The embeddings implementation relies on the `boto3` library.
+
+### Setup
+- Ensure you have model access from the [AWS Bedrock Console](https://us-east-1.console.aws.amazon.com/bedrock/home?region=us-east-1#/modelaccess)
+- Authenticate the boto3 client using a method described in the [AWS documentation](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html)
+- Set up environment variables for authentication:
+  ```bash
+  export AWS_REGION=us-east-1
+  export AWS_ACCESS_KEY_ID=your-access-key
+  export AWS_SECRET_ACCESS_KEY=your-secret-key
+  ```
+
+### Usage
+
+<CodeGroup>
+```python Python
+import os
+from mem0 import Memory
+
+# For LLM if needed
+os.environ["OPENAI_API_KEY"] = "your-openai-api-key"
+
+# AWS credentials
+os.environ["AWS_REGION"] = "us-west-2"
+os.environ["AWS_ACCESS_KEY_ID"] = "your-access-key"
+os.environ["AWS_SECRET_ACCESS_KEY"] = "your-secret-key"
+
+config = {
+    "embedder": {
+        "provider": "aws_bedrock",
+        "config": {
+            "model": "amazon.titan-embed-text-v2: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 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")
+```
+</CodeGroup>
+
+### Config
+
+Here are the parameters available for configuring AWS Bedrock embedder:
+
+<Tabs>
+<Tab title="Python">
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `model` | The name of the embedding model to use | `amazon.titan-embed-text-v1` |
+</Tab>
+</Tabs>

docs/components/embedders/models/azure_openai.mdx

@@ -0,0 +1,136 @@
+---
+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 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 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>
+
+As an alternative to using an API key, the Azure Identity credential chain can be used to authenticate with [Azure OpenAI role-based security](https://learn.microsoft.com/en-us/azure/ai-foundry/openai/how-to/role-based-access-control). 
+
+<Note> If an API key is provided, it will be used for authentication over an Azure Identity </Note>
+
+Below is a sample configuration for using Mem0 with Azure OpenAI and Azure Identity:
+
+```python
+import os
+from mem0 import Memory
+# You can set the values directly in the config dictionary or use environment variables
+
+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": "<your-deployment-name>",
+                  "api_version": "<version-to-use>",
+                  "azure_endpoint": "<your-api-base-url>",
+                  "default_headers": {
+                    "CustomHeader": "your-custom-header",
+                  }
+              }
+        }
+    }
+}
+```
+
+Refer to [Azure Identity troubleshooting tips](https://github.com/Azure/azure-sdk-for-python/blob/main/sdk/identity/azure-identity/TROUBLESHOOTING.md#troubleshoot-environmentcredential-authentication-issues) for setting up an Azure Identity credential.
+
+### Config
+
+Here are the parameters available for configuring Azure 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` |
+| `azure_kwargs` | The Azure OpenAI configs | `config_keys` |
+</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`          | Azure OpenAI API key                          | `None`                     |
+| `modelProperties` | Object containing endpoint and other settings | `{ endpoint: "",...rest   }`|
+</Tab>
+</Tabs>

docs/components/embedders/models/google_AI.mdx

@@ -0,0 +1,79 @@
+---
+title: Google AI
+---
+
+To use Google AI 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
+
+<CodeGroup>
+```python 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 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: "google",
+      config: {
+        apiKey: process.env["GOOGLE_API_KEY"],
+        model: "gemini-embedding-001",
+        embeddingDims: 1536,
+      },
+    },
+};
+
+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 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 Gemini embedder:
+<Tabs>
+<Tab title="Python">
+| Parameter        | Description                          | Default Value           |
+| ---------------- | ------------------------------------ | ----------------------- |
+| `model`          | The name of the embedding model to use| `models/text-embedding-004` |
+| `embedding_dims` | Dimensions of the embedding model     | `1536`                  |
+| `api_key`        | The Google API key                   | `None`                  |
+</Tab>
+<Tab title="TypeScript">
+| Parameter         | Description                                   | Default Value              |
+| ----------------- | --------------------------------------------- | -------------------------- |
+| `model`           | The name of the embedding model to use        | `gemini-embedding-001`     |
+| `embeddingDims`   | Dimensions of the embedding model             | `1536`                     |
+| `apiKey`          | Google API key                                | `None`                     |
+</Tab>
+</Tabs>

docs/components/embedders/models/huggingface.mdx

@@ -0,0 +1,75 @@
+---
+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 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")
+```
+
+### Using Text Embeddings Inference (TEI)
+
+You can also use Hugging Face's Text Embeddings Inference service for faster and more efficient embeddings:
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "your_api_key" # For LLM
+
+# Using HuggingFace Text Embeddings Inference API
+config = {
+    "embedder": {
+        "provider": "huggingface",
+        "config": {
+            "huggingface_base_url": "http://localhost:3000/v1"
+        }
+    }
+}
+
+m = Memory.from_config(config)
+m.add("This text will be embedded using the TEI service.", user_id="john")
+```
+
+To run the TEI service, you can use Docker:
+
+```bash
+docker run -d -p 3000:80 -v huggingfacetei:/data --platform linux/amd64 \
+    ghcr.io/huggingface/text-embeddings-inference:cpu-1.6 \
+    --model-id BAAI/bge-small-en-v1.5
+```
+
+### 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` |
+| `huggingface_base_url` | URL to connect to Text Embeddings Inference (TEI) API | `None` |

docs/components/embedders/models/langchain.mdx

@@ -0,0 +1,196 @@
+---
+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 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';
+import { OpenAIEmbeddings } from "@langchain/openai";
+
+// Initialize a LangChain embeddings model directly
+const openaiEmbeddings = new OpenAIEmbeddings({
+    modelName: "text-embedding-3-small",
+    dimensions: 1536,
+    apiKey: process.env.OPENAI_API_KEY,
+});
+
+const config = {
+  embedder: {
+    provider: 'langchain',
+    config: {
+      model: openaiEmbeddings,
+    },
+  },
+};
+
+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 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>
+
+## 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
+
+<CodeGroup>
+#### HuggingFace Embeddings
+
+```python 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
+        }
+    }
+}
+```
+
+```typescript TypeScript
+import { Memory } from 'mem0ai/oss';
+import { HuggingFaceEmbeddings } from "@langchain/community/embeddings/hf";
+
+// Initialize a HuggingFace embeddings model
+const hfEmbeddings = new HuggingFaceEmbeddings({
+    modelName: "BAAI/bge-small-en-v1.5",
+    encode: {
+        normalize_embeddings: true,
+    },
+});
+
+const config = {
+  embedder: {
+    provider: 'langchain',
+    config: {
+      model: hfEmbeddings,
+    },
+  },
+};
+```
+</CodeGroup>
+
+<CodeGroup>
+#### Ollama Embeddings
+
+```python 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
+        }
+    }
+}
+```
+
+```typescript TypeScript
+import { Memory } from 'mem0ai/oss';
+import { OllamaEmbeddings } from "@langchain/community/embeddings/ollama";
+
+// Initialize an Ollama embeddings model
+const ollamaEmbeddings = new OllamaEmbeddings({
+    model: "nomic-embed-text",
+    baseUrl: "http://localhost:11434", // Ollama server URL
+});
+
+const config = {
+  embedder: {
+    provider: 'langchain',
+    config: {
+      model: ollamaEmbeddings,
+    },
+  },
+};
+```
+</CodeGroup>
+
+<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 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 LM Studio embedder:
+
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `model` | The name of the LM Studio 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,74 @@
+You can use embedding models from Ollama to run Mem0 locally.
+
+### Usage
+
+<CodeGroup>
+```python 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 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: 'ollama',
+    config: {
+      model: 'nomic-embed-text:latest', // or any other Ollama embedding model
+      url: 'http://localhost:11434', // Ollama server URL
+    },
+  },
+};
+
+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 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 Ollama embedder:
+
+<Tabs>
+<Tab title="Python">
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `model` | The name of the Ollama model to use | `nomic-embed-text` |
+| `embedding_dims` | Dimensions of the embedding model | `512` |
+| `ollama_base_url` | Base URL for ollama connection | `None` |
+</Tab>
+<Tab title="TypeScript">
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `model` | The name of the Ollama model to use | `nomic-embed-text:latest` |
+| `url` | Base URL for Ollama server | `http://localhost:11434` |
+| `embeddingDims` | Dimensions of the embedding model | 768
+</Tab>
+</Tabs>

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 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 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 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,32 @@
+---
+title: Overview
+---
+
+Mem0 offers support for various embedding models, allowing users to choose the one that best suits their needs.
+
+## Supported Embedders
+
+See the list of supported embedders below.
+
+<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="Google AI" href="/components/embedders/models/google_AI"></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>
+  <Card title="AWS Bedrock" href="/components/embedders/models/aws_bedrock"></Card>
+</CardGroup>
+
+## Usage
+
+To utilize an embedding model, 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 embedding model.
+
+For a comprehensive list of available parameters for embedding model configuration, please refer to [Config](./config).

docs/components/llms/config.mdx

@@ -0,0 +1,135 @@
+---
+title: Configurations
+---
+
+## 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               |
+    | `sarvam_base_url`    | Base URL for Sarvam API                       | Sarvam            |
+    | `reasoning_effort`   | Reasoning level (low, medium, high)           | Sarvam            |
+    | `frequency_penalty`  | Penalize frequent tokens (-2.0 to 2.0)        | Sarvam            |
+    | `presence_penalty`   | Penalize existing tokens (-2.0 to 2.0)        | Sarvam            |
+    | `seed`               | Seed for deterministic sampling               | Sarvam            |
+    | `stop`               | Stop sequences (max 4)                        | Sarvam            |
+    | `lmstudio_base_url`  | Base URL for LM Studio API                    | LM Studio         |
+    | `response_callback`  | LLM response callback function                | OpenAI            |
+  </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,67 @@
+---
+title: Anthropic
+---
+
+
+To use Anthropic's models, please set the `ANTHROPIC_API_KEY` which you find on their [Account Settings Page](https://console.anthropic.com/account/keys).
+
+## Usage
+
+<CodeGroup>
+```python Python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "your-api-key" # used for embedding model
+os.environ["ANTHROPIC_API_KEY"] = "your-api-key"
+
+config = {
+    "llm": {
+        "provider": "anthropic",
+        "config": {
+            "model": "claude-sonnet-4-20250514",
+            "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 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-sonnet-4-20250514',
+      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 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,43 @@
+---
+title: AWS Bedrock
+---
+
+### Setup
+- Before using the AWS Bedrock LLM, make sure you have the appropriate model access from [Bedrock Console](https://us-east-1.console.aws.amazon.com/bedrock/home?region=us-east-1#/modelaccess).
+- You will also need to authenticate the `boto3` client by using a method in the [AWS documentation](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html#configuring-credentials)
+- You will have to export `AWS_REGION`, `AWS_ACCESS_KEY`, and `AWS_SECRET_ACCESS_KEY` to set environment variables.
+
+### Usage
+
+```python
+import os
+from mem0 import Memory
+
+os.environ['AWS_REGION'] = 'us-west-2'
+os.environ["AWS_ACCESS_KEY_ID"] = "xx"
+os.environ["AWS_SECRET_ACCESS_KEY"] = "xx"
+
+config = {
+    "llm": {
+        "provider": "aws_bedrock",
+        "config": {
+            "model": "anthropic.claude-3-5-haiku-20241022-v1:0",
+            "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 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,161 @@
+---
+title: Azure OpenAI
+---
+
+<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/).
+
+Optionally, you can use Azure Identity to authenticate with Azure OpenAI, which allows you to use managed identities or service principals for production and Azure CLI login for development instead of an API key. If an Azure Identity is to be used, ***do not*** set the `LLM_AZURE_OPENAI_API_KEY` environment variable or the api_key in the config dictionary.
+
+> **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["OPENAI_API_KEY"] = "your-api-key" # used for embedding model
+
+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 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 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",
+                  }
+              }
+        }
+    }
+}
+```
+
+As an alternative to using an API key, the Azure Identity credential chain can be used to authenticate with [Azure OpenAI role-based security](https://learn.microsoft.com/en-us/azure/ai-foundry/openai/how-to/role-based-access-control). 
+
+<Note> If an API key is provided, it will be used for authentication over an Azure Identity </Note>
+
+Below is a sample configuration for using Mem0 with Azure OpenAI and Azure Identity:
+
+```python
+import os
+from mem0 import Memory
+# You can set the values directly in the config dictionary or use environment variables
+
+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": "<your-deployment-name>",
+                  "api_version": "<version-to-use>",
+                  "azure_endpoint": "<your-api-base-url>",
+                  "default_headers": {
+                    "CustomHeader": "your-custom-header",
+                  }
+              }
+        }
+    }
+}
+```
+
+Refer to [Azure Identity troubleshooting tips](https://github.com/Azure/azure-sdk-for-python/blob/main/sdk/identity/azure-identity/TROUBLESHOOTING.md#troubleshoot-environmentcredential-authentication-issues) for setting up an Azure Identity credential.
+
+
+## Config
+
+All available parameters for the `azure_openai` config are present in [Master List of All Params in Config](../config).

docs/components/llms/models/deepseek.mdx

@@ -0,0 +1,55 @@
+---
+title: DeepSeek
+---
+
+To use DeepSeek LLM models, you have to set the `DEEPSEEK_API_KEY` environment variable. You can also optionally set `DEEPSEEK_API_BASE` if you need to use a different API endpoint (defaults to "https://api.deepseek.com").
+
+## Usage
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["DEEPSEEK_API_KEY"] = "your-api-key"
+os.environ["OPENAI_API_KEY"] = "your-api-key" # for embedder model
+
+config = {
+    "llm": {
+        "provider": "deepseek",
+        "config": {
+            "model": "deepseek-chat",  # default model
+            "temperature": 0.2,
+            "max_tokens": 2000,
+            "top_p": 1.0
+        }
+    }
+}
+
+m = Memory.from_config(config)
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about 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/google_AI.mdx

@@ -0,0 +1,74 @@
+---
+title: Google AI
+---
+
+To use the Gemini model, set the `GOOGLE_API_KEY` environment variable. You can obtain the Google/Gemini API key from [Google AI Studio](https://aistudio.google.com/app/apikey).
+
+> **Note:** As of the latest release, Mem0 uses the new `google.genai` SDK instead of the deprecated `google.generativeai`. All message formatting and model interaction now use the updated `types` module from `google.genai`.
+
+> **Note:** Some Gemini models are being deprecated and will retire soon. It is recommended to migrate to the latest stable models like `"gemini-2.0-flash-001"` or `"gemini-2.0-flash-lite-001"` to ensure ongoing support and improvements.
+
+## Usage
+
+<CodeGroup>
+```python Python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "your-openai-api-key"  # Used for embedding model
+os.environ["GOOGLE_API_KEY"] = "your-gemini-api-key"
+
+config = {
+    "llm": {
+        "provider": "gemini",
+        "config": {
+            "model": "gemini-2.0-flash-001",
+            "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 thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I’m not a big fan of thrillers, but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thrillers and suggest sci-fi movies instead."}
+]
+
+m.add(messages, user_id="alice", metadata={"category": "movies"})
+
+```
+```typescript TypeScript
+import { Memory } from "mem0ai/oss";
+
+const config = {
+    llm: {
+        // You can also use "google" as provider ( for backward compatibility )
+        provider: "gemini",
+        config: {
+            model: "gemini-2.0-flash-001",
+            temperature: 0.1
+        }
+    }
+}
+
+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 thriller movies? They can be quite engaging." },
+    { role: "user", content: "I’m not a big fan of thrillers, but I love sci-fi movies." },
+    { role: "assistant", content: "Got it! I'll avoid thrillers and suggest sci-fi movies instead." }
+]
+
+await memory.add(messages, { userId: "alice", metadata: { category: "movies" } });
+```
+</CodeGroup>
+
+## Config
+
+All available parameters for the `Gemini` config are present in [Master List of All Params in Config](../config).

docs/components/llms/models/groq.mdx

@@ -0,0 +1,68 @@
+---
+title: Groq
+---
+
+[Groq](https://groq.com/) is the creator of the world's first Language Processing Unit (LPU), providing exceptional speed performance for AI workloads running on their LPU Inference Engine.
+
+In order to use LLMs from Groq, go to their [platform](https://console.groq.com/keys) and get the API key. Set the API key as `GROQ_API_KEY` environment variable to use the model as given below in the example.
+
+## Usage
+
+<CodeGroup>
+```python Python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "your-api-key" # used for embedding model
+os.environ["GROQ_API_KEY"] = "your-api-key"
+
+config = {
+    "llm": {
+        "provider": "groq",
+        "config": {
+            "model": "mixtral-8x7b-32768",
+            "temperature": 0.1,
+            "max_tokens": 2000,
+        }
+    }
+}
+
+m = Memory.from_config(config)
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about 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 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,109 @@
+---
+title: LangChain
+---
+
+
+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-4.1-nano-2025-04-14",
+    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 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';
+import { ChatOpenAI } from "@langchain/openai";
+
+// Initialize a LangChain model directly
+const openaiModel = new ChatOpenAI({
+    modelName: "gpt-4",
+    temperature: 0.2,
+    maxTokens: 2000,
+    apiKey: process.env.OPENAI_API_KEY,
+});
+
+const config = {
+  llm: {
+    provider: 'langchain',
+    config: {
+      model: openaiModel,
+    },
+  },
+};
+
+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 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>
+
+## 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,34 @@
+[Litellm](https://litellm.vercel.app/docs/) is compatible with over 100 large language models (LLMs), all using a standardized input/output format. You can explore the [available models](https://litellm.vercel.app/docs/providers) to use with Litellm. Ensure you set the `API_KEY` for the model you choose to use.
+
+## Usage
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "your-api-key"
+
+config = {
+    "llm": {
+        "provider": "litellm",
+        "config": {
+            "model": "gpt-4.1-nano-2025-04-14",
+            "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 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,83 @@
+---
+title: LM Studio
+---
+
+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
+            "lmstudio_response_format": {"type": "json_schema", "json_schema": {"type": "object", "schema": {}}},
+        }
+    }
+}
+
+m = Memory.from_config(config)
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about 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 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,66 @@
+---
+title: Mistral AI
+---
+
+To use mistral's models, please obtain the Mistral AI api key from their [console](https://console.mistral.ai/). Set the `MISTRAL_API_KEY` environment variable to use the model as given below in the example.
+
+## Usage
+
+<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 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 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,64 @@
+---
+title: Ollama
+---
+
+You can use LLMs from Ollama to run Mem0 locally. These [models](https://ollama.com/search?c=tools) support tool calling.
+
+## Usage
+
+<CodeGroup>
+```python 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 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: 'ollama',
+    config: {
+      model: 'llama3.1:8b', // or any other Ollama model
+      url: 'http://localhost:11434', // Ollama server URL
+      temperature: 0.1,
+    },
+  },
+};
+
+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 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 `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
+---
+
+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).
+
+> **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["OPENAI_API_KEY"] = "your-api-key"
+
+config = {
+    "llm": {
+        "provider": "openai",
+        "config": {
+            "model": "gpt-4.1-nano-2025-04-14",
+            "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 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 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-4.1-nano-2025-04-14",
+            "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/sarvam.mdx

@@ -0,0 +1,73 @@
+---
+title: Sarvam AI
+---
+
+**Sarvam AI** is an Indian AI company developing language models with a focus on Indian languages and cultural context. Their latest model **Sarvam-M** is designed to understand and generate content in multiple Indian languages while maintaining high performance in English.
+
+To use Sarvam AI's models, please set the `SARVAM_API_KEY` which you can get from their [platform](https://dashboard.sarvam.ai/).
+
+## Usage
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "your-api-key" # used for embedding model
+os.environ["SARVAM_API_KEY"] = "your-api-key"
+
+config = {
+    "llm": {
+        "provider": "sarvam",
+        "config": {
+            "model": "sarvam-m",
+            "temperature": 0.7,
+        }
+    }
+}
+
+m = Memory.from_config(config)
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about 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="alex")
+```
+
+## Advanced Usage with Sarvam-Specific Features
+
+```python
+import os
+from mem0 import Memory
+
+config = {
+    "llm": {
+        "provider": "sarvam",
+        "config": {
+            "model": {
+                "name": "sarvam-m",
+                "reasoning_effort": "high",  # Enable advanced reasoning
+                "frequency_penalty": 0.1,    # Reduce repetition
+                "seed": 42                   # For deterministic outputs
+            },
+            "temperature": 0.3,
+            "max_tokens": 2000,
+            "api_key": "your-sarvam-api-key"
+        }
+    }
+}
+
+m = Memory.from_config(config)
+
+# Example with Hindi conversation
+messages = [
+    {"role": "user", "content": "मैं SBI में joint account खोलना चाहता हूँ।"},
+    {"role": "assistant", "content": "SBI में joint account खोलने के लिए आपको कुछ documents की जरूरत होगी। क्या आप जानना चाहते हैं कि कौन से documents चाहिए?"}
+]
+m.add(messages, user_id="rajesh", metadata={"language": "hindi", "topic": "banking"})
+```
+
+## Config
+
+All available parameters for the `sarvam` config are present in [Master List of All Params in Config](../config).

docs/components/llms/models/together.mdx

@@ -0,0 +1,39 @@
+---
+title: Together
+---
+
+To use Together LLM models, you have to set the `TOGETHER_API_KEY` environment variable. You can obtain the Together 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 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 `together` config are present in [Master List of All Params in Config](../config).

docs/components/llms/models/vllm.mdx

@@ -0,0 +1,107 @@
+---
+title: vLLM
+---
+
+[vLLM](https://docs.vllm.ai/) is a high-performance inference engine for large language models that provides significant performance improvements for local inference. It's designed to maximize throughput and memory efficiency for serving LLMs.
+
+## Prerequisites
+
+1. **Install vLLM**:
+
+   ```bash
+   pip install vllm
+   ```
+
+2. **Start vLLM server**:
+
+   ```bash
+   # For testing with a small model
+   vllm serve microsoft/DialoGPT-medium --port 8000
+
+   # For production with a larger model (requires GPU)
+   vllm serve Qwen/Qwen2.5-32B-Instruct --port 8000
+   ```
+
+## Usage
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "your-api-key"  # used for embedding model
+
+config = {
+    "llm": {
+        "provider": "vllm",
+        "config": {
+            "model": "Qwen/Qwen2.5-32B-Instruct",
+            "vllm_base_url": "http://localhost:8000/v1",
+            "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 thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I'm not a big fan of thrillers, but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thrillers and suggest sci-fi movies instead."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
+```
+
+## Configuration Parameters
+
+| Parameter       | Description                       | Default                       | Environment Variable |
+| --------------- | --------------------------------- | ----------------------------- | -------------------- |
+| `model`         | Model name running on vLLM server | `"Qwen/Qwen2.5-32B-Instruct"` | -                    |
+| `vllm_base_url` | vLLM server URL                   | `"http://localhost:8000/v1"`  | `VLLM_BASE_URL`      |
+| `api_key`       | API key (dummy for local)         | `"vllm-api-key"`              | `VLLM_API_KEY`       |
+| `temperature`   | Sampling temperature              | `0.1`                         | -                    |
+| `max_tokens`    | Maximum tokens to generate        | `2000`                        | -                    |
+
+## Environment Variables
+
+You can set these environment variables instead of specifying them in config:
+
+```bash
+export VLLM_BASE_URL="http://localhost:8000/v1"
+export VLLM_API_KEY="your-vllm-api-key"
+export OPENAI_API_KEY="your-openai-api-key"  # for embeddings
+```
+
+## Benefits
+
+- **High Performance**: 2-24x faster inference than standard implementations
+- **Memory Efficient**: Optimized memory usage with PagedAttention
+- **Local Deployment**: Keep your data private and reduce API costs
+- **Easy Integration**: Drop-in replacement for other LLM providers
+- **Flexible**: Works with any model supported by vLLM
+
+## Troubleshooting
+
+1. **Server not responding**: Make sure vLLM server is running
+
+   ```bash
+   curl http://localhost:8000/health
+   ```
+
+2. **404 errors**: Ensure correct base URL format
+
+   ```python
+   "vllm_base_url": "http://localhost:8000/v1"  # Note the /v1
+   ```
+
+3. **Model not found**: Check model name matches server
+
+4. **Out of memory**: Try smaller models or reduce `max_model_len`
+
+   ```bash
+   vllm serve Qwen/Qwen2.5-32B-Instruct --max-model-len 4096
+   ```
+
+## Config
+
+All available parameters for the `vllm` config are present in [Master List of All Params in Config](../config).

docs/components/llms/models/xAI.mdx

@@ -0,0 +1,41 @@
+---
+title: xAI
+---
+
+[xAI](https://x.ai/) is a new AI company founded by Elon Musk that develops large language models, including Grok. Grok is trained on real-time data from X (formerly Twitter) and aims to provide accurate, up-to-date responses with a touch of wit and humor.
+
+In order to use LLMs from xAI, go to their [platform](https://console.x.ai) and get the API key. Set the API key as `XAI_API_KEY` environment variable to use the model as given below in the example.
+
+## Usage
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "your-api-key" # used for embedding model
+os.environ["XAI_API_KEY"] = "your-api-key"
+
+config = {
+    "llm": {
+        "provider": "xai",
+        "config": {
+            "model": "grok-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 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,61 @@
+---
+title: Overview
+---
+
+Mem0 includes built-in support for various popular large language models. Memory can utilize the LLM provided by the user, ensuring efficient use for specific needs.
+
+## Usage
+
+To use a llm, you must provide a configuration to customize its usage. If no configuration is supplied, a default configuration will be applied, and `OpenAI` will be used as the llm.
+
+For a comprehensive list of available parameters for llm configuration, please refer to [Config](./config).
+
+## Supported LLMs
+
+See the list of supported LLMs below.
+
+<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="DeepSeek" href="/components/llms/models/deepseek" />
+  <Card title="xAI" href="/components/llms/models/xAI" />
+  <Card title="Sarvam AI" href="/components/llms/models/sarvam" />
+  <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/rerankers/config.mdx

@@ -0,0 +1,105 @@
+---
+title: Config
+description: "Configuration options for rerankers in Mem0"
+---
+
+## Common Configuration Parameters
+
+All rerankers share these common configuration parameters:
+
+| Parameter  | Description                                         | Type  | Default  |
+| ---------- | --------------------------------------------------- | ----- | -------- |
+| `provider` | Reranker provider name                              | `str` | Required |
+| `top_k`    | Maximum number of results to return after reranking | `int` | `None`   |
+| `api_key`  | API key for the reranker service                    | `str` | `None`   |
+
+## Provider-Specific Configuration
+
+### Zero Entropy
+
+| Parameter | Description                                  | Type  | Default      |
+| --------- | -------------------------------------------- | ----- | ------------ |
+| `model`   | Model to use: `zerank-1` or `zerank-1-small` | `str` | `"zerank-1"` |
+| `api_key` | Zero Entropy API key                         | `str` | `None`       |
+
+### Cohere
+
+| Parameter            | Description                                  | Type   | Default                 |
+| -------------------- | -------------------------------------------- | ------ | ----------------------- |
+| `model`              | Cohere rerank model                          | `str`  | `"rerank-english-v3.0"` |
+| `api_key`            | Cohere API key                               | `str`  | `None`                  |
+| `return_documents`   | Whether to return document texts in response | `bool` | `False`                 |
+| `max_chunks_per_doc` | Maximum chunks per document                  | `int`  | `None`                  |
+
+### Sentence Transformer
+
+| Parameter           | Description                                  | Type   | Default                                  |
+| ------------------- | -------------------------------------------- | ------ | ---------------------------------------- |
+| `model`             | HuggingFace cross-encoder model name         | `str`  | `"cross-encoder/ms-marco-MiniLM-L-6-v2"` |
+| `device`            | Device to run model on (`cpu`, `cuda`, etc.) | `str`  | `None`                                   |
+| `batch_size`        | Batch size for processing                    | `int`  | `32`                                     |
+| `show_progress_bar` | Show progress during processing              | `bool` | `False`                                  |
+
+### Hugging Face
+
+| Parameter | Description                                  | Type  | Default                     |
+| --------- | -------------------------------------------- | ----- | --------------------------- |
+| `model`   | HuggingFace reranker model name              | `str` | `"BAAI/bge-reranker-large"` |
+| `api_key` | HuggingFace API token                        | `str` | `None`                      |
+| `device`  | Device to run model on (`cpu`, `cuda`, etc.) | `str` | `None`                      |
+
+### LLM-based
+
+| Parameter        | Description                                | Type    | Default                |
+| ---------------- | ------------------------------------------ | ------- | ---------------------- |
+| `model`          | LLM model to use for scoring               | `str`   | `"gpt-4o-mini"`        |
+| `provider`       | LLM provider (`openai`, `anthropic`, etc.) | `str`   | `"openai"`             |
+| `api_key`        | API key for LLM provider                   | `str`   | `None`                 |
+| `temperature`    | Temperature for LLM generation             | `float` | `0.0`                  |
+| `max_tokens`     | Maximum tokens for LLM response            | `int`   | `100`                  |
+| `scoring_prompt` | Custom prompt template for scoring         | `str`   | Default scoring prompt |
+
+### LLM Reranker
+
+| Parameter      | Description                 | Type   | Default  |
+| -------------- | --------------------------- | ------ | -------- |
+| `llm.provider` | LLM provider for reranking  | `str`  | Required |
+| `llm.config`   | LLM configuration object    | `dict` | Required |
+| `top_n`        | Number of results to return | `int`  | `None`   |
+
+## Environment Variables
+
+You can set API keys using environment variables:
+
+- `ZERO_ENTROPY_API_KEY` - Zero Entropy API key
+- `COHERE_API_KEY` - Cohere API key
+- `HUGGINGFACE_API_KEY` - HuggingFace API token
+- `OPENAI_API_KEY` - OpenAI API key (for LLM-based reranker)
+- `ANTHROPIC_API_KEY` - Anthropic API key (for LLM-based reranker)
+
+## Basic Configuration Example
+
+```python Python
+config = {
+    "vector_store": {
+        "provider": "chroma",
+        "config": {
+            "collection_name": "my_memories",
+            "path": "./chroma_db"
+        }
+    },
+    "llm": {
+        "provider": "openai",
+        "config": {
+            "model": "gpt-4.1-nano-2025-04-14"
+        }
+    },
+    "reranker": {
+        "provider": "zero_entropy",
+        "config": {
+            "model": "zerank-1",
+            "top_k": 5
+        }
+    }
+}
+```

docs/components/rerankers/custom-prompts.mdx

@@ -0,0 +1,220 @@
+---
+title: Custom Prompts
+---
+
+When using LLM rerankers, you can customize the prompts used for ranking to better suit your specific use case and domain.
+
+## Default Prompt
+
+The default LLM reranker prompt is designed to be general-purpose:
+
+```
+Given a query and a list of memory entries, rank the memory entries based on their relevance to the query.
+Rate each memory on a scale of 1-10 where 10 is most relevant.
+
+Query: {query}
+
+Memory entries:
+{memories}
+
+Provide your ranking as a JSON array with scores for each memory.
+```
+
+## Custom Prompt Configuration
+
+You can provide a custom prompt template when configuring the LLM reranker:
+
+```python
+from mem0 import Memory
+
+custom_prompt = """
+You are an expert at ranking memories for a personal AI assistant.
+Given a user query and a list of memory entries, rank each memory based on:
+1. Direct relevance to the query
+2. Temporal relevance (recent memories may be more important)
+3. Emotional significance
+4. Actionability
+
+Query: {query}
+User Context: {user_context}
+
+Memory entries:
+{memories}
+
+Rate each memory from 1-10 and provide reasoning.
+Return as JSON: {{"rankings": [{{"index": 0, "score": 8, "reason": "..."}}]}}
+"""
+
+config = {
+    "reranker": {
+        "provider": "llm_reranker",
+        "config": {
+            "llm": {
+                "provider": "openai",
+                "config": {
+                    "model": "gpt-4.1-nano-2025-04-14",
+                    "api_key": "your-openai-key"
+                }
+            },
+            "custom_prompt": custom_prompt,
+            "top_n": 5
+        }
+    }
+}
+
+memory = Memory.from_config(config)
+```
+
+## Prompt Variables
+
+Your custom prompt can use the following variables:
+
+| Variable         | Description                           |
+| ---------------- | ------------------------------------- |
+| `{query}`        | The search query                      |
+| `{memories}`     | The list of memory entries to rank    |
+| `{user_id}`      | The user ID (if available)            |
+| `{user_context}` | Additional user context (if provided) |
+
+## Domain-Specific Examples
+
+### Customer Support
+
+```python
+customer_support_prompt = """
+You are ranking customer support conversation memories.
+Prioritize memories that:
+- Relate to the current customer issue
+- Show previous resolution patterns
+- Indicate customer preferences or constraints
+
+Query: {query}
+Customer Context: Previous interactions with this customer
+
+Memories:
+{memories}
+
+Rank each memory 1-10 based on support relevance.
+"""
+```
+
+### Educational Content
+
+```python
+educational_prompt = """
+Rank these learning memories for a student query.
+Consider:
+- Prerequisite knowledge requirements
+- Learning progression and difficulty
+- Relevance to current learning objectives
+
+Student Query: {query}
+Learning Context: {user_context}
+
+Available memories:
+{memories}
+
+Score each memory for educational value (1-10).
+"""
+```
+
+### Personal Assistant
+
+```python
+personal_assistant_prompt = """
+Rank personal memories for relevance to the user's query.
+Consider:
+- Recent vs. historical importance
+- Personal preferences and habits
+- Contextual relationships between memories
+
+Query: {query}
+Personal context: {user_context}
+
+Memories to rank:
+{memories}
+
+Provide relevance scores (1-10) with brief explanations.
+"""
+```
+
+## Advanced Prompt Techniques
+
+### Multi-Criteria Ranking
+
+```python
+multi_criteria_prompt = """
+Evaluate memories using multiple criteria:
+
+1. RELEVANCE (40%): How directly related to the query
+2. RECENCY (20%): How recent the memory is
+3. IMPORTANCE (25%): Personal or business significance
+4. ACTIONABILITY (15%): How useful for next steps
+
+Query: {query}
+Context: {user_context}
+
+Memories:
+{memories}
+
+For each memory, provide:
+- Overall score (1-10)
+- Breakdown by criteria
+- Final ranking recommendation
+
+Format: JSON with detailed scoring
+"""
+```
+
+### Contextual Ranking
+
+```python
+contextual_prompt = """
+Consider the following context when ranking memories:
+- Current user situation: {user_context}
+- Time of day: {current_time}
+- Recent activities: {recent_activities}
+
+Query: {query}
+
+Rank these memories considering both direct relevance and contextual appropriateness:
+{memories}
+
+Provide contextually-aware relevance scores (1-10).
+"""
+```
+
+## Best Practices
+
+1. **Be Specific**: Clearly define what makes a memory relevant for your use case
+2. **Use Examples**: Include examples in your prompt for better model understanding
+3. **Structure Output**: Specify the exact JSON format you want returned
+4. **Test Iteratively**: Refine your prompt based on actual ranking performance
+5. **Consider Token Limits**: Keep prompts concise while being comprehensive
+
+## Prompt Testing
+
+You can test different prompts by comparing ranking results:
+
+```python
+# Test multiple prompt variations
+prompts = [
+    default_prompt,
+    custom_prompt_v1,
+    custom_prompt_v2
+]
+
+for i, prompt in enumerate(prompts):
+    config["reranker"]["config"]["custom_prompt"] = prompt
+    memory = Memory.from_config(config)
+
+    results = memory.search("test query", user_id="test_user")
+    print(f"Prompt {i+1} results: {results}")
+```
+
+## Common Issues
+
+- **Too Long**: Keep prompts under token limits for your chosen LLM
+- **Too Vague**: Be specific about ranking criteria
+- **Inconsistent Format**: Ensure JSON output format is clearly specified
+- **Missing Context**: Include relevant variables for your use case

docs/components/rerankers/models/cohere.mdx

@@ -0,0 +1,145 @@
+---
+title: Cohere
+description: "Reranking with Cohere"
+---
+
+Cohere provides enterprise-grade reranking models with excellent multilingual support and production-ready performance.
+
+## Models
+
+Cohere offers several reranking models:
+
+- **`rerank-english-v3.0`**: Latest English reranker with best performance
+- **`rerank-multilingual-v3.0`**: Multilingual support for global applications
+- **`rerank-english-v2.0`**: Previous generation English reranker
+
+## Installation
+
+```bash
+pip install cohere
+```
+
+## Configuration
+
+```python Python
+from mem0 import Memory
+
+config = {
+    "vector_store": {
+        "provider": "chroma",
+        "config": {
+            "collection_name": "my_memories",
+            "path": "./chroma_db"
+        }
+    },
+    "llm": {
+        "provider": "openai",
+        "config": {
+            "model": "gpt-4.1-nano-2025-04-14"
+        }
+    },
+    "reranker": {
+        "provider": "cohere",
+        "config": {
+            "model": "rerank-english-v3.0",
+            "api_key": "your-cohere-api-key",  # or set COHERE_API_KEY
+            "top_k": 5,
+            "return_documents": False,
+            "max_chunks_per_doc": None
+        }
+    }
+}
+
+memory = Memory.from_config(config)
+```
+
+## Environment Variables
+
+Set your API key as an environment variable:
+
+```bash
+export COHERE_API_KEY="your-api-key"
+```
+
+## Usage Example
+
+```python Python
+import os
+from mem0 import Memory
+
+# Set API key
+os.environ["COHERE_API_KEY"] = "your-api-key"
+
+# Initialize memory with Cohere reranker
+config = {
+    "vector_store": {"provider": "chroma"},
+    "llm": {"provider": "openai", "config": {"model": "gpt-4o-mini"}},
+    "rerank": {
+        "provider": "cohere",
+        "config": {
+            "model": "rerank-english-v3.0",
+            "top_k": 3
+        }
+    }
+}
+
+memory = Memory.from_config(config)
+
+# Add memories
+messages = [
+    {"role": "user", "content": "I work as a data scientist at Microsoft"},
+    {"role": "user", "content": "I specialize in machine learning and NLP"},
+    {"role": "user", "content": "I enjoy playing tennis on weekends"}
+]
+
+memory.add(messages, user_id="bob")
+
+# Search with reranking
+results = memory.search("What is the user's profession?", user_id="bob")
+
+for result in results['results']:
+    print(f"Memory: {result['memory']}")
+    print(f"Vector Score: {result['score']:.3f}")
+    print(f"Rerank Score: {result['rerank_score']:.3f}")
+    print()
+```
+
+## Multilingual Support
+
+For multilingual applications, use the multilingual model:
+
+```python Python
+config = {
+    "rerank": {
+        "provider": "cohere",
+        "config": {
+            "model": "rerank-multilingual-v3.0",
+            "top_k": 5
+        }
+    }
+}
+```
+
+## Configuration Parameters
+
+| Parameter            | Description                      | Type   | Default                 |
+| -------------------- | -------------------------------- | ------ | ----------------------- |
+| `model`              | Cohere rerank model to use       | `str`  | `"rerank-english-v3.0"` |
+| `api_key`            | Cohere API key                   | `str`  | `None`                  |
+| `top_k`              | Maximum documents to return      | `int`  | `None`                  |
+| `return_documents`   | Whether to return document texts | `bool` | `False`                 |
+| `max_chunks_per_doc` | Maximum chunks per document      | `int`  | `None`                  |
+
+## Features
+
+- **High Quality**: Enterprise-grade relevance scoring
+- **Multilingual**: Support for 100+ languages
+- **Scalable**: Production-ready with high throughput
+- **Reliable**: SLA-backed service with 99.9% uptime
+
+## Best Practices
+
+1. **Model Selection**: Use `rerank-english-v3.0` for English, `rerank-multilingual-v3.0` for other languages
+2. **Batch Processing**: Process multiple queries efficiently
+3. **Error Handling**: Implement retry logic for production systems
+4. **Monitoring**: Track reranking performance and costs

docs/components/rerankers/models/huggingface.mdx

@@ -0,0 +1,350 @@
+---
+title: Hugging Face Reranker
+description: 'Access thousands of reranking models from Hugging Face Hub'
+---
+
+## Overview
+
+The Hugging Face reranker provider gives you access to thousands of reranking models available on the Hugging Face Hub. This includes popular models like BAAI's BGE rerankers and other state-of-the-art cross-encoder models.
+
+## Configuration
+
+### Basic Setup
+
+```python
+from mem0 import Memory
+
+config = {
+    "reranker": {
+        "provider": "huggingface",
+        "config": {
+            "model": "BAAI/bge-reranker-base",
+            "device": "cpu"
+        }
+    }
+}
+
+m = Memory.from_config(config)
+```
+
+### Configuration Parameters
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `model` | str | Required | Hugging Face model identifier |
+| `device` | str | "cpu" | Device to run model on ("cpu", "cuda", "mps") |
+| `batch_size` | int | 32 | Batch size for processing |
+| `max_length` | int | 512 | Maximum input sequence length |
+| `trust_remote_code` | bool | False | Allow remote code execution |
+
+### Advanced Configuration
+
+```python
+config = {
+    "reranker": {
+        "provider": "huggingface",
+        "config": {
+            "model": "BAAI/bge-reranker-large",
+            "device": "cuda",
+            "batch_size": 16,
+            "max_length": 512,
+            "trust_remote_code": False,
+            "model_kwargs": {
+                "torch_dtype": "float16"
+            }
+        }
+    }
+}
+```
+
+## Popular Models
+
+### BGE Rerankers (Recommended)
+
+```python
+# Base model - good balance of speed and quality
+config = {
+    "reranker": {
+        "provider": "huggingface",
+        "config": {
+            "model": "BAAI/bge-reranker-base",
+            "device": "cuda"
+        }
+    }
+}
+
+# Large model - better quality, slower
+config = {
+    "reranker": {
+        "provider": "huggingface",
+        "config": {
+            "model": "BAAI/bge-reranker-large",
+            "device": "cuda"
+        }
+    }
+}
+
+# v2 models - latest improvements
+config = {
+    "reranker": {
+        "provider": "huggingface",
+        "config": {
+            "model": "BAAI/bge-reranker-v2-m3",
+            "device": "cuda"
+        }
+    }
+}
+```
+
+### Multilingual Models
+
+```python
+# Multilingual BGE reranker
+config = {
+    "reranker": {
+        "provider": "huggingface",
+        "config": {
+            "model": "BAAI/bge-reranker-v2-multilingual",
+            "device": "cuda"
+        }
+    }
+}
+```
+
+### Domain-Specific Models
+
+```python
+# For code search
+config = {
+    "reranker": {
+        "provider": "huggingface",
+        "config": {
+            "model": "microsoft/codebert-base",
+            "device": "cuda"
+        }
+    }
+}
+
+# For biomedical content
+config = {
+    "reranker": {
+        "provider": "huggingface",
+        "config": {
+            "model": "dmis-lab/biobert-base-cased-v1.1",
+            "device": "cuda"
+        }
+    }
+}
+```
+
+## Usage Examples
+
+### Basic Usage
+
+```python
+from mem0 import Memory
+
+m = Memory.from_config(config)
+
+# Add some memories
+m.add("I love hiking in the mountains", user_id="alice")
+m.add("Pizza is my favorite food", user_id="alice")
+m.add("I enjoy reading science fiction books", user_id="alice")
+
+# Search with reranking
+results = m.search(
+    "What outdoor activities do I enjoy?",
+    user_id="alice",
+    rerank=True
+)
+
+for result in results["results"]:
+    print(f"Memory: {result['memory']}")
+    print(f"Score: {result['score']:.3f}")
+```
+
+### Batch Processing
+
+```python
+# Process multiple queries efficiently
+queries = [
+    "What are my hobbies?",
+    "What food do I like?",
+    "What books interest me?"
+]
+
+results = []
+for query in queries:
+    result = m.search(query, user_id="alice", rerank=True)
+    results.append(result)
+```
+
+## Performance Optimization
+
+### GPU Acceleration
+
+```python
+# Use GPU for better performance
+config = {
+    "reranker": {
+        "provider": "huggingface",
+        "config": {
+            "model": "BAAI/bge-reranker-base",
+            "device": "cuda",
+            "batch_size": 64,  # Increase batch size for GPU
+        }
+    }
+}
+```
+
+### Memory Optimization
+
+```python
+# For limited memory environments
+config = {
+    "reranker": {
+        "provider": "huggingface",
+        "config": {
+            "model": "BAAI/bge-reranker-base",
+            "device": "cpu",
+            "batch_size": 8,   # Smaller batch size
+            "max_length": 256, # Shorter sequences
+            "model_kwargs": {
+                "torch_dtype": "float16"  # Half precision
+            }
+        }
+    }
+}
+```
+
+## Model Comparison
+
+| Model | Size | Quality | Speed | Memory | Best For |
+|-------|------|---------|-------|---------|----------|
+| bge-reranker-base | 278M | Good | Fast | Low | General use |
+| bge-reranker-large | 560M | Better | Medium | Medium | High quality needs |
+| bge-reranker-v2-m3 | 568M | Best | Medium | Medium | Latest improvements |
+| bge-reranker-v2-multilingual | 568M | Good | Medium | Medium | Multiple languages |
+
+## Error Handling
+
+```python
+try:
+    results = m.search(
+        "test query",
+        user_id="alice",
+        rerank=True
+    )
+except Exception as e:
+    print(f"Reranking failed: {e}")
+    # Fall back to vector search only
+    results = m.search(
+        "test query",
+        user_id="alice",
+        rerank=False
+    )
+```
+
+## Custom Models
+
+### Using Private Models
+
+```python
+# Use a private model from Hugging Face
+config = {
+    "reranker": {
+        "provider": "huggingface",
+        "config": {
+            "model": "your-org/custom-reranker",
+            "device": "cuda",
+            "use_auth_token": "your-hf-token"
+        }
+    }
+}
+```
+
+### Local Model Path
+
+```python
+# Use a locally downloaded model
+config = {
+    "reranker": {
+        "provider": "huggingface",
+        "config": {
+            "model": "/path/to/local/model",
+            "device": "cuda"
+        }
+    }
+}
+```
+
+## Best Practices
+
+1. **Choose the Right Model**: Balance quality vs speed based on your needs
+2. **Use GPU**: Significantly faster than CPU for larger models
+3. **Optimize Batch Size**: Tune based on your hardware capabilities
+4. **Monitor Memory**: Watch GPU/CPU memory usage with large models
+5. **Cache Models**: Download once and reuse to avoid repeated downloads
+
+## Troubleshooting
+
+### Common Issues
+
+**Out of Memory Error**
+```python
+# Reduce batch size and sequence length
+config = {
+    "reranker": {
+        "provider": "huggingface",
+        "config": {
+            "model": "BAAI/bge-reranker-base",
+            "batch_size": 4,
+            "max_length": 256
+        }
+    }
+}
+```
+
+**Model Download Issues**
+```python
+# Set cache directory
+import os
+os.environ["TRANSFORMERS_CACHE"] = "/path/to/cache"
+
+# Or use offline mode
+config = {
+    "reranker": {
+        "provider": "huggingface",
+        "config": {
+            "model": "BAAI/bge-reranker-base",
+            "local_files_only": True
+        }
+    }
+}
+```
+
+**CUDA Not Available**
+```python
+import torch
+
+config = {
+    "reranker": {
+        "provider": "huggingface",
+        "config": {
+            "model": "BAAI/bge-reranker-base",
+            "device": "cuda" if torch.cuda.is_available() else "cpu"
+        }
+    }
+}
+```
+
+## Next Steps
+
+<CardGroup cols={2}>
+  <Card title="Reranker Overview" icon="sort" href="/components/rerankers/overview">
+    Learn about reranking concepts
+  </Card>
+  <Card title="Configuration Guide" icon="gear" href="/components/rerankers/config">
+    Detailed configuration options
+  </Card>
+</CardGroup>