Fix: add pgvector support to NodeJS OSS VectorStoreFactory (fixes #3491) (#3997)

Co-authored-by: kartik-mem0 <kartik.labhshetwar@mem0.ai>

.github/workflows/cd.yml

@@ -18,20 +18,17 @@ jobs:
         with:
           python-version: '3.11'
 
-      - name: Install Poetry
+      - name: Install Hatch
         run: |
-          curl -sSL https://install.python-poetry.org | python3 -
-          echo "$HOME/.local/bin" >> $GITHUB_PATH
+          pip install hatch
 
       - name: Install dependencies
         run: |
-          cd mem0
-          poetry install
+          hatch env create
 
       - name: Build a binary wheel and a source tarball
         run: |
-          cd mem0
-          poetry build
+          hatch build --clean
 
       # TODO: Needs to setup mem0 repo on Test PyPI
       # - name: Publish distribution 📦 to Test PyPI

.github/workflows/ci.yml

@@ -7,6 +7,8 @@ on:
       - 'mem0/**'
       - 'tests/**'
       - 'embedchain/**'
+      - '.github/workflows/**'
+      - 'pyproject.toml'
   pull_request:
     paths:
       - 'mem0/**'
@@ -28,6 +30,8 @@ jobs:
           mem0:
             - 'mem0/**'
             - 'tests/**'
+            - '.github/workflows/**'
+            - 'pyproject.toml'
           embedchain:
             - 'embedchain/**'
 
@@ -37,28 +41,38 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ["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
-        uses: snok/install-poetry@v1
-        with:
-          version: 1.4.2
-          virtualenvs-create: true
-          virtualenvs-in-project: true
+      - 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-poetry-dependencies
+        id: cached-hatch-dependencies
         uses: actions/cache@v3
         with:
           path: .venv
-          key: venv-mem0-${{ runner.os }}-${{ hashFiles('**/poetry.lock') }}
+          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: make install_all
-        if: steps.cached-poetry-dependencies.outputs.cache-hit != 'true'
+        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
 
@@ -68,28 +82,28 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ["3.9", "3.10", "3.11"]
+        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 poetry
-        uses: snok/install-poetry@v1
-        with:
-          version: 1.4.2
-          virtualenvs-create: true
-          virtualenvs-in-project: true
+      - name: Install Hatch
+        run: pip install hatch
       - name: Load cached venv
-        id: cached-poetry-dependencies
+        id: cached-hatch-dependencies
         uses: actions/cache@v3
         with:
           path: .venv
-          key: venv-embedchain-${{ runner.os }}-${{ hashFiles('**/poetry.lock') }}
+          key: venv-embedchain-${{ runner.os }}-${{ hashFiles('**/pyproject.toml') }}
       - name: Install dependencies
         run: cd embedchain && make install_all
-        if: steps.cached-poetry-dependencies.outputs.cache-hit != 'true'
+        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: cd embedchain && make lint
       - name: Run tests and generate coverage report
@@ -99,4 +113,4 @@ jobs:
         with:
           file: coverage.xml
         env:
-          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}

.github/workflows/openclaw-checks.yml

@@ -0,0 +1,100 @@
+name: openclaw checks
+
+on:
+  workflow_dispatch:
+  push:
+    branches: [main]
+    paths:
+      - 'openclaw/**'
+      - '.github/workflows/openclaw-checks.yml'
+  pull_request:
+    paths:
+      - 'openclaw/**'
+      - '.github/workflows/openclaw-checks.yml'
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          version: 9
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: 'pnpm'
+          cache-dependency-path: openclaw/pnpm-lock.yaml
+
+      - name: Install dependencies
+        run: cd openclaw && pnpm install --frozen-lockfile
+
+      - name: Type check
+        run: cd openclaw && pnpm exec tsc --noEmit
+
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        node-version: [20, 22]
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          version: 9
+
+      - name: Setup Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node-version }}
+          cache: 'pnpm'
+          cache-dependency-path: openclaw/pnpm-lock.yaml
+
+      - name: Install dependencies
+        run: cd openclaw && pnpm install --frozen-lockfile
+
+      - name: Run tests with coverage
+        run: cd openclaw && pnpm exec vitest run --coverage
+
+      - name: Upload coverage to Codecov
+        if: matrix.node-version == 20
+        uses: codecov/codecov-action@v4
+        with:
+          flags: openclaw
+          directory: openclaw/coverage
+        env:
+          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          version: 9
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: 'pnpm'
+          cache-dependency-path: openclaw/pnpm-lock.yaml
+
+      - name: Install dependencies
+        run: cd openclaw && pnpm install --frozen-lockfile
+
+      - name: Build
+        run: cd openclaw && pnpm build
+
+      - name: Verify dist output exists
+        run: |
+          test -f openclaw/dist/index.js || (echo "Build output missing: dist/index.js" && exit 1)
+          test -f openclaw/dist/index.d.ts || (echo "Build output missing: dist/index.d.ts" && exit 1)

.github/workflows/ts-sdk-ci.yml

@@ -0,0 +1,110 @@
+name: TypeScript SDK CI
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - 'mem0-ts/**'
+      - '.github/workflows/ts-sdk-ci.yml'
+  pull_request:
+    paths:
+      - 'mem0-ts/**'
+
+jobs:
+  check_changes:
+    runs-on: ubuntu-latest
+    outputs:
+      ts_sdk_changed: ${{ steps.filter.outputs.ts_sdk }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dorny/paths-filter@v2
+        id: filter
+        with:
+          filters: |
+            ts_sdk:
+              - 'mem0-ts/**'
+
+  build_ts_sdk:
+    needs: check_changes
+    if: needs.check_changes.outputs.ts_sdk_changed == 'true'
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        node-version: [20, 22]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: pnpm/action-setup@v4
+        with:
+          version: 10
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node-version }}
+          cache: 'pnpm'
+          cache-dependency-path: mem0-ts/pnpm-lock.yaml
+
+      - name: Install dependencies
+        working-directory: mem0-ts
+        run: pnpm install --frozen-lockfile
+
+      - name: Lint
+        working-directory: mem0-ts
+        run: npx prettier --check .
+
+      - name: Build
+        working-directory: mem0-ts
+        run: pnpm run build
+
+      - name: Run unit tests
+        working-directory: mem0-ts
+        run: pnpm run test:unit
+
+      - name: Verify package exports
+        working-directory: mem0-ts
+        run: |
+          node -e "const m = require('./dist/index.js'); console.log('Client exports:', Object.keys(m).length)"
+          node -e "const m = require('./dist/oss/index.js'); console.log('OSS exports:', Object.keys(m).length)"
+
+      - name: Upload coverage
+        if: matrix.node-version == 20
+        uses: actions/upload-artifact@v4
+        with:
+          name: coverage-report
+          path: mem0-ts/coverage/
+
+  integration_ts_sdk:
+    needs: build_ts_sdk
+    runs-on: ubuntu-latest
+    strategy:
+      max-parallel: 1
+      matrix:
+        node-version: [20, 22]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: pnpm/action-setup@v4
+        with:
+          version: 10
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node-version }}
+          cache: 'pnpm'
+          cache-dependency-path: mem0-ts/pnpm-lock.yaml
+
+      - name: Install dependencies
+        working-directory: mem0-ts
+        run: pnpm install --frozen-lockfile
+
+      - name: Build
+        working-directory: mem0-ts
+        run: pnpm run build
+
+      - name: Run integration tests (with cleanup)
+        working-directory: mem0-ts
+        env:
+          MEM0_API_KEY: ${{ secrets.MEM0_API_KEY }}
+        run: pnpm run test:integration

CONTRIBUTING.md

@@ -16,18 +16,20 @@ To make a contribution, follow these steps:
 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
-make install_all
+# 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
@@ -40,16 +42,22 @@ pre-commit install
 
 ### 🧪 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 tests
-
-# or
-
+# 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
 ```
 
-Several packages have been removed from Poetry to make the package lighter. Therefore, it is recommended to run `make install_all` to install the remaining packages and ensure all tests pass. Make sure that all tests pass before submitting a pull request.
+Make sure that all tests pass across all supported Python versions before submitting a pull request.
 
-We look forward to your pull requests and can't wait to see your contributions!
+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

@@ -8,36 +8,48 @@ PROJECT_NAME := mem0ai
 all: format sort lint
 
 install:
-	poetry install
+	hatch env create
 
 install_all:
-	poetry install
-	poetry run pip install groq together boto3 litellm ollama chromadb weaviate weaviate-client sentence_transformers vertexai \
-	                        google-generativeai elasticsearch opensearch-py vecs pinecone pinecone-text faiss-cpu
+	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:
-	poetry run ruff format mem0/
+	hatch run format
 
 # Sort imports with isort
 sort:
-	poetry run isort mem0/
+	hatch run isort mem0/
 
 # Lint code with ruff
 lint:
-	poetry run ruff check mem0/
+	hatch run lint
 
 docs:
 	cd docs && mintlify dev
 
 build:
-	poetry build
+	hatch build
 
 publish:
-	poetry publish
+	hatch publish
 
 clean:
-	poetry run rm -rf dist
+	rm -rf dist
 
 test:
-	poetry run pytest tests
+	hatch run test
+
+test-py-3.9:
+	hatch run dev_py_3_9:test
+
+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,87 +1,103 @@
 <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">
+    <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" style="width: 250px; height: 55px;" width="250" height="55"/>
-  </a>
-  <a href="https://www.ycombinator.com/launches/LpA-mem0-open-source-memory-layer-for-ai-apps" target="_blank">
-    <img alt="Launch YC: Mem0 - Open Source Memory Layer for AI Apps" src="https://www.ycombinator.com/launches/LpA-mem0-open-source-memory-layer-for-ai-apps/upvote_embed.svg"/>
+  <a 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>
 
-
-  <p align="center">
-    <a href="https://mem0.ai">Learn more</a>
-    ·
-    <a href="https://mem0.dev/DiG">Join Discord</a>
-    ·
-    <a href="https://mem0.dev/demo">Demo</a>
-  </p>
+<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>
 
 <p align="center">
   <a href="https://mem0.dev/DiG">
-    <img src="https://dcbadge.vercel.app/api/server/6PzXDgEjG5?style=flat" alt="Mem0 Discord">
+    <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" >
+    <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://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>
 
+<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) (pronounced as "mem-zero") enhances AI assistants and agents with an intelligent memory layer, enabling personalized AI interactions. Mem0 remembers user preferences, adapts to individual needs, and continuously improves over time, making it ideal for customer support chatbots, AI assistants, and autonomous systems.
+[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.
 
-### Features & Use Cases
+### Key Features & Use Cases
 
-Core Capabilities:
-- **Multi-Level Memory**: User, Session, and AI Agent memory retention with adaptive personalization
-- **Developer-Friendly**: Simple API integration, cross-platform consistency, and hassle-free managed service
+**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**: Seamless conversations with context and personalization
-- **Learning & Support**: Tailored content recommendations and context-aware customer assistance
-- **Healthcare & Companions**: Patient history tracking and deeper relationship building
-- **Productivity & Gaming**: Streamlined workflows and adaptive environments based on user behavior
+**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
 
-## Get Started
+## 🚀 Quickstart Guide <a name="quickstart"></a>
 
-Get started quickly with [Mem0 Platform](https://app.mem0.ai) - our fully managed solution that provides automatic updates, advanced analytics, enterprise security, and dedicated support. [Create a free account](https://app.mem0.ai) to begin.
+Choose between our hosted platform or self-hosted package:
 
-For complete control, you can self-host Mem0 using our open-source package. See the [Quickstart guide](#quickstart) below to set up your own instance.
+### Hosted Platform
 
-## Quickstart Guide <a name="quickstart"></a>
+Get up and running in minutes with automatic updates, analytics, and enterprise security.
 
-Install the Mem0 package via pip:
+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 mem0ai
 ```
 
-Install the Mem0 package via npm:
-
+Install sdk via npm:
 ```bash
 npm install mem0ai
 ```
 
 ### Basic Usage
 
-Mem0 requires an LLM to function, with `gpt-4o-mini` from OpenAI as the default. However, it supports a variety of LLMs; for details, refer to our [Supported LLMs documentation](https://docs.mem0.ai/llms).
+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).
 
 First step is to instantiate the memory:
 
@@ -96,11 +112,11 @@ def chat_with_memories(message: str, user_id: str = "default_user") -> str:
     # Retrieve relevant memories
     relevant_memories = memory.search(query=message, user_id=user_id, limit=3)
     memories_str = "\n".join(f"- {entry['memory']}" for entry in relevant_memories["results"])
-    
+
     # Generate Assistant response
     system_prompt = f"You are a helpful AI. Answer the question based on query and memories.\nUser Memories:\n{memories_str}"
     messages = [{"role": "system", "content": system_prompt}, {"role": "user", "content": message}]
-    response = openai_client.chat.completions.create(model="gpt-4o-mini", messages=messages)
+    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
@@ -122,68 +138,34 @@ if __name__ == "__main__":
     main()
 ```
 
-See the example for [Node.js](https://docs.mem0.ai/examples/ai_companion_js).
+For detailed integration steps, see the [Quickstart](https://docs.mem0.ai/quickstart) and [API Reference](https://docs.mem0.ai/api-reference).
 
-For more advanced usage and API documentation, visit our [documentation](https://docs.mem0.ai).
+## 🔗 Integrations & Demos
 
-> [!TIP]
-> For a hassle-free experience, try our [hosted platform](https://app.mem0.ai) with automatic updates and enterprise features.
+- **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))
 
-## Demos
+## 📚 Documentation & Support
 
-- Mem0 - ChatGPT with Memory: A personalized AI chat app powered by Mem0 that remembers your preferences, facts, and memories.
+- Full docs: https://docs.mem0.ai
+- Community: [Discord](https://mem0.dev/DiG) · [Twitter](https://x.com/mem0ai)
+- Contact: founders@mem0.ai
 
-[Mem0 - ChatGPT with Memory](https://github.com/user-attachments/assets/cebc4f8e-bdb9-4837-868d-13c5ab7bb433)
+## Citation
 
-Try live [demo](https://mem0.dev/demo/)
+We now have a paper you can cite:
 
-<br/><br/>
+```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}
+}
+```
 
-- AI Companion: Experience personalized conversations with an AI that remembers your preferences and past interactions
+## ⚖️ License
 
-[AI Companion Demo](https://github.com/user-attachments/assets/3fc72023-a72c-4593-8be0-3cee3ba744da)
-
-<br/><br/>
-
-- Enhance your AI interactions by storing memories across ChatGPT, Perplexity, and Claude using our browser extension. Get [chrome extension](https://chromewebstore.google.com/detail/mem0/onihkkbipkfeijkadecaafbgagkhglop?hl=en).
-
-
-[Chrome Extension Demo](https://github.com/user-attachments/assets/ca92e40b-c453-4ff6-b25e-739fb18a8650)
-
-<br/><br/>
-
-- Customer support bot using <strong>Langgraph and Mem0</strong>. Get the complete code from [here](https://docs.mem0.ai/integrations/langgraph)
-
-
-[Langgraph: Customer Bot](https://github.com/user-attachments/assets/ca6b482e-7f46-42c8-aa08-f88d1d93a5f4)
-
-<br/><br/>
-
-- Use Mem0 with CrewAI to get personalized results. Full example [here](https://docs.mem0.ai/integrations/crewai)
-
-[CrewAI Demo](https://github.com/user-attachments/assets/69172a79-ccb9-4340-91f1-caa7d2dd4213)
-
-
-
-## Documentation
-
-For detailed usage instructions and API reference, visit our [documentation](https://docs.mem0.ai). You'll find:
-- Complete API reference
-- Integration guides
-- Advanced configuration options
-- Best practices and examples
-- More details about:
-  - Open-source version
-  - [Hosted Mem0 Platform](https://app.mem0.ai)
-
-## Support
-
-Join our community for support and discussions. If you have any questions, feel free to reach out to us using one of the following methods:
-
-- [Join our Discord](https://mem0.dev/DiG)
-- [Follow us on Twitter](https://x.com/mem0ai)
-- [Email founders](mailto:founders@mem0.ai)
-
-## License
-
-This project is licensed under the Apache 2.0 License - see the [LICENSE](LICENSE) file for details.
+Apache 2.0 — see the [LICENSE](https://github.com/mem0ai/mem0/blob/main/LICENSE) file for details.

cookbooks/customer-support-chatbot.ipynb

@@ -13,7 +13,7 @@
     "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[\"OPENAI_API_KEY\"] = \"your_openai_api_key\"  # needed for embedding model\n",
     "os.environ[\"ANTHROPIC_API_KEY\"] = \"your_anthropic_api_key\""
    ]
   },
@@ -33,7 +33,7 @@
     "                    \"model\": \"claude-3-5-sonnet-latest\",\n",
     "                    \"temperature\": 0.1,\n",
     "                    \"max_tokens\": 2000,\n",
-    "                }\n",
+    "                },\n",
     "            }\n",
     "        }\n",
     "        self.client = anthropic.Client(api_key=os.environ[\"ANTHROPIC_API_KEY\"])\n",
@@ -50,11 +50,7 @@
     "        - Keep track of open issues and follow-ups\n",
     "        \"\"\"\n",
     "\n",
-    "    def store_customer_interaction(self,\n",
-    "                                 user_id: str,\n",
-    "                                 message: str,\n",
-    "                                 response: str,\n",
-    "                                 metadata: Dict = None):\n",
+    "    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",
@@ -63,24 +59,17 @@
     "        metadata[\"timestamp\"] = datetime.now().isoformat()\n",
     "\n",
     "        # Format conversation for storage\n",
-    "        conversation = [\n",
-    "            {\"role\": \"user\", \"content\": message},\n",
-    "            {\"role\": \"assistant\", \"content\": response}\n",
-    "        ]\n",
+    "        conversation = [{\"role\": \"user\", \"content\": message}, {\"role\": \"assistant\", \"content\": response}]\n",
     "\n",
     "        # Store in Mem0\n",
-    "        self.memory.add(\n",
-    "            conversation,\n",
-    "            user_id=user_id,\n",
-    "            metadata=metadata\n",
-    "        )\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",
+    "            limit=5,  # Adjust based on needs\n",
     "        )\n",
     "\n",
     "    def handle_customer_query(self, user_id: str, query: str) -> str:\n",
@@ -112,15 +101,12 @@
     "            model=\"claude-3-5-sonnet-latest\",\n",
     "            messages=[{\"role\": \"user\", \"content\": prompt}],\n",
     "            max_tokens=2000,\n",
-    "            temperature=0.1\n",
+    "            temperature=0.1,\n",
     "        )\n",
     "\n",
     "        # Store interaction\n",
     "        self.store_customer_interaction(\n",
-    "            user_id=user_id,\n",
-    "            message=query,\n",
-    "            response=response,\n",
-    "            metadata={\"type\": \"support_query\"}\n",
+    "            user_id=user_id, message=query, response=response, metadata={\"type\": \"support_query\"}\n",
     "        )\n",
     "\n",
     "        return response.content[0].text"
@@ -203,12 +189,12 @@
     "    # Get user input\n",
     "    query = input()\n",
     "    print(\"Customer:\", query)\n",
-    "    \n",
+    "\n",
     "    # Check if user wants to exit\n",
-    "    if query.lower() == 'exit':\n",
+    "    if query.lower() == \"exit\":\n",
     "        print(\"Thank you for using our support service. Goodbye!\")\n",
     "        break\n",
-    "    \n",
+    "\n",
     "    # Handle the query and print the response\n",
     "    response = chatbot.handle_customer_query(user_id, query)\n",
     "    print(\"Support:\", response, \"\\n\\n\")"

cookbooks/helper/mem0_teachability.py

@@ -7,10 +7,12 @@
 # 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
 
 

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/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/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/search-memories)** - Retrieve relevant memories using semantic search
+3. **[Get Memories](/api-reference/memory/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/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/search-memories">
+    Learn advanced search and filtering techniques
+  </Card>
+</CardGroup>

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

@@ -1,4 +1,5 @@
 ---
 title: 'Delete User'
-openapi: delete /v1/entities/{entity_type}/{entity_id}/
+description: "Remove a user entity from the Mem0 platform by entity type and ID using the DELETE endpoint."
+openapi: delete /v2/entities/{entity_type}/{entity_id}/
 ---

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

@@ -1,4 +1,5 @@
 ---
 title: 'Get Users'
+description: "Retrieve a list of all user entities stored in the Mem0 platform using the GET endpoint."
 openapi: get /v1/entities/
 ---

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

@@ -0,0 +1,7 @@
+---
+title: 'Get Event'
+description: "Retrieve details of a specific event by ID, including status and payload for async memory operations."
+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,14 @@
+---
+title: 'Get Events'
+description: "List recent events for your organization and project, useful for dashboards, alerting, and audit logging."
+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

@@ -1,4 +1,98 @@
 ---
 title: 'Add Memories'
+description: "Add facts, messages, or metadata to a user memory store with support for async processing and event tracking."
 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

@@ -1,4 +1,5 @@
 ---
 title: 'Batch Delete Memories'
+description: "Delete multiple memories in a single batch request using the Mem0 API DELETE endpoint."
 openapi: delete /v1/batch/
 ---

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

@@ -1,4 +1,5 @@
 ---
 title: 'Batch Update Memories'
+description: "Update multiple memories in a single batch request using the Mem0 API PUT endpoint."
 openapi: put /v1/batch/
 ---

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

@@ -1,6 +1,7 @@
 ---
 title: 'Create Memory Export'
+description: "Submit an export job to create a structured memory export using a customizable Pydantic schema and filters."
 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.
+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

@@ -1,4 +1,5 @@
 ---
 title: 'Delete Memories'
+description: "Delete all memories matching specified filters from the Mem0 memory store using the DELETE endpoint."
 openapi: delete /v1/memories/
 ---

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

@@ -1,4 +1,5 @@
 ---
 title: 'Delete Memory'
+description: "Delete a single memory by its unique memory ID from the Mem0 platform using the DELETE endpoint."
 openapi: delete /v1/memories/{memory_id}/
 ---

docs/api-reference/memory/feedback.mdx

@@ -1,4 +1,5 @@
 ---
 title: 'Feedback'
+description: "Submit positive or negative feedback on memory results to help improve memory accuracy and relevance."
 openapi: post /v1/feedback/
 ---

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

@@ -0,0 +1,100 @@
+---
+title: "Get Memories"
+description: "Retrieve memories with advanced filtering using logical operators like AND, OR, NOT, and comparison queries."
+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

@@ -1,6 +1,7 @@
 ---
 title: 'Get Memory Export'
-openapi: get /v1/exports/
+description: "Retrieve the latest structured memory export after submitting an export job, with optional entity filters."
+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

@@ -1,4 +1,5 @@
 ---
 title: 'Get Memory'
+description: "Retrieve a single memory by its unique memory ID from the Mem0 platform using the GET endpoint."
 openapi: get /v1/memories/{memory_id}/
 ---

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

@@ -1,4 +1,5 @@
 ---
 title: 'Memory History'
+description: "Retrieve the full change history of a specific memory to track how it has evolved over time."
 openapi: get /v1/memories/{memory_id}/history/
 ---

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

@@ -0,0 +1,105 @@
+---
+title: 'Search Memories'
+description: "Search memories with semantic queries and advanced filtering using logical and comparison operators."
+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

@@ -1,4 +1,5 @@
 ---
 title: 'Update Memory'
+description: "Update the content or metadata of a single memory by its unique ID using the PUT endpoint."
 openapi: put /v1/memories/{memory_id}/
 ---

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

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

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

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

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

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

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

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

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

@@ -1,5 +1,6 @@
 ---
 title: 'Add Member'
+description: "Add a new member to an organization with a specified role such as READER or OWNER access level."
 openapi: post /api/v1/orgs/organizations/{org_id}/members/
 ---
 

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

@@ -1,4 +1,5 @@
 ---
 title: 'Create Organization'
+description: "Create a new organization on the Mem0 platform to manage projects, members, and memory resources."
 openapi: post /api/v1/orgs/organizations/
 ---

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

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

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

@@ -1,4 +1,5 @@
 ---
 title: 'Delete Organization'
+description: "Permanently delete an organization and its associated resources from the Mem0 platform."
 openapi: delete /api/v1/orgs/organizations/{org_id}/
 ---

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

@@ -1,4 +1,5 @@
 ---
 title: 'Get Members'
+description: "Retrieve a list of all members belonging to a specific organization on the Mem0 platform."
 openapi: get /api/v1/orgs/organizations/{org_id}/members/
 ---

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

@@ -1,4 +1,5 @@
 ---
 title: 'Get Organization'
+description: "Retrieve details of a specific organization by its ID from the Mem0 platform using the GET endpoint."
 openapi: get /api/v1/orgs/organizations/{org_id}/
 ---

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

@@ -1,4 +1,5 @@
 ---
 title: 'Get Organizations'
+description: "Retrieve a list of all organizations associated with your Mem0 account using the GET endpoint."
 openapi: get /api/v1/orgs/organizations/
 ---

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

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

docs/api-reference/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/overview.mdx

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

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

@@ -1,5 +1,6 @@
 ---
 title: 'Add Member'
+description: "Add a new member to a project with a specified role such as READER or OWNER access level."
 openapi: post /api/v1/orgs/organizations/{org_id}/projects/{project_id}/members/
 ---
 

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

@@ -1,4 +1,5 @@
 ---
 title: 'Create Project'
+description: "Create a new project within an organization on the Mem0 platform to isolate memory resources."
 openapi: post /api/v1/orgs/organizations/{org_id}/projects/
 ---

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

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

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

@@ -1,4 +1,5 @@
 ---
 title: 'Delete Project'
+description: "Permanently delete a project and its associated data from the Mem0 platform by project ID."
 openapi: delete /api/v1/orgs/organizations/{org_id}/projects/{project_id}/
 ---

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

@@ -1,4 +1,5 @@
 ---
 title: 'Get Members'
+description: "Retrieve a list of all members belonging to a specific project on the Mem0 platform."
 openapi: get /api/v1/orgs/organizations/{org_id}/projects/{project_id}/members/
 ---

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

@@ -1,4 +1,5 @@
 ---
 title: 'Get Project'
+description: "Retrieve details of a specific project by its organization and project ID using the GET endpoint."
 openapi: get /api/v1/orgs/organizations/{org_id}/projects/{project_id}/
 ---

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

@@ -1,4 +1,5 @@
 ---
 title: 'Get Projects'
+description: "Retrieve a list of all projects within an organization on the Mem0 platform using the GET endpoint."
 openapi: get /api/v1/orgs/organizations/{org_id}/projects/
 ---

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

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

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

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

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

@@ -1,9 +1,6 @@
 ---
 title: 'Create Webhook'
+description: "Create a new webhook for a project to receive real-time notifications about memory events."
 openapi: post /api/v1/webhooks/projects/{project_id}/
 ---
 
-## Create Webhook
-
-Create a webhook by providing the project ID and the webhook details.
-

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

@@ -1,8 +1,5 @@
 ---
 title: 'Delete Webhook'
+description: "Delete an existing webhook by its ID to stop receiving notifications for memory events."
 openapi: delete /api/v1/webhooks/{webhook_id}/
 ---
-
-## Delete Webhook
-
-Delete a webhook by providing the webhook ID.

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

@@ -1,9 +1,6 @@
 ---
 title: 'Get Webhook'
+description: "Retrieve webhook configuration details for a specific project on the Mem0 platform."
 openapi: get /api/v1/webhooks/projects/{project_id}/
 ---
 
-## Get Webhook
-
-Get a webhook by providing the project ID.
-

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

@@ -1,9 +1,6 @@
 ---
 title: 'Update Webhook'
+description: "Update an existing webhook configuration, such as its URL or event subscriptions, by webhook ID."
 openapi: put /api/v1/webhooks/{webhook_id}/
 ---
 
-## Update Webhook
-
-Update a webhook by providing the webhook ID and the fields to update.
-

docs/changelog/overview.mdx

@@ -1,90 +0,0 @@
----
-title: "Product Updates"
-mode: "wide"
----
-
-<Tabs>
-<Tab title="Python">
-
-<Update label="2025-04-02" description="v0.1.79">
-
-**New Features:**
-- **FAISS Support:** Added FAISS vector store support
-
-</Update>
-
-<Update label="2025-04-02" description="v0.1.78">
-
-**New Features:**
-- **Livekit Integration:** Added Mem0 livekit example
-- **Evaluation:** Added evaluation framework and tools
-
-**Documentation:**
-- **Multimodal:** Updated multimodal documentation
-- **Examples:** Added examples for email processing
-- **API Reference:** Updated API reference section
-- **Elevenlabs:** Added Elevenlabs integration example
-
-**Bug Fixes:**
-- **OpenAI Environment Variables:** Fixed issues with OpenAI environment variables
-- **Deployment Errors:** Added `package.json` file to fix deployment errors
-- **Tools:** Fixed tools issues and improved formatting
-- **Docs:** Updated API reference section for `expiration date`
-</Update>
-
-<Update label="2025-03-26" description="v0.1.77">
-
-**Bug Fixes:**
-- **OpenAI Environment Variables:** Fixed issues with OpenAI environment variables
-- **Deployment Errors:** Added `package.json` file to fix deployment errors
-- **Tools:** Fixed tools issues and improved formatting
-- **Docs:** Updated API reference section for `expiration date`
-</Update>
-
-<Update label="2025-03-19" description="v0.1.76">
-**New Features:**
-- **Supabase Vector Store:** Added support for Supabase Vector Store
-- **Supabase History DB:** Added Supabase History DB to run Mem0 OSS on Serverless
-- **Feedback Method:** Added feedback method to client
-
-**Bug Fixes:**
-- **Azure OpenAI:** Fixed issues with Azure OpenAI
-- **Azure AI Search:** Fixed test cases for Azure AI Search
-</Update>
-
-</Tab>
-
-<Tab title="TypeScript">
-
-<Update label="2025-03-26" description="v2.1.12">
-**New Features:**
-- **Vercel AI SDK Update:** Support for tools call
-
-**Improvements:**
-- **Updated Supabase TS Docs**
-
-</Update>
-
-<Update label="2025-03-19" description="v2.1.11">
-**New Features:**
-- **Supabase Vector Store Integration**
-- **Feedback Method**
-</Update>
-
-</Tab>
-
-<Tab title="Platform">
-
-<Update label="2025-03-28" description="">
-- **Updated Playground Prompt**
-- **Send Email on User Addition to Org/Proj**
-- **Fix Search Entity**
-</Update>
-
-<Update label="2025-03-19" description="">
-- **General Stability & Performance Improvements**
-</Update>
-
-</Tab>
-</Tabs>
-

docs/components/embedders/config.mdx

@@ -1,9 +1,9 @@
 ---
 title: Configurations
-icon: "gear"
-iconType: "solid"
+description: "Reference for embedder configuration options in Mem0, including provider selection and model settings."
 ---
 
+
 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?

docs/components/embedders/models/aws_bedrock.mdx

@@ -0,0 +1,63 @@
+---
+title: AWS Bedrock
+description: "Configure AWS Bedrock as an embedding provider in Mem0 with IAM credentials and boto3 authentication."
+---
+
+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

@@ -1,12 +1,14 @@
 ---
 title: Azure OpenAI
+description: "Configure Azure OpenAI as an embedding provider in Mem0 with API key, deployment, and endpoint settings."
 ---
 
 To use Azure OpenAI embedding models, set the `EMBEDDING_AZURE_OPENAI_API_KEY`, `EMBEDDING_AZURE_DEPLOYMENT`, `EMBEDDING_AZURE_ENDPOINT` and `EMBEDDING_AZURE_API_VERSION` environment variables. You can obtain the Azure OpenAI API key from the Azure.
 
 ### Usage
 
-```python
+<CodeGroup>
+```python Python
 import os
 from mem0 import Memory
 
@@ -22,7 +24,7 @@ config = {
     "embedder": {
         "provider": "azure_openai",
         "config": {
-            "model": "text-embedding-3-large"
+            "model": "text-embedding-3-large",
             "azure_kwargs": {
                   "api_version": "",
                   "azure_deployment": "",
@@ -39,19 +41,97 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "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/gemini.mdx

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

docs/components/embedders/models/google_AI.mdx

@@ -0,0 +1,80 @@
+---
+title: Google AI
+description: "Configure Google AI as an embedding provider in Mem0 using Gemini models and the GOOGLE_API_KEY variable."
+---
+
+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

@@ -1,5 +1,6 @@
 ---
 title: Hugging Face
+description: "Configure Hugging Face as an embedding provider in Mem0 for local embedding generation with open-source models."
 ---
 
 You can use embedding models from Huggingface to run Mem0 locally.
@@ -24,13 +25,45 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
-    {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "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:
@@ -39,4 +72,5 @@ Here are the parameters available for configuring Huggingface embedder:
 | --- | --- | --- |
 | `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` |
+| `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,197 @@
+---
+title: LangChain
+description: "Use LangChain as an embedding provider in Mem0 to access a wide range of models through a unified interface."
+---
+
+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

@@ -1,3 +1,7 @@
+---
+title: "LM Studio"
+description: "Configure LM Studio as an embedding provider in Mem0 for local embedding generation with models like nomic-embed-text."
+---
 You can use embedding models from LM Studio to run Mem0 locally.
 
 ### Usage
@@ -20,7 +24,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "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."}
 ]
@@ -29,10 +33,10 @@ m.add(messages, user_id="john")
 
 ### Config
 
-Here are the parameters available for configuring Ollama embedder:
+Here are the parameters available for configuring LM Studio embedder:
 
 | Parameter | Description | Default Value |
 | --- | --- | --- |
-| `model` | The name of the OpenAI model to use | `nomic-embed-text-v1.5-GGUF/nomic-embed-text-v1.5.f16.gguf` |
+| `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

@@ -1,8 +1,13 @@
+---
+title: "Ollama"
+description: "Configure Ollama as an embedding provider in Mem0 to generate embeddings locally using open-source models."
+---
 You can use embedding models from Ollama to run Mem0 locally.
 
 ### Usage
 
-```python
+<CodeGroup>
+```python Python
 import os
 from mem0 import Memory
 
@@ -20,19 +25,54 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
-    {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "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 OpenAI model to use | `nomic-embed-text` |
+| `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` |
+| `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

@@ -1,5 +1,6 @@
 ---
 title: OpenAI
+description: "Configure OpenAI as an embedding provider in Mem0 using models like text-embedding-3-large for vector generation."
 ---
 
 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).
@@ -25,7 +26,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "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."}
 ]

docs/components/embedders/models/together.mdx

@@ -1,5 +1,6 @@
 ---
 title: Together
+description: "Configure Together AI as an embedding provider in Mem0 with support for 768-dimensional embedding models."
 ---
 
 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).
@@ -27,7 +28,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "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."}
 ]

docs/components/embedders/models/vertexai.mdx

@@ -1,3 +1,7 @@
+---
+title: "Vertex AI"
+description: "Configure Google Cloud Vertex AI as an embedding provider in Mem0 with support for task-specific embedding types."
+---
 ### 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/).
@@ -27,7 +31,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "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."}
 ]

docs/components/embedders/overview.mdx

@@ -1,7 +1,6 @@
 ---
 title: Overview
-icon: "info"
-iconType: "solid"
+description: "Overview of all supported embedding model providers in Mem0, including OpenAI, Azure, Ollama, and more."
 ---
 
 Mem0 offers support for various embedding models, allowing users to choose the one that best suits their needs.
@@ -19,14 +18,16 @@ See the list of supported embedders below.
   <Card title="Azure OpenAI" href="/components/embedders/models/azure_openai"></Card>
   <Card title="Ollama" href="/components/embedders/models/ollama"></Card>
   <Card title="Hugging Face" href="/components/embedders/models/huggingface"></Card>
-  <Card title="Gemini" href="/components/embedders/models/gemini"></Card>
+  <Card title="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 a embedder, you must provide a configuration to customize its usage. If no configuration is supplied, a default configuration will be applied, and `OpenAI` will be used as the embedder.
+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 embedder configuration, please refer to [Config](./config).
+For a comprehensive list of available parameters for embedding model configuration, please refer to [Config](./config).

docs/components/llms/config.mdx

@@ -1,7 +1,6 @@
 ---
 title: Configurations
-icon: "gear"
-iconType: "solid"
+description: "Reference for LLM configuration options in Mem0 for Python and TypeScript, including value precedence rules."
 ---
 
 ## How to define configurations?
@@ -56,6 +55,7 @@ config = {
 
 m = Memory.from_config(config)
 m.add("Your text here", user_id="user", metadata={"category": "example"})
+
 ```
 
 ```typescript TypeScript
@@ -74,6 +74,7 @@ const config = {
 const memory = new Memory(config);
 await memory.add("Your text here", { userId: "user123", metadata: { category: "example" } });
 ```
+
 </CodeGroup>
 
 ## Why is Config Needed?
@@ -108,7 +109,14 @@ Here's a comprehensive list of all parameters that can be used across different
     | `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          |

docs/components/llms/models/anthropic.mdx

@@ -1,8 +1,10 @@
 ---
 title: Anthropic
+description: "Configure Anthropic Claude models as the LLM provider in Mem0 with API key setup and usage examples."
 ---
 
-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).
+
+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
 
@@ -18,7 +20,7 @@ config = {
     "llm": {
         "provider": "anthropic",
         "config": {
-            "model": "claude-3-7-sonnet-latest",
+            "model": "claude-sonnet-4-20250514",
             "temperature": 0.1,
             "max_tokens": 2000,
         }
@@ -28,7 +30,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "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."}
 ]
@@ -43,7 +45,7 @@ const config = {
     provider: 'anthropic',
     config: {
       apiKey: process.env.ANTHROPIC_API_KEY || '',
-      model: 'claude-3-7-sonnet-latest',
+      model: 'claude-sonnet-4-20250514',
       temperature: 0.1,
       maxTokens: 2000,
     },
@@ -53,7 +55,7 @@ const config = {
 const memory = new Memory(config);
 const messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "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."}
 ]

docs/components/llms/models/aws_bedrock.mdx

@@ -1,5 +1,6 @@
 ---
 title: AWS Bedrock
+description: "Configure AWS Bedrock as an LLM provider in Mem0 with IAM authentication and Claude model support."
 ---
 
 ### Setup
@@ -13,16 +14,15 @@ title: AWS Bedrock
 import os
 from mem0 import Memory
 
-os.environ["OPENAI_API_KEY"] = "your-api-key" # used for embedding model
-os.environ['AWS_REGION'] = 'us-east-1'
-os.environ["AWS_ACCESS_KEY"] = "xx"
+os.environ['AWS_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": "arn:aws:bedrock:us-east-1:123456789012:model/your-model-name",
+            "model": "anthropic.claude-3-5-haiku-20241022-v1:0",
             "temperature": 0.2,
             "max_tokens": 2000,
         }
@@ -32,7 +32,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "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."}
 ]

docs/components/llms/models/azure_openai.mdx

@@ -1,18 +1,26 @@
 ---
 title: Azure OpenAI
+description: "Configure Azure OpenAI as an LLM provider in Mem0 with Azure Identity authentication and deployment settings."
 ---
 
+<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
 
-```python
+<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"
@@ -41,14 +49,45 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "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"})
 ```
 
-We also support the new [OpenAI structured-outputs](https://platform.openai.com/docs/guides/structured-outputs/introduction) model.
+```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
@@ -80,6 +119,44 @@ config = {
 }
 ```
 
+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

@@ -1,5 +1,6 @@
 ---
 title: DeepSeek
+description: "Configure DeepSeek as an LLM provider in Mem0 with API key setup and optional custom endpoint configuration."
 ---
 
 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").
@@ -28,7 +29,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "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."}
 ]

docs/components/llms/models/gemini.mdx

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

docs/components/llms/models/google_AI.mdx

@@ -1,39 +1,75 @@
 ---
 title: Google AI
+description: "Configure Google Gemini as an LLM provider in Mem0 using the google.genai SDK and GOOGLE_API_KEY variable."
 ---
 
-To use Google AI model, you have to set the `GOOGLE_API_KEY` environment variable. You can obtain the Google API key from the [Google Maker Suite](https://makersuite.google.com/app/apikey)
+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
 
-```python
+<CodeGroup>
+```python Python
 import os
 from mem0 import Memory
 
-os.environ["OPENAI_API_KEY"] = "your-api-key" # used for embedding model
-os.environ["GEMINI_API_KEY"] = "your-api-key"
+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": "litellm",
+        "provider": "gemini",
         "config": {
-            "model": "gemini/gemini-pro",
+            "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 a thriller movies? They can be quite engaging."},
-    {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
-    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+    {"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 `litellm` config are present in [Master List of All Params in Config](../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

@@ -1,5 +1,6 @@
 ---
 title: Groq
+description: "Configure Groq as an LLM provider in Mem0 for high-speed inference using LPU-powered language models."
 ---
 
 [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.
@@ -30,7 +31,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "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."}
 ]
@@ -55,7 +56,7 @@ const config = {
 const memory = new Memory(config);
 const messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "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."}
 ]

docs/components/llms/models/langchain.mdx

@@ -0,0 +1,110 @@
+---
+title: LangChain
+description: "Use LangChain as an LLM provider in Mem0 to integrate with various chat models through a unified interface."
+---
+
+
+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

@@ -1,3 +1,7 @@
+---
+title: "LiteLLM"
+description: "Use LiteLLM as an LLM provider in Mem0 to access over 100 language models through a unified interface."
+---
 [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
@@ -12,7 +16,7 @@ config = {
     "llm": {
         "provider": "litellm",
         "config": {
-            "model": "gpt-4o-mini",
+            "model": "gpt-4.1-nano-2025-04-14",
             "temperature": 0.2,
             "max_tokens": 2000,
         }
@@ -22,7 +26,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "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."}
 ]

docs/components/llms/models/lmstudio.mdx

@@ -1,5 +1,6 @@
 ---
 title: LM Studio
+description: "Configure LM Studio as an LLM provider in Mem0 for running local language models via an OpenAI-compatible API."
 ---
 
 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.
@@ -21,6 +22,7 @@ config = {
             "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": {}}},
         }
     }
 }
@@ -28,7 +30,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "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."}
 ]
@@ -56,7 +58,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "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."}
 ]

docs/components/llms/models/minimax.mdx

@@ -0,0 +1,56 @@
+---
+title: MiniMax
+description: "Configure MiniMax as an LLM provider in Mem0 with API key setup and optional custom endpoint configuration."
+---
+
+To use MiniMax LLM models, you have to set the `MINIMAX_API_KEY` environment variable. You can also optionally set `MINIMAX_API_BASE` if you need to use a different API endpoint (defaults to "https://api.minimax.io/v1").
+
+## Usage
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["MINIMAX_API_KEY"] = "your-api-key"
+os.environ["OPENAI_API_KEY"] = "your-api-key" # for embedder model
+
+config = {
+    "llm": {
+        "provider": "minimax",
+        "config": {
+            "model": "MiniMax-M2.7",  # 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": "minimax",
+        "config": {
+            "model": "MiniMax-M2.7",
+            "minimax_base_url": "https://your-custom-endpoint.com",
+            "api_key": "your-api-key"  # alternatively to using environment variable
+        }
+    }
+}
+```
+
+## Config
+
+All available parameters for the `minimax` config are present in [Master List of All Params in Config](../config).

docs/components/llms/models/mistral_AI.mdx

@@ -1,12 +1,14 @@
 ---
 title: Mistral AI
+description: "Configure Mistral AI as an LLM provider in Mem0 using the litellm integration and Mixtral model family."
 ---
 
-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.
+To use mistral's models, please obtain the Mistral AI api key from their [console](https://console.mistral.ai/). Set the `MISTRAL_API_KEY` environment variable to use the model as given below in the example.
 
 ## Usage
 
-```python
+<CodeGroup>
+```python Python
 import os
 from mem0 import Memory
 
@@ -27,13 +29,39 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "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

@@ -1,8 +1,14 @@
-You can use LLMs from Ollama to run Mem0 locally. These [models](https://ollama.com/search?c=tools) support tool support.
+---
+title: Ollama
+description: "Configure Ollama as an LLM provider in Mem0 for running local language models with tool-calling support."
+---
+
+You can use LLMs from Ollama to run Mem0 locally. These [models](https://ollama.com/search?c=tools) support tool calling.
 
 ## Usage
 
-```python
+<CodeGroup>
+```python Python
 import os
 from mem0 import Memory
 
@@ -22,13 +28,38 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
-    {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "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

@@ -1,9 +1,12 @@
 ---
 title: OpenAI
+description: "Configure OpenAI as an LLM provider in Mem0 with support for GPT models and Openrouter compatibility."
 ---
 
 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>
@@ -17,7 +20,7 @@ config = {
     "llm": {
         "provider": "openai",
         "config": {
-            "model": "gpt-4o",
+            "model": "gpt-4.1-nano-2025-04-14",
             "temperature": 0.2,
             "max_tokens": 2000,
         }
@@ -38,7 +41,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "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."}
 ]
@@ -63,7 +66,7 @@ const config = {
 const memory = new Memory(config);
 const messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "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."}
 ]
@@ -83,7 +86,7 @@ config = {
     "llm": {
         "provider": "openai_structured",
         "config": {
-            "model": "gpt-4o-2024-08-06",
+            "model": "gpt-4.1-nano-2025-04-14",
             "temperature": 0.0,
         }
     }
@@ -92,10 +95,6 @@ config = {
 m = Memory.from_config(config)
 ```
 
-<Note>
-  OpenAI structured-outputs is currently only available in the Python implementation.
-</Note>
-
 ## Config
 
-All available parameters for the `openai` config are present in [Master List of All Params in Config](../config).
+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,74 @@
+---
+title: Sarvam AI
+description: "Configure Sarvam AI as an LLM provider in Mem0, specializing in Indian language support with the Sarvam-M model."
+---
+
+**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

@@ -1,4 +1,9 @@
-To use TogetherAI LLM models, you have to set the `TOGETHER_API_KEY` environment variable. You can obtain the TogetherAI API key from their [Account settings page](https://api.together.xyz/settings/api-keys).
+---
+title: Together
+description: "Configure Together AI as an LLM provider in Mem0 with API key setup and Mixtral model configuration."
+---
+
+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
 
@@ -23,7 +28,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "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."}
 ]
@@ -32,4 +37,4 @@ m.add(messages, user_id="alice", metadata={"category": "movies"})
 
 ## Config
 
-All available parameters for the `togetherai` config are present in [Master List of All Params in Config](../config).
+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,108 @@
+---
+title: vLLM
+description: "Configure vLLM as an LLM provider in Mem0 for high-performance local inference with GPU-optimized serving."
+---
+
+[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

@@ -1,5 +1,6 @@
 ---
 title: xAI
+description: "Configure xAI Grok models as an LLM provider in Mem0 with API key setup and usage examples."
 ---
 
 [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.
@@ -19,7 +20,7 @@ config = {
     "llm": {
         "provider": "xai",
         "config": {
-            "model": "grok-2-latest",
+            "model": "grok-3-beta",
             "temperature": 0.1,
             "max_tokens": 2000,
         }
@@ -29,7 +30,7 @@ config = {
 m = Memory.from_config(config)
 messages = [
     {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "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."}
 ]

docs/components/llms/overview.mdx

@@ -1,7 +1,6 @@
 ---
 title: Overview
-icon: "info"
-iconType: "solid"
+description: "Overview of all supported LLM providers in Mem0, including OpenAI, Anthropic, Groq, Ollama, and more."
 ---
 
 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.
@@ -12,7 +11,9 @@ To use a llm, you must provide a configuration to customize its usage. If no con
 
 For a comprehensive list of available parameters for llm configuration, please refer to [Config](./config).
 
-To view all supported llms, visit the [Supported LLMs](./models).
+## 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**.
@@ -26,13 +27,15 @@ To view all supported llms, visit the [Supported LLMs](./models).
   <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="Mistral AI" href="/components/llms/models/mistral_AI" />
+  <Card title="Google AI" href="/components/llms/models/google_AI" />
   <Card title="AWS bedrock" href="/components/llms/models/aws_bedrock" />
-  <Card title="Gemini" href="/components/llms/models/gemini" />
   <Card title="DeepSeek" href="/components/llms/models/deepseek" />
+  <Card title="MiniMax" href="/components/llms/models/minimax" />
   <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

docs/components/rerankers/config.mdx

@@ -0,0 +1,105 @@
+---
+title: Config
+description: "Reference for shared and provider-specific reranker configuration options in Mem0, including top_k and API key settings."
+---
+
+## 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,221 @@
+---
+title: Custom Prompts
+description: "Customize the LLM reranker prompt template in Mem0 to control how search results are ranked and scored."
+---
+
+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: "Configure Cohere as a reranker in Mem0 with support for English and multilingual reranking models."
+---
+
+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>

docs/components/rerankers/models/llm.mdx

@@ -0,0 +1,226 @@
+---
+title: LLM as Reranker
+description: "Use any LLM as a flexible reranker in Mem0 with custom prompts and domain-specific scoring logic."
+---
+
+<Warning>
+**This page has been superseded.** Please see [LLM Reranker](/components/rerankers/models/llm_reranker) for the complete and up-to-date documentation on using LLMs for reranking.
+</Warning>
+
+LLM-based reranker provides maximum flexibility by using any Large Language Model to score document relevance. This approach allows for custom prompts and domain-specific scoring logic.
+
+## Supported LLM Providers
+
+Any LLM provider supported by Mem0 can be used for reranking:
+
+- **OpenAI**: GPT-4, GPT-3.5-turbo, etc.
+- **Anthropic**: Claude models
+- **Together**: Open-source models
+- **Groq**: Fast inference
+- **Ollama**: Local models
+- And more...
+
+## 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-4o-mini"
+        }
+    },
+    "reranker": {
+        "provider": "llm",
+        "config": {
+            "model": "gpt-4o-mini",
+            "provider": "openai",
+            "api_key": "your-openai-api-key",  # or set OPENAI_API_KEY
+            "top_k": 5,
+            "temperature": 0.0
+        }
+    }
+}
+
+memory = Memory.from_config(config)
+```
+
+## Custom Scoring Prompt
+
+You can provide a custom prompt for relevance scoring:
+
+```python Python
+custom_prompt = """You are a relevance scoring assistant. Rate how well this document answers the query.
+
+Query: "{query}"
+Document: "{document}"
+
+Score from 0.0 to 1.0 where:
+- 1.0: Perfect match, directly answers the query
+- 0.8-0.9: Highly relevant, good match  
+- 0.6-0.7: Moderately relevant, partial match
+- 0.4-0.5: Slightly relevant, limited useful information
+- 0.0-0.3: Not relevant or no useful information
+
+Provide only a single numerical score between 0.0 and 1.0."""
+
+config["reranker"]["config"]["scoring_prompt"] = custom_prompt
+```
+
+## Usage Example
+
+```python Python
+import os
+from mem0 import Memory
+
+# Set API key
+os.environ["OPENAI_API_KEY"] = "your-api-key"
+
+# Initialize memory with LLM reranker
+config = {
+    "vector_store": {"provider": "chroma"},
+    "llm": {"provider": "openai", "config": {"model": "gpt-4o-mini"}},
+    "reranker": {
+        "provider": "llm",
+        "config": {
+            "model": "gpt-4o-mini",
+            "provider": "openai",
+            "temperature": 0.0
+        }
+    }
+}
+
+memory = Memory.from_config(config)
+
+# Add memories
+messages = [
+    {"role": "user", "content": "I'm learning Python programming"},
+    {"role": "user", "content": "I find object-oriented programming challenging"}, 
+    {"role": "user", "content": "I love hiking in national parks"}
+]
+
+memory.add(messages, user_id="david")
+
+# Search with LLM reranking
+results = memory.search("What programming topics is the user studying?", user_id="david")
+
+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()
+```
+
+```text Output
+Memory: I'm learning Python programming
+Vector Score: 0.856
+Rerank Score: 0.920
+
+Memory: I find object-oriented programming challenging
+Vector Score: 0.782
+Rerank Score: 0.850
+```
+
+## Domain-Specific Scoring
+
+Create specialized scoring for your domain:
+
+```python Python
+medical_prompt = """You are a medical relevance expert. Score how relevant this medical record is to the clinical query.
+
+Clinical Query: "{query}"
+Medical Record: "{document}"
+
+Consider:
+- Clinical relevance and accuracy
+- Patient safety implications
+- Diagnostic value
+- Treatment relevance
+
+Score from 0.0 to 1.0. Provide only the numerical score."""
+
+config = {
+    "reranker": {
+        "provider": "llm",
+        "config": {
+            "model": "gpt-4o-mini",
+            "provider": "openai",
+            "scoring_prompt": medical_prompt,
+            "temperature": 0.0
+        }
+    }
+}
+```
+
+## Multiple LLM Providers
+
+Use different LLM providers for reranking:
+
+```python Python
+# Using Anthropic Claude
+anthropic_config = {
+    "reranker": {
+        "provider": "llm",
+        "config": {
+            "model": "claude-3-haiku-20240307",
+            "provider": "anthropic",
+            "temperature": 0.0
+        }
+    }
+}
+
+# Using local Ollama model
+ollama_config = {
+    "reranker": {
+        "provider": "llm",
+        "config": {
+            "model": "llama2:7b",
+            "provider": "ollama",
+            "temperature": 0.0
+        }
+    }
+}
+```
+
+## Configuration Parameters
+
+| Parameter | Description | Type | Default |
+|-----------|-------------|------|---------|
+| `model` | LLM model to use for scoring | `str` | `"gpt-4o-mini"` |
+| `provider` | LLM provider name | `str` | `"openai"` |
+| `api_key` | API key for the LLM provider | `str` | `None` |
+| `top_k` | Maximum documents to return | `int` | `None` |
+| `temperature` | Temperature for LLM generation | `float` | `0.0` |
+| `max_tokens` | Maximum tokens for LLM response | `int` | `100` |
+| `scoring_prompt` | Custom prompt template | `str` | Default prompt |
+
+## Advantages
+
+- **Maximum Flexibility**: Custom prompts for any use case
+- **Domain Expertise**: Leverage LLM knowledge for specialized domains
+- **Interpretability**: Understand scoring through prompt engineering
+- **Multi-criteria**: Score based on multiple relevance factors
+
+## Considerations
+
+- **Latency**: Higher latency than specialized rerankers
+- **Cost**: LLM API costs per reranking operation
+- **Consistency**: May have slight variations in scoring
+- **Prompt Engineering**: Requires careful prompt design
+
+## Best Practices
+
+1. **Temperature**: Use 0.0 for consistent scoring
+2. **Prompt Design**: Be specific about scoring criteria
+3. **Token Efficiency**: Keep prompts concise to reduce costs
+4. **Caching**: Cache results for repeated queries when possible
+5. **Fallback**: Handle API errors gracefully