Merge branch 'main' into mem0-1.0.0

Release beta version
Fix reranker config and added huggingface reranker
2025-09-18 20:23:20 +05:30 · 2025-09-18 20:15:10 +05:30 · 2025-09-16 10:48:35 +05:30 · 2025-09-16 04:14:38 +05:30 · 2025-09-16 00:13:42 +05:30 · 2025-09-16 00:01:42 +05:30
542 changed files with 13419 additions and 65262 deletions
@@ -1,56 +1,41 @@
-name: Bug Report
-description: Report a bug in mem0
-labels: ["bug"]
+name: 🐛 Bug Report
+description: Create a report to help us reproduce and fix the bug

 body:
-  - type: dropdown
-    id: component
-    attributes:
-      label: Component
-      description: Which part of mem0 is affected?
-      options:
-        - Core / Python SDK
-        - TypeScript SDK
-        - Vector Store (Qdrant, PGVector, Redis, Chroma, etc.)
-        - Graph Memory (Neo4j, Memgraph, etc.)
-        - Ollama / Local Models
-        - OpenMemory (MCP Server)
-        - OpenClaw
-        - REST API
-        - Other
-    validations:
-      required: true
+- type: markdown
+  attributes:
+    value: >
+      #### Before submitting a bug, please make sure the issue hasn't been already addressed by searching through [the existing and past issues](https://github.com/embedchain/embedchain/issues?q=is%3Aissue+sort%3Acreated-desc+).
+- type: textarea
+  attributes:
+    label: 🐛 Describe the bug
+    description: |
+      Please provide a clear and concise description of what the bug is.

-  - type: textarea
-    id: description
-    attributes:
-      label: Description
-      value: |
-        ### Summary
+      If relevant, add a minimal example so that we can reproduce the error by running the code. It is very important for the snippet to be as succinct (minimal) as possible, so please take time to trim down any irrelevant code to help us debug efficiently. We are going to copy-paste your code and we expect to get the same result as you did: avoid any external data, and include the relevant imports, etc. For example:

-        A clear summary of the bug.
+      ```python
+      # All necessary imports at the beginning
+      import embedchain as ec
+      # Your code goes here

-        ### Steps to Reproduce

-        ```python
-        from mem0 import Memory
+      ```

-        m = Memory()
-        # Your code here...
-        ```
+      Please also paste or describe the results you observe instead of the expected results. If you observe an error, please paste the error message including the **full** traceback of the exception. It may be relevant to wrap error messages in ```` ```triple quotes blocks``` ````.
+    placeholder: |
+      A clear and concise description of what the bug is.

-        ### Expected Behavior
+      ```python
+      Sample code to reproduce the problem
+      ```

-        What you expected to happen.
-
-        ### Actual Behavior
-
-        What actually happened. Paste the full error traceback if applicable.
-
-        ### Environment
-
-        - mem0 version:
-        - Python/Node version:
-        - OS:
-    validations:
-      required: true
+      ```
+      The error message you got, with the full traceback.
+      ````
+  validations:
+    required: true
+- type: markdown
+  attributes:
+    value: >
+      Thanks for contributing 🎉!
@@ -1,8 +1,8 @@
-blank_issues_enabled: false
+blank_issues_enabled: true
 contact_links:
-  - name: Discord Community
+  - name: 1-on-1 Session
+    url: https://cal.com/taranjeetio/ec
+    about: Speak directly with Taranjeet, the founder, to discuss issues, share feedback, or explore improvements for Embedchain
+  - name: Discord
    url: https://discord.gg/6PzXDgEjG5
-    about: Ask questions and discuss with the community
-  - name: Documentation
-    url: https://docs.mem0.ai
-    about: Read the official mem0 documentation
+    about: General community discussions
@@ -1,23 +1,11 @@
-name: Documentation Issue
-description: Report an issue or suggest an improvement to the mem0 docs
-labels: ["documentation"]
+name: Documentation
+description: Report an issue related to the Embedchain docs.
+title: "DOC: <Please write a comprehensive title after the 'DOC: ' prefix>"

 body:
-  - type: textarea
-    id: description
-    attributes:
-      label: Description
-      value: |
-        ### Page
-
-        Link to the docs page: https://docs.mem0.ai/...
-
-        ### What's Wrong or Missing
-
-        Describe what's incorrect, unclear, or missing.
-
-        ### Suggested Fix
-
-        How should the docs be improved?
-    validations:
-      required: true
+- type: textarea
+  attributes:
+    label: "Issue with current documentation:"
+    description: >
+      Please make sure to leave a reference to the document/code you're
+      referring to.
@@ -1,42 +1,23 @@
-name: Feature Request
-description: Suggest a new feature or improvement for mem0
-labels: ["enhancement"]
+name: 🚀 Feature request
+description: Submit a proposal/request for a new Embedchain feature

 body:
-  - type: dropdown
-    id: component
-    attributes:
-      label: Component
-      description: Which part of mem0 does this relate to?
-      options:
-        - Core / Python SDK
-        - TypeScript SDK
-        - Vector Store (Qdrant, PGVector, Redis, Chroma, etc.)
-        - Graph Memory (Neo4j, Memgraph, etc.)
-        - Ollama / Local Models
-        - OpenMemory (MCP Server)
-        - OpenClaw
-        - REST API
-        - Benchmarks / Evals
-        - Other
-    validations:
-      required: true
-
-  - type: textarea
-    id: description
-    attributes:
-      label: Description
-      value: |
-        ### Use Case
-
-        What problem are you trying to solve?
-
-        ### Proposed Solution
-
-        How should this work? Include API examples or pseudocode if helpful.
-
-        ### Alternatives Considered
-
-        Any workarounds you've tried or other approaches considered.
-    validations:
-      required: true
+- type: textarea
+  id: feature-request
+  attributes:
+    label: 🚀 The feature
+    description: >
+      A clear and concise description of the feature proposal
+  validations:
+    required: true
+- type: textarea
+  attributes:
+    label: Motivation, pitch
+    description: >
+      Please outline the motivation for the proposal. Is your feature request related to a specific problem? e.g., *"I'm working on X and would like Y to be possible"*. If this is related to another GitHub issue, please link here too.
+  validations:
+    required: true
+- type: markdown
+  attributes:
+    value: >
+      Thanks for contributing 🎉!
@@ -1,38 +1,41 @@
-## Linked Issue
-
-Closes #<!-- issue number -->
-
 ## Description

-<!-- What does this PR do? Why is it needed? -->
+Please include a summary of the change and which issue is fixed. Please also include relevant motivation and context. List any dependencies that are required for this change.

-## Type of Change
+Fixes # (issue)

- [ ] Bug fix (non-breaking change that fixes an issue)
- [ ] New feature (non-breaking change that adds functionality)
- [ ] Breaking change (fix or feature that would cause existing functionality to change)
- [ ] Refactor (no functional changes)
+## Type of change
+
+Please delete options that are not relevant.
+
+- [ ] Bug fix (non-breaking change which fixes an issue)
+- [ ] New feature (non-breaking change which adds functionality)
+- [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected)
+- [ ] Refactor (does not change functionality, e.g. code style improvements, linting)
 - [ ] Documentation update

-## Breaking Changes
+## How Has This Been Tested?

-<!-- If this is a breaking change, describe what breaks and the migration path. Delete this section if not applicable. -->
+Please describe the tests that you ran to verify your changes. Provide instructions so we can reproduce. Please also list any relevant details for your test configuration

-N/A
+Please delete options that are not relevant.

-## Test Coverage
+- [ ] Unit Test
+- [ ] Test Script (please provide)

- [ ] I added/updated unit tests
- [ ] I added/updated integration tests
- [ ] I tested manually (describe below)
- [ ] No tests needed (explain why)
+## Checklist:

-<!-- Describe how you tested this, or link to CI results. -->
+- [ ] My code follows the style guidelines of this project
+- [ ] I have performed a self-review of my own code
+- [ ] I have commented my code, particularly in hard-to-understand areas
+- [ ] I have made corresponding changes to the documentation
+- [ ] My changes generate no new warnings
+- [ ] I have added tests that prove my fix is effective or that my feature works
+- [ ] New and existing unit tests pass locally with my changes
+- [ ] Any dependent changes have been merged and published in downstream modules
+- [ ] I have checked my code and corrected any misspellings

-## Checklist
+## Maintainer Checklist

- [ ] My code follows the project's style guidelines
- [ ] I have performed a self-review of my code
- [ ] I have added tests that prove my fix/feature works
- [ ] New and existing tests pass locally
- [ ] I have updated documentation if needed
+- [ ] closes #xxxx (Replace xxxx with the GitHub issue number)
+- [ ] Made sure Checks passed
@@ -1,20 +0,0 @@
-# Maps dropdown selections to GitHub labels
-# Used by the advanced-issue-labeler GitHub Action
-
-component:
-  - label: "sdk-python"
-    matcher: "Core / Python SDK"
-  - label: "sdk-typescript"
-    matcher: "TypeScript SDK"
-  - label: "vector-store"
-    matcher: "Vector Store"
-  - label: "graph-memory"
-    matcher: "Graph Memory"
-  - label: "ollama"
-    matcher: "Ollama"
-  - label: "openmemory"
-    matcher: "OpenMemory"
-  - label: "openclaw"
-    matcher: "OpenClaw"
-  - label: "rest-api"
-    matcher: "REST API"
@@ -7,8 +7,6 @@ on:
      - 'mem0/**'
      - 'tests/**'
      - 'embedchain/**'
-      - '.github/workflows/**'
-      - 'pyproject.toml'
  pull_request:
    paths:
      - 'mem0/**'
@@ -30,8 +28,6 @@ jobs:
          mem0:
            - 'mem0/**'
            - 'tests/**'
-            - '.github/workflows/**'
-            - 'pyproject.toml'
          embedchain:
            - 'embedchain/**'

@@ -48,13 +44,6 @@ jobs:
        uses: actions/setup-python@v4
        with:
          python-version: ${{ matrix.python-version }}
-      - 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
@@ -1,39 +0,0 @@
-name: Auto-label issues
-
-on:
-  issues:
-    types: [opened]
-
-permissions:
-  contents: read
-  issues: write
-
-jobs:
-  label:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: stefanbuck/github-issue-parser@v3
-        id: issue-parser
-        with:
-          template-path: .github/ISSUE_TEMPLATE/bug_report.yml
-
-      - uses: redhat-plumbers-in-action/advanced-issue-labeler@v3
-        with:
-          issue-form: ${{ steps.issue-parser.outputs.jsonString }}
-          section: component
-          token: ${{ secrets.GITHUB_TOKEN }}
-          config-path: .github/advanced-issue-labeler.yml
-
-      - uses: stefanbuck/github-issue-parser@v3
-        id: feature-parser
-        if: contains(github.event.issue.labels.*.name, 'enhancement')
-        with:
-          template-path: .github/ISSUE_TEMPLATE/feature_request.yml
-
-      - uses: redhat-plumbers-in-action/advanced-issue-labeler@v3
-        if: contains(github.event.issue.labels.*.name, 'enhancement')
-        with:
-          issue-form: ${{ steps.feature-parser.outputs.jsonString }}
-          section: component
-          token: ${{ secrets.GITHUB_TOKEN }}
-          config-path: .github/advanced-issue-labeler.yml
@@ -1,100 +0,0 @@
-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)
@@ -1,48 +0,0 @@
-name: Close stale issues
-
-on:
-  schedule:
-    - cron: '0 0 * * *'
-  workflow_dispatch:
-
-permissions:
-  issues: write
-  pull-requests: write
-
-jobs:
-  stale:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/stale@v9
-        with:
-          # Issue settings
-          days-before-issue-stale: 90
-          days-before-issue-close: 14
-          stale-issue-label: 'stale'
-          stale-issue-message: >
-            This issue has been automatically marked as stale because it has not
-            had any activity in 90 days. It will be closed in 14 days if no
-            further activity occurs. If this is still relevant, please leave a
-            comment or remove the `stale` label.
-          close-issue-message: >
-            This issue has been closed due to inactivity. If this is still
-            relevant, feel free to reopen it or create a new issue.
-
-          # PR settings — mark stale but never auto-close
-          days-before-pr-stale: 90
-          days-before-pr-close: -1
-          stale-pr-label: 'stale'
-          stale-pr-message: >
-            This pull request has been automatically marked as stale because it
-            has not had any activity in 90 days. Please update your branch and
-            address any review comments, or it may be closed in the future.
-
-          # Exempt these labels from stale processing
-          exempt-issue-labels: 'P0-critical,P1-high,good first issue,security'
-          exempt-pr-labels: 'P0-critical,P1-high'
-
-          # Remove stale label when there is new activity
-          remove-stale-when-updated: true
-
-          # Process up to 100 issues per run to stay within API limits
-          operations-per-run: 100
@@ -1,110 +0,0 @@
-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
@@ -103,7 +103,7 @@ memory = Memory()
 # With custom configuration
 config = MemoryConfig(
    vector_store={"provider": "qdrant", "config": {"host": "localhost"}},
-    llm={"provider": "openai", "config": {"model": "gpt-4.1-nano-2025-04-14"}},
+    llm={"provider": "openai", "config": {"model": "gpt-4o-mini"}},
    embedder={"provider": "openai", "config": {"model": "text-embedding-3-small"}}
 )
 memory = Memory(config)
@@ -273,7 +273,7 @@ config = MemoryConfig(

 ### Supported Providers

-#### LLM Providers (20 supported)
+#### LLM Providers (19 supported)
 - **openai** - OpenAI GPT models (default)
 - **anthropic** - Claude models
 - **gemini** - Google Gemini
@@ -284,7 +284,6 @@ config = MemoryConfig(
 - **azure_openai** - Azure OpenAI
 - **litellm** - LiteLLM proxy
 - **deepseek** - DeepSeek models
- **minimax** - MiniMax models
 - **xai** - xAI models
 - **sarvam** - Sarvam AI
 - **lmstudio** - LM Studio local server
@@ -340,7 +339,7 @@ config = MemoryConfig(
    llm={
        "provider": "openai",
        "config": {
-            "model": "gpt-4.1-nano-2025-04-14",
+            "model": "gpt-4o-mini",
            "temperature": 0.1,
            "max_tokens": 1000
        }
@@ -528,7 +527,7 @@ const memory = new Memory({
  },
  llm: {
    provider: 'openai',
-    config: { model: 'gpt-4.1-nano' }
+    config: { model: 'gpt-4o-mini' }
  }
 });

@@ -1,221 +1,347 @@
-# Migration Guide: Upgrading to mem0 1.0.0
+# Migration Guide: Upgrading to mem0ai 1.0.0

-## TL;DR
+This guide will help you migrate from mem0ai 0.x to the new 1.0.0 version.

-**What changed?** We simplified the API by removing confusing version parameters. Now everything returns a consistent format: `{"results": [...]}`.
+## Breaking Changes

-**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
+### 1. API Version Changes

-**Time needed:** ~5-10 minutes for most projects
+**Before (0.x):**
+```python
+# Multiple API versions supported
+memory = Memory(config=MemoryConfig(version="v1.1"))

---
+# Client with output_format parameter
+client.add(messages, output_format="v1.1")
+client.search(query, version="v1", output_format="v1.1") 
+client.get_all(version="v1", output_format="v1.1")
+```

-## Quick Migration Guide
+**After (1.0.0):**
+```python
+# v1.1 format is default (v1.0 is deprecated)
+memory = Memory()  # Defaults to v1.1 format

-### 1. Install the Update
+# Client API with correct versioning behavior:
+client.add(messages)  # Uses v1 API endpoint, returns v1.1 format
+client.search(query)  # Uses v2 API endpoint, returns v1.1 format  
+client.get_all()  # Uses v2 API endpoint, returns v1.1 format
+```
+
+### 2. API Versioning Strategy Clarification
+
+**IMPORTANT: Understanding the New Versioning Strategy**
+
+The API versioning strategy in mem0ai 1.0.0 has been unified and simplified:
+
+#### **Endpoint vs Format Distinction**
+- **API Endpoints** (`/v1/`, `/v2/`): Control which REST API version to use
+- **Response Formats** (v1.0, v1.1): Control the structure of the returned data
+
+#### **New Unified Strategy:**
+- **Add operations**: Always use `/v1/` endpoint with v1.1 response format (no more output_format parameter)
+- **Search operations**: Always use `/v2/` endpoint with v1.1 response format  
+- **Get_all operations**: Always use `/v2/` endpoint with v1.1 response format
+- **Response format**: All operations now return v1.1 format (`{"results": [...]}`)
+
+#### **What Changed:**
+- ✅ **Consistent response format**: Everything returns v1.1 format
+- ✅ **Simplified API**: No more `output_format` or `version` parameters to manage
+- ✅ **Endpoint optimization**: Add uses v1, Search/Get use v2 for best performance
+- ❌ **Removed v1.0 support**: v1.0 response format is no longer supported
+
+### 3. Response Format Standardization
+
+**Before (0.x):**
+```python
+# Inconsistent response formats based on api_version
+result = memory.add(messages)
+# Could return list or dict depending on version
+
+memories = memory.get_all()  
+# Could return list or dict depending on version
+```
+
+**After (1.0.0):**
+```python
+# v1.1 format is now default (consistent dict format)
+result = memory.add(messages)
+# Returns: {"results": [...], "relations": [...] (if graph enabled)}
+
+memories = memory.get_all()
+# Returns: {"results": [...], "relations": [...] (if graph enabled)}
+
+# v1.0 format still works but shows deprecation warning
+memory_v1 = Memory(config=MemoryConfig(version="v1.0"))
+result = memory_v1.add(messages)  # Returns raw list [{...}] (with warning)
+```
+
+## Migration Steps
+
+### Step 1: Update Dependencies

 ```bash
 pip install mem0ai==1.0.0
 ```

-### 2. Update Your Code
+### Step 2: Update Code

-**If you're using the Memory API:**
+#### Memory API Changes

 ```python
 # Before
+from mem0 import Memory
+
 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")
+# After - no changes needed, v1.1 is automatic
+from mem0 import Memory
+
+memory = Memory()  # Defaults to v1.1 format
 ```

-**If you're using the Client API:**
+#### Client API Changes

 ```python
 # Before
-client.add(messages, output_format="v1.1")
-client.search(query, version="v2", output_format="v1.1")
+from mem0 import MemoryClient
+
+client = MemoryClient(api_key="your-key")
+
+# Remove all version and output_format parameters
+result = client.add(messages, output_format="v1.1")
+memories = client.search(query, version="v2", output_format="v1.1")
+all_memories = client.get_all(version="v2", output_format="v1.1")

 # After
-client.add(messages)  # Just remove those extra parameters
-client.search(query)
+from mem0 import MemoryClient
+
+client = MemoryClient(api_key="your-key")
+
+# Simplified API calls
+result = client.add(messages)
+memories = client.search(query)
+all_memories = client.get_all()
 ```

-### 3. Update How You Handle Responses
-
-All responses now use the same format: a dictionary with `"results"` key.
+#### Response Handling

 ```python
-# Before - you might have done this
-result = memory.add("I like pizza")
-for item in result:  # Treating it as a list
+# Before - inconsistent response formats
+result = memory.add(messages)
+if isinstance(result, list):
+    # Handle v1.0 format
+    for item in result:
+        print(item)
+else:
+    # Handle v1.1+ format
+    for item in result["results"]:
+        print(item)
+
+# After - consistent response format
+result = memory.add(messages)
+for item in result["results"]:
    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)
+# Access graph relations if enabled
 if "relations" in result:
    for relation in result["relations"]:
        print(relation)
 ```

---
+### Step 3: Remove Deprecated Code

-## Enhanced Message Handling
-
-The platform client (MemoryClient) now supports the same flexible message formats as the OSS version:
+Remove any code that handled multiple API versions:

 ```python
-from mem0 import MemoryClient
+# Remove these patterns
+if version == "v1.0":
+    # handle old format
+elif version == "v1.1":
+    # handle new format

-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")
+# Remove version-specific logic
+def handle_response(response, api_version):
+    if api_version == "v1.0":
+        return response  # list format
+    else:
+        return response["results"]  # dict format
 ```

-### Async Mode Configuration
+### Step 4: Update Configuration

-The `async_mode` parameter now defaults to `True` but can be configured:
+#### Vector Store Configuration

 ```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
+# Before - version in config
 config = MemoryConfig(
    version="v1.1",
    vector_store=VectorStoreConfig(...)
 )

-# After
+# After - no version needed
 config = MemoryConfig(
    vector_store=VectorStoreConfig(...)
 )
 ```

---
+#### Enhanced GCP Support
+
+```python
+# New: Enhanced Vertex AI configuration options
+from mem0.configs.vector_stores.vertex_ai_vector_search import GoogleMatchingEngineConfig
+
+# Option 1: Using credentials file (existing)
+config = GoogleMatchingEngineConfig(
+    project_id="your-project",
+    credentials_path="/path/to/service-account.json",
+    # ... other params
+)
+
+# Option 2: Using credentials dict (new in v1.0.0)
+service_account_info = {
+    "type": "service_account",
+    "project_id": "your-project",
+    # ... rest of service account JSON
+}
+
+config = GoogleMatchingEngineConfig(
+    project_id="your-project",
+    service_account_json=service_account_info,
+    # ... other params
+)
+```

 ## Testing Your Migration

-Quick sanity check:
+### 1. Test Basic Functionality

 ```python
 from mem0 import Memory

+# Test memory operations
 memory = Memory()

-# Add should return a dict with "results"
-result = memory.add("I like pizza", user_id="test")
+# Test adding memories
+result = memory.add("I like pizza")
 assert "results" in result
+assert len(result["results"]) > 0

-# Search should return a dict with "results"
-search = memory.search("food", user_id="test")
-assert "results" in search
+# Test searching
+search_result = memory.search("food preferences", user_id="test_user")
+assert "results" in search_result

-# Get all should return a dict with "results"
-all_memories = memory.get_all(user_id="test")
+# Test listing all
+all_memories = memory.get_all(user_id="test_user")
 assert "results" in all_memories
-
-print("✅ Migration successful!")
 ```
+
+### 2. Test Client Operations
+
+```python
+from mem0 import MemoryClient
+
+client = MemoryClient(api_key="your-api-key")
+
+# Test all client methods work without deprecated parameters
+messages = [{"role": "user", "content": "I love traveling"}]
+result = client.add(messages, user_id="test_user")
+assert "results" in result or isinstance(result, list)  # Platform may vary
+
+memories = client.search("travel", user_id="test_user")
+all_memories = client.get_all(user_id="test_user")
+```
+
+## New Features in v1.0.0
+
+### 1. Improved Vector Store Support
+
+- Fixed OpenSearch vector store integration
+- Enhanced error handling across all vector stores
+- Better performance and reliability
+
+### 2. Enhanced GCP Integration
+
+- Support for service account JSON dict (in addition to file path)
+- Improved Vertex AI Vector Search configuration
+
+### 3. Simplified API
+
+- Default API version is now v1.1 (v1.0 deprecated)
+- Removed deprecated parameters
+- Standardized response formats
+
+## Deprecation Warning for v1.0 Users
+
+If you're currently using `version="v1.0"`, you'll see a deprecation warning:
+
+```
+DeprecationWarning: The v1.0 API format is deprecated and will be removed in mem0ai 2.0.0. 
+Please upgrade to v1.1 format which returns a dict with 'results' key. 
+Set version='v1.1' in your MemoryConfig.
+```
+
+**To resolve this:**
+```python
+# Before (shows warning)
+memory = Memory(config=MemoryConfig(version="v1.0"))
+
+# After (no warning)
+memory = Memory()  # Uses v1.1 by default
+# OR explicitly set v1.1
+memory = Memory(config=MemoryConfig(version="v1.1"))
+```
+
+## Common Issues and Solutions
+
+### Issue 1: "KeyError: 'results'"
+
+**Problem:** Your code expects the old list format response.
+
+**Solution:** Update response handling:
+```python
+# Before
+for memory in response:  # Assuming response is a list
+    print(memory)
+
+# After  
+for memory in response["results"]:
+    print(memory)
+```
+
+### Issue 2: "TypeError: unexpected keyword argument 'output_format'"
+
+**Problem:** Code still passing deprecated parameters.
+
+**Solution:** Remove all deprecated parameters:
+```python
+# Before
+client.add(messages, output_format="v1.1", async_mode=True)
+
+# After
+client.add(messages)
+```
+
+### Issue 3: Vector Store Connection Issues
+
+**Problem:** Vector store tests failing after upgrade.
+
+**Solution:** The OpenSearch integration has been fixed. Update your test configurations and retry.
+
+## Support
+
+If you encounter issues during migration:
+
+1. Check the [GitHub Issues](https://github.com/mem0ai/mem0/issues) for similar problems
+2. Review the updated [API documentation](https://docs.mem0.ai/)  
+3. Create a new issue with your specific migration problem
+
+## Summary
+
+mem0ai 1.0.0 provides a cleaner, more consistent API while removing deprecated features. The migration primarily involves:
+
+1. Removing deprecated parameters (`output_format`, `version`, `async_mode`)
+2. Updating response handling to expect consistent `{"results": [...]}` format
+3. Updating dependencies to v1.0.0
+
+Most applications will require minimal changes, mainly removing deprecated parameters and updating response parsing logic.
@@ -97,7 +97,7 @@ npm install mem0ai

 ### Basic Usage

-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).
+Mem0 requires an LLM to function, with `gpt-4o-mini` from OpenAI as the default. However, it supports a variety of LLMs; for details, refer to our [Supported LLMs documentation](https://docs.mem0.ai/components/llms/overview).

 First step is to instantiate the memory:

@@ -116,7 +116,7 @@ def chat_with_memories(message: str, user_id: str = "default_user") -> str:
    # Generate Assistant response
    system_prompt = f"You are a helpful AI. Answer the question based on query and memories.\nUser Memories:\n{memories_str}"
    messages = [{"role": "system", "content": system_prompt}, {"role": "user", "content": message}]
-    response = openai_client.chat.completions.create(model="gpt-4.1-nano-2025-04-14", messages=messages)
+    response = openai_client.chat.completions.create(model="gpt-4o-mini", messages=messages)
    assistant_response = response.choices[0].message.content

    # Create new memories from the conversation
@@ -168,4 +168,4 @@ We now have a paper you can cite:

 ## ⚖️ License

-Apache 2.0 — see the [LICENSE](https://github.com/mem0ai/mem0/blob/main/LICENSE) file for details.
+Apache 2.0 — see the [LICENSE](LICENSE) file for details.
@@ -1,3 +1,3 @@
 <Note type="info">
-  <strong>🎉 Mem0 1.0.0 is here!</strong> Enhanced filtering, reranking, and smarter memory management.
+  📢 Announcing our research paper: Mem0 achieves <strong>26%</strong> higher accuracy than OpenAI Memory, <strong>91%</strong> lower latency, and <strong>90%</strong> token savings! [Read the paper](https://mem0.ai/research) to learn how we're revolutionizing AI agent memory.
 </Note>
@@ -1,108 +1,191 @@
 ---
-title: "Overview"
-icon: "terminal"
+title: Overview
+icon: "info"
 iconType: "solid"
-description: "REST APIs for memory management, search, and entity operations"
 ---

-## Mem0 REST API
+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.

-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.
+## Key Features

-<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>
+- **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

-## Quick Start Guide
+Our API is organized into several main categories:

-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>
-
---
+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 Token-based authentication. Include your API key in the Authorization header:
+All API requests require authentication using HTTP Basic Auth. Ensure you include your API key in the Authorization header of each request.

-```bash
-Authorization: Token <your-api-key>
+## 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')
 ```

-Get your API key from the [Mem0 Dashboard](https://app.mem0.ai/dashboard/api-keys).
+  </Tab>

-<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>
+  <Tab title="Node.js">

---
+```javascript
+import { MemoryClient } from "mem0ai";
+const client = new MemoryClient({organizationId: "YOUR_ORG_ID", projectId: "YOUR_PROJECT_ID"});
+```

-## Next Steps
+  </Tab>
+</Tabs>

-<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>
+### Project Management Methods

-  <Card title="Search with Filters" icon="filter" href="/api-reference/memory/search-memories">
-    Learn advanced search and filtering techniques
-  </Card>
-</CardGroup>
+The Mem0 client provides comprehensive project management capabilities 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
+
+<Note>
+This action will remove all memories, messages, and other related data in the project. This operation is irreversible.
+</Note>
+
+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
+
+- **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 also 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())
+```
+
+## 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.
@@ -1,5 +1,4 @@
 ---
 title: 'Delete User'
-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}/
+openapi: delete /v1/entities/{entity_type}/{entity_id}/
 ---
@@ -1,5 +1,4 @@
 ---
 title: 'Get Users'
-description: "Retrieve a list of all user entities stored in the Mem0 platform using the GET endpoint."
 openapi: get /v1/entities/
 ---
@@ -1,7 +0,0 @@
---
-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.
@@ -1,14 +0,0 @@
---
-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.
-
@@ -1,98 +1,4 @@
 ---
 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.
+---
@@ -1,5 +1,4 @@
 ---
 title: 'Batch Delete Memories'
-description: "Delete multiple memories in a single batch request using the Mem0 API DELETE endpoint."
 openapi: delete /v1/batch/
 ---
@@ -1,5 +1,4 @@
 ---
 title: 'Batch Update Memories'
-description: "Update multiple memories in a single batch request using the Mem0 API PUT endpoint."
 openapi: put /v1/batch/
 ---
@@ -1,7 +1,6 @@
 ---
 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.
@@ -1,5 +1,4 @@
 ---
 title: 'Delete Memories'
-description: "Delete all memories matching specified filters from the Mem0 memory store using the DELETE endpoint."
 openapi: delete /v1/memories/
 ---
@@ -1,5 +1,4 @@
 ---
 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}/
 ---
@@ -1,5 +1,4 @@
 ---
 title: 'Feedback'
-description: "Submit positive or negative feedback on memory results to help improve memory accuracy and relevance."
 openapi: post /v1/feedback/
 ---
@@ -1,100 +0,0 @@
---
-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>
@@ -1,6 +1,5 @@
 ---
 title: 'Get Memory Export'
-description: "Retrieve the latest structured memory export after submitting an export job, with optional entity filters."
 openapi: post /v1/exports/get
 ---

@@ -1,5 +1,4 @@
 ---
 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}/
 ---
@@ -1,5 +1,4 @@
 ---
 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/
 ---
@@ -1,105 +0,0 @@
---
-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>
@@ -1,5 +1,4 @@
 ---
 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}/
 ---
@@ -0,0 +1,4 @@
+---
+title: 'Get Memories (v1 - Deprecated)'
+openapi: get /v1/memories/
+---
@@ -0,0 +1,4 @@
+---
+title: 'Search Memories (v1 - Deprecated)'
+openapi: post /v1/memories/search/
+---
@@ -0,0 +1,65 @@
+---
+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, 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 = 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>
+
+<CodeGroup>
+```python Wildcard Example
+# Using wildcard to get all memories for a specific user across all run_ids
+memories = m.get_all(
+    filters={
+        "AND": [
+            {
+                "user_id": "alex"
+            },
+            {
+                "run_id": "*"
+            }
+        ]
+    },
+    version="v2"
+)
+```
+</CodeGroup>
@@ -0,0 +1,108 @@
+---
+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, 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
+  related_memories = m.search(
+      query="What are Alice's hobbies?",
+      version="v2",
+      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 = m.search(
+      query="What are Alice's hobbies?",
+      version="v2",
+      filters={
+          "AND": [
+              {
+                  "user_id": "alice"
+              },
+              {
+                  "run_id": "*"
+              }
+          ]
+      },
+  )
+  ```
+  </CodeGroup>
+
+  <CodeGroup>
+  ```python Categories Filter Examples
+  # Example 1: Using 'contains' for partial matching
+  finance_memories = m.search(
+      query="What are my financial goals?",
+      version="v2",
+      filters={
+          "AND": [
+              { "user_id": "alice" },
+              {
+                  "categories": {
+                      "contains": "finance"
+                  }
+              }
+          ]
+      },
+  )
+
+  # Example 2: Using 'in' for exact matching
+  personal_memories = m.search(
+      query="What personal information do you have?",
+      version="v2",
+      filters={
+          "AND": [
+              { "user_id": "alice" },
+              {
+                  "categories": {
+                      "in": ["personal_information"]
+                  }
+              }
+          ]
+      },
+  )
+  ```
+  </CodeGroup>
@@ -1,6 +1,5 @@
 ---
 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/
 ---

@@ -1,5 +1,4 @@
 ---
 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/
 ---
@@ -1,5 +1,4 @@
 ---
 title: 'Delete Organization'
-description: "Permanently delete an organization and its associated resources from the Mem0 platform."
 openapi: delete /api/v1/orgs/organizations/{org_id}/
 ---
@@ -1,5 +1,4 @@
 ---
 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/
 ---
@@ -1,5 +1,4 @@
 ---
 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}/
 ---
@@ -1,5 +1,4 @@
 ---
 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/
 ---
@@ -1,197 +0,0 @@
---
-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>
@@ -1,6 +1,5 @@
 ---
 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/
 ---

@@ -1,5 +1,4 @@
 ---
 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/
 ---
@@ -1,5 +1,4 @@
 ---
 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}/
 ---
@@ -1,5 +1,4 @@
 ---
 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/
 ---
@@ -1,5 +1,4 @@
 ---
 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}/
 ---
@@ -1,5 +1,4 @@
 ---
 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/
 ---
@@ -1,6 +1,9 @@
 ---
 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.
+
@@ -1,5 +1,8 @@
 ---
 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.
@@ -1,6 +1,9 @@
 ---
 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.
+
@@ -1,6 +1,9 @@
 ---
 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.
+
@@ -1,6 +1,5 @@
 ---
 title: "Product Updates"
-description: "Latest releases, bug fixes, and improvements for the Mem0 Python and TypeScript SDKs."
 mode: "wide"
 ---

@@ -8,157 +7,6 @@ mode: "wide"
 <Tabs>
 <Tab title="Python">

-<Update label="2026-03-19" description="v1.0.7">
-
-**Bug Fixes:**
- **Core:** Fixed control characters in LLM JSON responses causing parse failures (#4420)
- **Core:** Replaced hardcoded US/Pacific timezone references with `timezone.utc` (#4404)
- **Core:** Preserved `http_auth` in `_safe_deepcopy_config` for OpenSearch (#4418)
- **Core:** Normalized malformed LLM fact output before embedding (#4224)
- **Embeddings:** Pass `encoding_format='float'` in OpenAI embeddings for proxy compatibility (#4058)
- **LLMs:** Fixed Ollama to pass tools to `client.chat` and parse `tool_calls` from response (#4176)
- **Reranker:** Support nested LLM config in `LLMReranker` for non-OpenAI providers (#4405)
- **Vector Stores:** Cast `vector_distance` to float in Redis search (#4377)
-
-**Improvements:**
- **Embeddings:** Improved Ollama embedder with model name normalization and error handling (#4403)
-
-</Update>
-
-<Update label="2026-03-16" description="v1.0.6">
-
-**Bug Fixes:**
- **Telemetry:** Fixed telemetry vector store initialization still running when `MEM0_TELEMETRY` is disabled (#4351)
- **Core:** Removed destructive `vector_store.reset()` call from `delete_all()` that was wiping the entire vector store instead of deleting only the target memories (#4349)
- **OSS:** `OllamaLLM` now respects the configured URL instead of always falling back to localhost (#4320)
- **Core:** Fixed `KeyError` when LLM omits the `entities` key in tool call response (#4313)
- **Prompts:** Ensured JSON instruction is included in prompts when using `json_object` response format (#4271)
- **Core:** Fixed incorrect database parameter handling (#3913)
-
-**Dependencies:**
- Updated LangChain dependencies to v1.0.0 (#4353)
- Bumped protobuf dependency to 5.29.6 and extended upper bound to `<7.0.0` (#4326)
-
-</Update>
-
-<Update label="2026-03-03" description="v1.0.5">
- **Telemetry Fix**
-  - Fixed an issue where the PostHog client was initialized even after telemetry was disabled. Although events were not captured, the client was unnecessarily initialized.
-</Update>
-
-<Update label="2026-02-17" description="v1.0.4">
-
-**New Features & Updates:**
- **Memory Update:**
-  - Added `timestamp` parameter to `update()` — accepts Unix epoch (int/float) or ISO 8601 string
-
-</Update>
-
-<Update label="2026-01-29" description="v1.0.3">
-
-**New Features & Updates:**
- **Project Settings:**
-  - Added inclusion prompt, exclusion prompt, memory depth, and usecase setting
-
-</Update>
-
-<Update label="2026-01-13" description="v1.0.2">
-
-**New Features & Updates:**
- **Vector Stores:**
-  - Added DriverInfo metadata to MongoDB vector store
-
-</Update>
-
-<Update label="2025-11-14" description="v1.0.1">
-
-**New Features & Updates:**
- **Vector Stores:**
-  - Added Apache Cassandra vector store support
- **Embeddings:**
-  - Added FastEmbed embedding support for local embeddings
- **Graph Store:**
-  - Added configurable embedding similarity threshold for graph store node matching
-
-**Bug Fixes:**
- **Core:**
-  - Fixed condition check for memories_result type in Memory class
-  - Fixed list_memories endpoint Pydantic validation error
-  - Fixed memory deletion not removing from vector store
-
-</Update>
-
-<Update label="2025-10-16" description="v1.0.0">
-
-**New Features & Updates:**
- **Vector Stores:**
-  - Added Azure MySQL support
-  - Added Azure AI Search Vector Store support
- **LLMs:**
-  - Added Tool Call support for LangchainLLM
-  - Enabled custom model and parameters for Hugging Face with huggingface_base_url
-  - Updated default LLM configuration
- **Rerankers:**
-  - Added reranker support: Cohere, ZeroEntropy, Hugging Face, Sentence Transformers, and LLMs
- **Core:**
-  - Added metadata filtering for OSS
-  - Added Assistant memory retrieval
-  - Enabled async mode as default
-
-**Improvements:**
- **Prompts:**
-  - Improved prompt for better memory retrieval
- **Dependencies:**
-  - Updated dependency compatibility with OpenAI 2.x
- **Validation:**
-  - Validated embedding_dims for Kuzu integration
-
-**Bug Fixes:**
- **Vector Stores:**
-  - Fixed Databricks Vector Store integration
-  - Fixed Milvus DB bug and added test coverage
-  - Fixed Weaviate search method
- **LLMs:**
-  - Fixed bug with thinking LLM in vLLM
-
-</Update>
-
-<Update label="2025-09-25" description="v0.1.118">
-
-**New Features & Updates:**
- **Vector Stores:**
-  - Added Valkey vector store support
-  - Added support for ChromaDB Cloud
-  - Added Mem0 vector store backend integration for Neptune Analytics
- **Graph Store:**
-  - Added Neptune-DB graph store with vector store
- **Core:**
-  - Implemented structured exception classes with error codes and suggested actions
-
-**Improvements:**
- **Dependencies:**
-  - Updated OpenAI dependency and improved Ollama compatibility
- **Testing:**
-  - Added Weaviate DB test
-  - Added comprehensive test suite for SQLiteManager
- **Documentation:**
-  - Updated category docs
-  - Updated Search V2 / Get All V2 filters documentation
-  - Refactored AWS example title
-  - Fixed Quickstart cURL example
-
-**Bug Fixes:**
- **Vector Stores:**
-  - Databricks bug fixes
-  - Fixed S3 Vectors memory initialization issue from configuration
- **Core:**
-  - Fixed JSON parsing with new memories
-  - Replaced hardcoded LLM provider with provider from configuration
- **LLMs:**
-  - Fixed Bedrock Anthropic models to use system field
-
-</Update>
-
 <Update label="2025-09-03" description="v0.1.117">

 **New Features & Updates:**
@@ -763,98 +611,6 @@ mode: "wide"

 <Tab title="TypeScript">

-<Update label="2026-03-19" description="v2.4.2">
-
-**Bug Fixes:**
- **Client:** Fixed webhook `createWebhook` and `updateWebhook` API serialization
- **Client:** Added missing `MEMORY_CATEGORIZED` event type to `WebhookEvent` enum
- **Types:** Added `WebhookCreatePayload` and `WebhookUpdatePayload` for better type safety
-
-**Tests:**
- Added end-to-end unit test coverage for the platform client — CRUD, batch, search, webhooks, users, project, and initialization (#4357)
- Added real API integration tests for memory CRUD, batch operations, search, user management, project configuration, and webhook lifecycle (#4395)
- Deleted obsolete e2e test files replaced by the new structured test suite (#4419)
-
-</Update>
-
-<Update label="2026-03-16" description="v2.4.1">
-
-**Bug Fixes:**
- **Core:** Fixed code block content extraction — content inside code blocks is now properly extracted instead of being deleted (#4317)
-
-**Improvements:**
- **Code Quality:** Fixed linting issues across the SDK (#4334)
-
-</Update>
-
-<Update label="2026-03-14" description="v2.4.0">
-
-**Bug Fixes:**
- **OSS Storage:** Fixed `SQLITE_CANTOPEN` errors when running as a LaunchAgent, systemd service, or in containers where `process.cwd()` is read-only (e.g. `/`). Default `vector_store.db` location changed from `process.cwd()/vector_store.db` to `~/.mem0/vector_store.db`.
- **OSS Storage:** Fixed `historyDbPath` config being silently ignored — config merging always overwrote it with defaults. Top-level `historyDbPath` is now correctly propagated into `historyStore.config` with proper precedence.
- **OSS Storage:** Added `ensureSQLiteDirectory()` — parent directories for SQLite database files are now auto-created before opening, preventing `SQLITE_CANTOPEN` when using nested paths.
-
-**Improvements:**
- **Migration:** Added deprecation warning when an existing `vector_store.db` is found at the old `process.cwd()` location, guiding users to move it or set `vectorStore.config.dbPath` explicitly.
- **Config:** Limited default SQLite config spreading to only SQLite history providers, preventing config leaking into Supabase or other providers.
-
-</Update>
-
-<Update label="2026-03-09" description="v2.3.0">
-
-**Breaking Changes:**
- **Dependencies:** Minimum Node.js version for OSS sqlite features is now Node 20+ (due to `better-sqlite3` v12)
-
-**Bug Fixes:**
- **OSS Storage:** Replaced `sqlite3` with `better-sqlite3` to fix native binding resolution failures under jiti-based loaders (e.g. OpenClaw plugin system). Fixes issues where the `bindings` module walked V8 stack frames with synthetic filenames, failing to locate the native `.node` addon.
- **OSS Storage:** Fixed async init race condition in `SQLiteManager` — `init()` is now synchronous
- **OSS Vector Store:** Migrated `MemoryVectorStore` from `sqlite3` to `better-sqlite3` with transactional batch inserts
-
-**Improvements:**
- **Performance:** Cached prepared statements in `SQLiteManager` for faster history operations
- **Performance:** Batch `insert()` in `MemoryVectorStore` wrapped in a transaction for atomicity
- **Build:** Updated `tsup.config.ts` externals from `sqlite3` to `better-sqlite3`
-
-</Update>
-
-<Update label="2026-02-17" description="v2.2.3">
-
-**New Features & Updates:**
- **Memory Update:**
-  - Added `timestamp` parameter to `update()` — accepts Unix epoch or ISO 8601 string
-
-</Update>
-
-<Update label="2026-01-29" description="v2.2.2">
-
-**New Features & Updates:**
- **Project Settings:**
-  - Added inclusion prompt, exclusion prompt, memory depth, and usecase setting
-
-</Update>
-
-<Update label="2025-12-30" description="v2.2.1">
-
-**Improvements:**
- **Client:** Added support for keyword arguments in `add` and `search` methods, allowing additional properties beyond defined options for experimental features
-
-</Update>
-
-<Update label="2025-12-29" description="v2.2.0">
-
-**New Features:**
- **Vector Stores:** Added Azure AI Search vector store support
-
-**Improvements:**
- **Config:** Fixed embedder config schema to support `embeddingDims` and `url` parameters
- **Graph Memory:** Replaced hardcoded LLM provider with provider from configuration
-
-**Bug Fixes:**
- **Embedders:** Fixed hardcoded `embeddingDims` values in embedders (OpenAI, Ollama, Google, Azure)
- **Build:** Fixed TypeScript build errors
-
-</Update>
-
 <Update label="2025-09-04" description="v2.1.38">
 **New Features:**
 - **Client:** Added `metadata` param to `update` method.
@@ -881,17 +637,17 @@ mode: "wide"
 </Update>

 <Update label="2025-06-24" description="v2.1.33">
-**Improvement:**
+**Improvement :**
 - **Client:** Added `immutable` param to `add` method.
 </Update>

 <Update label="2025-06-20" description="v2.1.32">
-**Improvement:**
+**Improvement :**
 - **Client:** Made `api_version` V2 as default.
 </Update>

 <Update label="2025-06-17" description="v2.1.31">
-**Improvement:**
+**Improvement :**
 - **Client:** Added param `filter_memories`.
 </Update>

@@ -1331,21 +1087,6 @@ mode: "wide"

 <Tab title="Vercel AI SDK">

-<Update label="2025-12-26" description="v2.0.5">
-**Bug Fix:**
- **Vercel AI SDK:** Removed unnecessary dependencies to make the package lighter.
-</Update>
-
-<Update label="2025-09-25" description="v2.0.4">
-**Bug Fix:**
- **Vercel AI SDK:** Fixed version parameter in the AI SDK to use V2 for addition.
-</Update>
-
-<Update label="2025-09-25" description="v2.0.3">
-**New Features:**
- **Vercel AI SDK:** Added file support for multimodal capabilities with memory context
-</Update>
-
 <Update label="2025-09-03" description="v2.0.2">
 **Bug Fix:**
 - **Vercel AI SDK:** Fixed streaming response in the AI SDK.
@@ -1,6 +1,7 @@
 ---
 title: Configurations
-description: "Reference for embedder configuration options in Mem0, including provider selection and model settings."
+icon: "gear"
+iconType: "solid"
 ---


@@ -1,6 +1,5 @@
 ---
 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.
@@ -42,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 thriller movies? They can be quite engaging."},
+    {"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."}
 ]
@@ -1,6 +1,5 @@
 ---
 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.
@@ -24,7 +23,7 @@ config = {
    "embedder": {
        "provider": "azure_openai",
        "config": {
-            "model": "text-embedding-3-large",
+            "model": "text-embedding-3-large"
            "azure_kwargs": {
                  "api_version": "",
                  "azure_deployment": "",
@@ -41,7 +40,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 thriller movies? They can be quite engaging."},
+    {"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."}
 ]
@@ -69,7 +68,7 @@ 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": "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."}
 ]
@@ -118,20 +117,9 @@ Refer to [Azure Identity troubleshooting tips](https://github.com/Azure/azure-sd
 ### 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>
@@ -1,6 +1,5 @@
 ---
 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).
@@ -27,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 thriller movies? They can be quite engaging."},
+    {"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."}
 ]
@@ -39,19 +38,19 @@ import { Memory } from 'mem0ai/oss';

 const config = {
  embedder: {
-      provider: "google",
-      config: {
-        apiKey: process.env["GOOGLE_API_KEY"],
-        model: "gemini-embedding-001",
-        embeddingDims: 1536,
-      },
+    provider: 'google',
+    config: {
+      apiKey: process.env.GOOGLE_API_KEY || '',
+      model: 'text-embedding-004',
+      // The output dimensionality is fixed at 768 for Google AI embeddings
    },
+  },
 };

 const memory = new Memory(config);
 const messages = [
    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
+    {"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."}
 ]
@@ -62,19 +61,9 @@ await memory.add(messages, { userId: "john" });
 ### 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>
+
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `model` | The name of the embedding model to use | `models/text-embedding-004` |
+| `embedding_dims` | Dimensions of the embedding model (output_dimensionality will be considered as embedding_dims, so please set embedding_dims accordingly) | `768` |
+| `api_key` | The Google API key | `None` |
@@ -1,6 +1,5 @@
 ---
 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.
@@ -25,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 thriller movies? They can be quite engaging."},
+    {"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."}
 ]
@@ -1,6 +1,5 @@
 ---
 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.
@@ -37,7 +36,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 thriller movies? They can be quite engaging."},
+    {"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."}
 ]
@@ -67,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 thriller movies? They can be quite engaging."},
+    {"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."}
 ]
@@ -1,7 +1,3 @@
---
-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
@@ -24,7 +20,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 thriller movies? They can be quite engaging."},
+    {"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."}
 ]
@@ -33,10 +29,10 @@ m.add(messages, user_id="john")

 ### Config

-Here are the parameters available for configuring LM Studio embedder:
+Here are the parameters available for configuring Ollama embedder:

 | Parameter | Description | Default Value |
 | --- | --- | --- |
-| `model` | The name of the LM Studio model to use | `nomic-embed-text-v1.5-GGUF/nomic-embed-text-v1.5.f16.gguf` |
+| `model` | The name of the OpenAI model to use | `nomic-embed-text-v1.5-GGUF/nomic-embed-text-v1.5.f16.gguf` |
 | `embedding_dims` | Dimensions of the embedding model | `1536` |
 | `lmstudio_base_url` | Base URL for LM Studio connection | `http://localhost:1234/v1` |
@@ -1,7 +1,3 @@
---
-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
@@ -25,7 +21,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 thriller movies? They can be quite engaging."},
+    {"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."}
 ]
@@ -48,7 +44,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 thriller movies? They can be quite engaging."},
+    {"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."}
 ]
@@ -73,6 +69,5 @@ Here are the parameters available for configuring Ollama embedder:
 | --- | --- | --- |
 | `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>
@@ -1,6 +1,5 @@
 ---
 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).
@@ -26,7 +25,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 thriller movies? They can be quite engaging."},
+    {"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."}
 ]
@@ -1,6 +1,5 @@
 ---
 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).
@@ -28,7 +27,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 thriller movies? They can be quite engaging."},
+    {"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."}
 ]
@@ -1,7 +1,3 @@
---
-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/).
@@ -31,7 +27,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 thriller movies? They can be quite engaging."},
+    {"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."}
 ]
@@ -1,6 +1,7 @@
 ---
 title: Overview
-description: "Overview of all supported embedding model providers in Mem0, including OpenAI, Azure, Ollama, and more."
+icon: "info"
+iconType: "solid"
 ---

 Mem0 offers support for various embedding models, allowing users to choose the one that best suits their needs.
@@ -28,6 +29,6 @@ See the list of supported embedders below.

 ## Usage

-To utilize an embedding model, you must provide a configuration to customize its usage. If no configuration is supplied, a default configuration will be applied, and `OpenAI` will be used as the embedding model.
+To utilize a embedder, you must provide a configuration to customize its usage. If no configuration is supplied, a default configuration will be applied, and `OpenAI` will be used as the embedder.

-For a comprehensive list of available parameters for embedding model configuration, please refer to [Config](./config).
+For a comprehensive list of available parameters for embedder configuration, please refer to [Config](./config).
@@ -1,6 +1,7 @@
 ---
 title: Configurations
-description: "Reference for LLM configuration options in Mem0 for Python and TypeScript, including value precedence rules."
+icon: "gear"
+iconType: "solid"
 ---

 ## How to define configurations?
@@ -1,6 +1,5 @@
 ---
 title: Anthropic
-description: "Configure Anthropic Claude models as the LLM provider in Mem0 with API key setup and usage examples."
 ---


@@ -30,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 thriller movies? They can be quite engaging."},
+    {"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."}
 ]
@@ -55,7 +54,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 thriller movies? They can be quite engaging."},
+    {"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."}
 ]
@@ -1,6 +1,5 @@
 ---
 title: AWS Bedrock
-description: "Configure AWS Bedrock as an LLM provider in Mem0 with IAM authentication and Claude model support."
 ---

 ### Setup
@@ -32,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 thriller movies? They can be quite engaging."},
+    {"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."}
 ]
@@ -1,6 +1,5 @@
 ---
 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>
@@ -49,7 +48,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 thriller movies? They can be quite engaging."},
+    {"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."}
 ]
@@ -78,7 +77,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 thriller movies? They can be quite engaging."},
+    {"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."}
 ]
@@ -1,6 +1,5 @@
 ---
 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").
@@ -29,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 thriller movies? They can be quite engaging."},
+    {"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."}
 ]
@@ -1,6 +1,5 @@
 ---
 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 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).
@@ -1,6 +1,5 @@
 ---
 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.
@@ -31,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 thriller movies? They can be quite engaging."},
+    {"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."}
 ]
@@ -56,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 thriller movies? They can be quite engaging."},
+    {"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."}
 ]
@@ -1,6 +1,5 @@
 ---
 title: LangChain
-description: "Use LangChain as an LLM provider in Mem0 to integrate with various chat models through a unified interface."
 ---


@@ -21,7 +20,7 @@ os.environ["OPENAI_API_KEY"] = "your-api-key"

 # Initialize a LangChain model directly
 openai_model = ChatOpenAI(
-    model="gpt-4.1-nano-2025-04-14",
+    model="gpt-4o",
    temperature=0.2,
    max_tokens=2000
 )
@@ -39,7 +38,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 thriller movies? They can be quite engaging."},
+    {"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."}
 ]
@@ -70,7 +69,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 thriller movies? They can be quite engaging."},
+    {"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."}
 ]
@@ -1,7 +1,3 @@
---
-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
@@ -16,7 +12,7 @@ config = {
    "llm": {
        "provider": "litellm",
        "config": {
-            "model": "gpt-4.1-nano-2025-04-14",
+            "model": "gpt-4o-mini",
            "temperature": 0.2,
            "max_tokens": 2000,
        }
@@ -26,7 +22,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 thriller movies? They can be quite engaging."},
+    {"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."}
 ]
@@ -1,6 +1,5 @@
 ---
 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.
@@ -30,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 thriller movies? They can be quite engaging."},
+    {"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."}
 ]
@@ -58,7 +57,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 thriller movies? They can be quite engaging."},
+    {"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."}
 ]
@@ -1,56 +0,0 @@
---
-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).
@@ -1,6 +1,5 @@
 ---
 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.
@@ -29,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 thriller movies? They can be quite engaging."},
+    {"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."}
 ]
@@ -54,7 +53,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 thriller movies? They can be quite engaging."},
+    {"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."}
 ]
@@ -1,9 +1,4 @@
---
-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.
+You can use LLMs from Ollama to run Mem0 locally. These [models](https://ollama.com/search?c=tools) support tool support.

 ## Usage

@@ -28,7 +23,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 thriller movies? They can be quite engaging."},
+    {"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."}
 ]
@@ -52,7 +47,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 thriller movies? They can be quite engaging."},
+    {"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."}
 ]
@@ -1,6 +1,5 @@
 ---
 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).
@@ -20,7 +19,7 @@ config = {
    "llm": {
        "provider": "openai",
        "config": {
-            "model": "gpt-4.1-nano-2025-04-14",
+            "model": "gpt-4o",
            "temperature": 0.2,
            "max_tokens": 2000,
        }
@@ -41,7 +40,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 thriller movies? They can be quite engaging."},
+    {"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."}
 ]
@@ -66,7 +65,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 thriller movies? They can be quite engaging."},
+    {"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."}
 ]
@@ -86,7 +85,7 @@ config = {
    "llm": {
        "provider": "openai_structured",
        "config": {
-            "model": "gpt-4.1-nano-2025-04-14",
+            "model": "gpt-4o-2024-08-06",
            "temperature": 0.0,
        }
    }
@@ -1,6 +1,5 @@
 ---
 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.
@@ -29,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 thriller movies? They can be quite engaging."},
+    {"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."}
 ]
@@ -1,9 +1,4 @@
---
-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).
+To use TogetherAI LLM models, you have to set the `TOGETHER_API_KEY` environment variable. You can obtain the TogetherAI API key from their [Account settings page](https://api.together.xyz/settings/api-keys).

 ## Usage

@@ -28,7 +23,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 thriller movies? They can be quite engaging."},
+    {"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."}
 ]
@@ -37,4 +32,4 @@ m.add(messages, user_id="alice", metadata={"category": "movies"})

 ## Config

-All available parameters for the `together` config are present in [Master List of All Params in Config](../config).
+All available parameters for the `togetherai` config are present in [Master List of All Params in Config](../config).
@@ -1,6 +1,5 @@
 ---
 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.
@@ -1,6 +1,5 @@
 ---
 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.
@@ -30,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 thriller movies? They can be quite engaging."},
+    {"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."}
 ]
@@ -1,6 +1,7 @@
 ---
 title: Overview
-description: "Overview of all supported LLM providers in Mem0, including OpenAI, Anthropic, Groq, Ollama, and more."
+icon: "info"
+iconType: "solid"
 ---

 Mem0 includes built-in support for various popular large language models. Memory can utilize the LLM provided by the user, ensuring efficient use for specific needs.
@@ -27,11 +28,10 @@ See the list of supported LLMs below.
  <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="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" />
@@ -1,71 +1,57 @@
 ---
 title: Config
-description: "Reference for shared and provider-specific reranker configuration options in Mem0, including top_k and API key settings."
+description: 'Configuration options for rerankers in Mem0'
+icon: "gear"
+iconType: "solid"
 ---

 ## 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`   |
+| 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`       |
+| 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`                  |
+| 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`                      |
+| 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` |

 ### 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`   |
+| 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 |

 ## Environment Variables

@@ -73,7 +59,6 @@ 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)

@@ -91,10 +76,10 @@ config = {
    "llm": {
        "provider": "openai",
        "config": {
-            "model": "gpt-4.1-nano-2025-04-14"
+            "model": "gpt-4o-mini"
        }
    },
-    "reranker": {
+    "rerank": {
        "provider": "zero_entropy",
        "config": {
            "model": "zerank-1",
@@ -102,4 +87,4 @@ config = {
        }
    }
 }
-```
+```
@@ -1,221 +0,0 @@
---
-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
@@ -1,6 +1,8 @@
 ---
 title: Cohere
-description: "Configure Cohere as a reranker in Mem0 with support for English and multilingual reranking models."
+description: 'Enterprise-grade reranking with Cohere'
+icon: "building"
+iconType: "solid"
 ---

 Cohere provides enterprise-grade reranking models with excellent multilingual support and production-ready performance.
@@ -35,10 +37,10 @@ config = {
    "llm": {
        "provider": "openai",
        "config": {
-            "model": "gpt-4.1-nano-2025-04-14"
+            "model": "gpt-4o-mini"
        }
    },
-    "reranker": {
+    "rerank": {
        "provider": "cohere",
        "config": {
            "model": "rerank-english-v3.0",
@@ -122,13 +124,13 @@ config = {

 ## 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`                  |
+| 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

@@ -142,4 +144,4 @@ config = {
 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
+4. **Monitoring**: Track reranking performance and costs
@@ -1,350 +0,0 @@
---
-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>
@@ -1,12 +1,10 @@
 ---
-title: LLM as Reranker
-description: "Use any LLM as a flexible reranker in Mem0 with custom prompts and domain-specific scoring logic."
+title: LLM-based
+description: 'Flexible reranking using any Large Language Model'
+icon: "robot"
+iconType: "solid"
 ---

-<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
@@ -39,7 +37,7 @@ config = {
            "model": "gpt-4o-mini"
        }
    },
-    "reranker": {
+    "rerank": {
        "provider": "llm",
        "config": {
            "model": "gpt-4o-mini",
@@ -73,7 +71,7 @@ Score from 0.0 to 1.0 where:

 Provide only a single numerical score between 0.0 and 1.0."""

-config["reranker"]["config"]["scoring_prompt"] = custom_prompt
+config["rerank"]["config"]["scoring_prompt"] = custom_prompt
 ```

 ## Usage Example
@@ -89,7 +87,7 @@ os.environ["OPENAI_API_KEY"] = "your-api-key"
 config = {
    "vector_store": {"provider": "chroma"},
    "llm": {"provider": "openai", "config": {"model": "gpt-4o-mini"}},
-    "reranker": {
+    "rerank": {
        "provider": "llm",
        "config": {
            "model": "gpt-4o-mini",
@@ -120,16 +118,6 @@ for result in results['results']:
    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:
@@ -149,7 +137,7 @@ Consider:
 Score from 0.0 to 1.0. Provide only the numerical score."""

 config = {
-    "reranker": {
+    "rerank": {
        "provider": "llm",
        "config": {
            "model": "gpt-4o-mini",
@@ -168,7 +156,7 @@ Use different LLM providers for reranking:
 ```python Python
 # Using Anthropic Claude
 anthropic_config = {
-    "reranker": {
+    "rerank": {
        "provider": "llm",
        "config": {
            "model": "claude-3-haiku-20240307",
@@ -180,8 +168,8 @@ anthropic_config = {

 # Using local Ollama model
 ollama_config = {
-    "reranker": {
-        "provider": "llm",
+    "rerank": {
+        "provider": "llm", 
        "config": {
            "model": "llama2:7b",
            "provider": "ollama",
@@ -1,489 +0,0 @@
---
-title: LLM Reranker
-description: 'Use any language model as a reranker with custom prompts'
---
-
-## Overview
-
-The LLM reranker allows you to use any supported language model as a reranker. This approach uses prompts to instruct the LLM to score and rank memories based on their relevance to the query. While slower than specialized rerankers, it offers maximum flexibility and can be fine-tuned with custom prompts.
-
-## Configuration
-
-### Basic Setup
-
-```python
-from mem0 import Memory
-
-config = {
-    "reranker": {
-        "provider": "llm_reranker",
-        "config": {
-            "llm": {
-                "provider": "openai",
-                "config": {
-                    "model": "gpt-4",
-                    "api_key": "your-openai-api-key"
-                }
-            }
-        }
-    }
-}
-
-m = Memory.from_config(config)
-```
-
-### Configuration Parameters
-
-| Parameter | Type | Default | Description |
-|-----------|------|---------|-------------|
-| `llm` | dict | Required | LLM configuration object |
-| `top_k` | int | 10 | Number of results to rerank |
-| `temperature` | float | 0.0 | LLM temperature for consistency |
-| `custom_prompt` | str | None | Custom reranking prompt |
-| `score_range` | tuple | (0, 10) | Score range for relevance |
-
-### Advanced Configuration
-
-```python
-config = {
-    "reranker": {
-        "provider": "llm_reranker",
-        "config": {
-            "llm": {
-                "provider": "anthropic",
-                "config": {
-                    "model": "claude-3-sonnet-20240229",
-                    "api_key": "your-anthropic-api-key"
-                }
-            },
-            "top_k": 15,
-            "temperature": 0.0,
-            "score_range": (1, 5),
-            "custom_prompt": """
-            Rate the relevance of each memory to the query on a scale of 1-5.
-            Consider semantic similarity, context, and practical utility.
-            Only provide the numeric score.
-            """
-        }
-    }
-}
-```
-
-## Supported LLM Providers
-
-### OpenAI
-
-```python
-config = {
-    "reranker": {
-        "provider": "llm_reranker",
-        "config": {
-            "llm": {
-                "provider": "openai",
-                "config": {
-                    "model": "gpt-4",
-                    "api_key": "your-openai-api-key",
-                    "temperature": 0.0
-                }
-            }
-        }
-    }
-}
-```
-
-### Anthropic
-
-```python
-config = {
-    "reranker": {
-        "provider": "llm_reranker",
-        "config": {
-            "llm": {
-                "provider": "anthropic",
-                "config": {
-                    "model": "claude-3-sonnet-20240229",
-                    "api_key": "your-anthropic-api-key"
-                }
-            }
-        }
-    }
-}
-```
-
-### Ollama (Local)
-
-```python
-config = {
-    "reranker": {
-        "provider": "llm_reranker",
-        "config": {
-            "llm": {
-                "provider": "ollama",
-                "config": {
-                    "model": "llama2",
-                    "ollama_base_url": "http://localhost:11434"
-                }
-            }
-        }
-    }
-}
-```
-
-### Azure OpenAI
-
-```python
-config = {
-    "reranker": {
-        "provider": "llm_reranker",
-        "config": {
-            "llm": {
-                "provider": "azure_openai",
-                "config": {
-                    "model": "gpt-4",
-                    "api_key": "your-azure-api-key",
-                    "azure_endpoint": "https://your-resource.openai.azure.com/",
-                    "azure_deployment": "gpt-4-deployment"
-                }
-            }
-        }
-    }
-}
-```
-
-## Custom Prompts
-
-### Default Prompt Behavior
-
-The default prompt asks the LLM to score relevance on a 0-10 scale:
-
-```
-Given a query and a memory, rate how relevant the memory is to answering the query.
-Score from 0 (completely irrelevant) to 10 (perfectly relevant).
-Only provide the numeric score.
-
-Query: {query}
-Memory: {memory}
-Score:
-```
-
-### Custom Prompt Examples
-
-#### Domain-Specific Scoring
-
-```python
-custom_prompt = """
-You are a medical information specialist. Rate how relevant each memory is for answering the medical query.
-Consider clinical accuracy, specificity, and practical applicability.
-Rate from 1-10 where:
- 1-3: Irrelevant or potentially harmful
- 4-6: Somewhat relevant but incomplete
- 7-8: Relevant and helpful
- 9-10: Highly relevant and clinically useful
-
-Query: {query}
-Memory: {memory}
-Score:
-"""
-
-config = {
-    "reranker": {
-        "provider": "llm_reranker",
-        "config": {
-            "llm": {
-                "provider": "openai",
-                "config": {
-                    "model": "gpt-4",
-                    "api_key": "your-api-key"
-                }
-            },
-            "custom_prompt": custom_prompt
-        }
-    }
-}
-```
-
-#### Contextual Relevance
-
-```python
-contextual_prompt = """
-Rate how well this memory answers the specific question asked.
-Consider:
- Direct relevance to the question
- Completeness of information
- Recency and accuracy
- Practical usefulness
-
-Rate 1-5:
-1 = Not relevant
-2 = Slightly relevant
-3 = Moderately relevant
-4 = Very relevant
-5 = Perfectly answers the question
-
-Query: {query}
-Memory: {memory}
-Score:
-"""
-```
-
-#### Conversational Context
-
-```python
-conversation_prompt = """
-You are helping evaluate which memories are most useful for a conversational AI assistant.
-Rate how helpful this memory would be for generating a relevant response.
-
-Consider:
- Direct relevance to user's intent
- Emotional appropriateness
- Factual accuracy
- Conversation flow
-
-Rate 0-10:
-Query: {query}
-Memory: {memory}
-Score:
-"""
-```
-
-## Usage Examples
-
-### Basic Usage
-
-```python
-from mem0 import Memory
-
-m = Memory.from_config(config)
-
-# Add memories
-m.add("I'm allergic to peanuts", user_id="alice")
-m.add("I love Italian food", user_id="alice")
-m.add("I'm vegetarian", user_id="alice")
-
-# Search with LLM reranking
-results = m.search(
-    "What foods should I avoid?",
-    user_id="alice",
-    rerank=True
-)
-
-for result in results["results"]:
-    print(f"Memory: {result['memory']}")
-    print(f"LLM Score: {result['score']:.2f}")
-```
-
-### Batch Processing with Error Handling
-
-```python
-def safe_llm_rerank_search(query, user_id, max_retries=3):
-    for attempt in range(max_retries):
-        try:
-            return m.search(query, user_id=user_id, rerank=True)
-        except Exception as e:
-            print(f"Attempt {attempt + 1} failed: {e}")
-            if attempt == max_retries - 1:
-                # Fall back to vector search
-                return m.search(query, user_id=user_id, rerank=False)
-
-# Use the safe function
-results = safe_llm_rerank_search("What are my preferences?", "alice")
-```
-
-## Performance Considerations
-
-### Speed vs Quality Trade-offs
-
-| Model Type | Speed | Quality | Cost | Best For |
-|------------|-------|---------|------|----------|
-| GPT-3.5 Turbo | Fast | Good | Low | High-volume applications |
-| GPT-4 | Medium | Excellent | Medium | Quality-critical applications |
-| Claude 3 Sonnet | Medium | Excellent | Medium | Balanced performance |
-| Ollama Local | Variable | Good | Free | Privacy-sensitive applications |
-
-### Optimization Strategies
-
-```python
-# Fast configuration for high-volume use
-fast_config = {
-    "reranker": {
-        "provider": "llm_reranker",
-        "config": {
-            "llm": {
-                "provider": "openai",
-                "config": {
-                    "model": "gpt-3.5-turbo",
-                    "api_key": "your-api-key"
-                }
-            },
-            "top_k": 5,  # Limit candidates
-            "temperature": 0.0
-        }
-    }
-}
-
-# High-quality configuration
-quality_config = {
-    "reranker": {
-        "provider": "llm_reranker",
-        "config": {
-            "llm": {
-                "provider": "openai",
-                "config": {
-                    "model": "gpt-4",
-                    "api_key": "your-api-key"
-                }
-            },
-            "top_k": 15,
-            "temperature": 0.0
-        }
-    }
-}
-```
-
-## Advanced Use Cases
-
-### Multi-Step Reasoning
-
-```python
-reasoning_prompt = """
-Evaluate this memory's relevance using multi-step reasoning:
-
-1. What is the main intent of the query?
-2. What key information does the memory contain?
-3. How directly does the memory address the query?
-4. What additional context might be needed?
-
-Based on this analysis, rate relevance 1-10:
-
-Query: {query}
-Memory: {memory}
-
-Analysis:
-Step 1 (Intent):
-Step 2 (Information):
-Step 3 (Directness):
-Step 4 (Context):
-Final Score:
-"""
-```
-
-### Comparative Ranking
-
-```python
-comparative_prompt = """
-You will see a query and multiple memories. Rank them in order of relevance.
-Consider which memories best answer the question and would be most helpful.
-
-Query: {query}
-
-Memories to rank:
-{memories}
-
-Provide scores 1-10 for each memory, considering their relative usefulness.
-"""
-```
-
-### Emotional Intelligence
-
-```python
-emotional_prompt = """
-Consider both factual relevance and emotional appropriateness.
-Rate how suitable this memory is for responding to the user's query.
-
-Factors to consider:
- Factual accuracy and relevance
- Emotional tone and sensitivity
- User's likely emotional state
- Appropriateness of response
-
-Query: {query}
-Memory: {memory}
-Emotional Context: {context}
-Score (1-10):
-"""
-```
-
-## Error Handling and Fallbacks
-
-```python
-class RobustLLMReranker:
-    def __init__(self, primary_config, fallback_config=None):
-        self.primary = Memory.from_config(primary_config)
-        self.fallback = Memory.from_config(fallback_config) if fallback_config else None
-
-    def search(self, query, user_id, max_retries=2):
-        # Try primary LLM reranker
-        for attempt in range(max_retries):
-            try:
-                return self.primary.search(query, user_id=user_id, rerank=True)
-            except Exception as e:
-                print(f"Primary reranker attempt {attempt + 1} failed: {e}")
-
-        # Try fallback reranker
-        if self.fallback:
-            try:
-                return self.fallback.search(query, user_id=user_id, rerank=True)
-            except Exception as e:
-                print(f"Fallback reranker failed: {e}")
-
-        # Final fallback: vector search only
-        return self.primary.search(query, user_id=user_id, rerank=False)
-
-# Usage
-primary_config = {
-    "reranker": {
-        "provider": "llm_reranker",
-        "config": {"llm": {"provider": "openai", "config": {"model": "gpt-4"}}}
-    }
-}
-
-fallback_config = {
-    "reranker": {
-        "provider": "llm_reranker",
-        "config": {"llm": {"provider": "openai", "config": {"model": "gpt-3.5-turbo"}}}
-    }
-}
-
-reranker = RobustLLMReranker(primary_config, fallback_config)
-results = reranker.search("What are my preferences?", "alice")
-```
-
-## Best Practices
-
-1. **Use Specific Prompts**: Tailor prompts to your domain and use case
-2. **Set Temperature to 0**: Ensure consistent scoring across runs
-3. **Limit Top-K**: Don't rerank too many candidates to control costs
-4. **Implement Fallbacks**: Always have a backup plan for API failures
-5. **Monitor Costs**: Track API usage, especially with expensive models
-6. **Cache Results**: Consider caching reranking results for repeated queries
-7. **Test Prompts**: Experiment with different prompts to find what works best
-
-## Troubleshooting
-
-### Common Issues
-
-**Inconsistent Scores**
- Set temperature to 0.0
- Use more specific prompts
- Consider using multiple calls and averaging
-
-**API Rate Limits**
- Implement exponential backoff
- Use cheaper models for high-volume scenarios
- Add retry logic with delays
-
-**Poor Ranking Quality**
- Refine your custom prompt
- Try different LLM models
- Add examples to your prompt
-
-## Next Steps
-
-<CardGroup cols={2}>
-  <Card title="Custom Prompts Guide" icon="pencil" href="/components/rerankers/custom-prompts">
-    Learn to craft effective reranking prompts
-  </Card>
-  <Card title="Performance Optimization" icon="bolt" href="/components/rerankers/optimization">
-    Optimize LLM reranker performance
-  </Card>
-</CardGroup>
@@ -1,6 +1,8 @@
 ---
 title: Sentence Transformer
 description: 'Local reranking with HuggingFace cross-encoder models'
+icon: "server"
+iconType: "solid"
 ---

 Sentence Transformer reranker provides local reranking using HuggingFace cross-encoder models, perfect for privacy-focused deployments where you want to keep data on-premises.
@@ -65,7 +67,7 @@ config = {
        "config": {
            "model": "cross-encoder/ms-marco-MiniLM-L-6-v2",
            "device": "cuda",  # Use GPU
-            "batch_size": 64   # high batch size for high memory GPUs
+            "batch_size": 64   # Larger batch size for GPU
        }
    }
 }
@@ -1,9 +1,11 @@
 ---
 title: Zero Entropy
-description: "Configure Zero Entropy neural reranking models in Mem0 with zerank-1 and zerank-1-small support."
+description: 'State-of-the-art neural reranking with Zero Entropy'
+icon: "sparkles"
+iconType: "solid"
 ---

-[Zero Entropy](https://www.zeroentropy.dev) provides neural reranking models that significantly improve search relevance with fast performance.
+[Zero Entropy](https://www.zeroentropy.dev) provides state-of-the-art neural reranking models that significantly improve search relevance with fast performance.

 ## Models

@@ -1,311 +0,0 @@
---
-title: Performance Optimization
-description: "Best practices for optimizing reranker performance in Mem0, covering candidate sizing, batching, and tuning."
---
-
-Optimizing reranker performance is crucial for maintaining fast search response times while improving result quality. This guide covers best practices for different reranker types.
-
-## General Optimization Principles
-
-### Candidate Set Size
-The number of candidates sent to the reranker significantly impacts performance:
-
-```python
-# Optimal candidate sizes for different rerankers
-config_map = {
-    "cohere": {"initial_candidates": 100, "top_n": 10},
-    "sentence_transformer": {"initial_candidates": 50, "top_n": 10},
-    "huggingface": {"initial_candidates": 30, "top_n": 5},
-    "llm_reranker": {"initial_candidates": 20, "top_n": 5}
-}
-```
-
-### Batching Strategy
-Process multiple queries efficiently:
-
-```python
-# Configure for batch processing
-config = {
-    "reranker": {
-        "provider": "sentence_transformer",
-        "config": {
-            "model": "cross-encoder/ms-marco-MiniLM-L-6-v2",
-            "batch_size": 16,  # Process multiple candidates at once
-            "top_n": 10
-        }
-    }
-}
-```
-
-## Provider-Specific Optimizations
-
-### Cohere Optimization
-
-```python
-# Optimized Cohere configuration
-config = {
-    "reranker": {
-        "provider": "cohere",
-        "config": {
-            "model": "rerank-english-v3.0",
-            "top_n": 10,
-            "max_chunks_per_doc": 10,  # Limit chunk processing
-            "return_documents": False   # Reduce response size
-        }
-    }
-}
-```
-
-**Best Practices:**
- Use v3.0 models for better speed/accuracy balance
- Limit candidates to 100 or fewer
- Cache API responses when possible
- Monitor API rate limits
-
-### Sentence Transformer Optimization
-
-```python
-# Performance-optimized configuration
-config = {
-    "reranker": {
-        "provider": "sentence_transformer",
-        "config": {
-            "model": "cross-encoder/ms-marco-MiniLM-L-6-v2",
-            "device": "cuda",  # Use GPU when available
-            "batch_size": 32,
-            "top_n": 10,
-            "max_length": 512  # Limit input length
-        }
-    }
-}
-```
-
-**Device Optimization:**
-```python
-import torch
-
-# Auto-detect best device
-device = "cuda" if torch.cuda.is_available() else "mps" if torch.backends.mps.is_available() else "cpu"
-
-config = {
-    "reranker": {
-        "provider": "sentence_transformer",
-        "config": {
-            "device": device,
-            "model": "cross-encoder/ms-marco-MiniLM-L-6-v2"
-        }
-    }
-}
-```
-
-### Hugging Face Optimization
-
-```python
-# Optimized for Hugging Face models
-config = {
-    "reranker": {
-        "provider": "huggingface",
-        "config": {
-            "model": "BAAI/bge-reranker-base",
-            "use_fp16": True,  # Half precision for speed
-            "max_length": 512,
-            "batch_size": 8,
-            "top_n": 10
-        }
-    }
-}
-```
-
-### LLM Reranker Optimization
-
-```python
-# Optimized LLM reranker configuration
-config = {
-    "reranker": {
-        "provider": "llm_reranker",
-        "config": {
-            "llm": {
-                "provider": "openai",
-                "config": {
-                    "model": "gpt-3.5-turbo",  # Faster than gpt-4
-                    "temperature": 0,  # Deterministic results
-                    "max_tokens": 500  # Limit response length
-                }
-            },
-            "batch_ranking": True,  # Rank multiple at once
-            "top_n": 5,  # Fewer results for faster processing
-            "timeout": 10  # Request timeout
-        }
-    }
-}
-```
-
-## Performance Monitoring
-
-### Latency Tracking
-```python
-import time
-from mem0 import Memory
-
-def measure_reranker_performance(config, queries, user_id):
-    memory = Memory.from_config(config)
-
-    latencies = []
-    for query in queries:
-        start_time = time.time()
-        results = memory.search(query, user_id=user_id)
-        latency = time.time() - start_time
-        latencies.append(latency)
-
-    return {
-        "avg_latency": sum(latencies) / len(latencies),
-        "max_latency": max(latencies),
-        "min_latency": min(latencies)
-    }
-```
-
-### Memory Usage Monitoring
-```python
-import psutil
-import os
-
-def monitor_memory_usage():
-    process = psutil.Process(os.getpid())
-    return {
-        "memory_mb": process.memory_info().rss / 1024 / 1024,
-        "memory_percent": process.memory_percent()
-    }
-```
-
-## Caching Strategies
-
-### Result Caching
-```python
-from functools import lru_cache
-import hashlib
-
-class CachedReranker:
-    def __init__(self, config):
-        self.memory = Memory.from_config(config)
-        self.cache_size = 1000
-
-    @lru_cache(maxsize=1000)
-    def search_cached(self, query_hash, user_id):
-        return self.memory.search(query, user_id=user_id)
-
-    def search(self, query, user_id):
-        query_hash = hashlib.md5(f"{query}_{user_id}".encode()).hexdigest()
-        return self.search_cached(query_hash, user_id)
-```
-
-### Model Caching
-```python
-# Pre-load models to avoid initialization overhead
-config = {
-    "reranker": {
-        "provider": "sentence_transformer",
-        "config": {
-            "model": "cross-encoder/ms-marco-MiniLM-L-6-v2",
-            "cache_folder": "/path/to/model/cache",
-            "device": "cuda"
-        }
-    }
-}
-```
-
-## Parallel Processing
-
-### Async Configuration
-```python
-import asyncio
-from mem0 import Memory
-
-async def parallel_search(config, queries, user_id):
-    memory = Memory.from_config(config)
-
-    # Process multiple queries concurrently
-    tasks = [
-        memory.search_async(query, user_id=user_id)
-        for query in queries
-    ]
-
-    results = await asyncio.gather(*tasks)
-    return results
-```
-
-## Hardware Optimization
-
-### GPU Configuration
-```python
-# Optimize for GPU usage
-import torch
-
-if torch.cuda.is_available():
-    torch.cuda.set_per_process_memory_fraction(0.8)  # Reserve GPU memory
-
-config = {
-    "reranker": {
-        "provider": "sentence_transformer",
-        "config": {
-            "device": "cuda",
-            "model": "cross-encoder/ms-marco-electra-base",
-            "batch_size": 64,  # Larger batch for GPU
-            "fp16": True  # Half precision
-        }
-    }
-}
-```
-
-### CPU Optimization
-```python
-import torch
-
-# Optimize CPU threading
-torch.set_num_threads(4)  # Adjust based on your CPU
-
-config = {
-    "reranker": {
-        "provider": "sentence_transformer",
-        "config": {
-            "device": "cpu",
-            "model": "cross-encoder/ms-marco-MiniLM-L-6-v2",
-            "num_workers": 4  # Parallel processing
-        }
-    }
-}
-```
-
-## Benchmarking Different Configurations
-
-```python
-def benchmark_rerankers():
-    configs = [
-        {"provider": "cohere", "model": "rerank-english-v3.0"},
-        {"provider": "sentence_transformer", "model": "cross-encoder/ms-marco-MiniLM-L-6-v2"},
-        {"provider": "huggingface", "model": "BAAI/bge-reranker-base"}
-    ]
-
-    test_queries = ["sample query 1", "sample query 2", "sample query 3"]
-
-    results = {}
-    for config in configs:
-        provider = config["provider"]
-        performance = measure_reranker_performance(
-            {"reranker": {"provider": provider, "config": config}},
-            test_queries,
-            "test_user"
-        )
-        results[provider] = performance
-
-    return results
-```
-
-## Production Best Practices
-
-1. **Model Selection**: Choose the right balance of speed vs. accuracy
-2. **Resource Allocation**: Monitor CPU/GPU usage and memory consumption
-3. **Error Handling**: Implement fallbacks for reranker failures
-4. **Load Balancing**: Distribute reranking load across multiple instances
-5. **Monitoring**: Track latency, throughput, and error rates
-6. **Caching**: Cache frequent queries and model predictions
-7. **Batch Processing**: Group similar queries for efficient processing
@@ -1,78 +1,47 @@
 ---
 title: Overview
-description: 'Pick the right reranker path to boost Mem0 search relevance.'
+icon: "arrow-up-arrow-down"
+iconType: "solid"
 ---

-Mem0 rerankers rescore vector search hits so your agents surface the most relevant memories. Use this hub to decide when reranking helps, configure a provider, and fine-tune performance.
+Mem0 includes built-in support for various reranking providers to improve the relevance of memory search results. Rerankers post-process initial vector search results by re-scoring and re-ordering them using more sophisticated relevance models.

-<Info>
-Reranking trades extra latency for better precision. Start once you have baseline search working and measure before/after relevance.
-</Info>
+## Usage

-<CardGroup cols={3}>
-  <Card
-    title="Understand Reranking"
-    description="See how reranker-enhanced search changes your retrieval flow."
-    icon="search"
-    href="/open-source/features/reranker-search"
-  />
-  <Card
-    title="Configure Providers"
-    description="Add reranker blocks to your memory configuration."
-    icon="settings"
-    href="/components/rerankers/config"
-  />
-  <Card
-    title="Optimize Performance"
-    description="Balance relevance, latency, and cost with tuning tactics."
-    icon="speedometer"
-    href="/components/rerankers/optimization"
-  />
-  <Card
-    title="Custom Prompts"
-    description="Shape LLM-based reranking with tailored instructions."
-    icon="code"
-    href="/components/rerankers/custom-prompts"
-  />
-  <Card
-    title="Zero Entropy Guide"
-    description="Adopt the managed neural reranker for production workloads."
-    icon="sparkles"
-    href="/components/rerankers/models/zero_entropy"
-  />
-  <Card
-    title="Sentence Transformers"
-    description="Keep reranking on-device with cross-encoder models."
-    icon="cpu"
-    href="/components/rerankers/models/sentence_transformer"
-  />
-</CardGroup>
+To use a reranker, you must provide a `rerank` configuration section in your memory config. If no reranker is configured, search results will rely on vector similarity scoring alone.

-## Picking the Right Reranker
+For comprehensive configuration parameters for each reranker, please refer to [Config](./config).

- **API-first** when you need top quality and can absorb request costs (Cohere, Zero Entropy).  
- **Self-hosted** for privacy-sensitive deployments that must stay on your hardware (Sentence Transformer, Hugging Face).  
- **LLM-driven** when you need bespoke scoring logic or complex prompts.  
- **Hybrid** by enabling reranking only on premium journeys to control spend.
+## How Reranking Works

-## Implementation Checklist
+1. **Initial Search**: Vector similarity search retrieves candidate memories
+2. **Reranking**: Selected reranker re-scores candidates using advanced models
+3. **Final Results**: Re-ordered results with both vector and rerank scores

-1. Confirm baseline search KPIs so you can measure uplift.  
-2. Select a provider and add the `reranker` block to your config.  
-3. Test latency impact with production-like query batches.  
-4. Decide whether to enable reranking globally or per-search via the `rerank` flag.
+<Note>
+Reranking operates as a post-processing step and can significantly improve search relevance at the cost of additional latency and API calls.
+</Note>
+
+## Supported Rerankers
+
+See the list of supported rerankers below.

 <CardGroup cols={2}>
-  <Card
-    title="Set Up Reranking"
-    description="Walk through the configuration fields and defaults."
-    icon="settings"
-    href="/components/rerankers/config"
-  />
-  <Card
-    title="Example: Reranker Search"
-    description="Follow the feature guide to see reranking in action."
-    icon="rocket"
-    href="/open-source/features/reranker-search"
-  />
+  <Card title="Zero Entropy" href="/components/rerankers/models/zero_entropy" />
+  <Card title="Cohere" href="/components/rerankers/models/cohere" />
+  <Card title="Sentence Transformer" href="/components/rerankers/models/sentence_transformer" />
+  <Card title="LLM-based" href="/components/rerankers/models/llm" />
 </CardGroup>
+
+## When to Use Reranking
+
+- **Improved Relevance**: When vector search alone doesn't provide sufficiently relevant results
+- **Domain-Specific Queries**: For specialized terminology or context that benefits from advanced models
+- **Quality vs Speed Trade-off**: When you can accept higher latency for better search quality
+- **Production Systems**: Where search quality directly impacts user experience
+
+Choose the reranker that best fits your use case:
+- **Zero Entropy**: Best balance of speed and quality for general use
+- **Cohere**: Enterprise-grade with excellent multilingual support  
+- **Sentence Transformer**: Local deployment for privacy-sensitive applications
+- **LLM-based**: Maximum customization with custom prompts and logic
@@ -1,6 +1,7 @@
 ---
 title: Configurations
-description: "Reference for vector database configuration options in Mem0, including provider selection and connection settings."
+icon: "gear"
+iconType: "solid"
 ---

 ## How to define configurations?
@@ -1,6 +1,5 @@
 ---
 title: Azure AI Search
-description: "Use Azure AI Search as a vector store in Mem0 for managed vector search with service name and API key setup."
 ---

 [Azure AI Search](https://learn.microsoft.com/azure/search/search-what-is-azure-search/) (formerly known as "Azure Cognitive Search") provides secure information retrieval at scale over user-owned content in traditional and generative AI search applications.
@@ -28,7 +27,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 thriller movies? They can be quite engaging."},
+    {"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."}
 ]
@@ -108,13 +107,13 @@ To enable Role-Based Access Control (RBAC) for Azure AI Search, follow these ste
    - Click **Add** > **Add role assignment**.
 6. **Choose Role:**
    - Mem0 requires the **Search Index Data Contributor** and **Search Service Contributor** role.
-7. **Choose Member**
-    - To assign to a User, Group, Service Principal or Managed Identity:
+7. **Choose Member** 
+    - To assign to a User, Group, Service Principle or Managed Identity:
        - For production it is recommended to use a service principal or managed identity.
            - For a service principal: select **User, group, or service principal** and search for the service principal.
            - For a managed identity: select **Managed identity** and choose the managed identity.
        - For development, you can assign the role to a user account.
-            - For development: select **User, group, or service principal** and pick an Azure Entra ID account (the same used with `az login`).
+            - For development: select ***User, group, or service principal** and pick a Azure Entra ID account (the same used with `az login`).
 8. **Complete the Assignment:**
    - Click **Review + Assign**.

@@ -134,7 +133,7 @@ config = {
 }
 ```

-### Environment Variables to Use Azure Identity Credential
+### Environment Variables to set to use Azure Identity Credential:
 * For an Environment Credential, you will need to setup a Service Principal and set the following environment variables:
  - `AZURE_TENANT_ID`: Your Azure Active Directory tenant ID.
  - `AZURE_CLIENT_ID`: The client ID of your service principal or managed identity.
@@ -143,7 +142,7 @@ config = {
  - `AZURE_CLIENT_ID`: The client ID of the user-assigned managed identity.
 * For a System-Assigned Managed Identity, no additional environment variables are needed.

-### Developer Logins for Azure Identity Credential
+### Developer logins to use for a Azure Identity Credential:
 * For an Azure CLI Credential, you need to have the Azure CLI installed and logged in with `az login`.
 * For an Azure PowerShell Credential, you need to have the Azure PowerShell module installed and logged in with `Connect-AzAccount`.
 * For an Azure Developer CLI Credential, you need to have the Azure Developer CLI installed and logged in with `azd auth login`.
@@ -1,129 +0,0 @@
---
-title: Azure MySQL
-description: "Use Azure Database for MySQL as a vector store in Mem0 with JSON-based vector storage for semantic search."
---
-
-[Azure Database for MySQL](https://azure.microsoft.com/products/mysql) is a fully managed relational database service that provides enterprise-grade reliability and security. It supports JSON-based vector storage for semantic search capabilities in AI applications.
-
-### Usage
-
-```python
-import os
-from mem0 import Memory
-
-os.environ["OPENAI_API_KEY"] = "sk-xx"
-
-config = {
-    "vector_store": {
-        "provider": "azure_mysql",
-        "config": {
-            "host": "your-server.mysql.database.azure.com",
-            "port": 3306,
-            "user": "your_username",
-            "password": "your_password",
-            "database": "mem0_db",
-            "collection_name": "memories",
-        }
-    }
-}
-
-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"})
-```
-
-#### Using Azure Managed Identity
-
-For production deployments, use Azure Managed Identity instead of passwords:
-
-```python
-config = {
-    "vector_store": {
-        "provider": "azure_mysql",
-        "config": {
-            "host": "your-server.mysql.database.azure.com",
-            "user": "your_username",
-            "database": "mem0_db",
-            "collection_name": "memories",
-            "use_azure_credential": True,  # Uses DefaultAzureCredential
-            "ssl_disabled": False
-        }
-    }
-}
-```
-
-<Note>
-When `use_azure_credential` is enabled, the password is obtained via Azure DefaultAzureCredential (supports Managed Identity, Azure CLI, etc.)
-</Note>
-
-### Config
-
-Here are the parameters available for configuring Azure MySQL:
-
-| Parameter | Description | Default Value |
-| --- | --- | --- |
-| `host` | MySQL server hostname | Required |
-| `port` | MySQL server port | `3306` |
-| `user` | Database user | Required |
-| `password` | Database password (optional with Azure credential) | `None` |
-| `database` | Database name | Required |
-| `collection_name` | Table name for storing vectors | `"mem0"` |
-| `embedding_model_dims` | Dimensions of embedding vectors | `1536` |
-| `use_azure_credential` | Use Azure DefaultAzureCredential | `False` |
-| `ssl_ca` | Path to SSL CA certificate | `None` |
-| `ssl_disabled` | Disable SSL (not recommended) | `False` |
-| `minconn` | Minimum connections in pool | `1` |
-| `maxconn` | Maximum connections in pool | `5` |
-
-### Setup
-
-#### Create MySQL Flexible Server using Azure CLI:
-
-```bash
-# Create resource group
-az group create --name mem0-rg --location eastus
-
-# Create MySQL Flexible Server
-az mysql flexible-server create \
-    --resource-group mem0-rg \
-    --name mem0-mysql-server \
-    --location eastus \
-    --admin-user myadmin \
-    --admin-password <YourPassword> \
-    --version 8.0.21
-
-# Create database
-az mysql flexible-server db create \
-    --resource-group mem0-rg \
-    --server-name mem0-mysql-server \
-    --database-name mem0_db
-
-# Configure firewall
-az mysql flexible-server firewall-rule create \
-    --resource-group mem0-rg \
-    --name mem0-mysql-server \
-    --rule-name AllowMyIP \
-    --start-ip-address <YourIP> \
-    --end-ip-address <YourIP>
-```
-
-#### Enable Azure AD Authentication:
-
-1. In Azure Portal, navigate to your MySQL Flexible Server
-2. Go to **Security** > **Authentication** and enable Azure AD
-3. Add your application's managed identity as a MySQL user:
-
-```sql
-CREATE AADUSER 'your-app-identity' IDENTIFIED BY 'your-client-id';
-GRANT ALL PRIVILEGES ON mem0_db.* TO 'your-app-identity'@'%';
-FLUSH PRIVILEGES;
-```
-
-<Tip>
-For production, use [Managed Identity](https://learn.microsoft.com/azure/active-directory/managed-identities-azure-resources/) to eliminate password management.
-</Tip>
@@ -1,6 +1,5 @@
 ---
 title: Baidu VectorDB (Mochow)
-description: "Use Baidu Mochow as an enterprise vector database in Mem0 for high-performance vector storage and retrieval."
 ---

 [Baidu VectorDB](https://cloud.baidu.com/doc/VDB/index.html) is an enterprise-level distributed vector database service developed by Baidu Intelligent Cloud. It is powered by Baidu's proprietary "Mochow" vector database kernel, providing high performance, availability, and security for vector search.
@@ -38,7 +37,7 @@ m.add(messages, user_id="alice", metadata={"category": "movies"})

 ### Config

-Here are the parameters available for configuring Baidu VectorDB:
+Here are the available parameters for the `mochow` config:

 | Parameter | Description | Default Value |
 | --- | --- | --- |
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
parshvadaftari	aa3206cafd	Merge branch 'main' into mem0-1.0.0	2025-09-18 20:23:20 +05:30
parshvadaftari	f98cd925a6	Release beta version	2025-09-18 20:15:10 +05:30
parshvadaftari	86a2b00c65	Fix reranker config and added huggingface reranker	2025-09-16 10:48:35 +05:30
parshvadaftari	c1ee71ad3f	Fixed json parsing acros differnet LLM providers	2025-09-16 04:14:38 +05:30
parshvadaftari	a93a7ea6cf	Add gcp auth for better supporton service account	2025-09-16 00:13:42 +05:30
parshvadaftari	2dd4e93af4	Merge branch 'main' into mem0-1.0.0	2025-09-16 00:01:42 +05:30
parshvadaftari	15fe2b978f	Added memgraph compatbility across different versions	2025-09-14 03:47:59 +05:30
parshvadaftari	c1b9da45aa	Add async_mode default value to True	2025-09-14 02:36:32 +05:30
parshvadaftari	78ea40c291	Added assisstant memory retrieval	2025-09-13 20:56:39 +05:30
parshvadaftari	f0d98ec4cb	Enhanced reranker and updated corresponding docs	2025-09-11 02:33:55 +05:30
parshvadaftari	5182c8f311	Refactor reranking and output format for the OSS and platform	2025-09-02 02:20:24 +05:30
parshvadaftari	61e8668584	Added metadata filtering and reranker for the OSS	2025-09-02 01:15:17 +05:30
parshvadaftari	a9a1d57dfa	Merge branch 'main' into user/parshva/mem0_1.0.0	2025-09-01 23:14:37 +05:30
parshvadaftari	0cc26fdabf	Initial commit for 1.0.0	2025-08-27 20:38:44 +05:30