chore: update changelog, bump versions to Python 2.0.13, TypeScript 3.1.1, OpenCode plugin 0.2.2 (#6504 )

fix(llms/anthropic): find the text block in no-tools responses instead of indexing content[0] (#6481 )
fix(ts-oss/baidu): convert L2 distance to similarity score in search() (#6485 )
2026-07-22 23:27:47 +05:30 · 2026-07-22 21:34:48 +05:30 · 2026-07-22 20:37:12 +05:30 · 2026-07-21 21:39:00 +05:30 · 2026-07-21 18:47:39 +05:30 · 2026-07-21 17:47:25 +05:30
403 changed files with 35368 additions and 3272 deletions
@@ -12,7 +12,7 @@
      "name": "mem0",
      "source": "./integrations/mem0-plugin",
      "description": "Mem0 memory layer for AI applications. Add persistent memory, personalization, and semantic search to Claude workflows.",
-      "version": "0.2.12"
+      "version": "0.2.13"
    }
  ]
 }
@@ -12,7 +12,7 @@
      "name": "mem0",
      "source": "./integrations/mem0-plugin",
      "description": "Mem0 memory layer for AI applications. Add persistent memory, personalization, and semantic search.",
-      "version": "0.2.12"
+      "version": "0.2.13"
    }
  ]
 }
@@ -9,12 +9,10 @@ body:
      label: Component
      description: Which part of mem0 is affected?
      options:
-        - Core / Python SDK
+        - Python SDK
        - TypeScript SDK
-        - Vector Store (Qdrant, PGVector, Redis, Chroma, etc.)
-        - Graph Memory (Neo4j, Memgraph, etc.)
-        - Ollama / Local Models
-        - OpenClaw
+        - Vector Store
+        - Plugin
        - REST API
        - Other
    validations:
@@ -9,14 +9,11 @@ body:
      label: Component
      description: Which part of mem0 does this relate to?
      options:
-        - Core / Python SDK
+        - Python SDK
        - TypeScript SDK
-        - Vector Store (Qdrant, PGVector, Redis, Chroma, etc.)
-        - Graph Memory (Neo4j, Memgraph, etc.)
-        - Ollama / Local Models
-        - OpenClaw
+        - Vector Store
+        - Plugin
        - REST API
-        - Benchmarks / Evals
        - Other
    validations:
      required: true
@@ -1,18 +1,15 @@
-# 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: "openclaw"
-    matcher: "OpenClaw"
-  - label: "rest-api"
-    matcher: "REST API"
+policy:
+  - section:
+      - id: ['component']
+        block-list: ['Other']
+        label:
+          - name: 'sdk-python'
+            keys: ['Python SDK']
+          - name: 'sdk-typescript'
+            keys: ['TypeScript SDK']
+          - name: 'vector-store'
+            keys: ['Vector Store']
+          - name: 'plugin'
+            keys: ['Plugin']
+          - name: 'rest-api'
+            keys: ['REST API']
@@ -0,0 +1,44 @@
+{
+  "language": {
+    "sdk-python": [
+      "python", "pip install", "pypi", "pyproject", "requirements.txt",
+      "from mem0", "import mem0", "traceback", "pydantic", "asyncmemory",
+      "poetry", "virtualenv", "venv", "conda", "pytest", "async def"
+    ],
+    "sdk-typescript": [
+      "typescript", "javascript", "pnpm", "yarn", "node.js", "nodejs",
+      "mem0-ts", "mem0ai/oss", "tsconfig", "await import",
+      "=> {", "undefined is not"
+    ]
+  },
+  "area": {
+    "plugin": [
+      "openclaw", "openclaw-mem0", "openclaw.json", "openclaw plugin",
+      "claude code", "opencode", "pi agent", "mem0-plugin",
+      "cursor plugin", "codex plugin", "editor plugin"
+    ],
+    "openmemory": [
+      "openmemory", "open memory", "localhost:8765", "localhost:3000",
+      "openmemory ui", "openmemory/api", "openmemory/ui"
+    ],
+    "cli": ["mem0-cli", "@mem0/cli", "npx mem0", "command line"],
+    "vector-store": [
+      "pgvector", "pinecone", "chroma", "chromadb", "weaviate",
+      "milvus", "faiss", "vector store", "vectorstore",
+      "elasticsearch", "supabase", "azure ai search",
+      "s3 vectors", "mongodb"
+    ],
+    "integrations": [
+      "vercel ai", "vercel-ai-sdk", "@mem0/vercel-ai-provider",
+      "llamaindex", "crewai", "autogen", "langgraph"
+    ],
+    "rest-api": [
+      "rest api", "fastapi", "docker-compose", "/v1/memories",
+      "localhost:8000", "localhost:8888", "curl -x", "http endpoint"
+    ],
+    "documentation": [
+      "docs.mem0.ai", "documentation", "typo", "readme", "docstring", "broken link",
+      "issue on docs", "docs:", "link to the docs page", "issue with current documentation"
+    ]
+  }
+}
@@ -0,0 +1,63 @@
+sdk-python:
+  - changed-files:
+      - any-glob-to-any-file:
+          - 'mem0/**'
+          - 'tests/**'
+          - 'cli/python/**'
+          - 'pyproject.toml'
+          - 'poetry.lock'
+
+sdk-typescript:
+  - changed-files:
+      - any-glob-to-any-file:
+          - 'mem0-ts/**'
+          - 'cli/node/**'
+
+vector-store:
+  - changed-files:
+      - any-glob-to-any-file:
+          - 'mem0/vector_stores/**'
+          - 'mem0-ts/src/oss/src/vector_stores/**'
+
+rest-api:
+  - changed-files:
+      - any-glob-to-any-file: 'server/**'
+
+openmemory:
+  - changed-files:
+      - any-glob-to-any-file: 'openmemory/**'
+
+integrations:
+  - changed-files:
+      - any-glob-to-any-file: 'integrations/**'
+
+plugin:
+  - changed-files:
+      - all-globs-to-any-file:
+          - 'integrations/**'
+          - '!integrations/vercel-ai-sdk/**'
+      - any-glob-to-any-file:
+          - 'skills/**'
+          - '.agents/**'
+          - '.claude-plugin/**'
+          - '.codex-plugin/**'
+          - '.cursor-plugin/**'
+          - 'marketplace.json'
+
+cli:
+  - changed-files:
+      - any-glob-to-any-file: 'cli/**'
+
+documentation:
+  - changed-files:
+      - any-glob-to-any-file:
+          - 'docs/**'
+          - 'examples/**'
+          - '*.md'
+
+ci:
+  - changed-files:
+      - any-glob-to-any-file:
+          - '.github/**'
+          - 'scripts/**'
+          - '.pre-commit-config.yaml'
@@ -0,0 +1,44 @@
+const fs = require('fs');
+
+function componentLabels(keywords) {
+  return Object.values(keywords).flatMap(Object.keys);
+}
+
+function toMatcher(term) {
+  const escaped = term.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const prefix = /^[a-z0-9]/i.test(term) ? '\\b' : '';
+  return new RegExp(prefix + escaped, 'i');
+}
+
+function scoreGroup(text, group) {
+  let winner = null;
+  let best = 0;
+  for (const [label, terms] of Object.entries(group)) {
+    const score = terms.reduce((n, term) => n + (toMatcher(term).test(text) ? 1 : 0), 0);
+    if (score > best) {
+      winner = label;
+      best = score;
+    }
+  }
+  return winner;
+}
+
+const UMBRELLA = { plugin: 'integrations' };
+
+function inferComponentLabels(text, keywords) {
+  if (!text) return [];
+  const labels = [scoreGroup(text, keywords.language), scoreGroup(text, keywords.area)].filter(
+    Boolean,
+  );
+  for (const label of labels.slice()) {
+    const parent = UMBRELLA[label];
+    if (parent && !labels.includes(parent)) labels.push(parent);
+  }
+  return labels;
+}
+
+function loadKeywords(file) {
+  return JSON.parse(fs.readFileSync(file, 'utf8'));
+}
+
+module.exports = { componentLabels, inferComponentLabels, loadKeywords };
@@ -0,0 +1,108 @@
+const assert = require('assert');
+const path = require('path');
+const { inferComponentLabels, loadKeywords } = require('./infer-component-labels.js');
+
+const keywords = loadKeywords(path.join(__dirname, '..', 'component-keywords.json'));
+
+const cases = [
+  {
+    number: 6210,
+    title: "but(anthropic): sampling parameters returns 400 error for new model",
+    body: "### Component\n\nCore / Python SDK\n\n### Description\n\n### Summary\n\nWhen using Anthropic latest models such as `claude-opus-4-7`, `claude-opus-4-8`, or `claude-sonnet-5`, Mem0 still sends sampling parameters like `temperature` / `top_p`. These models do not support those parameters, causing Anthropic API requests to fail.\n\nSee https://platform.claude.com/docs/en/about-claude/models/migration-guide\n\n### Steps to Reproduce\n\n```python\n  from mem0 import Memory\n\n  m = Memory.from_config({\n      \"llm\": {\n          \"provider\": \"anthropic\",\n          \"config\": {\n              \"model\": \"claude-opus-4-8\",\n              \"api_key\": \"your-anthropic-api-key\"\n          },\n      },\n      ...\n  })\n```\n\n### Expected Behavior\n\nMem0 should detect Anthropic models that do not support sampling parameters and omit temperature and top_p from the request.\n\nFor models that still support sampling parameters, such as claude-opus-4-6, claude-sonnet-4-6, and claude-haiku-4-5, Mem0 should continue sending supported sampling parameters till they're deprecated.\n\n### Actual Behavior\n\nMem0 includes temperature by default for Anthropic requests. With newer Anthropic models that do not support sampling parameters, the API request fails because unsupported parameters are sent.\n\n### Environment\n\n  - mem0 version: 2.0.11\n  - Python/Node version: Python 3.11\n  - OS: macOS\n",
+    expected: ["sdk-python"],
+  },
+  {
+    number: 5770,
+    title: "feat(ts-sdk): add FastEmbed embedding provider",
+    body: "## Summary\n\nThe Python SDK supports **FastEmbed** as an embedding provider, but the TypeScript OSS SDK (`mem0ai/oss`) does not. Add it to bring the TS SDK to parity.\n\n| | |\n|---|---|\n| Python reference | `mem0/embeddings/fastembed.py` |\n| Registered in (Python) | `mem0/utils/factory.py` (EmbedderFactory) |\n| Target file (TypeScript) | `mem0-ts/src/oss/src/embeddings/fastembed.ts` |\n| Suggested implementation | Use the `fastembed` npm package (ONNX local embeddings). |\n\n## Requirements\n\n- [ ] Implement `FastEmbedEmbedder` in `mem0-ts/src/oss/src/embeddings/fastembed.ts`, extending `Embedder` (`mem0-ts/src/oss/src/embeddings/base.ts`) and mirroring the Python provider's behavior (embed / embedBatch).\n- [ ] Register the `\"fastembed\"` provider in `mem0-ts/src/oss/src/utils/factory.ts` (EmbedderFactory).\n- [ ] Add config typing in `mem0-ts/src/oss/src/types/`.\n- [ ] Add a unit test under `mem0-ts/src/oss/src/tests/`.\n- [ ] Add `fastembed` to `mem0-ts/package.json` (optional/peer dependency, lazy-imported like other providers).\n- [ ] Update docs under `docs/` if this provider is user-facing.\n\n## Reference pattern\n\nMirror an existing TS provider: `embeddings/openai.ts`.\n\n## Notes\n\n`fastembed` (v2.x) is the JS port of Qdrant's FastEmbed — local/offline embeddings. Mirror the default model in `mem0/embeddings/fastembed.py`.\n\n---\n_Part of the TypeScript ↔ Python SDK provider-parity effort. One provider per issue (atomic)._\n",
+    expected: ["sdk-typescript"],
+  },
+  {
+    number: 3940,
+    title: "Milvus database will return distance not similarity score",
+    body: "### 🐛 Describe the bug\n\nMilvus database will return distance not similarity score\n\n## in milvus.py\n\ndef _parse_output(self, data: list):\n        \"\"\"\n        Parse the output data.\n\n        Args:\n            data (Dict): Output data.\n\n        Returns:\n            List[OutputData]: Parsed output data.\n        \"\"\"\n        memory = []\n\n        for value in data:\n            uid, score, metadata = (\n                value.get(\"id\"),\n                value.get(\"distance\"),  # here\n                value.get(\"entity\", {}).get(\"metadata\"),\n            )\n\n            memory_obj = OutputData(id=uid, score=score, payload=metadata)\n            memory.append(memory_obj)\n\n        return memory\n",
+    expected: ["vector-store"],
+  },
+  {
+    number: 5290,
+    title: "Recall search failed: Bad Request Using OpenAI Embedding Model",
+    body: "### Component\n\nOpenClaw\n\n### Description\n\n### Summary\nuse openclaw.json config:\n\n```json\n...\n\"embedder\": {\n              \"provider\": \"openai\",\n              \"config\": {\n                \"model\": \"bge-base-zh-v1.5\",\n                \"embedding_dims\": 1024,\n                \"embeddingDims\": 1024,\n                \"url\": \"https://xxxxxxxxx/v1\",\n                \"apiKey\": \"xxxxxxxxxxxx\"\n              }\n            },\n\"vectorStore\": {\n              \"provider\": \"qdrant\",\n              \"config\": {\n                \"url\": \"http://qdrant:6333\",\n                \"apiKey\": \"${QDRANT_API_KEY}\",\n                \"collectionName\": \"mem0\",\n                \"embeddingModelDims\": 1024\n              }\n            }\n```\n```\n\nopenclaw log info is：\n\n```\n23:14:20 Api key is used with unsecure connection.\n23:14:21 [mem0] Recall search failed: Bad Request\n23:14:21 [plugins] openclaw-mem0: skills-mode recall (strategy=smart) injecting 0 memories (~20 tokens)\n23:14:22 [ws] ⇄ res ✓ sessions.list 256ms conn=d1eb9bc4…17da id=201b8113…c9dc\n23:14:22 [ws] ⇄ res ✓ sessions.list 264ms conn=d1eb9bc4…17da id=4939f962…2f16\n23:14:34 [ws] ⇄ res ✓ sessions.list 250ms conn=d1eb9bc4…17da id=f7ad503f…baa6\n23:15:12 [mem0] **Recall search failed: Bad Request**\n23:15:12 [plugins] openclaw-mem0: skills-mode recall (strategy=smart) injecting 0 memories (~20 tokens)\n23:15:12 [ws] ⇄ res ✓ sessions.list 288ms conn=d1eb9bc4…17da id=9e20bb86…371e\n23:15:13 [ws] ⇄ res ✓ sessions.list 268ms conn=d1eb9bc4…17da id=3b49a2ad…7ada\n23:15:20 [ws] ⇄ res ✓ sessions.list 235ms conn=d1eb9bc4…17da id=a192da30…069f\n```\n\n### Actual Behavior\n\nembedding model response ok,response message has 1024 vectors,but the vectors are submitted to vector-db:qdrant with all zero vectors,and vectors has only 256 size.\n\n```http\nPOST /collections/mem0/points/search HTTP/1.1\nhost: qdrant:6333\nconnection: keep-alive\nuser-agent: qdrant-js/1.13.0\napi-key: xxxxxxxxxxxxxxxxxxxxxxxxxxxx\nContent-Type: application/json\nAccept: application/json\naccept-language: *\nsec-fetch-mode: cors\naccept-encoding: gzip, deflate\ncontent-length: 651\n\n{\"vector\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"limit\":120,\"offset\":0,\"filter\":{\"must\":[{\"key\":\"user_id\",\"match\":{\"value\":\"agent\"}}]},\"with_payload\":true,\"with_vector\":false}\n\n**HTTP/1.1 400 Bad Request**\ntransfer-encoding: chunked\ncontent-type: application/json\nvary: accept-encoding, Origin, Access-Control-Request-Method, Access-Control-Request-Headers\ncontent-encoding: gzip\n\n```\n\n### Expected Behavior\n\nembedding model response ok by tcpdump, response message has 1024 vectors,and this vectors are submitted to vector-db:qdrant with the same vectors,and vectors has also 1024 size.\n\n\n### Environment\n\n- openclaw-mem0 version: 1.0.11\n- qdrant: 1.13.6\n",
+    expected: ["plugin", "integrations"],
+  },
+  {
+    number: 3696,
+    title: "Cannot set expiration_date for memory in REST API server (Docker Compose)",
+    body: "### 🐛 Describe the bug\n\nI'm using docker compose to deploy a REST API server. When adding memory, I'm unable to set the expiration_date. Is this feature not supported?",
+    expected: ["rest-api"],
+  },
+  {
+    number: 3444,
+    title: "Fix: Openmemory run.sh non-existent vector-store route",
+    body: "### 🐛 Describe the bug\n\n# Vector_store not implemented\nThere is many references to ` ${NEXT_PUBLIC_API_URL}/api/v1/config/mem0/vector_store` in lines 280, 293, 306, 319,  332, 345, 358, and 371. \n```bash\ncurl -fsS -X PUT \"${NEXT_PUBLIC_API_URL}/api/v1/config/mem0/vector_store\" # Line 280 and for each vector store\n```\nBut the api route is not implemented in `api/app/routers/config.py`.\n# Suggested solution\nI would implement `vector_store` route or remove and use `update_configuration` for all config updates. Also Create class with all config keys for vector_store",
+    expected: ["openmemory"],
+  },
+  {
+    number: 6252,
+    title: "cursor: on_file_read_cursor.sh ignores auto_search / MEM0_AUTO_SEARCH",
+    body: "### Component\n\nCursor / mem0-plugin\n\n### Description\n\n`on_file_read_cursor.sh` never checks `MEM0_AUTO_SEARCH`. In Claude Code, #6065/#6071 added a guard on `on_file_read.sh`, but the Cursor PreToolUse variant still always calls `file_context.py` (and thus Platform search) once `MEM0_API_KEY` is set.\n\n### Expected\n\nWhen `auto_search: false` / `MEM0_AUTO_SEARCH=false`, `on_file_read_cursor.sh` should exit 0 without searching.\n\n### Actual\n\nTimeline search still runs.\n\n### Related\n\n#6065, #6071, #6250\n",
+    expected: ["plugin", "integrations"],
+  },
+  {
+    number: 6032,
+    title: "docs: fix typos and punctuation errors across docs",
+    body: "### Description\n\n### Page\nMultiple pages — see list below.\n\n### What's Wrong or Missing\n1. https://docs.mem0.ai/components/llms/overview — \"a llm\" should be \"an LLM\"\n2. https://docs.mem0.ai/components/vectordbs/dbs/azure — 2 comma splices + \"setup\" used as a verb (should be \"set up\")\n3. https://docs.mem0.ai/components/embedders/models/azure_openai — \"from the Azure.\" is an incomplete sentence\n4. https://docs.mem0.ai/components/llms/models/azure_openai — same incomplete \"from the Azure\" phrasing\n5. https://docs.mem0.ai/cookbooks/companions/voice-companion-openai — \"an important information\" (uncountable noun)\n6. https://docs.mem0.ai/cookbooks/essentials/exporting-memories — comma splice\n7. https://docs.mem0.ai/cookbooks/integrations/tavily-search — \"usecase\" should be \"use case\"\n8. https://docs.mem0.ai/cookbooks/overview — broken parallelism in bullet list\n9. README.md — \"Github App\" should be \"GitHub App\"\n10. https://docs.mem0.ai/platform/overview — table cell not capitalized like other rows\n\n### Suggested Fix\nApply the corrections listed above for each page. I will submit a PR soon addressing all of the issues mentioned.",
+    expected: ["documentation"],
+  },
+];
+
+const cliRegressionCase = {
+  number: 3144,
+  title: "Bug Report: Memory Score Does Not Match Expected Relevance in Local Search",
+  body: "### 🐛 Describe the bug\n\n#### Description\n\nWhen using the locally deployed `mem0` server, the returned memory `score` from the `search` interface does not align with the expected semantic relevance. In particular, irrelevant or less relevant memories sometimes receive higher scores than directly related ones.\n\n#### Reproduction Steps\n\n```python\nmem0 = mem0_client(mode=\"local\")\nprint(\"Mem0 client initialized successfully.\")\n\nprint(\"Adding memories...\")\nresult = mem0.add(messages=[\n    {\"role\": \"user\", \"content\": \"I like drinking coffee in the morning\"},\n    {\"role\": \"user\", \"content\": \"I enjoy reading books at night\"}\n], user_id=\"alice\")\nprint(\"Memory added:\", result)\n\nprint(\"Searching memories...\")\nsearch_result = mem0.search(query=\"coffee\", user_id=\"alice\", top_k=2)\nprint(\"Search results:\", search_result)\n```\n\n#### Actual Output\n\n```json\n{\n  \"results\": [\n    {\n      \"id\": \"5099b5be-c673-4f09-99de-a196f43b6476\",\n      \"memory\": \"Likes drinking coffee in the morning\",\n      \"score\": 0.5115111920687857\n    },\n    {\n      \"id\": \"08df5c51-c52b-4c45-a5b6-b3f864ea149a\",\n      \"memory\": \"Enjoys reading books at night\",\n      \"score\": 0.7755568273863331\n    }\n  ],\n  \"relations\": [\n    {\"source\": \"coffee\", \"relationship\": \"consumed_in\", \"destination\": \"morning\"},\n    {\"source\": \"user_id:_alice\", \"relationship\": \"likes\", \"destination\": \"coffee\"},\n    {\"source\": \"user_id:_alice\", \"relationship\": \"likes_drinking\", \"destination\": \"coffee\"},\n    {\"source\": \"user_id:_alice\", \"relationship\": \"in_time\", \"destination\": \"morning\"},\n    {\"source\": \"user_id:_alice\", \"relationship\": \"drinks_in\", \"destination\": \"morning\"}\n  ]\n}\n```\n\n#### Expected Behavior\n\nThe memory `\"Likes drinking coffee in the morning\"` should have a **higher score** than `\"Enjoys reading books at night\"` when querying for `\"coffee\"`, since it is directly semantically related.",
+};
+
+let failures = 0;
+
+function run(name, fn) {
+  try {
+    fn();
+    console.log(`PASS ${name}`);
+  } catch (err) {
+    failures++;
+    console.error(`FAIL ${name}: ${err.message}`);
+  }
+}
+
+for (const { number, title, body, expected } of cases) {
+  const text = `${title}
+
+${body}`;
+  run(`#${number}`, () => {
+    assert.deepStrictEqual(inferComponentLabels(text, keywords), expected);
+  });
+}
+
+run('#3144 cliKeywordPrefixSubstringRegression', () => {
+  const text = `${cliRegressionCase.title}
+
+${cliRegressionCase.body}`;
+  const inferred = inferComponentLabels(text, keywords);
+  assert.ok(!inferred.includes('cli'), `expected 'cli' absent (body contains 'Mem0 client', a substring of the removed 'mem0 cli' term), got ${JSON.stringify(inferred)}`);
+});
+
+run('noKeywordMatchReturnsEmptyArray', () => {
+  const text = 'The weather today is sunny and I went for a walk in the park with my dog.';
+  assert.deepStrictEqual(inferComponentLabels(text, keywords), []);
+});
+
+run('emptyStringReturnsEmptyArray', () => {
+  assert.deepStrictEqual(inferComponentLabels('', keywords), []);
+});
+
+if (failures > 0) {
+  console.error(`
+${failures} test(s) failed.`);
+  process.exit(1);
+}
+console.log(`
+All ${cases.length + 3} tests passed.`);
@@ -12,28 +12,56 @@ jobs:
  label:
    runs-on: ubuntu-latest
    steps:
+      - uses: actions/checkout@v4
+
      - uses: stefanbuck/github-issue-parser@v3
        id: issue-parser
+        continue-on-error: true
        with:
          template-path: .github/ISSUE_TEMPLATE/bug_report.yml

      - uses: redhat-plumbers-in-action/advanced-issue-labeler@v3
+        continue-on-error: true
        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')
+      - name: Infer component from text when the form was not used
+        uses: actions/github-script@v7
        with:
-          template-path: .github/ISSUE_TEMPLATE/feature_request.yml
+          script: |
+            const {
+              componentLabels,
+              inferComponentLabels,
+              loadKeywords,
+            } = require(`${process.env.GITHUB_WORKSPACE}/.github/scripts/infer-component-labels.js`);

-      - 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
+            const { data: issue } = await github.rest.issues.get({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: context.issue.number,
+            });
+
+            const keywords = loadKeywords(`${process.env.GITHUB_WORKSPACE}/.github/component-keywords.json`);
+            const known = componentLabels(keywords);
+            const existing = issue.labels.map((label) => label.name || label);
+            if (existing.some((name) => known.includes(name))) {
+              core.info(`Component label already present: ${existing.join(', ')}`);
+              return;
+            }
+
+            const labels = inferComponentLabels(`${issue.title}\n\n${issue.body || ''}`, keywords);
+
+            if (labels.length === 0) {
+              core.info('No component could be inferred from the issue text');
+              return;
+            }
+
+            core.info(`Inferred: ${labels.join(', ')}`);
+            await github.rest.issues.addLabels({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: context.issue.number,
+              labels,
+            });
@@ -0,0 +1,64 @@
+name: PR Labeler
+
+on:
+  pull_request_target:
+    types: [opened, synchronize, reopened, edited]
+
+concurrency:
+  group: pr-labeler-${{ github.event.pull_request.number }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read
+  pull-requests: write
+  issues: read
+
+jobs:
+  label:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/labeler@v5
+        with:
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Propagate labels from linked issues
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const allowed = new Set([
+              'sdk-python', 'sdk-typescript', 'vector-store', 'plugin',
+              'rest-api', 'openmemory', 'documentation', 'ci', 'cli', 'integrations',
+            ]);
+            const umbrella = { plugin: 'integrations' };
+            const { repository } = await github.graphql(
+              `query ($owner: String!, $repo: String!, $number: Int!) {
+                repository(owner: $owner, name: $repo) {
+                  pullRequest(number: $number) {
+                    closingIssuesReferences(first: 20) {
+                      nodes { labels(first: 50) { nodes { name } } }
+                    }
+                  }
+                }
+              }`,
+              { owner: context.repo.owner, repo: context.repo.repo, number: context.issue.number },
+            );
+
+            const labels = new Set();
+            for (const issue of repository.pullRequest.closingIssuesReferences.nodes) {
+              for (const label of issue.labels.nodes) {
+                if (allowed.has(label.name)) labels.add(label.name);
+              }
+            }
+
+            for (const label of [...labels]) {
+              if (umbrella[label]) labels.add(umbrella[label]);
+            }
+
+            if (labels.size > 0) {
+              await github.rest.issues.addLabels({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: context.issue.number,
+                labels: [...labels],
+              });
+            }
@@ -462,6 +462,7 @@ Publishing is routed through a single entry point: **`release.yml` (Release Rout
 | Workflow | File | Purpose |
 |----------|------|---------|
 | Issue Labeler | `issue-labeler.yml` | Automatic issue labeling |
+| PR Labeler | `pr-labeler.yml` | Path-based PR labeling plus propagating labels from linked issues |
 | Stale Bot | `stale.yml` | Marks stale issues and PRs |
 | llms.txt Check | `docs-llms-txt-check.yml` | Blocks PRs touching `docs/**/*.mdx` when `docs/llms.txt` is out of sync. Fix locally with `python scripts/check-llms-txt-coverage.py --write`. |

@@ -46,12 +46,12 @@

 | Benchmark | Old | New  | Tokens  | Latency p50  |
 | --- | --- | --- | --- | --- |
-| **LoCoMo** | 71.4 | **91.6** | 7.0K  | 0.88s  |
-| **LongMemEval** | 67.8 | **94.8** | 6.8K  | 1.09s  |
+| **LoCoMo** | 71.4 | **92.5** | 7.0K  | 0.88s  |
+| **LongMemEval** | 67.8 | **94.4** | 6.8K  | 1.09s  |
 | **BEAM (1M)** | — | **64.1** | 6.7K  | 1.00s  |
 | **BEAM (10M)** | — | **48.6** | 6.9K  | 1.05s  |

-All benchmarks run on the same production-representative model stack. Single-pass retrieval (one call, no agentic loops).
+All benchmarks run on the same production-representative model stack. Single-pass retrieval (one call, no agentic loops) at a top_200 retrieval budget. Scores reflect Mem0's managed platform, which includes proprietary optimizations not available in the open-source SDK; open-source users should expect directionally similar gains but not identical numbers.

 **What changed:**
 - **Single-pass ADD-only extraction** -- one LLM call, no UPDATE/DELETE. Memories accumulate; nothing is overwritten.
@@ -63,8 +63,8 @@ All benchmarks run on the same production-representative model stack. Single-pas
 See the [migration guide](https://docs.mem0.ai/migration/oss-v2-to-v3) for upgrade instructions. The [evaluation framework](https://github.com/mem0ai/memory-benchmarks) is open-sourced so anyone can reproduce the numbers.

 ## Research Highlights
- **91.6 on LoCoMo** -- +20 points over the previous algorithm
- **94.8 on LongMemEval** -- +27 points, with +53.6 on assistant memory recall
+- **92.5 on LoCoMo** -- +21 points over the previous algorithm
+- **94.4 on LongMemEval** -- +27 points, with 98.2 on assistant memory recall
 - **64.1 on BEAM (1M)** -- production-scale memory evaluation at 1M tokens
 - [Read the full paper](https://mem0.ai/research)

@@ -1,6 +1,6 @@
 {
  "name": "@mem0/cli",
-  "version": "0.2.10",
+  "version": "0.2.11",
  "description": "The official CLI for mem0 — the memory layer for AI agents",
  "type": "module",
  "bin": {
@@ -17,6 +17,10 @@ import {
 	type SearchOptions,
 } from "./base.js";

+function encodePathSegment(value: unknown): string {
+	return encodeURIComponent(String(value));
+}
+
 export class PlatformBackend implements Backend {
 	private baseUrl: string;
 	private headers: Record<string, string>;
@@ -218,9 +222,13 @@ export class PlatformBackend implements Backend {
 	}

 	async get(memoryId: string): Promise<Record<string, unknown>> {
-		return (await this._request("GET", `/v1/memories/${memoryId}/`, {
-			params: { source: "CLI" },
-		})) as Record<string, unknown>;
+		return (await this._request(
+			"GET",
+			`/v1/memories/${encodePathSegment(memoryId)}/`,
+			{
+				params: { source: "CLI" },
+			},
+		)) as Record<string, unknown>;
 	}

 	async listMemories(
@@ -277,9 +285,13 @@ export class PlatformBackend implements Backend {
 		if (content) payload.text = content;
 		if (metadata) payload.metadata = metadata;
 		payload.source = "CLI";
-		return (await this._request("PUT", `/v1/memories/${memoryId}/`, {
-			json: payload,
-		})) as Record<string, unknown>;
+		return (await this._request(
+			"PUT",
+			`/v1/memories/${encodePathSegment(memoryId)}/`,
+			{
+				json: payload,
+			},
+		)) as Record<string, unknown>;
 	}

 	async delete(
@@ -297,9 +309,13 @@ export class PlatformBackend implements Backend {
 			})) as Record<string, unknown>;
 		}
 		if (memoryId) {
-			return (await this._request("DELETE", `/v1/memories/${memoryId}/`, {
-				params: { source: "CLI" },
-			})) as Record<string, unknown>;
+			return (await this._request(
+				"DELETE",
+				`/v1/memories/${encodePathSegment(memoryId)}/`,
+				{
+					params: { source: "CLI" },
+				},
+			)) as Record<string, unknown>;
 		}
 		throw new Error("Either memoryId or --all is required");
 	}
@@ -323,7 +339,7 @@ export class PlatformBackend implements Backend {
 		for (const [entityType, entityId] of entities) {
 			results[entityType] = (await this._request(
 				"DELETE",
-				`/v2/entities/${entityType}/${entityId}/`,
+				`/v2/entities/${encodePathSegment(entityType)}/${encodePathSegment(entityId)}/`,
 				{ params: { source: "CLI" } },
 			)) as Record<string, unknown>;
 		}
@@ -386,9 +402,9 @@ export class PlatformBackend implements Backend {
 	}

 	async getEvent(eventId: string): Promise<Record<string, unknown>> {
-		return (await this._request("GET", `/v1/event/${eventId}/`)) as Record<
-			string,
-			unknown
-		>;
+		return (await this._request(
+			"GET",
+			`/v1/event/${encodePathSegment(eventId)}/`,
+		)) as Record<string, unknown>;
 	}
 }
@@ -2,7 +2,7 @@
 * Tests for the Platform backend (mem0 Platform API client).
 */

-import { describe, it, expect, vi } from "vitest";
+import { beforeEach, describe, expect, it, vi } from "vitest";
 import { PlatformBackend } from "../src/backend/platform.js";
 import { createDefaultConfig } from "../src/config.js";

@@ -12,6 +12,22 @@ function makeBackend(): PlatformBackend {
  return new PlatformBackend(createDefaultConfig().platform);
 }

+function mockFetch() {
+  const fetchMock = vi.fn().mockResolvedValue({
+    ok: true,
+    status: 200,
+    headers: { get: vi.fn().mockReturnValue(null) },
+    json: vi.fn().mockResolvedValue({ message: "ok" }),
+  });
+  vi.stubGlobal("fetch", fetchMock);
+  return fetchMock;
+}
+
+beforeEach(() => {
+  vi.restoreAllMocks();
+  vi.unstubAllGlobals();
+});
+
 describe("deleteEntities", () => {
  it("returns all results keyed by entity type for a multi-entity delete", async () => {
    const backend = makeBackend();
@@ -50,3 +66,35 @@ describe("deleteEntities", () => {
    );
  });
 });
+
+describe("PlatformBackend path encoding", () => {
+  it("encodes memory IDs before interpolating them into paths", async () => {
+    const fetchMock = mockFetch();
+    const backend = makeBackend();
+
+    await backend.get("mem/a?b#c");
+    await backend.update("mem/a?b#c", "updated");
+    await backend.delete("mem/a?b#c");
+
+    const urls = fetchMock.mock.calls.map((call) => call[0]);
+    expect(urls).toEqual([
+      "https://api.mem0.ai/v1/memories/mem%2Fa%3Fb%23c/?source=CLI",
+      "https://api.mem0.ai/v1/memories/mem%2Fa%3Fb%23c/",
+      "https://api.mem0.ai/v1/memories/mem%2Fa%3Fb%23c/?source=CLI",
+    ]);
+  });
+
+  it("encodes entity and event IDs before interpolating them into paths", async () => {
+    const fetchMock = mockFetch();
+    const backend = makeBackend();
+
+    await backend.deleteEntities({ userId: "org/team?active#frag" });
+    await backend.getEvent("evt/a?b#c");
+
+    const urls = fetchMock.mock.calls.map((call) => call[0]);
+    expect(urls).toEqual([
+      "https://api.mem0.ai/v2/entities/user/org%2Fteam%3Factive%23frag/?source=CLI",
+      "https://api.mem0.ai/v1/event/evt%2Fa%3Fb%23c/",
+    ]);
+  });
+});
@@ -4,7 +4,7 @@ build-backend = "hatchling.build"

 [project]
 name = "mem0-cli"
-version = "0.2.9"
+version = "0.2.10"
 description = "The official CLI for mem0 — the memory layer for AI agents"
 readme = "README.md"
 license = "Apache-2.0"
@@ -1,3 +1,3 @@
 """mem0 CLI — the command-line interface for the mem0 memory layer."""

-__version__ = "0.2.9"
+__version__ = "0.2.10"
@@ -3,6 +3,7 @@
 from __future__ import annotations

 from typing import Any
+from urllib.parse import quote

 import httpx

@@ -11,6 +12,10 @@ from mem0_cli.backend.base import Backend
 from mem0_cli.config import PlatformConfig


+def _encode_path_segment(value: Any) -> str:
+    return quote(str(value), safe="")
+
+
 class PlatformBackend(Backend):
    """Backend that talks to the mem0 Platform API."""

@@ -196,7 +201,11 @@ class PlatformBackend(Backend):
        )

    def get(self, memory_id: str) -> dict:
-        return self._request("GET", f"/v1/memories/{memory_id}/", params={"source": "CLI"})
+        return self._request(
+            "GET",
+            f"/v1/memories/{_encode_path_segment(memory_id)}/",
+            params={"source": "CLI"},
+        )

    def list_memories(
        self,
@@ -250,7 +259,11 @@ class PlatformBackend(Backend):
        if metadata:
            payload["metadata"] = metadata
        payload["source"] = "CLI"
-        return self._request("PUT", f"/v1/memories/{memory_id}/", json=payload)
+        return self._request(
+            "PUT",
+            f"/v1/memories/{_encode_path_segment(memory_id)}/",
+            json=payload,
+        )

    def delete(
        self,
@@ -274,7 +287,11 @@ class PlatformBackend(Backend):
                params["run_id"] = run_id
            return self._request("DELETE", "/v1/memories/", params=params)
        elif memory_id:
-            return self._request("DELETE", f"/v1/memories/{memory_id}/", params={"source": "CLI"})
+            return self._request(
+                "DELETE",
+                f"/v1/memories/{_encode_path_segment(memory_id)}/",
+                params={"source": "CLI"},
+            )
        else:
            raise ValueError("Either memory_id or --all is required")

@@ -302,7 +319,9 @@ class PlatformBackend(Backend):
        results: dict = {}
        for entity_type, entity_id in entities.items():
            results[entity_type] = self._request(
-                "DELETE", f"/v2/entities/{entity_type}/{entity_id}/", params={"source": "CLI"}
+                "DELETE",
+                f"/v2/entities/{_encode_path_segment(entity_type)}/{_encode_path_segment(entity_id)}/",
+                params={"source": "CLI"},
            )
        return results

@@ -348,7 +367,7 @@ class PlatformBackend(Backend):
        return result if isinstance(result, list) else result.get("results", [])

    def get_event(self, event_id: str) -> dict:
-        return self._request("GET", f"/v1/event/{event_id}/")
+        return self._request("GET", f"/v1/event/{_encode_path_segment(event_id)}/")


 class AuthError(Exception):
@@ -0,0 +1,43 @@
+from unittest.mock import MagicMock
+
+from mem0_cli.backend.platform import PlatformBackend
+
+
+def _backend(sample_config):
+    backend = PlatformBackend(sample_config.platform)
+    backend._client = MagicMock()
+    backend._client.request.return_value = MagicMock(
+        status_code=200,
+        json=lambda: {"message": "ok"},
+        headers={},
+        raise_for_status=lambda: None,
+    )
+    return backend
+
+
+def test_memory_id_path_segments_are_encoded(sample_config):
+    backend = _backend(sample_config)
+
+    backend.get("mem/a?b#c")
+    backend.update("mem/a?b#c", content="updated")
+    backend.delete("mem/a?b#c")
+
+    paths = [call.args[1] for call in backend._client.request.call_args_list]
+    assert paths == [
+        "/v1/memories/mem%2Fa%3Fb%23c/",
+        "/v1/memories/mem%2Fa%3Fb%23c/",
+        "/v1/memories/mem%2Fa%3Fb%23c/",
+    ]
+
+
+def test_entity_and_event_path_segments_are_encoded(sample_config):
+    backend = _backend(sample_config)
+
+    backend.delete_entities(user_id="org/team?active#frag")
+    backend.get_event("evt/a?b#c")
+
+    paths = [call.args[1] for call in backend._client.request.call_args_list]
+    assert paths == [
+        "/v2/entities/user/org%2Fteam%3Factive%23frag/",
+        "/v1/event/evt%2Fa%3Fb%23c/",
+    ]
@@ -24,7 +24,7 @@ mintlify dev

 ### Publishing Changes

-Install our Github App to auto propagate changes from your repo to your deployment. Changes will be deployed to production automatically after pushing to the default branch. Find the link to install on your dashboard. 
+Install our GitHub App to auto-propagate changes from your repo to your deployment. Changes will be deployed to production automatically after pushing to the default branch. Find the link to install on your dashboard. 

 #### Troubleshooting

@@ -0,0 +1,5 @@
+{/* Subtle, value-anchored nudge to star the repo. Drop in at peak-end "win" moments in the OSS docs (after a successful add/search, a server bootstrap, etc.). Keep it off the Platform/API pages. */}
+{/* Clicks are tracked via PostHog autocapture: the data-ph-capture-attribute-cta below tags each click with cta="star-on-github" so it's filterable as an event property. Metric = count of $autocapture where cta = star-on-github; break down by Current URL to see which win-moment converts. */}
+<Callout icon="star" iconType="solid" color="#FACC15">
+  **Using Mem0?** <a href="https://github.com/mem0ai/mem0" data-ph-capture-attribute-cta="star-on-github">Star us on GitHub</a> to help more developers discover memory for AI apps.
+</Callout>
@@ -97,7 +97,7 @@ Get your API key from the <a href="https://app.mem0.ai/dashboard/api-keys?utm_so

 ## Next Steps

-<CardGroup cols={2}>
+<CardGroup cols={3}>
  <Card title="Add Your First Memory" icon="rocket" href="/api-reference/memory/add-memories">
    Start storing memories via the REST API
  </Card>
@@ -105,4 +105,8 @@ Get your API key from the <a href="https://app.mem0.ai/dashboard/api-keys?utm_so
  <Card title="Search with Filters" icon="filter" href="/api-reference/memory/search-memories">
    Learn advanced search and filtering techniques
  </Card>
+
+  <Card title="Build with cookbooks" icon="book-open" href="/cookbooks/overview">
+    See the API used end to end in real projects.
+  </Card>
 </CardGroup>
@@ -79,7 +79,7 @@ new_project = client.project.create(

 ### Update Project Settings

-Modify project configuration including custom instructions, categories, language preferences, retrieval criteria, and memory decay:
+Modify project configuration including custom instructions, categories, language preferences, and memory decay:

 ```python
 # Update project with custom categories
@@ -98,14 +98,6 @@ client.project.update(
 # Use the input language for memory storage and retrieval
 client.project.update(multilingual=True)

-# Set retrieval criteria to control which memories are surfaced in search
-client.project.update(
-    retrieval_criteria=[
-        {"name": "relevance", "description": "How directly relevant this memory is to the current topic or user query", "weight": 3},
-        {"name": "access_frequency", "description": "How often this memory has been accessed or surfaced recently", "weight": 1}
-    ]
-)
-
 # Enable Memory Decay (boosts recently-accessed memories at search time)
 client.project.update(decay=True)

@@ -120,34 +112,6 @@ client.project.update(
 )
 ```

-#### Set Retrieval Criteria
-
-`retrieval_criteria` is a per-project list of dictionaries (`List[Dict]`) that shapes how memories are ranked and filtered during search. Each dictionary has three fields: `name` (identifier), `description` (interpreted by the LLM to score each memory), and `weight` (relative influence on the final score). Use this to focus retrieval on intent-aligned or signal-specific memories:
-
-```python
-client.project.update(
-    retrieval_criteria=[
-        {
-            "name": "joy",
-            "description": "Measure the intensity of positive emotions such as happiness, excitement, or amusement expressed in the memory. A higher score reflects greater joy.",
-            "weight": 3
-        },
-        {
-            "name": "curiosity",
-            "description": "Assess the extent to which the memory reflects inquisitiveness or interest in exploring new information. A higher score reflects stronger curiosity.",
-            "weight": 2
-        },
-        {
-            "name": "access_frequency",
-            "description": "How often this memory has been accessed or surfaced recently.",
-            "weight": 1
-        }
-    ]
-)
-```
-
-Pass an empty list to clear all criteria and restore default retrieval behaviour.
-
 #### Toggle Memory Decay

 `decay` is a per-project boolean that turns on [Memory Decay](/platform/features/memory-decay): a search-time ranking bias that reinforces recently-accessed memories and gently dampens stale ones. The flag is `false` by default; set it via the same project-update endpoint:
@@ -4,6 +4,22 @@ description: "Major product launches, headline features, and milestones for Mem0
 mode: "wide"
 ---

+<Update label="2026-07-13" description="TypeScript provider expansion">
+
+**TypeScript OSS SDK: 26 New Providers, Reranking, and Zero-Dependency Imports**
+
+TypeScript SDK v3.1.0 is the largest provider release for the OSS SDK so far, closing most of the remaining gap with the Python SDK. Python SDK v2.0.12 ships alongside it with fixes and security patches.
+
+- **17 new vector stores:** Pinecone, Weaviate, Milvus, Chroma, MongoDB, Elasticsearch, OpenSearch, Databricks, AWS Neptune Analytics, S3 Vectors, Azure MySQL, Google Vertex AI Vector Search, Turbopuffer, Upstash Vector, Valkey, Cassandra, and Baidu Mochow.
+- **5 new LLM providers:** AWS Bedrock, xAI Grok, Together, vLLM, and Sarvam.
+- **4 new embedding providers:** Vertex AI, HuggingFace, FastEmbed, and Together.
+- **Reranking in TypeScript:** Four rerankers (Cohere, ZeroEntropy, cross-encoder, and LLM-based) with per-search rerank via a `rerank` option on `search()`.
+- **Install only what you use:** Importing `mem0ai/oss` no longer pulls in any provider SDK. Provider packages are resolved lazily on first use, so an app that configures only OpenAI and Qdrant does not need the other provider SDKs installed.
+
+See [SDK & Tools](/changelog/sdk) for version details and PR links.
+
+</Update>
+
 <Update label="2026-06-27" description="SDK memory expiration">

 **SDK Memory Expiration: Expiring Memories Across Python and TypeScript**
@@ -7,6 +7,51 @@ mode: "wide"
 <Tabs>
 <Tab title="Python">

+<Update label="2026-07-22" description="v2.0.13">
+
+**Bug Fixes:**
+- **Vector Stores:** Fix `reset()` silently leaving stale vectors behind on local (on-disk) Qdrant when the old collection directory could not be removed, for example an open file handle on Windows or NFS ([#6412](https://github.com/mem0ai/mem0/pull/6412))
+- **Core:** Stop `update()` metadata from overwriting or injecting `user_id`, `agent_id`, `run_id`, or `actor_id`. These identity fields are immutable after creation, so passing them in `metadata` can no longer move a memory into a different tenant's scope ([#6278](https://github.com/mem0ai/mem0/pull/6278))
+- **Vector Stores:** Scope Pinecone `delete_col()`/`reset()` to the configured namespace instead of deleting the whole index, so resetting a namespaced Pinecone store no longer wipes out the other namespaces sharing that index ([#6287](https://github.com/mem0ai/mem0/pull/6287))
+- **Vector Stores:** Convert Baidu Mochow's raw L2 distance into a similarity score in `search()` (`1 / (1 + distance)`), so closer matches rank higher instead of lower, matching the Milvus provider and the rest of the `VectorStoreBase` contract ([#6435](https://github.com/mem0ai/mem0/pull/6435))
+- **LLMs:** Read `OPENAI_BASE_URL` (was `OPENAI_API_BASE`) in `OpenAIStructuredLLM`, matching the official OpenAI SDK's environment variable and the rest of the OpenAI-compatible providers ([#6322](https://github.com/mem0ai/mem0/pull/6322))
+
+**Improvements:**
+- **LLMs:** Remove a dead, no-op `api_key` attribute check from `LLMBase.__init__` ([#6460](https://github.com/mem0ai/mem0/pull/6460))
+
+**Changes:**
+- **Client:** Remove the `retrieval_criteria` parameter from `MemoryClient.update_project()`/`AsyncMemoryClient.update_project()` and `Project.update()`/`AsyncProject.update()`. It was accepted and forwarded but never affected retrieval, so removing it is not a behavior change ([#6313](https://github.com/mem0ai/mem0/pull/6313))
+
+</Update>
+
+<Update label="2026-07-13" description="v2.0.12">
+
+**New Features:**
+- **Memory (OSS):** Accept `text` in `Memory.update()` and `AsyncMemory.update()`. `data` still works but is now deprecated, so prefer `text` in new code ([#6044](https://github.com/mem0ai/mem0/pull/6044))
+
+**Bug Fixes:**
+- **Core:** Coerce non-string entity IDs (`user_id`, `agent_id`, `run_id`) instead of crashing on `.strip()`, so passing an integer ID no longer raises `AttributeError` ([#6206](https://github.com/mem0ai/mem0/pull/6206))
+- **Core:** Stop requiring `langchain-core` for the default async procedural memory path. The optional dependency is now only imported when you pass a custom LangChain LLM, matching the sync behavior ([#6209](https://github.com/mem0ai/mem0/pull/6209))
+- **Client:** Encode dynamic URL path segments so IDs containing special characters no longer produce malformed requests ([#5963](https://github.com/mem0ai/mem0/pull/5963))
+- **LLMs:** Skip `temperature` and `top_p` for newer Anthropic models that reject sampling parameters. Detection is automatic per model family and version, and the new `enable_sampling_parameters` config flag overrides it ([#6211](https://github.com/mem0ai/mem0/pull/6211))
+- **Vector Stores:** Stop writing internal `OutputData` model fields as properties on Weaviate `update()` ([#6149](https://github.com/mem0ai/mem0/pull/6149))
+- **Vector Stores:** Improve wildcard search handling in Milvus ([#6187](https://github.com/mem0ai/mem0/pull/6187))
+- **Vector Stores:** Keep env-resolved Upstash Vector credentials after config validation. An env-var-only config previously passed validation and then failed to build ([#5811](https://github.com/mem0ai/mem0/pull/5811))
+- **Vector Stores:** Restore the previous payload when a Neptune Analytics vector upsert fails inside `update()`, so a partial write can no longer leave the payload and embedding out of sync ([#5824](https://github.com/mem0ai/mem0/pull/5824))
+
+**Changes:**
+- **LLMs:** The Together default model is now `MiniMaxAI/MiniMax-M3` (was `mistralai/Mixtral-8x7B-Instruct-v0.1`) ([#6049](https://github.com/mem0ai/mem0/pull/6049))
+- **LLMs:** The xAI default model is now `grok-4.3` (was `grok-2-latest`) ([#6115](https://github.com/mem0ai/mem0/pull/6115))
+- **Embeddings:** The Together default embedding model is now `intfloat/multilingual-e5-large-instruct` at 1024 dimensions (was `togethercomputer/m2-bert-80M-8k-retrieval` at 768). If you use the Together embedder without pinning `model`, existing vectors were written at the old dimension: either re-embed them, or pin `model` and `embedding_dims` to the old values ([#5989](https://github.com/mem0ai/mem0/pull/5989))
+- **Rerankers:** The Cohere default rerank model is now `rerank-v3.5` (was `rerank-english-v3.0`) ([#6055](https://github.com/mem0ai/mem0/pull/6055))
+
+**Security:**
+- **Vector Stores:** Fix SQL and Cypher injection vulnerabilities in the PGVector, Azure MySQL, and Neptune providers ([#4878](https://github.com/mem0ai/mem0/pull/4878))
+- **Vector Stores:** Validate Elasticsearch filter keys and values to prevent term query injection ([#5980](https://github.com/mem0ai/mem0/pull/5980))
+- **Dependencies:** Require `transformers>=5.3.0` to remediate GHSA-29pf-2h5f-8g72 (CVE-2026-4372) ([#6110](https://github.com/mem0ai/mem0/pull/6110))
+
+</Update>
+
 <Update label="2026-07-01" description="v2.0.11">

 **Bug Fixes:**
@@ -1100,6 +1145,49 @@ See the [OSS v2 to v3 migration guide](https://docs.mem0.ai/migration/oss-v2-to-

 <Tab title="TypeScript">

+<Update label="2026-07-22" description="v3.1.1">
+
+**New Features:**
+- **Embeddings:** Add an AWS Bedrock embedding provider ([#6185](https://github.com/mem0ai/mem0/pull/6185))
+
+**Bug Fixes:**
+- **Packaging:** Finish the lazy-loading work started in v3.1.0. The remaining LLMs (Anthropic, Google, Groq, LangChain, Mistral, Ollama), embedders (Google, LangChain, Ollama, Vertex AI), vector stores (Azure AI Search, Azure MySQL, Baidu, LangChain, Qdrant, Redis, Supabase, Valkey, Vectorize), and the Supabase history store still imported their SDKs at module load, so importing `mem0ai/oss` required every provider package to be installed ([#6389](https://github.com/mem0ai/mem0/pull/6389))
+- **Vector Stores:** Convert Baidu Mochow's raw L2 distance into a similarity score in `search()` (`1 / (1 + distance)`), so closer matches rank higher instead of lower. A row the backend returns without a score is now left `undefined` instead of being treated as the closest match ([#6485](https://github.com/mem0ai/mem0/pull/6485))
+- **Memory (OSS):** Coerce non-string entity IDs (e.g. a numeric `user_id`) to strings instead of crashing on `.trim()` ([#6263](https://github.com/mem0ai/mem0/pull/6263))
+- **Memory (OSS):** Stop `update()` metadata from overwriting or injecting `user_id`, `agent_id`, `run_id`, or `actor_id` (in either snake_case or camelCase). These identity fields are immutable after creation, so passing them in `metadata` can no longer move a memory into a different tenant's scope ([#6343](https://github.com/mem0ai/mem0/pull/6343))
+- **Vector Stores:** Scope Pinecone `deleteCol()`/`reset()` to the configured namespace instead of deleting the whole index, so resetting a namespaced Pinecone store no longer wipes out the other namespaces sharing that index ([#6287](https://github.com/mem0ai/mem0/pull/6287))
+
+**Changes:**
+- **Client:** Remove the unused `retrievalCriteria` field from `PromptUpdatePayload`. It was accepted and forwarded but never affected retrieval, so removing it is not a behavior change ([#6313](https://github.com/mem0ai/mem0/pull/6313))
+
+</Update>
+
+<Update label="2026-07-13" description="v3.1.0">
+
+The largest provider release for the TypeScript OSS SDK so far: 17 new vector stores, 5 new LLM providers, 4 new embedders, and reranking support. Importing `mem0ai/oss` no longer pulls in any provider SDK, so you only install what you actually configure.
+
+**New Features:**
+- **Rerankers:** Add reranking to the OSS SDK with four providers (Cohere, ZeroEntropy, cross-encoder, and LLM-based), plus per-search rerank via a `rerank` option on `search()` ([#6055](https://github.com/mem0ai/mem0/pull/6055))
+- **Memory (OSS):** Accept `text` in `Memory.update()`. `data` still works but is now deprecated, so prefer `text` in new code ([#6044](https://github.com/mem0ai/mem0/pull/6044))
+- **Vector Stores:** Add Pinecone ([#5802](https://github.com/mem0ai/mem0/pull/5802)), Weaviate ([#5800](https://github.com/mem0ai/mem0/pull/5800)), Milvus ([#5889](https://github.com/mem0ai/mem0/pull/5889)), Chroma ([#6145](https://github.com/mem0ai/mem0/pull/6145)), MongoDB ([#5793](https://github.com/mem0ai/mem0/pull/5793)), Elasticsearch ([#5866](https://github.com/mem0ai/mem0/pull/5866)), and OpenSearch ([#5810](https://github.com/mem0ai/mem0/pull/5810))
+- **Vector Stores:** Add Databricks ([#5824](https://github.com/mem0ai/mem0/pull/5824)), AWS Neptune Analytics ([#5797](https://github.com/mem0ai/mem0/pull/5797)), S3 Vectors ([#5822](https://github.com/mem0ai/mem0/pull/5822)), Azure MySQL ([#5827](https://github.com/mem0ai/mem0/pull/5827)), and Google Vertex AI Vector Search ([#5791](https://github.com/mem0ai/mem0/pull/5791))
+- **Vector Stores:** Add Turbopuffer ([#5801](https://github.com/mem0ai/mem0/pull/5801)), Upstash Vector ([#5811](https://github.com/mem0ai/mem0/pull/5811)), Valkey ([#5826](https://github.com/mem0ai/mem0/pull/5826)), Cassandra ([#5823](https://github.com/mem0ai/mem0/pull/5823)), and Baidu Mochow ([#5790](https://github.com/mem0ai/mem0/pull/5790))
+- **LLMs:** Add AWS Bedrock ([#5890](https://github.com/mem0ai/mem0/pull/5890)), xAI Grok ([#6115](https://github.com/mem0ai/mem0/pull/6115)), Together ([#6049](https://github.com/mem0ai/mem0/pull/6049)), vLLM ([#5805](https://github.com/mem0ai/mem0/pull/5805)), and Sarvam ([#6130](https://github.com/mem0ai/mem0/pull/6130))
+- **Embeddings:** Add Vertex AI ([#5882](https://github.com/mem0ai/mem0/pull/5882)), HuggingFace ([#6027](https://github.com/mem0ai/mem0/pull/6027)), FastEmbed ([#5862](https://github.com/mem0ai/mem0/pull/5862)), and Together ([#5989](https://github.com/mem0ai/mem0/pull/5989))
+
+**Improvements:**
+- **Packaging:** Lazy-load optional provider SDKs so importing `mem0ai/oss` never requires them. Provider packages are now resolved on first use, so an app that only configures OpenAI and Qdrant does not need the other provider SDKs installed ([#6280](https://github.com/mem0ai/mem0/pull/6280))
+
+**Bug Fixes:**
+- **Memory (OSS):** Re-raise LLM extraction transport failures instead of returning `[]`, so a network error during extraction surfaces as an error rather than a silently empty result ([#6102](https://github.com/mem0ai/mem0/pull/6102))
+- **Vector Stores:** Prevent an unhandled promise rejection in the Supabase and Redis constructors ([#6111](https://github.com/mem0ai/mem0/pull/6111))
+- **Client:** Encode dynamic URL path segments so IDs containing special characters no longer produce malformed requests ([#5963](https://github.com/mem0ai/mem0/pull/5963))
+
+**Security:**
+- **Dependencies:** Patch the `fast-xml-parser` and `tar` transitive CVEs ([#6160](https://github.com/mem0ai/mem0/pull/6160))
+
+</Update>
+
 <Update label="2026-07-01" description="v3.0.13">

 **Bug Fixes:**
@@ -1606,6 +1694,13 @@ See the [TypeScript SDK migration guide](https://docs.mem0.ai/migration/ts-v2-to

 <Tab title="CLI">

+<Update label="2026-07-13" description="Python v0.2.10 / Node v0.2.11">
+
+**Bug Fixes:**
+- **Platform backend:** Encode dynamic URL path segments so memory and entity IDs containing special characters no longer produce malformed requests (Python and Node [#5963](https://github.com/mem0ai/mem0/pull/5963))
+
+</Update>
+
 <Update label="2026-07-01" description="Python v0.2.9 / Node v0.2.10">

 **Bug Fixes:**
@@ -1764,6 +1859,15 @@ A full-featured command-line interface for Mem0, available in both Python and No
 <Tabs>
 <Tab title="Mem0 Plugin">

+<Update label="2026-07-14" description="mem0-plugin v0.2.13">
+
+**Fixes:**
+- **Assistant messages no longer stored as your own:** The session-summary hook (fires at the end of every assistant turn) and the post-compaction hook were sending the assistant's own message to Mem0 tagged `role: "user"`. Because Mem0 extracts *facts about the user* from each message and uses `role` to decide who spoke, the assistant's first-person prose was being saved as the human's stated preferences — "I recommend we drop Redis" became `User prefers dropping Redis entirely`. Both hooks now send `role: "assistant"`, so the same session is stored as `Assistant recommended...`. Affects Claude Code, Cursor, Codex, and Antigravity, which share these hooks.
+
+Existing memories written by the previous versions are not rewritten. If your memories contain preferences you never expressed, delete them — the plugin will not recreate them.
+
+</Update>
+
 <Update label="2026-06-30" description="mem0-plugin v0.2.12">

 **New Features:**
@@ -2014,6 +2118,13 @@ Initial release of the Mem0 plugin for Claude Code and Cursor, followed by Codex

 <Tab title="OpenCode">

+<Update label="2026-07-22" description="OpenCode plugin v0.2.2">
+
+**Fixes:**
+- **Shell-profile API key recovery:** When `MEM0_API_KEY` isn't set in the process environment, the plugin now falls back to reading it from `.zshrc`, `.bashrc`, `.zprofile`, `.bash_profile`, or `.profile`, fixing startup failures on clients (e.g. Desktop) that launch without shell-exported environment variables.
+
+</Update>
+
 <Update label="2026-06-30" description="OpenCode plugin v0.2.1">

 **Improvements:**
@@ -2087,6 +2198,15 @@ Initial release of the Mem0 plugin for Claude Code and Cursor, followed by Codex

 <Tab title="Antigravity">

+<Update label="2026-07-14" description="Antigravity plugin v0.1.5">
+
+**Fixes:**
+- **Assistant messages no longer stored as your own:** The session-summary hook (fires at the end of every assistant turn) and the post-compaction hook were sending the assistant's own message to Mem0 tagged `role: "user"`. Because Mem0 extracts *facts about the user* from each message and uses `role` to decide who spoke, the assistant's first-person prose was being saved as the human's stated preferences — "I recommend we drop Redis" became `User prefers dropping Redis entirely`. Both hooks now send `role: "assistant"`, so the same session is stored as `Assistant recommended...`.
+
+Existing memories written by the previous versions are not rewritten. If your memories contain preferences you never expressed, delete them — the plugin will not recreate them.
+
+</Update>
+
 <Update label="2026-06-30" description="Antigravity plugin v0.1.4">

 **New Features:**
@@ -3,11 +3,27 @@ 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.
+To use AWS Bedrock embedding models, you need the appropriate AWS credentials and permissions. Python uses `boto3`, and TypeScript uses `@aws-sdk/client-bedrock-runtime`.
+
+Both SDKs support the Amazon Titan and Cohere embedding model families.

 ### Setup
- Ensure you have model access from the [AWS Bedrock Console](https://us-east-1.console.aws.amazon.com/bedrock/home?region=us-east-1#/modelaccess)
- Authenticate the boto3 client using a method described in the [AWS documentation](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html)
+
+- Model access is automatic: Bedrock enables serverless foundation models on first invocation in AWS commercial regions, and the [Model access page has been retired](https://docs.aws.amazon.com/bedrock/latest/userguide/model-access.html). Cohere models are served from AWS Marketplace, so an account's first invocation must come from a principal with the `aws-marketplace:Subscribe` permission; after that, any user in the account can invoke them. Browse the models available to you in the [Bedrock model catalog](https://console.aws.amazon.com/bedrock/).
+- Install the AWS client for your language:
+
+  <CodeGroup>
+  ```bash Python
+  pip install boto3
+  ```
+
+  ```bash TypeScript
+  npm install @aws-sdk/client-bedrock-runtime
+  ```
+  </CodeGroup>
+
+  In TypeScript this package is an optional peer dependency, so it is only required when you actually use the Bedrock embedder.
+
 - Set up environment variables for authentication:
  ```bash
  export AWS_REGION=us-east-1
@@ -15,6 +31,8 @@ To use AWS Bedrock embedding models, you need to have the appropriate AWS creden
  export AWS_SECRET_ACCESS_KEY=your-secret-key
  ```

+Both SDKs fall back to the standard AWS credential chain (environment variables, shared config, SSO, or an instance role) when you do not pass credentials in the config, so you rarely need to hardcode keys. See the [boto3 credentials guide](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html) for the Python resolution order.
+
 ### Usage

 <CodeGroup>
@@ -48,8 +66,46 @@ messages = [
 ]
 m.add(messages, user_id="alice")
 ```
+
+```typescript TypeScript
+import { Memory } from "mem0ai/oss";
+
+// Credentials are read from the AWS default chain (AWS_REGION,
+// AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, SSO, or an instance role).
+const memory = new Memory({
+  embedder: {
+    provider: "aws_bedrock",
+    config: {
+      model: "amazon.titan-embed-text-v2:0",
+      awsRegion: "us-west-2",
+    },
+  },
+});
+
+const messages = [
+  { role: "user", content: "I'm planning to watch a movie tonight. Any recommendations?" },
+  { role: "assistant", content: "How about thriller movies? They can be quite engaging." },
+  { role: "user", content: "I'm not a big fan of thriller movies but I love sci-fi movies." },
+  { role: "assistant", content: "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future." },
+];
+await memory.add(messages, { userId: "alice" });
+```
 </CodeGroup>

+### Choosing a model
+
+| Model | Notes |
+| --- | --- |
+| `amazon.titan-embed-text-v1` | Default. Fixed 1536-dimension output. |
+| `amazon.titan-embed-text-v2:0` | Supports a configurable output size of 256, 512, or 1024. |
+| `cohere.embed-english-v3` | English text. Embeds up to 96 texts per request. |
+| `cohere.embed-multilingual-v3` | Multilingual text. Embeds up to 96 texts per request. |
+| `cohere.embed-v4:0` | Text. Embeds up to 96 texts per request. Supports a configurable output size of 256, 512, 1024, or 1536. TypeScript only. |
+
+Custom output sizes are model specific. In Python, only Titan Text Embeddings V2 accepts one. In TypeScript, Titan Text Embeddings V2 and Cohere Embed v4 both do, and `embeddingDims` is ignored on Titan V1 and on Cohere v3, which have no such parameter. When you do set it, make sure your vector store dimension matches, otherwise inserts will fail.
+
+Bedrock caps a Cohere embedding call at 96 texts. The TypeScript SDK splits larger batches into multiple requests for you, so a 200 text batch becomes 3 calls.
+
 ### Config

 Here are the parameters available for configuring AWS Bedrock embedder:
@@ -64,4 +120,16 @@ Here are the parameters available for configuring AWS Bedrock embedder:
 | `aws_secret_access_key` | AWS secret access key for authentication | `None` |
 | `aws_session_token` | AWS session token for temporary credentials | `None` |
 </Tab>
+<Tab title="TypeScript">
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `model` | The name of the embedding model to use | `amazon.titan-embed-text-v1` |
+| `awsRegion` | AWS region for the Bedrock client. Falls back to the `AWS_REGION` environment variable | `us-west-2` |
+| `embeddingDims` | Output vector size. Titan Text Embeddings V2 (256, 512, or 1024) and Cohere Embed v4 (256, 512, 1024, or 1536) only | `undefined` |
+| `awsAccessKeyId` | AWS access key ID for authentication | `undefined` |
+| `awsSecretAccessKey` | AWS secret access key for authentication | `undefined` |
+| `awsSessionToken` | AWS session token for temporary credentials | `undefined` |
+
+Omit the three credential fields to use the AWS default credential chain. If you do pass them, `awsAccessKeyId` and `awsSecretAccessKey` are both required.
+</Tab>
 </Tabs>
@@ -3,7 +3,7 @@ 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.
+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 Portal.

 ### Usage

@@ -7,10 +7,18 @@ You can use FastEmbed to run embedding models locally in Mem0. FastEmbed is an O

 ### Installation

-```bash
+FastEmbed is an optional dependency, so install it alongside Mem0.
+
+<CodeGroup>
+```bash Python
 pip install fastembed
 ```

+```bash TypeScript
+npm install fastembed
+```
+</CodeGroup>
+
 ### Usage

 <CodeGroup>
@@ -38,13 +46,66 @@ messages = [
 ]
 m.add(messages, user_id="john")
 ```
+
+```typescript TypeScript
+import { Memory } from "mem0ai/oss";
+
+// FastEmbed needs no API key. Leave the embedder config empty to use the
+// default model (fast-bge-small-en-v1.5), or set `model` to one of the
+// supported models listed below.
+const memory = new Memory({
+  embedder: {
+    provider: "fastembed",
+    config: {
+      model: "fast-bge-small-en-v1.5",
+    },
+  },
+  llm: {
+    provider: "openai",
+    config: { apiKey: process.env.OPENAI_API_KEY }, // For fact extraction
+  },
+});
+
+const messages = [
+  { role: "user", content: "I'm planning to watch a movie tonight. Any recommendations?" },
+  { role: "assistant", content: "How about thriller movies? They can be quite engaging." },
+  { role: "user", content: "I'm not a big fan of thriller movies but I love sci-fi movies." },
+  { role: "assistant", content: "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future." },
+];
+await memory.add(messages, { userId: "john" });
+```
 </CodeGroup>

+<Note>
+  **The Python and TypeScript SDKs default to different models.** Python defaults to `thenlper/gte-large` (1024 dimensions), while TypeScript defaults to `fast-bge-small-en-v1.5` (384 dimensions). The TypeScript package (`fastembed` on npm) ships a fixed set of ONNX models and does not include `thenlper/gte-large`. Because the two defaults produce vectors of different dimensions, do not point both SDKs at the same vector store collection unless you configure them to use the same model.
+</Note>
+
+The TypeScript SDK supports these FastEmbed models. Pass the exact string as `model`:
+
+- `fast-bge-small-en-v1.5` (default)
+- `fast-bge-small-en`
+- `fast-bge-base-en`
+- `fast-bge-base-en-v1.5`
+- `fast-bge-small-zh-v1.5`
+- `fast-all-MiniLM-L6-v2`
+- `fast-multilingual-e5-large`
+
 ### Config

-Here are the parameters available for configuring FastEmbed embedder:
+Here are the parameters available for configuring the FastEmbed embedder:

+<Tabs>
+<Tab title="Python">
 | Parameter | Description | Default Value |
 | --- | --- | --- |
 | `model` | The name of the FastEmbed model to use | `thenlper/gte-large` |
 | `embedding_dims` | Dimensions of the embedding model (auto-derived from the model if not set) | `None` |
+</Tab>
+<Tab title="TypeScript">
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `model` | The FastEmbed model to use (see the supported list above) | `fast-bge-small-en-v1.5` |
+
+The embedding dimension is detected automatically at startup, so you do not need to set it manually.
+</Tab>
+</Tabs>
@@ -5,6 +5,10 @@ description: "Configure Hugging Face as an embedding provider in Mem0 for local

 You can use embedding models from Huggingface to run Mem0 locally.

+<Note>
+The TypeScript SDK supports Hugging Face only through a hosted [Text Embeddings Inference (TEI)](#using-text-embeddings-inference-tei) endpoint, or any OpenAI-compatible Hugging Face endpoint. The local `sentence-transformers` mode shown first is Python-only.
+</Note>
+
 ### Usage

 ```python
@@ -34,9 +38,10 @@ m.add(messages, user_id="john")

 ### Using Text Embeddings Inference (TEI)

-You can also use Hugging Face's Text Embeddings Inference service for faster and more efficient embeddings:
+You can also use Hugging Face's Text Embeddings Inference service for faster and more efficient embeddings. This is the mode the TypeScript SDK uses.

-```python
+<CodeGroup>
+```python Python
 import os
 from mem0 import Memory

@@ -56,6 +61,24 @@ m = Memory.from_config(config)
 m.add("This text will be embedded using the TEI service.", user_id="john")
 ```

+```typescript TypeScript
+import { Memory } from 'mem0ai/oss';
+
+// Point at a running TEI server, or any OpenAI-compatible HF endpoint
+const config = {
+  embedder: {
+    provider: 'huggingface',
+    config: {
+      huggingfaceBaseUrl: 'http://localhost:3000/v1',
+    },
+  },
+};
+
+const memory = new Memory(config);
+await memory.add("This text will be embedded using the TEI service.", { userId: "john" });
+```
+</CodeGroup>
+
 To run the TEI service, you can use Docker:

 ```bash
@@ -66,11 +89,22 @@ docker run -d -p 3000:80 -v huggingfacetei:/data --platform linux/amd64 \

 ### Config

-Here are the parameters available for configuring Huggingface embedder:
+Here are the parameters available for configuring the Hugging Face embedder:

+<Tabs>
+<Tab title="Python">
 | Parameter | Description | Default Value |
 | --- | --- | --- |
 | `model` | The name of the model to use | `multi-qa-MiniLM-L6-cos-v1` |
 | `embedding_dims` | Dimensions of the embedding model | `selected_model_dimensions` |
 | `model_kwargs` | Additional arguments for the model | `None` |
-| `huggingface_base_url` | URL to connect to Text Embeddings Inference (TEI) API | `None` |
+| `huggingface_base_url` | URL to connect to Text Embeddings Inference (TEI) API | `None` |
+</Tab>
+<Tab title="TypeScript">
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `huggingfaceBaseUrl` | TEI or OpenAI-compatible endpoint URL. Required; falls back to `baseURL`, `url`, then the `HUGGINGFACE_BASE_URL` env var | `None` |
+| `model` | Model name sent to the endpoint (TEI ignores it) | `tei` |
+| `apiKey` | API key for the endpoint; falls back to the `HUGGINGFACE_API_KEY` env var | `"hf"` |
+</Tab>
+</Tabs>
@@ -1,15 +1,20 @@
 ---
 title: Together
-description: "Configure Together AI as an embedding provider in Mem0 with support for 768-dimensional embedding models."
+description: "Configure Together AI as an embedding provider in Mem0 with support for 1024-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).
+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.ai/settings/projects/~current/api-keys).

 ### Usage

-<Note> The `embedding_model_dims` parameter for `vector_store` should be set to `768` for Together embedder. </Note>
+<Note> The `embedding_model_dims` parameter for `vector_store` should be set to `1024` for Together embedder. </Note>

-```python
+<Warning>
+**Breaking default change.** The default Together embedding model is now `intfloat/multilingual-e5-large-instruct` (**1024-dim**), replacing the previous default `togethercomputer/m2-bert-80M-8k-retrieval` (**768-dim**). If you created a self-hosted vector store with the old default, its collection is 768-dim and will reject the new 1024-dim vectors **recreate/reindex the collection at 1024 dimensions** after upgrading. To defer the change, pin the previous values explicitly (`model="togethercomputer/m2-bert-80M-8k-retrieval"`, `embedding_dims=768`) note Together no longer lists this model among its recommended embeddings, so reindexing at 1024 is the durable path.
+</Warning>
+
+<CodeGroup>
+```python Python
 import os
 from mem0 import Memory

@@ -20,7 +25,7 @@ config = {
    "embedder": {
        "provider": "together",
        "config": {
-            "model": "togethercomputer/m2-bert-80M-8k-retrieval"
+            "model": "intfloat/multilingual-e5-large-instruct"
        }
    }
 }
@@ -29,18 +34,50 @@ 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": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]
 m.add(messages, user_id="john")
 ```

+```typescript TypeScript
+import { Memory } from 'mem0ai/oss';
+
+const config = {
+  embedder: {
+    provider: 'together',
+    config: {
+      apiKey: process.env.TOGETHER_API_KEY || '',
+      model: 'intfloat/multilingual-e5-large-instruct',
+      embeddingDims: 1024,
+    },
+  },
+};
+
+const memory = new Memory(config);
+await memory.add("I'm visiting Paris", { userId: "john" });
+```
+
+</CodeGroup>
+
 ### Config

 Here are the parameters available for configuring Together embedder:

+<Tabs>
+<Tab title="Python">
 | Parameter | Description | Default Value |
 | --- | --- | --- |
-| `model` | The name of the embedding model to use | `togethercomputer/m2-bert-80M-8k-retrieval` |
-| `embedding_dims` | Dimensions of the embedding model | `768` |
+| `model` | The name of the embedding model to use | `intfloat/multilingual-e5-large-instruct` |
+| `embedding_dims` | Dimensions of the embedding model | `1024` |
 | `api_key` | The Together API key | `None` |
+</Tab>
+<Tab title="TypeScript">
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `model` | The name of the embedding model to use | `intfloat/multilingual-e5-large-instruct` |
+| `embeddingDims` | Dimensions of the embedding model for vector store configuration | `1024` |
+| `apiKey` | The Together API key | `TOGETHER_API_KEY` |
+| `baseURL` | Base URL for an OpenAI-compatible Together endpoint | `https://api.together.ai/v1` |
+</Tab>
+</Tabs>
@@ -4,11 +4,36 @@ description: "Configure Google Cloud Vertex AI as an embedding provider in Mem0
 ---
 ### 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/).
+Google Cloud's Vertex AI serves text embedding models such as `gemini-embedding-001`. Mem0 uses them through the provider's own SDK, which you install alongside Mem0.
+
+### Installation
+
+The Vertex AI client is an optional dependency, so install it yourself.
+
+<CodeGroup>
+```bash Python
+pip install vertexai
+```
+
+```bash TypeScript
+npm install @google-cloud/aiplatform
+```
+</CodeGroup>
+
+### Authentication
+
+Both SDKs authenticate with [Application Default Credentials](https://cloud.google.com/docs/authentication/application-default-credentials). Pick whichever fits your environment:
+
+- **Local development:** run `gcloud auth application-default login`.
+- **Service account:** create a key in the [Google Cloud Console](https://console.cloud.google.com/) and point `GOOGLE_APPLICATION_CREDENTIALS` at the JSON file, or pass its path through the embedder config.
+- **Google Cloud runtimes** (Cloud Run, GKE, Compute Engine): the attached service account is picked up automatically.
+
+The TypeScript SDK reads the project ID from `googleProjectId`, then the `GCP_PROJECT_ID`, `GOOGLE_CLOUD_PROJECT`, and `GCLOUD_PROJECT` environment variables, and finally from your credentials. Set it explicitly when your credentials cover more than one project.

 ### Usage

-```python
+<CodeGroup>
+```python Python
 import os
 from mem0 import Memory

@@ -32,28 +57,87 @@ 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": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]
 m.add(messages, user_id="john")
 ```
-The embedding types can be one of the following:
+
+```typescript TypeScript
+import { Memory } from "mem0ai/oss";
+
+const config = {
+  embedder: {
+    provider: "vertexai",
+    config: {
+      model: "gemini-embedding-001",
+      // Optional. Falls back to GCP_PROJECT_ID / GOOGLE_CLOUD_PROJECT /
+      // GCLOUD_PROJECT, then to the project on your credentials.
+      googleProjectId: process.env.GCP_PROJECT_ID,
+      location: "us-central1",
+      // Optional. Path to a service account key file, or pass the JSON inline
+      // via googleServiceAccountJson.
+      vertexCredentialsJson: "/path/to/your/credentials.json",
+      embeddingDims: 256,
+      memoryAddEmbeddingType: "RETRIEVAL_DOCUMENT",
+      memoryUpdateEmbeddingType: "RETRIEVAL_DOCUMENT",
+      memorySearchEmbeddingType: "RETRIEVAL_QUERY",
+    },
+  },
+};
+
+const memory = new Memory(config);
+await memory.add("I love sci-fi movies but not thrillers", { userId: "john" });
+```
+</CodeGroup>
+
+### Embedding types
+
+Vertex AI embeds the same text differently depending on the task you declare. The embedding types can be one of the following:
 - SEMANTIC_SIMILARITY
 - CLASSIFICATION
 - CLUSTERING
 - RETRIEVAL_DOCUMENT, RETRIEVAL_QUERY, QUESTION_ANSWERING, FACT_VERIFICATION
- CODE_RETRIEVAL_QUERY  
-Check out the [Vertex AI documentation](https://cloud.google.com/vertex-ai/generative-ai/docs/embeddings/task-types#supported_task_types) for more information.  
-  
+- CODE_RETRIEVAL_QUERY
+
+Check out the [Vertex AI documentation](https://cloud.google.com/vertex-ai/generative-ai/docs/embeddings/task-types#supported_task_types) for more information.
+
+<Note>
+These embedding types map to the add, update, and search memory actions in both the Python and TypeScript SDKs. Stored memories use the add or update type, and searches use the search type.
+</Note>
+
+### Choosing a model
+
+<Warning>
+`gemini-embedding-001` accepts **one input text per request**. When Mem0 embeds several texts at once, such as the memories extracted from a single conversation turn, it issues one request per text. The older `text-embedding-005` and `text-multilingual-embedding-002` models accept up to 250 texts per request, so they are faster and cheaper for large batches. See [Get text embeddings](https://cloud.google.com/vertex-ai/generative-ai/docs/embeddings/get-text-embeddings).
+</Warning>
+
 ### Config

 Here are the parameters available for configuring the Vertex AI embedder:

-| Parameter                 | Description                                      | Default Value        |
-| ------------------------- | ------------------------------------------------ | -------------------- |
-| `model`                   | The name of the Vertex AI embedding model to use | `gemini-embedding-001` |
-| `vertex_credentials_json` | Path to the Google Cloud credentials JSON file   | `None`               |
-| `embedding_dims`          | Dimensions of the embedding model                | `256`                |
-| `memory_add_embedding_type` | The type of embedding to use for the add memory action | `RETRIEVAL_DOCUMENT` |
-| `memory_update_embedding_type` | The type of embedding to use for the update memory action | `RETRIEVAL_DOCUMENT` |
-| `memory_search_embedding_type` | The type of embedding to use for the search memory action | `RETRIEVAL_QUERY` |
+<Tabs>
+<Tab title="Python">
+| Parameter                        | Description                                                | Default Value          |
+| -------------------------------- | ---------------------------------------------------------- | ---------------------- |
+| `model`                          | The name of the Vertex AI embedding model to use           | `gemini-embedding-001` |
+| `vertex_credentials_json`        | Path to the Google Cloud credentials JSON file             | `None`                 |
+| `embedding_dims`                 | Dimensions of the embedding model                          | `256`                  |
+| `memory_add_embedding_type`      | The embedding type to use for the add memory action        | `RETRIEVAL_DOCUMENT`   |
+| `memory_update_embedding_type`   | The embedding type to use for the update memory action     | `RETRIEVAL_DOCUMENT`   |
+| `memory_search_embedding_type`   | The embedding type to use for the search memory action     | `RETRIEVAL_QUERY`      |
+</Tab>
+<Tab title="TypeScript">
+| Parameter                     | Description                                                                 | Default Value          |
+| ----------------------------- | -------------------------------------------------------------------------- | ---------------------- |
+| `model`                       | The name of the Vertex AI embedding model to use                           | `gemini-embedding-001` |
+| `googleProjectId`             | Google Cloud project ID (falls back to `GCP_PROJECT_ID` env var, then to your credentials) | Resolved from credentials |
+| `location`                    | Google Cloud region (falls back to `GCP_LOCATION` env var)                 | `us-central1`          |
+| `vertexCredentialsJson`       | Path to the Google Cloud credentials JSON file                             | `None`                 |
+| `googleServiceAccountJson`    | Service account credentials as a JSON string or object                     | `None`                 |
+| `embeddingDims`               | Dimensions of the embedding model                                          | `256`                  |
+| `memoryAddEmbeddingType`      | The embedding type to use for the add memory action                        | `RETRIEVAL_DOCUMENT`   |
+| `memoryUpdateEmbeddingType`   | The embedding type to use for the update memory action                     | `RETRIEVAL_DOCUMENT`   |
+| `memorySearchEmbeddingType`   | The embedding type to use for the search memory action                     | `RETRIEVAL_QUERY`      |
+</Tab>
+</Tabs>
@@ -10,21 +10,21 @@ Mem0 offers support for various embedding models, allowing users to choose the o
 See the list of supported embedders below.

 <Note>
-  All embedders listed below are supported in the Python implementation. The TypeScript implementation supports: **OpenAI**, **Azure OpenAI**, **Google AI**, **Langchain**, **LM Studio**, and **Ollama**.
+  All embedders listed below are supported in the Python implementation. The TypeScript implementation supports: **OpenAI**, **Azure OpenAI**, **AWS Bedrock**, **FastEmbed**, **Google AI**, **Hugging Face**, **Langchain**, **LM Studio**, **Ollama**, **Together**, and **Vertex AI**.
 </Note>

 <CardGroup cols={4}>
-  <Card title="OpenAI" href="/components/embedders/models/openai"></Card>
-  <Card title="Azure OpenAI" href="/components/embedders/models/azure_openai"></Card>
-  <Card title="Ollama" href="/components/embedders/models/ollama"></Card>
-  <Card title="Hugging Face" href="/components/embedders/models/huggingface"></Card>
-  <Card title="Google AI" href="/components/embedders/models/google_AI"></Card>
-  <Card title="Vertex AI" href="/components/embedders/models/vertexai"></Card>
-  <Card title="Together" href="/components/embedders/models/together"></Card>
-  <Card title="LM Studio" href="/components/embedders/models/lmstudio"></Card>
-  <Card title="Langchain" href="/components/embedders/models/langchain"></Card>
-  <Card title="AWS Bedrock" href="/components/embedders/models/aws_bedrock"></Card>
-  <Card title="FastEmbed" href="/components/embedders/models/fastembed"></Card>
+  <Card title="OpenAI" icon="/images/provider-icons/openai.svg" href="/components/embedders/models/openai"></Card>
+  <Card title="Azure OpenAI" icon="/images/provider-icons/azure-color.svg" href="/components/embedders/models/azure_openai"></Card>
+  <Card title="Ollama" icon="/images/provider-icons/ollama.svg" href="/components/embedders/models/ollama"></Card>
+  <Card title="Hugging Face" icon="/images/provider-icons/huggingface.svg" href="/components/embedders/models/huggingface"></Card>
+  <Card title="Google AI" icon="/images/provider-icons/google-color.svg" href="/components/embedders/models/google_AI"></Card>
+  <Card title="Vertex AI" icon="/images/provider-icons/vertexai.svg" href="/components/embedders/models/vertexai"></Card>
+  <Card title="Together" icon="/images/provider-icons/together-color.svg" href="/components/embedders/models/together"></Card>
+  <Card title="LM Studio" icon="/images/provider-icons/lmstudio.svg" href="/components/embedders/models/lmstudio"></Card>
+  <Card title="Langchain" icon="/images/provider-icons/langchain-color.svg" href="/components/embedders/models/langchain"></Card>
+  <Card title="AWS Bedrock" icon="/images/provider-icons/bedrock-color.svg" href="/components/embedders/models/aws_bedrock"></Card>
+  <Card title="FastEmbed" icon="/images/provider-icons/qdrant.svg" href="/components/embedders/models/fastembed"></Card>
 </CardGroup>

 ## Usage
@@ -5,16 +5,18 @@ description: "Configure AWS Bedrock as an LLM provider in Mem0 with IAM authenti

 ### Setup
 - Before using the AWS Bedrock LLM, make sure you have the appropriate model access from [Bedrock Console](https://us-east-1.console.aws.amazon.com/bedrock/home?region=us-east-1#/modelaccess).
- You will also need to authenticate the `boto3` client by using a method in the [AWS documentation](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html#configuring-credentials)
- You will have to export `AWS_REGION`, `AWS_ACCESS_KEY_ID`, and `AWS_SECRET_ACCESS_KEY` to set environment variables.
+- Model availability is per-region. `anthropic.claude-sonnet-4-20250514-v1:0` supports on-demand inference in `us-east-1` and `ap-southeast-4`; from any other region, use the cross-region inference profile ID `us.anthropic.claude-sonnet-4-20250514-v1:0` instead.
+- Install the AWS SDK for your language: `pip install boto3` (Python) or `npm install @aws-sdk/client-bedrock-runtime` (TypeScript).
+- Both SDKs fall back to the standard AWS credential chain (environment variables, `~/.aws/credentials`, or an attached IAM role), so exporting `AWS_REGION`, `AWS_ACCESS_KEY_ID`, and `AWS_SECRET_ACCESS_KEY` is the quickest way to get started. In TypeScript you can also pass credentials inline with `awsRegion`, `awsAccessKeyId`, `awsSecretAccessKey`, and `awsSessionToken`, as shown below.

 ### Usage

-```python
+<CodeGroup>
+```python Python
 import os
 from mem0 import Memory

-os.environ['AWS_REGION'] = 'us-west-2'
+os.environ['AWS_REGION'] = 'us-east-1'
 os.environ["AWS_ACCESS_KEY_ID"] = "xx"
 os.environ["AWS_SECRET_ACCESS_KEY"] = "xx"

@@ -22,7 +24,7 @@ config = {
    "llm": {
        "provider": "aws_bedrock",
        "config": {
-            "model": "anthropic.claude-3-5-haiku-20241022-v1:0",
+            "model": "anthropic.claude-sonnet-4-20250514-v1:0",
            "temperature": 0.2,
            "max_tokens": 2000,
        }
@@ -39,6 +41,43 @@ messages = [
 m.add(messages, user_id="alice", metadata={"category": "movies"})
 ```

+```typescript TypeScript
+import { Memory } from 'mem0ai/oss';
+
+const config = {
+  llm: {
+    provider: 'aws_bedrock',
+    config: {
+      model: 'anthropic.claude-sonnet-4-20250514-v1:0',
+      temperature: 0.2,
+      maxTokens: 2000,
+      // Optional. Omit these to use the default AWS credential chain.
+      awsRegion: process.env.AWS_REGION,
+      awsAccessKeyId: process.env.AWS_ACCESS_KEY_ID,
+      awsSecretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+    },
+  },
+};
+
+const memory = new Memory(config);
+const messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+];
+await memory.add(messages, { userId: 'alice', metadata: { category: 'movies' } });
+```
+</CodeGroup>
+
+<Note>
+  `@aws-sdk/client-bedrock-runtime` is an optional peer dependency of `mem0ai`, so npm will not install it for you. The TypeScript provider loads it lazily and throws a clear error on the first request if the package is missing.
+</Note>
+
+<Note>
+  The TypeScript provider calls the Bedrock [Converse API](https://docs.aws.amazon.com/bedrock/latest/userguide/conversation-inference.html), a single uniform interface across the current Bedrock model families. Streaming and `InvokeModel`-only models are not supported yet.
+</Note>
+
 ### Config

-All available parameters for the `aws_bedrock` config are present in [Master List of All Params in Config](../config).
+All available parameters for the `aws_bedrock` config are present in [Master List of All Params in Config](../config).
@@ -5,7 +5,7 @@ description: "Configure Azure OpenAI as an LLM provider in Mem0 with Azure Ident

 <Note> Mem0 Now Supports Azure OpenAI Models in TypeScript SDK </Note>

-To use Azure OpenAI models, you have to set the `LLM_AZURE_OPENAI_API_KEY`, `LLM_AZURE_ENDPOINT`, `LLM_AZURE_DEPLOYMENT` and `LLM_AZURE_API_VERSION` environment variables. You can obtain the Azure API key from the [Azure](https://azure.microsoft.com/).
+To use Azure OpenAI models, you have to set the `LLM_AZURE_OPENAI_API_KEY`, `LLM_AZURE_ENDPOINT`, `LLM_AZURE_DEPLOYMENT` and `LLM_AZURE_API_VERSION` environment variables. You can obtain the Azure API key from the [Azure Portal](https://azure.microsoft.com/).

 Optionally, you can use Azure Identity to authenticate with Azure OpenAI, which allows you to use managed identities or service principals for production and Azure CLI login for development instead of an API key. If an Azure Identity is to be used, ***do not*** set the `LLM_AZURE_OPENAI_API_KEY` environment variable or the api_key in the config dictionary.

@@ -9,7 +9,8 @@ To use Sarvam AI's models, please set the `SARVAM_API_KEY` which you can get fro

 ## Usage

-```python
+<CodeGroup>
+```python Python
 import os
 from mem0 import Memory

@@ -34,8 +35,35 @@ messages = [
    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]
 m.add(messages, user_id="alex")
+
 ```

+```typescript TypeScript
+import { Memory } from 'mem0ai/oss';
+
+const config = {
+  llm: {
+    provider: 'sarvam',
+    config: {
+      apiKey: process.env.SARVAM_API_KEY || '',
+      model: 'sarvam-m',
+      temperature: 0.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": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+];
+await memory.add(messages, { userId: 'alex' });
+```
+
+</CodeGroup>
+
 ## Advanced Usage with Sarvam-Specific Features

 ```python
@@ -1,13 +1,15 @@
 ---
 title: Together
-description: "Configure Together AI as an LLM provider in Mem0 with API key setup and Mixtral model configuration."
+description: "Configure Together AI as an LLM provider in Mem0 with API key setup and optional custom endpoint 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 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.ai/settings/projects/~current/api-keys).
+In the TypeScript SDK, you can optionally set `TOGETHER_API_BASE` or pass `baseURL` in the config (defaults to `https://api.together.ai/v1`).

 ## Usage

-```python
+<CodeGroup>
+```python Python
 import os
 from mem0 import Memory

@@ -18,7 +20,7 @@ config = {
    "llm": {
        "provider": "together",
        "config": {
-            "model": "mistralai/Mixtral-8x7B-Instruct-v0.1",
+            "model": "MiniMaxAI/MiniMax-M3",
            "temperature": 0.2,
            "max_tokens": 2000,
        }
@@ -29,12 +31,68 @@ 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": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]
 m.add(messages, user_id="alice", metadata={"category": "movies"})
 ```

+```typescript TypeScript
+import { Memory } from 'mem0ai/oss';
+
+const config = {
+  llm: {
+    provider: 'together',
+    config: {
+      apiKey: process.env.TOGETHER_API_KEY || '',
+      model: 'MiniMaxAI/MiniMax-M3',
+      temperature: 0.2,
+      maxTokens: 2000,
+    },
+  },
+};
+
+const memory = new Memory(config);
+const messages = [
+  { role: "user", content: "I'm planning to watch a movie tonight. Any recommendations?" },
+  { role: "assistant", content: "How about thriller movies? They can be quite engaging." },
+  { role: "user", content: "I'm not a big fan of thriller movies but I love sci-fi movies." },
+  { role: "assistant", content: "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future." },
+];
+await memory.add(messages, { userId: 'alice', metadata: { category: 'movies' } });
+```
+</CodeGroup>
+
+You can also configure the API base URL in the config:
+
+<CodeGroup>
+```python Python
+config = {
+    "llm": {
+        "provider": "together",
+        "config": {
+            "model": "MiniMaxAI/MiniMax-M3",
+            "api_key": "your-api-key"
+        }
+    }
+}
+```
+
+```typescript TypeScript
+const config = {
+  llm: {
+    provider: "together",
+    config: {
+      model: "MiniMaxAI/MiniMax-M3",
+      baseURL: "https://api.together.ai/v1",
+      apiKey: "your-api-key",
+    },
+  },
+};
+```
+
+</CodeGroup>
+
 ## Config

-All available parameters for the `together` config are present in [Master List of All Params in Config](../config).
+All available parameters for the `together` config are present in [Master List of All Params in Config](../config).
@@ -25,7 +25,8 @@ description: "Configure vLLM as an LLM provider in Mem0 for high-performance loc

 ## Usage

-```python
+<CodeGroup>
+```python Python
 import os
 from mem0 import Memory

@@ -53,6 +54,46 @@ messages = [
 m.add(messages, user_id="alice", metadata={"category": "movies"})
 ```

+```typescript TypeScript
+import { Memory } from "mem0ai/oss";
+
+const config = {
+  llm: {
+    provider: "vllm",
+    config: {
+      model: "Qwen/Qwen2.5-32B-Instruct",
+      baseURL: "http://localhost:8000/v1",
+      apiKey: process.env.VLLM_API_KEY || "vllm-api-key",
+      temperature: 0.1,
+      maxTokens: 2000,
+    },
+  },
+};
+
+const memory = new Memory(config);
+const messages = [
+  {
+    role: "user",
+    content: "I'm planning to watch a movie tonight. Any recommendations?",
+  },
+  {
+    role: "assistant",
+    content: "How about thriller movies? They can be quite engaging.",
+  },
+  {
+    role: "user",
+    content: "I'm not a big fan of thrillers, but I love sci-fi movies.",
+  },
+  {
+    role: "assistant",
+    content: "Got it! I'll avoid thrillers and suggest sci-fi movies instead.",
+  },
+];
+await memory.add(messages, { userId: "alice", metadata: { category: "movies" } });
+```
+
+</CodeGroup>
+
 ## Configuration Parameters

 | Parameter       | Description                       | Default                       | Environment Variable |
@@ -5,11 +5,12 @@ description: "Configure xAI Grok models as an LLM provider in Mem0 with API key

 [xAI](https://x.ai/) is a new AI company founded by Elon Musk that develops large language models, including Grok. Grok is trained on real-time data from X (formerly Twitter) and aims to provide accurate, up-to-date responses with a touch of wit and humor.

-In order to use LLMs from xAI, go to their [platform](https://console.x.ai) and get the API key. Set the API key as `XAI_API_KEY` environment variable to use the model as given below in the example.
+In order to use LLMs from xAI, go to their [platform](https://console.x.ai) and get the API key. Set the API key as `XAI_API_KEY` environment variable to use the model as given below in the example. You can also optionally set `XAI_API_BASE` to use a different API endpoint (defaults to `https://api.x.ai/v1`).

 ## Usage

-```python
+<CodeGroup>
+```python Python
 import os
 from mem0 import Memory

@@ -37,6 +38,31 @@ messages = [
 m.add(messages, user_id="alice", metadata={"category": "movies"})
 ```

+```typescript TypeScript
+import { Memory } from 'mem0ai/oss';
+
+const config = {
+  llm: {
+    provider: 'xai',
+    config: {
+      apiKey: process.env.XAI_API_KEY || '',
+      model: 'grok-4.3',
+      temperature: 0.1,
+      maxTokens: 2000,
+    },
+  },
+};
+const memory = new Memory(config);
+const messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+];
+await memory.add(messages, { userId: 'alice', metadata: { category: 'movies' } });
+```
+</CodeGroup>
+
 ## Config

 All available parameters for the `xai` config are present in [Master List of All Params in Config](../config).
@@ -7,7 +7,7 @@ Mem0 includes built-in support for various popular large language models. Memory

 ## Usage

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

 For a comprehensive list of available parameters for llm configuration, please refer to [Config](./config).

@@ -16,26 +16,26 @@ For a comprehensive list of available parameters for llm configuration, please r
 See the list of supported LLMs below.

 <Note>
-  All LLMs are supported in Python. The following LLMs are also supported in TypeScript: **OpenAI**, **Anthropic**, **Groq**, **Azure OpenAI**, **DeepSeek**, **Google AI**, **Langchain**, **LM Studio**, **Mistral AI**, and **Ollama**.
+  All LLMs are supported in Python. The following LLMs are also supported in TypeScript: **OpenAI**, **Anthropic**, **AWS Bedrock**, **Groq**, **Azure OpenAI**, **DeepSeek**, **Google AI**, **Langchain**, **LM Studio**, **Mistral AI**, and **Ollama**.
 </Note>

 <CardGroup cols={4}>
-  <Card title="OpenAI" href="/components/llms/models/openai" />
-  <Card title="Ollama" href="/components/llms/models/ollama" />
-  <Card title="Azure OpenAI" href="/components/llms/models/azure_openai" />
-  <Card title="Anthropic" href="/components/llms/models/anthropic" />
-  <Card title="Together" href="/components/llms/models/together" />
-  <Card title="Groq" href="/components/llms/models/groq" />
-  <Card title="Litellm" href="/components/llms/models/litellm" />
-  <Card title="Mistral AI" href="/components/llms/models/mistral_AI" />
-  <Card title="Google AI" href="/components/llms/models/google_AI" />
-  <Card title="AWS bedrock" href="/components/llms/models/aws_bedrock" />
-  <Card title="DeepSeek" href="/components/llms/models/deepseek" />
-  <Card title="MiniMax" href="/components/llms/models/minimax" />
-  <Card title="xAI" href="/components/llms/models/xAI" />
-  <Card title="Sarvam AI" href="/components/llms/models/sarvam" />
-  <Card title="LM Studio" href="/components/llms/models/lmstudio" />
-  <Card title="Langchain" href="/components/llms/models/langchain" />
+  <Card title="OpenAI" icon="/images/provider-icons/openai.svg" href="/components/llms/models/openai" />
+  <Card title="Ollama" icon="/images/provider-icons/ollama.svg" href="/components/llms/models/ollama" />
+  <Card title="Azure OpenAI" icon="/images/provider-icons/azure-color.svg" href="/components/llms/models/azure_openai" />
+  <Card title="Anthropic" icon="/images/provider-icons/anthropic.svg" href="/components/llms/models/anthropic" />
+  <Card title="Together" icon="/images/provider-icons/together-color.svg" href="/components/llms/models/together" />
+  <Card title="Groq" icon="/images/provider-icons/groq.svg" href="/components/llms/models/groq" />
+  <Card title="Litellm" icon="shuffle" href="/components/llms/models/litellm" />
+  <Card title="Mistral AI" icon="/images/provider-icons/mistral-color.svg" href="/components/llms/models/mistral_AI" />
+  <Card title="Google AI" icon="/images/provider-icons/google-color.svg" href="/components/llms/models/google_AI" />
+  <Card title="AWS bedrock" icon="/images/provider-icons/bedrock-color.svg" href="/components/llms/models/aws_bedrock" />
+  <Card title="DeepSeek" icon="/images/provider-icons/deepseek-color.svg" href="/components/llms/models/deepseek" />
+  <Card title="MiniMax" icon="/images/provider-icons/minimax-color.svg" href="/components/llms/models/minimax" />
+  <Card title="xAI" icon="/images/provider-icons/xai.svg" href="/components/llms/models/xAI" />
+  <Card title="Sarvam AI" icon="/images/provider-icons/sarvam.svg" href="/components/llms/models/sarvam" />
+  <Card title="LM Studio" icon="/images/provider-icons/lmstudio.svg" href="/components/llms/models/lmstudio" />
+  <Card title="Langchain" icon="/images/provider-icons/langchain-color.svg" href="/components/llms/models/langchain" />
 </CardGroup>

 ## Structured vs Unstructured Outputs
@@ -26,7 +26,7 @@ All rerankers share these common configuration parameters:

 | Parameter            | Description                                  | Type   | Default                 |
 | -------------------- | -------------------------------------------- | ------ | ----------------------- |
-| `model`              | Cohere rerank model                          | `str`  | `"rerank-english-v3.0"` |
+| `model`              | Cohere rerank model                          | `str`  | `"rerank-v3.5"` |
 | `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`                  |
@@ -103,3 +103,30 @@ config = {
    }
 }
 ```
+
+## TypeScript SDK
+
+The self-hosted [TypeScript SDK](/open-source/features/reranker-search#typescript-sdk) (`mem0ai/oss`) supports the same five providers. Config keys are camelCase (`apiKey`, `topK`, `maxLength`) and each provider's SDK is a peer dependency you install per reranker.
+
+| Provider | Install | Default model | Key config fields |
+| --- | --- | --- | --- |
+| `cohere` | `pnpm add cohere-ai` | `rerank-v3.5` | `apiKey`, `model`, `topK` |
+| `zero_entropy` | `pnpm add zeroentropy` | `zerank-1` | `apiKey`, `model`, `topK` |
+| `sentence_transformer` | `pnpm add @huggingface/transformers` | `Xenova/ms-marco-MiniLM-L-6-v2` | `model`, `device`, `maxLength`, `normalize`, `topK` |
+| `huggingface` | `pnpm add @huggingface/transformers` | `Xenova/bge-reranker-base` | `model`, `device`, `maxLength`, `normalize`, `topK` |
+| `llm_reranker` | None (uses your LLM provider's own SDK) | `openai` / `gpt-4o-mini` | `provider`, `model`, `apiKey`, `llm` (nested override), `topK` |
+
+```typescript
+import { Memory } from "mem0ai/oss";
+
+const memory = new Memory({
+  reranker: {
+    provider: "zero_entropy",
+    config: { apiKey: process.env.ZERO_ENTROPY_API_KEY, topK: 5 },
+  },
+});
+```
+
+<Note>
+  The local cross-encoder providers (`sentence_transformer`, `huggingface`) run on [Transformers.js](https://huggingface.co/docs/transformers.js) and default to ONNX (`Xenova/*`) model mirrors, so Python default model strings must be swapped for their ONNX equivalents. `batchSize` and `showProgressBar` are accepted for parity with Python but are no-ops in the TypeScript runtime. See the [reranker feature guide](/open-source/features/reranker-search#typescript-sdk) for full examples.
+</Note>
@@ -9,9 +9,9 @@ Cohere provides enterprise-grade reranking models with excellent multilingual su

 Cohere offers several reranking models:

- **`rerank-english-v3.0`**: Latest English reranker with best performance
- **`rerank-multilingual-v3.0`**: Multilingual support for global applications
- **`rerank-english-v2.0`**: Previous generation English reranker
+- **`rerank-v3.5`** (default): Latest reranker, multilingual, best performance
+- **`rerank-english-v3.0`**: Previous generation, English only
+- **`rerank-multilingual-v3.0`**: Previous generation, multilingual

 ## Installation

@@ -41,7 +41,7 @@ config = {
    "reranker": {
        "provider": "cohere",
        "config": {
-            "model": "rerank-english-v3.0",
+            "model": "rerank-v3.5",
            "api_key": "your-cohere-api-key",  # or set COHERE_API_KEY
            "top_k": 5,
            "return_documents": False,
@@ -53,6 +53,34 @@ config = {
 memory = Memory.from_config(config)
 ```

+## TypeScript (self-hosted)
+
+The [TypeScript OSS SDK](/open-source/features/reranker-search#typescript-sdk) (`mem0ai/oss`) ships the Cohere reranker. Config keys are camelCase, it defaults to the `rerank-v3.5` model, and you opt in per search with `rerank: true`.
+
+```bash
+pnpm add cohere-ai
+```
+
+```typescript
+import { Memory } from "mem0ai/oss";
+
+const memory = new Memory({
+  reranker: {
+    provider: "cohere",
+    config: {
+      apiKey: process.env.COHERE_API_KEY, // or set COHERE_API_KEY
+      // model: "rerank-v3.5",     // default
+      topK: 5,
+    },
+  },
+});
+
+const results = await memory.search("What is the user's profession?", {
+  filters: { userId: "bob" },
+  rerank: true,
+});
+```
+
 ## Environment Variables

 Set your API key as an environment variable:
@@ -77,7 +105,7 @@ config = {
    "rerank": {
        "provider": "cohere",
        "config": {
-            "model": "rerank-english-v3.0",
+            "model": "rerank-v3.5",
            "top_k": 3
        }
    }
@@ -124,7 +152,7 @@ config = {

 | Parameter            | Description                      | Type   | Default                 |
 | -------------------- | -------------------------------- | ------ | ----------------------- |
-| `model`              | Cohere rerank model to use       | `str`  | `"rerank-english-v3.0"` |
+| `model`              | Cohere rerank model to use       | `str`  | `"rerank-v3.5"` |
 | `api_key`            | Cohere API key                   | `str`  | `None`                  |
 | `top_k`              | Maximum documents to return      | `int`  | `None`                  |
 | `return_documents`   | Whether to return document texts | `bool` | `False`                 |
@@ -139,7 +167,7 @@ config = {

 ## Best Practices

-1. **Model Selection**: Use `rerank-english-v3.0` for English, `rerank-multilingual-v3.0` for other languages
+1. **Model Selection**: `rerank-v3.5` handles English and multilingual workloads; pin an older `v3.0` model only if you need to reproduce prior results
 2. **Batch Processing**: Process multiple queries efficiently
 3. **Error Handling**: Implement retry logic for production systems
 4. **Monitoring**: Track reranking performance and costs
@@ -57,6 +57,40 @@ config = {
 }
 ```

+## TypeScript (self-hosted)
+
+The [TypeScript OSS SDK](/open-source/features/reranker-search#typescript-sdk) (`mem0ai/oss`) runs this reranker locally with [Transformers.js](https://huggingface.co/docs/transformers.js), the same cross-encoder path as `sentence_transformer`, just a different default model. It executes ONNX weights, so the default is the ONNX mirror `Xenova/bge-reranker-base`. Point `model` at any ONNX-exported reranker on the Hub (a raw `BAAI/bge-reranker-*` PyTorch checkpoint will not load in this runtime).
+
+```bash
+pnpm add @huggingface/transformers
+```
+
+```typescript
+import { Memory } from "mem0ai/oss";
+
+const memory = new Memory({
+  reranker: {
+    provider: "huggingface",
+    config: {
+      // model: "Xenova/bge-reranker-base", // default (ONNX)
+      device: "cpu", // "cpu" | "wasm" | "webgpu"
+      maxLength: 512, // max tokens per query-document pair
+      normalize: true, // sigmoid-normalize logits to [0, 1] (default)
+      topK: 5,
+    },
+  },
+});
+
+const results = await memory.search("What are the user's interests?", {
+  filters: { userId: "alice" },
+  rerank: true,
+});
+```
+
+<Note>
+  `batchSize` and `showProgressBar` are accepted for parity with the Python SDK but are no-ops in the TypeScript runtime. `trust_remote_code` and `model_kwargs` are Python-only.
+</Note>
+
 ## Popular Models

 ### BGE Rerankers (Recommended)
@@ -67,6 +67,43 @@ config = {
 }
 ```

+## TypeScript (self-hosted)
+
+The [TypeScript OSS SDK](/open-source/features/reranker-search#typescript-sdk) (`mem0ai/oss`) ships the LLM reranker under the provider name `llm_reranker`. It does **not** reuse the Memory's main `llm` instance; it builds its own LLM from the reranker's own config, defaulting to `openai` / `gpt-4o-mini`. Set `provider`/`model`/`apiKey` directly on `config`, or nest a fully separate `config.llm: { provider, config }` (its `provider`/`config` take priority over the top-level fields, which only backfill values missing from the nested config).
+
+```typescript
+import { Memory } from "mem0ai/oss";
+
+const memory = new Memory({
+  reranker: {
+    provider: "llm_reranker",
+    config: { apiKey: process.env.OPENAI_API_KEY },
+  },
+});
+
+const results = await memory.search("What movies do I like?", {
+  filters: { userId: "alice" },
+  rerank: true,
+});
+```
+
+To rerank with a different LLM provider than the Memory's main `llm`, nest it under `config.llm`:
+
+```typescript
+const memory = new Memory({
+  llm: { provider: "openai", config: { apiKey: process.env.OPENAI_API_KEY } },
+  reranker: {
+    provider: "llm_reranker",
+    config: {
+      llm: {
+        provider: "anthropic",
+        config: { apiKey: process.env.ANTHROPIC_API_KEY },
+      },
+    },
+  },
+});
+```
+
 ## Supported LLM Providers

 ### OpenAI
@@ -54,6 +54,40 @@ config = {
 memory = Memory.from_config(config)
 ```

+## TypeScript (self-hosted)
+
+The [TypeScript OSS SDK](/open-source/features/reranker-search#typescript-sdk) (`mem0ai/oss`) runs this reranker locally with [Transformers.js](https://huggingface.co/docs/transformers.js). Because it executes ONNX weights, the default model is the ONNX mirror of the Python default: `Xenova/ms-marco-MiniLM-L-6-v2`. Point `model` at any ONNX-exported cross-encoder on the Hub (a raw `cross-encoder/...` PyTorch checkpoint will not load in this runtime).
+
+```bash
+pnpm add @huggingface/transformers
+```
+
+```typescript
+import { Memory } from "mem0ai/oss";
+
+const memory = new Memory({
+  reranker: {
+    provider: "sentence_transformer",
+    config: {
+      // model: "Xenova/ms-marco-MiniLM-L-6-v2", // default (ONNX)
+      device: "cpu", // "cpu" | "wasm" | "webgpu"
+      maxLength: 512, // max tokens per query-document pair
+      normalize: true, // sigmoid-normalize logits to [0, 1] (default)
+      topK: 5,
+    },
+  },
+});
+
+const results = await memory.search("What books does the user like?", {
+  filters: { userId: "charlie" },
+  rerank: true,
+});
+```
+
+<Note>
+  `batchSize` and `showProgressBar` are accepted for parity with the Python SDK but are no-ops in the TypeScript runtime, because a search reranks a small candidate set in a single in-process forward pass. The model downloads once and is cached in-process.
+</Note>
+
 ## GPU Acceleration

 For better performance, use GPU acceleration:
@@ -50,6 +50,34 @@ config = {
 memory = Memory.from_config(config)
 ```

+## TypeScript (self-hosted)
+
+The [TypeScript OSS SDK](/open-source/features/reranker-search#typescript-sdk) (`mem0ai/oss`) ships the Zero Entropy reranker under the same provider name as Python, `zero_entropy`. It reads the key from config or `ZERO_ENTROPY_API_KEY` and defaults to the `zerank-1` model.
+
+```bash
+pnpm add zeroentropy
+```
+
+```typescript
+import { Memory } from "mem0ai/oss";
+
+const memory = new Memory({
+  reranker: {
+    provider: "zero_entropy",
+    config: {
+      apiKey: process.env.ZERO_ENTROPY_API_KEY,
+      // model: "zerank-1",   // default (or "zerank-1-small")
+      topK: 5,
+    },
+  },
+});
+
+const results = await memory.search("What Italian food does the user like?", {
+  filters: { userId: "alice" },
+  rerank: true,
+});
+```
+
 ## Environment Variables

 Set your API key as an environment variable:
@@ -47,7 +47,7 @@ config = {
    "reranker": {
        "provider": "cohere",
        "config": {
-            "model": "rerank-english-v3.0",
+            "model": "rerank-v3.5",
            "top_n": 10,
            "max_chunks_per_doc": 10,  # Limit chunk processing
            "return_documents": False   # Reduce response size
@@ -280,7 +280,7 @@ config = {
 ```python
 def benchmark_rerankers():
    configs = [
-        {"provider": "cohere", "model": "rerank-english-v3.0"},
+        {"provider": "cohere", "model": "rerank-v3.5"},
        {"provider": "sentence_transformer", "model": "cross-encoder/ms-marco-MiniLM-L-6-v2"},
        {"provider": "huggingface", "model": "BAAI/bge-reranker-base"}
    ]
@@ -9,6 +9,22 @@ Mem0 rerankers rescore vector search hits so your agents surface the most releva
 Reranking trades extra latency for better precision. Start once you have baseline search working and measure before/after relevance.
 </Info>

+## Supported Rerankers
+
+<CardGroup cols={3}>
+  <Card title="Cohere" icon="/images/provider-icons/cohere.svg" href="/components/rerankers/models/cohere" />
+  <Card title="Sentence Transformers" icon="vector-square" href="/components/rerankers/models/sentence_transformer" />
+  <Card title="Hugging Face" icon="/images/provider-icons/huggingface.svg" href="/components/rerankers/models/huggingface" />
+  <Card title="LLM Reranker" icon="wand-magic-sparkles" href="/components/rerankers/models/llm_reranker" />
+  <Card title="Zero Entropy" icon="/images/provider-icons/zeroentropy.svg" href="/components/rerankers/models/zero_entropy" />
+</CardGroup>
+
+<Note>
+All five rerankers are available in both the Python and the [TypeScript](/open-source/features/reranker-search#typescript-sdk) self-hosted SDKs. Each provider page has a **TypeScript (self-hosted)** section with the camelCase config.
+</Note>
+
+## Reranking Workflow
+
 <CardGroup cols={3}>
  <Card
    title="Understand Reranking"
@@ -19,13 +35,13 @@ Reranking trades extra latency for better precision. Start once you have baselin
  <Card
    title="Configure Providers"
    description="Add reranker blocks to your memory configuration."
-    icon="settings"
+    icon="gear"
    href="/components/rerankers/config"
  />
  <Card
    title="Optimize Performance"
    description="Balance relevance, latency, and cost with tuning tactics."
-    icon="speedometer"
+    icon="gauge"
    href="/components/rerankers/optimization"
  />
  <Card
@@ -43,7 +59,7 @@ Reranking trades extra latency for better precision. Start once you have baselin
  <Card
    title="Sentence Transformers"
    description="Keep reranking on-device with cross-encoder models."
-    icon="cpu"
+    icon="microchip"
    href="/components/rerankers/models/sentence_transformer"
  />
 </CardGroup>
@@ -66,7 +82,7 @@ Reranking trades extra latency for better precision. Start once you have baselin
  <Card
    title="Set Up Reranking"
    description="Walk through the configuration fields and defaults."
-    icon="settings"
+    icon="gear"
    href="/components/rerankers/config"
  />
  <Card
@@ -81,13 +81,13 @@ Azure client ID, secret, tenant ID, or certificate in environment variables for
 Utilizes Azure Workload Identity (relevant for Kubernetes and Azure workloads).

 3. **Managed Identity Credential:**
-Authenticates as a Managed Identity (for apps/services hosted in Azure with Managed Identity enabled), this is the most secure production credential.
+Authenticates as a Managed Identity (for apps/services hosted in Azure with Managed Identity enabled); this is the most secure production credential.

 4. **Shared Token Cache Credential / Visual Studio Credential (Windows only):**
 Uses cached credentials from Visual Studio sign-ins (and sometimes VS Code if SSO is enabled).

 5. **Azure CLI Credential:**
-Uses the currently logged-in user from the Azure CLI (`az login`), this is the most common development credential.
+Uses the currently logged-in user from the Azure CLI (`az login`); this is the most common development credential.

 6. **Azure PowerShell Credential:**
 Uses the identity from Azure PowerShell (`Connect-AzAccount`).
@@ -135,7 +135,7 @@ config = {
 ```

 ### Environment Variables to Use Azure Identity Credential
-* For an Environment Credential, you will need to setup a Service Principal and set the following environment variables:
+* For an Environment Credential, you will need to set up 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.
  - `AZURE_CLIENT_SECRET`: The client secret of your service principal.
@@ -5,10 +5,22 @@ description: "Use Baidu Mochow as an enterprise vector database in Mem0 for high

 [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.

+### Installation
+
+<CodeGroup>
+```bash Python
+pip install pymochow
+```
+
+```bash TypeScript
+npm install @mochow/mochow-sdk-node
+```
+
+</CodeGroup>
+
 ### Usage

 ```python
-import os
 from mem0 import Memory

 config = {
@@ -36,19 +48,63 @@ messages = [
 m.add(messages, user_id="alice", metadata={"category": "movies"})
 ```

+```typescript
+import { Memory } from "mem0ai/oss";
+
+const memory = new Memory({
+  embedder: {
+    provider: "openai",
+    config: {
+      apiKey: process.env.OPENAI_API_KEY || "",
+      model: "text-embedding-3-small",
+      embeddingDims: 1536,
+    },
+  },
+  vectorStore: {
+    provider: "baidu",
+    config: {
+      endpoint: process.env.BAIDU_ENDPOINT || "",
+      account: process.env.BAIDU_ACCOUNT || "root",
+      apiKey: process.env.BAIDU_API_KEY || "",
+      databaseName: "mem0",
+      tableName: "mem0_table",
+      embeddingModelDims: 1536,
+      metricType: "COSINE",
+    },
+  },
+  llm: {
+    provider: "openai",
+    config: {
+      apiKey: process.env.OPENAI_API_KEY || "",
+      model: "gpt-5-mini",
+    },
+  },
+});
+```
+
 ### Config

 Here are the parameters available for configuring Baidu VectorDB:

-| Parameter | Description | Default Value |
-| --- | --- | --- |
-| `endpoint` | Endpoint URL for your Baidu VectorDB instance | Required |
-| `account` | Baidu VectorDB account name | `root` |
-| `api_key` | API key for accessing Baidu VectorDB | Required |
-| `database_name` | Name of the database | `mem0` |
-| `table_name` | Name of the table | `mem0` |
-| `embedding_model_dims` | Dimensions of the embedding model | `1536` |
-| `metric_type` | Distance metric for similarity search | `L2` |
+| Parameter              | Description                                   | Default Value |
+| ---------------------- | --------------------------------------------- | ------------- |
+| `endpoint`             | Endpoint URL for your Baidu VectorDB instance | Required      |
+| `account`              | Baidu VectorDB account name                   | `root`        |
+| `api_key`              | API key for accessing Baidu VectorDB          | Required      |
+| `database_name`        | Name of the database                          | `mem0`        |
+| `table_name`           | Name of the table                             | `mem0`        |
+| `embedding_model_dims` | Dimensions of the embedding model             | `1536`        |
+| `metric_type`          | Distance metric for similarity search         | `L2`          |
+| `client`               | Prebuilt Mochow client (TypeScript SDK only)  | `None`        |
+
+For the TypeScript OSS SDK, use the camelCase equivalents:
+
+- `databaseName`
+- `tableName`
+- `embeddingModelDims`
+- `metricType`
+
+For OSS TS usage, `endpoint`, `account`, `apiKey`, `databaseName`, `tableName`, and `embeddingModelDims` are required unless you inject a prebuilt client. `metricType` defaults to `L2`, matching the Python SDK.

 ### Distance Metrics

@@ -66,3 +122,5 @@ The vector index is automatically configured with the following HNSW parameters:
 - `efconstruction`: 200 (size of the dynamic candidate list)
 - `auto_build`: true (automatically build index)
 - `auto_build_index_policy`: Incremental build with 10000 rows increment
+
+The TypeScript provider also creates a BM25 inverted index over a `textLemmatized` column so `keywordSearch()` runs against a real full-text index. Mem0 lemmatizes the query before it reaches the vector store, so only the lemmatized form of each memory is indexed. If you point `tableName` at a table created before this index existed, `keywordSearch()` returns `null` and search falls back to vector similarity alone; recreate the table to enable it.
@@ -7,7 +7,8 @@ description: "Use Apache Cassandra as a distributed vector store in Mem0 with se

 ### Usage

-```python
+<CodeGroup>
+```python Python
 import os
 from mem0 import Memory

@@ -37,11 +38,43 @@ messages = [
 m.add(messages, user_id="alice", metadata={"category": "movies"})
 ```

+```typescript TypeScript
+import { Memory } from 'mem0ai/oss';
+
+// Set OPENAI_API_KEY in your environment for the default embedder
+
+const config = {
+  vectorStore: {
+    provider: 'cassandra',
+    config: {
+      contactPoints: ['127.0.0.1'],
+      localDataCenter: 'datacenter1', // required with contactPoints; "datacenter1" is the default for a single-node cluster
+      port: 9042,
+      username: 'cassandra',
+      password: 'cassandra',
+      keyspace: 'mem0',
+      collectionName: 'memories',
+    },
+  },
+};
+
+const memory = new Memory(config);
+const messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+await memory.add(messages, { userId: "alice", metadata: { category: "movies" } });
+```
+</CodeGroup>
+
 #### Using DataStax Astra DB

 For managed Cassandra with DataStax Astra DB:

-```python
+<CodeGroup>
+```python Python
 config = {
    "vector_store": {
        "provider": "cassandra",
@@ -57,8 +90,24 @@ config = {
 }
 ```

+```typescript TypeScript
+const config = {
+  vectorStore: {
+    provider: 'cassandra',
+    config: {
+      username: 'token',
+      password: 'AstraCS:...', // Your Astra DB application token
+      keyspace: 'mem0',
+      collectionName: 'memories',
+      secureConnectBundle: '/path/to/secure-connect-bundle.zip',
+    },
+  },
+};
+```
+</CodeGroup>
+
 <Note>
-When using DataStax Astra DB, provide the secure connect bundle path. The contact_points parameter is ignored when a secure connect bundle is provided.
+When using DataStax Astra DB, provide the secure connect bundle path. Contact points and `localDataCenter` are not needed when a secure connect bundle is provided.
 </Note>

 ### Config
@@ -78,6 +127,10 @@ Here are the parameters available for configuring Apache Cassandra:
 | `protocol_version` | CQL protocol version | `4` |
 | `load_balancing_policy` | Custom load balancing policy | `None` |

+<Note>
+The TypeScript SDK uses camelCase keys: `contactPoints`, `collectionName`, `embeddingModelDims`, `secureConnectBundle`, `protocolVersion`, and `loadBalancingPolicy`. It also requires `localDataCenter` (for example, `datacenter1`) when you connect with `contactPoints` instead of a secure connect bundle. The Node.js driver needs this to route queries; it has no default.
+</Note>
+
 ### Setup

 #### Option 1: Local Cassandra Setup using Docker:
@@ -139,14 +192,20 @@ brew services start cassandra
 cqlsh
 ```

-### Python Client Installation
+### Client Installation

-Install the required Python package:
+Install the driver for your SDK:

-```bash
+<CodeGroup>
+```bash Python
 pip install cassandra-driver
 ```

+```bash TypeScript
+npm install cassandra-driver
+```
+</CodeGroup>
+
 ### Performance Considerations

 - **Replication Factor**: For production, use replication factor of at least 3
@@ -156,7 +215,8 @@ pip install cassandra-driver

 ### Advanced Configuration

-```python
+<CodeGroup>
+```python Python
 from cassandra.policies import DCAwareRoundRobinPolicy

 config = {
@@ -176,6 +236,28 @@ config = {
 }
 ```

+```typescript TypeScript
+// The Node.js driver routes to localDataCenter by default, so set it to your
+// primary DC for datacenter-aware routing. Pass loadBalancingPolicy only when
+// you need a custom policy from the cassandra-driver package.
+const config = {
+  vectorStore: {
+    provider: 'cassandra',
+    config: {
+      contactPoints: ['node1.example.com', 'node2.example.com', 'node3.example.com'],
+      localDataCenter: 'DC1',
+      port: 9042,
+      username: 'mem0_user',
+      password: 'secure_password',
+      keyspace: 'mem0_prod',
+      collectionName: 'memories',
+      protocolVersion: 4,
+    },
+  },
+};
+```
+</CodeGroup>
+
 <Warning>
 For production use, configure appropriate replication strategies and consistency levels based on your availability and consistency requirements.
 </Warning>
@@ -6,9 +6,8 @@ description: "Use Chroma as a vector database in Mem0 for local or cloud-hosted

 ### Usage

-#### Local Installation
-
-```python
+<CodeGroup>
+```python Python
 import os
 from mem0 import Memory

@@ -37,10 +36,46 @@ messages = [
 m.add(messages, user_id="alice", metadata={"category": "movies"})
 ```

+```typescript TypeScript
+import { Memory } from 'mem0ai/oss';
+
+// The Node.js client connects to a running Chroma server.
+// Start one locally with: chroma run --host localhost --port 8000
+const config = {
+  vectorStore: {
+    provider: 'chroma',
+    config: {
+      collectionName: 'memories',
+      host: 'localhost',
+      port: 8000,
+      // Optional: ChromaDB Cloud configuration
+      // apiKey: 'your-chroma-cloud-api-key',
+      // tenant: 'your-chroma-cloud-tenant-id',
+    },
+  },
+};
+
+const memory = new Memory(config);
+const messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+await memory.add(messages, { userId: "alice", metadata: { category: "movies" } });
+```
+</CodeGroup>
+
+<Note>
+The Node.js SDK uses the `chromadb` v3 client, which talks to a Chroma server over HTTP (local server or ChromaDB Cloud). Install it with `npm install chromadb`. Mem0 supplies the embeddings, so the collection is created without an embedding function.
+</Note>
+
 ### Config

 Here are the parameters available for configuring Chroma:

+<Tabs>
+<Tab title="Python">
 | Parameter | Description | Default Value |
 | --- | --- | --- |
 | `collection_name` | The name of the collection | `mem0` |
@@ -49,4 +84,19 @@ Here are the parameters available for configuring Chroma:
 | `host` | The host where the Chroma server is running | `None` |
 | `port` | The port where the Chroma server is running | `None` |
 | `api_key` | ChromaDB Cloud API key (for cloud usage) | `None` |
-| `tenant` | ChromaDB Cloud tenant ID (for cloud usage) | `None` |
+| `tenant` | ChromaDB Cloud tenant ID (for cloud usage) | `None` |
+</Tab>
+<Tab title="TypeScript">
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `collectionName` | The name of the collection | `mem0` |
+| `client` | Pre-configured `ChromaClient` or `CloudClient` instance | `None` |
+| `host` | The host where the Chroma server is running | `None` |
+| `port` | The port where the Chroma server is running | `None` |
+| `ssl` | Whether to use SSL when connecting to the Chroma server | `false` |
+| `path` | Full URL of a Chroma server, e.g. `http://localhost:8000` (alternative to `host` and `port`) | `None` |
+| `apiKey` | ChromaDB Cloud API key (for cloud usage) | `None` |
+| `tenant` | ChromaDB Cloud tenant ID (for cloud usage) | `None` |
+| `database` | ChromaDB Cloud database name (for cloud usage) | `mem0` |
+</Tab>
+</Tabs>
@@ -6,7 +6,8 @@ description: "Use Databricks Vector Search as a serverless vector store in Mem0

 ### Usage

-```python
+<CodeGroup>
+```python Python
 import os
 from mem0 import Memory

@@ -36,10 +37,44 @@ messages = [
 m.add(messages, user_id="alice", metadata={"category": "movies"})
 ```

+```typescript TypeScript
+// Requires the Databricks SQL driver (peer dependency): pnpm add @databricks/sql
+import { Memory } from 'mem0ai/oss';
+
+const config = {
+  vectorStore: {
+    provider: 'databricks',
+    config: {
+      workspaceUrl: 'https://your-workspace.databricks.com',
+      // SQL warehouse HTTP path, used for index writes (required)
+      httpPath: '/sql/1.0/warehouses/your-warehouse-id',
+      accessToken: 'your-access-token',
+      catalog: 'your_catalog',
+      schema: 'your_schema',
+      tableName: 'your_table',
+      collectionName: 'your_index_name',
+      embeddingModelDims: 1536,
+    },
+  },
+};
+
+const memory = new Memory(config);
+const messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+await memory.add(messages, { userId: "alice", metadata: { category: "movies" } });
+```
+</CodeGroup>
+
 ### Config

 Here are the parameters available for configuring Databricks Vector Search:

+<Tabs>
+<Tab title="Python">
 | Parameter | Description | Default Value |
 | --- | --- | --- |
 | `workspace_url` | The URL of your Databricks workspace | **Required** |
@@ -60,6 +95,32 @@ Here are the parameters available for configuring Databricks Vector Search:
 | `pipeline_type` | Sync pipeline type: `TRIGGERED` or `CONTINUOUS` | `TRIGGERED` |
 | `warehouse_name` | Databricks SQL warehouse name (if using SQL warehouse) | `None` |
 | `query_type` | Query type: `ANN` or `HYBRID` | `ANN` |
+</Tab>
+<Tab title="TypeScript">
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `workspaceUrl` | The URL of your Databricks workspace (or pass `host`) | **Required** |
+| `httpPath` | SQL warehouse HTTP path, used for index writes | **Required** |
+| `accessToken` | Personal Access Token for authentication | `None` |
+| `clientId` | Service principal client ID (alternative to `accessToken`) | `None` |
+| `clientSecret` | Service principal client secret (required with `clientId`) | `None` |
+| `endpointName` | Name of the Vector Search endpoint | `mem0_vector_search` |
+| `endpointType` | Type of endpoint (`STANDARD` or `STORAGE_OPTIMIZED`) | `STANDARD` |
+| `pipelineType` | Delta Sync pipeline type: `TRIGGERED` or `CONTINUOUS` | `TRIGGERED` |
+| `queryType` | Query type: `ANN` or `HYBRID` | `ANN` |
+| `catalog` | Unity Catalog catalog name | `main` |
+| `schema` | Unity Catalog schema name | `default` |
+| `collectionName` | Vector Search index name | `mem0` |
+| `tableName` | Source Delta table name | falls back to `collectionName` |
+| `embeddingModelDims` | Dimension of self-managed embeddings | `1536` |
+| `syncPollIntervalMs` | Poll interval while waiting for a `TRIGGERED` sync | `1000` |
+| `syncTimeoutMs` | Timeout while waiting for an index sync | `300000` |
+
+<Note>
+The TypeScript provider uses `DELTA_SYNC` indexes with self-managed embeddings: pass vectors directly. `DIRECT_ACCESS` indexes, Databricks-computed embeddings (`embedding_model_endpoint_name`), and Azure AD auth are Python-only today. It writes to the index through a SQL warehouse, so `httpPath` is required, and `@databricks/sql` must be installed as a peer dependency.
+</Note>
+</Tab>
+</Tabs>

 ### Authentication

@@ -6,15 +6,22 @@ description: "Use Elasticsearch as a vector database in Mem0 for distributed vec

 ### Installation

-Elasticsearch support requires additional dependencies. Install them with:
+Elasticsearch support requires the Elasticsearch client as an extra dependency.

-```bash
+<CodeGroup>
+```bash Python
 pip install elasticsearch>=8.0.0
 ```

+```bash TypeScript
+npm install mem0ai @elastic/elasticsearch
+```
+</CodeGroup>
+
 ### Usage

-```python
+<CodeGroup>
+```python Python
 import os
 from mem0 import Memory

@@ -36,12 +43,52 @@ 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": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]
 m.add(messages, user_id="alice", metadata={"category": "movies"})
 ```

+```typescript TypeScript
+import { Memory } from "mem0ai/oss";
+
+// Set OPENAI_API_KEY in your environment.
+const config = {
+  embedder: {
+    provider: "openai",
+    config: {
+      apiKey: process.env.OPENAI_API_KEY,
+      model: "text-embedding-3-small",
+    },
+  },
+  vectorStore: {
+    provider: "elasticsearch",
+    config: {
+      collectionName: "mem0",
+      embeddingModelDims: 1536,
+      host: "localhost",
+      port: 9200,
+      // For Elastic Cloud, pass cloudId and apiKey instead of host/port.
+      // For basic auth, pass username and password.
+    },
+  },
+};
+
+const memory = new Memory(config);
+const messages = [
+  { role: "user", content: "I'm planning to watch a movie tonight. Any recommendations?" },
+  { role: "assistant", content: "How about thriller movies? They can be quite engaging." },
+  { role: "user", content: "I'm not a big fan of thriller movies but I love sci-fi movies." },
+  { role: "assistant", content: "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future." },
+];
+await memory.add(messages, { userId: "alice", metadata: { category: "movies" } });
+```
+</CodeGroup>
+
+<Note>
+  The TypeScript SDK uses camelCase config keys: `collectionName`, `embeddingModelDims`, `cloudId`, `apiKey`, `useSsl`, `verifyCerts`, `caCerts`, `autoCreateIndex`, and `username` (in place of the Python `user`). `collectionName` and `embeddingModelDims` are required. Because the vector store embeds text with your configured embedder before writing, set an `embedder` in the config as shown above.
+</Note>
+
 ### Config

 Here are the parameters available for configuring Elasticsearch:
@@ -74,6 +121,10 @@ Here are the parameters available for configuring Elasticsearch:

 ### Custom Search Query

+<Note>
+  `custom_search_query` is available in the Python SDK only. The TypeScript SDK runs a fixed k-NN query with optional metadata filters.
+</Note>
+
 The `custom_search_query` parameter allows you to customize the search query when `Memory.search` is called.  
  
 __Example__  
@@ -6,7 +6,14 @@ description: "Use Milvus as an open-source vector database in Mem0, scalable fro

 ### Usage

-```python
+The TypeScript SDK loads the Milvus client lazily. Install it alongside `mem0ai` when you use this provider:
+
+```bash
+npm install @zilliz/milvus2-sdk-node
+```
+
+<CodeGroup>
+```python Python
 import os
 from mem0 import Memory

@@ -33,10 +40,39 @@ messages = [
 m.add(messages, user_id="alice", metadata={"category": "movies"})
 ```

+```typescript TypeScript
+import { Memory } from 'mem0ai/oss';
+
+const config = {
+  vectorStore: {
+    provider: 'milvus',
+    config: {
+      collectionName: 'test',
+      embeddingModelDims: 1536,
+      url: 'http://localhost:19530',
+      token: '8e4b8ca8cf2c67',
+      dbName: 'my_database',
+    },
+  },
+};
+
+const memory = new Memory(config);
+const messages = [
+  { role: "user", content: "I'm planning to watch a movie tonight. Any recommendations?" },
+  { role: "assistant", content: "How about thriller movies? They can be quite engaging." },
+  { role: "user", content: "I'm not a big fan of thriller movies but I love sci-fi movies." },
+  { role: "assistant", content: "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future." },
+];
+await memory.add(messages, { userId: "alice", metadata: { category: "movies" } });
+```
+</CodeGroup>
+
 ### Config

 Here are the parameters available for configuring Milvus:

+<Tabs>
+<Tab title="Python">
 | Parameter | Description | Default Value |
 | --- | --- | --- |
 | `url` | Full URL/Uri for Milvus/Zilliz server | `http://localhost:19530` |
@@ -45,3 +81,15 @@ Here are the parameters available for configuring Milvus:
 | `embedding_model_dims` | Dimensions of the embedding model | `1536` |
 | `metric_type` | Metric type for similarity search | `L2` |
 | `db_name` | Name of the database | `""` |
+</Tab>
+<Tab title="TypeScript">
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `url` | Full URL/Uri for Milvus/Zilliz server | `http://localhost:19530` |
+| `token` | Token for Zilliz Cloud (optional for a local setup) | `undefined` |
+| `collectionName` | The name of the collection | `mem0` |
+| `embeddingModelDims` | Dimensions of the embedding model | `1536` |
+| `metricType` | Metric type for similarity search (`L2`, `IP`, `COSINE`, `HAMMING`, `JACCARD`) | `L2` |
+| `dbName` | Name of the database | `undefined` |
+</Tab>
+</Tabs>
@@ -2,13 +2,15 @@
 title: "MongoDB"
 description: "Use MongoDB as a vector database in Mem0 with built-in vector search for high-dimensional similarity queries."
 ---
+
 # MongoDB

 [MongoDB](https://www.mongodb.com/) is a versatile document database that supports vector search capabilities, allowing for efficient high-dimensional similarity searches over large datasets with robust scalability and performance.

 ## Usage

-```python
+<CodeGroup>
+```python Python
 import os
 from mem0 import Memory

@@ -20,30 +22,90 @@ config = {
        "config": {
            "db_name": "mem0-db",
            "collection_name": "mem0-collection",
-            "mongo_uri":"mongodb://username:password@localhost:27017"
+            "mongo_uri": "mongodb://username:password@localhost:27017"
        }
    }
 }

 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."}
+    {
+        "role": "user",
+        "content": "I'm planning to watch a movie tonight. Any recommendations?",
+    },
+    {
+        "role": "assistant",
+        "content": "How about thriller movies? They can be quite engaging.",
+    },
+    {
+        "role": "user",
+        "content": "I’m not a big fan of thriller movies but I love sci-fi movies.",
+    },
+    {
+        "role": "assistant",
+        "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future.",
+    },
 ]
+
 m.add(messages, user_id="alice", metadata={"category": "movies"})
 ```

+```typescript TypeScript
+import { Memory } from "mem0ai/oss";
+
+const config = {
+  vectorStore: {
+    provider: "mongodb",
+    config: {
+      dbName: "mem0-db",
+      collectionName: "mem0-collection",
+      url: "mongodb://username:password@localhost:27017",
+    },
+  },
+};
+
+const memory = new Memory(config);
+
+const messages = [
+  {
+    role: "user",
+    content: "I'm planning to watch a movie tonight. Any recommendations?",
+  },
+  {
+    role: "assistant",
+    content: "How about thriller movies? They can be quite engaging.",
+  },
+  {
+    role: "user",
+    content: "I’m not a big fan of thriller movies but I love sci-fi movies.",
+  },
+  {
+    role: "assistant",
+    content:
+      "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future.",
+  },
+];
+
+await memory.add(messages, {
+  userId: "alice",
+  metadata: {
+    category: "movies",
+  },
+});
+```
+</CodeGroup>
+
 ## Config

 Here are the parameters available for configuring MongoDB:

-| Parameter | Description | Default Value |
-| --- | --- | --- |
-| db_name | Name of the MongoDB database | `"mem0_db"` |
-| collection_name | Name of the MongoDB collection | `"mem0"` |
-| embedding_model_dims | Dimensions of the embedding vectors | `1536` |
-| mongo_uri | The MongoDB URI connection string | `mongodb://localhost:27017` |
+| Python | TypeScript | Description | Default Value |
+| --- | --- | --- | --- |
+| db_name | dbName | Name of the MongoDB database | "mem0_db" |
+| collection_name | collectionName | Name of the MongoDB collection | "mem0" |
+| embedding_model_dims | embeddingModelDims | Dimensions of the embedding vectors | 1536 |
+| mongo_uri | url | The MongoDB URI connection string | mongodb://localhost:27017 |

-> **Note**: If `mongo_uri` is not provided, it will default to `mongodb://localhost:27017`.
+> **Note**: If `mongo_uri` (Python) or `url` (TypeScript) is not provided, it defaults to `mongodb://localhost:27017`. A local instance must be running MongoDB v8.2+ for vector search to work.
+
+> **Note**: The vector search index builds asynchronously after the first write. A search issued right after the first `add()` may return no results (and log an "index not initialized" message) until the index finishes building. This takes a few seconds on a local deployment and up to about a minute on Atlas. This is expected; the search returns results once the index is ready.
@@ -2,26 +2,37 @@
 title: "Neptune Analytics"
 description: "Use AWS Neptune Analytics as a vector store in Mem0, combining graph analytics with vector search capabilities."
 ---
-# Neptune Analytics Vector Store

-[Neptune Analytics](https://docs.aws.amazon.com/neptune-analytics/latest/userguide/what-is-neptune-analytics.html/) is a memory-optimized graph database engine for analytics. With Neptune Analytics, you can get insights and find trends by processing large amounts of graph data in seconds, including vector search.
+[Neptune Analytics](https://docs.aws.amazon.com/neptune-analytics/latest/userguide/what-is-neptune-analytics.html) is a memory-optimized graph database engine for analytics. With Neptune Analytics, you can get insights and find trends by processing large amounts of graph data in seconds, including vector search.

+### Installation

-## Installation
+The Neptune Analytics provider needs the AWS Neptune Graph client. Install it alongside `mem0ai`:

-```bash
+<CodeGroup>
+```bash Python
 pip install mem0ai[vector-stores]
 ```

-## Usage
+```bash TypeScript
+npm install @aws-sdk/client-neptune-graph
+```
+</CodeGroup>
+
+### Usage
+
+Configure AWS credentials in your environment (environment variables, shared config file, an IAM role, or an instance profile). Both SDKs pick them up automatically through the standard AWS credential chain.
+
+<CodeGroup>
+```python Python
+from mem0 import Memory

-```python
 config = {
    "vector_store": {
        "provider": "neptune",
        "config": {
            "collection_name": "mem0",
-            "endpoint": f"neptune-graph://my-graph-identifier",
+            "endpoint": "neptune-graph://g-abc123xyz0",
        },
    },
 }
@@ -29,18 +40,90 @@ config = {
 m = Memory.from_config(config)
 messages = [
    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
-    {"role": "assistant", "content": "How about a thriller movies? They can be quite engaging."},
+    {"role": "assistant", "content": "How about a thriller movie? 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"})
 ```

-## Parameters
+```typescript TypeScript
+import { Memory } from 'mem0ai/oss';

-Let's see the available parameters for the `neptune` config:
+const config = {
+  vectorStore: {
+    provider: 'neptune',
+    config: {
+      collectionName: 'mem0',
+      graphIdentifier: 'g-abc123xyz0',
+      // Any other key here (region, credentials, maxAttempts, ...) is
+      // forwarded to the underlying NeptuneGraphClient constructor.
+      region: 'us-east-1',
+    },
+  },
+};

+const memory = new Memory(config);
+const messages = [
+  { role: "user", content: "I'm planning to watch a movie tonight. Any recommendations?" },
+  { role: "assistant", content: "How about a thriller movie? They can be quite engaging." },
+  { role: "user", content: "I'm not a big fan of thriller movies but I love sci-fi movies." },
+  { role: "assistant", content: "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future." },
+];
+await memory.add(messages, { userId: "alice", metadata: { category: "movies" } });
+```
+</CodeGroup>
+
+### Config
+
+<Tabs>
+<Tab title="Python">
 | Parameter | Description | Default Value |
 | --- | --- | --- |
 | `collection_name` | The name of the collection to store the vectors | `mem0` |
-| `endpoint` | Connection URL for the Neptune Analytics service | `neptune-graph://my-graph-identifier` |
+| `endpoint` | Connection URL for the Neptune Analytics service, must be `neptune-graph://<graph-id>` | Required |
+</Tab>
+<Tab title="TypeScript">
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `collectionName` | The name of the collection to store the vectors | `memories` |
+| `graphIdentifier` | Graph ID, e.g. `g-abc123xyz0`. Takes priority over `endpoint`. | Required, unless `endpoint` supplies it |
+| `endpoint` | Either `neptune-graph://<graph-id>` (or a bare graph ID) to supply the graph ID, or an `https://` service endpoint to override the AWS endpoint. An `https://` value must be paired with `graphIdentifier`. | `undefined` |
+| `dimension` | Embedding vector dimension | Auto-detected from the embedder when omitted |
+| `client` | A pre-built `NeptuneGraphClient` to use instead of constructing one | `undefined` |
+| any other key | Forwarded as-is to the [`NeptuneGraphClient`](https://www.npmjs.com/package/@aws-sdk/client-neptune-graph) constructor, e.g. `region`, `credentials`, `maxAttempts` | N/A |
+</Tab>
+</Tabs>
+
+Both SDKs store vectors on graph nodes labeled `MEM0_VECTOR_<collection_name>`. Point them at the same
+graph with the same `collection_name` — the defaults differ, `mem0` in Python and `memories` in
+TypeScript — and `get()`, `list()`, and `delete()` interoperate across SDKs.
+
+<Note>
+`search()` is not currently cross-SDK compatible. The TypeScript provider filters on Neptune's reserved
+`~label` metafield, while the Python provider filters on a synthetic `label` property that only Python's
+own `insert()` writes. Python's `search()` therefore cannot see nodes written by the TypeScript provider.
+</Note>
+
+### IAM Permissions
+
+Your AWS identity (user or role) needs a policy that allows the [`ExecuteQuery`](https://docs.aws.amazon.com/neptune-analytics/latest/apiref/API_ExecuteQuery.html) actions used for reads, writes, and deletes:
+
+```json
+{
+  "Version": "2012-10-17",
+  "Statement": [
+    {
+      "Effect": "Allow",
+      "Action": [
+        "neptune-graph:ReadDataViaQuery",
+        "neptune-graph:WriteDataViaQuery",
+        "neptune-graph:DeleteDataViaQuery"
+      ],
+      "Resource": "*"
+    }
+  ]
+}
+```
+
+For production, scope the resource ARN down to your specific graph.
@@ -6,12 +6,18 @@ description: "Use OpenSearch as a vector database in Mem0 with k-NN search suppo

 ### Installation

-OpenSearch support requires additional dependencies. Install them with:
+OpenSearch support requires an additional client library. Install the one for your SDK:

-```bash
+<CodeGroup>
+```bash Python
 pip install opensearch-py
 ```

+```bash TypeScript
+npm install @opensearch-project/opensearch
+```
+</CodeGroup>
+
 ### Prerequisites

 Before using OpenSearch with Mem0, you need to set up a collection in AWS OpenSearch Service.
@@ -26,7 +32,8 @@ You can create a collection through the AWS Console:

 ### Usage

-```python
+<CodeGroup>
+```python Python
 import os
 from mem0 import Memory
 import boto3
@@ -56,8 +63,43 @@ config = {
 }
 ```

+```typescript TypeScript
+import { Memory } from 'mem0ai/oss';
+
+// Basic self-hosted OpenSearch. For AWS OpenSearch Serverless, build an
+// @opensearch-project/opensearch Client with AwsSigv4Signer and pass it as
+// `client` instead of host/port/user/password.
+const config = {
+  vectorStore: {
+    provider: 'opensearch',
+    config: {
+      collectionName: 'mem0',
+      embeddingModelDims: 1024,
+      host: 'localhost',
+      port: 9200,
+      user: 'admin',
+      password: 'admin',
+      useSSL: false,
+      verifyCerts: false,
+    },
+  },
+};
+
+const memory = new Memory(config);
+const messages = [
+  { role: "user", content: "I'm planning to watch a movie tonight. Any recommendations?" },
+  { role: "assistant", content: "How about thriller movies? They can be quite engaging." },
+  { role: "user", content: "I'm not a big fan of thriller movies but I love sci-fi movies." },
+  { role: "assistant", content: "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future." },
+];
+await memory.add(messages, { userId: "alice", metadata: { category: "movies" } });
+```
+</CodeGroup>
+
 ### Configuration Options

+<Tabs>
+<Tab title="Python">
 | Parameter | Type | Default | Description |
 |-----------|------|---------|-------------|
 | `collection_name` | string | required | Name of the OpenSearch index |
@@ -68,6 +110,23 @@ config = {
 | `use_ssl` | bool | False | Enable SSL/TLS connection |
 | `verify_certs` | bool | False | Verify SSL certificates |
 | `auto_refresh` | bool | False | Automatically refresh index after insert. OpenSearch refreshes every ~1 second by default, so this is rarely needed. |
+</Tab>
+<Tab title="TypeScript">
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `collectionName` | string | required | Name of the OpenSearch index |
+| `embeddingModelDims` | number | 1536 | Dimension of embedding vectors |
+| `host` | string | `localhost` | OpenSearch endpoint host |
+| `port` | number | 9200 | Port number |
+| `httpAuth` | object | None | Authentication credentials, an object or `[user, password]` tuple |
+| `user` | string | None | Username for basic auth (used together with `password`) |
+| `password` | string | None | Password for basic auth (used together with `user`) |
+| `useSSL` | boolean | false | Enable SSL/TLS connection |
+| `verifyCerts` | boolean | false | Verify SSL certificates |
+| `autoRefresh` | boolean | false | Refresh the index after each write so new memories are searchable immediately. Not supported on AWS Serverless. |
+| `client` | object | None | Preconfigured OpenSearch client, e.g. one built with AwsSigv4Signer for AWS auth |
+</Tab>
+</Tabs>

 <Note>
  The defaults above match a local OpenSearch instance. The AWS OpenSearch Serverless
@@ -10,7 +10,8 @@ description: "Use Pinecone as a fully managed vector database in Mem0 with serve

 ### Usage

-```python
+<CodeGroup>
+```python Python
 import os
 from mem0 import Memory

@@ -44,10 +45,43 @@ messages = [
 m.add(messages, user_id="alice", metadata={"category": "movies"})
 ```

+```typescript TypeScript
+import { Memory } from 'mem0ai/oss';
+
+// Set OPENAI_API_KEY and PINECONE_API_KEY in your environment
+const config = {
+  vectorStore: {
+    provider: 'pinecone',
+    config: {
+      collectionName: 'testing',
+      embeddingModelDims: 1536, // Matches OpenAI's text-embedding-3-small
+      namespace: 'my-namespace', // Optional: specify a namespace for multi-tenancy
+      serverlessConfig: {
+        cloud: 'aws', // 'aws' | 'gcp' | 'azure'
+        region: 'us-east-1',
+      },
+      metric: 'cosine',
+    },
+  },
+};
+
+const memory = new Memory(config);
+const messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+await memory.add(messages, { userId: "alice", metadata: { category: "movies" } });
+```
+</CodeGroup>
+
 ### Config

 Here are the parameters available for configuring Pinecone:

+<Tabs>
+<Tab title="Python">
 | Parameter | Description | Default Value |
 | --- | --- | --- |
 | `collection_name` | Name of the index/collection | Required |
@@ -61,11 +95,28 @@ Here are the parameters available for configuring Pinecone:
 | `metric` | Distance metric for vector similarity | `"cosine"` |
 | `batch_size` | Batch size for operations | `100` |
 | `namespace` | Namespace for the collection, useful for multi-tenancy. | `None` |
+</Tab>
+<Tab title="TypeScript">
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `collectionName` | Name of the index/collection | Required |
+| `embeddingModelDims` | Dimensions of the embedding model (must match your chosen embedding model) | `1536` |
+| `client` | Existing Pinecone client instance | `undefined` |
+| `apiKey` | API key for Pinecone | Environment variable: `PINECONE_API_KEY` |
+| `serverlessConfig` | Configuration for serverless deployment (`cloud`, `region`) | `undefined` |
+| `podConfig` | Configuration for pod-based deployment (`environment`, `podType`, `pods`, `replicas`, `shards`) | `undefined` |
+| `metric` | Distance metric for vector similarity (`cosine`, `dotproduct`, `euclidean`) | `"cosine"` |
+| `batchSize` | Batch size for insert operations | `100` |
+| `namespace` | Namespace for the collection, useful for multi-tenancy. | `undefined` |
+| `extraParams` | Extra parameters spread into the Pinecone `createIndex` call | `{}` |
+</Tab>
+</Tabs>

 > **Important**: You must choose either `serverless_config` or `pod_config` for your deployment, but not both.

 #### Serverless Config Example
-```python
+<CodeGroup>
+```python Python
 config = {
    "vector_store": {
        "provider": "pinecone",
@@ -82,8 +133,27 @@ config = {
 }
 ```

+```typescript TypeScript
+const config = {
+  vectorStore: {
+    provider: 'pinecone',
+    config: {
+      collectionName: 'memory_index',
+      embeddingModelDims: 1536, // For OpenAI's text-embedding-3-small
+      namespace: 'my-namespace', // Optional: custom namespace
+      serverlessConfig: {
+        cloud: 'aws', // 'gcp' | 'azure'
+        region: 'us-east-1', // Choose appropriate region
+      },
+    },
+  },
+};
+```
+</CodeGroup>
+
 #### Pod Config Example
-```python
+<CodeGroup>
+```python Python
 config = {
    "vector_store": {
        "provider": "pinecone",
@@ -99,4 +169,23 @@ config = {
        }
    }
 }
-```
+```
+
+```typescript TypeScript
+const config = {
+  vectorStore: {
+    provider: 'pinecone',
+    config: {
+      collectionName: 'memory_index',
+      embeddingModelDims: 1536, // For OpenAI's text-embedding-ada-002
+      namespace: 'my-namespace', // Optional: custom namespace
+      podConfig: {
+        environment: 'gcp-starter',
+        replicas: 1,
+        podType: 'starter',
+      },
+    },
+  },
+};
+```
+</CodeGroup>
@@ -42,7 +42,7 @@ const config = {
    provider: 'qdrant',
    config: {
      collectionName: 'memories',
-      embeddingModelDims: 1536,
+      dimension: 1536,
      host: 'localhost',
      port: 6333,
    },
@@ -83,7 +83,7 @@ Let's see the available parameters for the `qdrant` config:
 | Parameter | Description | Default Value |
 | --- | --- | --- |
 | `collectionName` | The name of the collection to store the vectors | `mem0` |
-| `embeddingModelDims` | Dimensions of the embedding model | `1536` |
+| `dimension` | Dimensions of the embedding model | `1536` |
 | `host` | The host where the Qdrant server is running | `None` |
 | `port` | The port where the Qdrant server is running | `None` |
 | `path` | Path for the Qdrant database | `/tmp/qdrant` |
@@ -9,15 +9,22 @@ description: "Use Amazon S3 Vectors as a cost-optimized vector storage service i

 S3 Vectors support requires additional dependencies. Install them with:

-```bash
+<CodeGroup>
+```bash Python
 pip install boto3
 ```

+```bash TypeScript
+npm install @aws-sdk/client-s3vectors
+```
+</CodeGroup>
+
 ### Usage

 To use Amazon S3 Vectors with Mem0, you need to have an AWS account and the necessary IAM permissions (`s3vectors:*`). Ensure your environment is configured with AWS credentials (e.g., via `~/.aws/credentials` or environment variables).

-```python
+<CodeGroup>
+```python Python
 import os
 from mem0 import Memory

@@ -47,6 +54,36 @@ messages = [
 m.add(messages, user_id="alice", metadata={"category": "movies"})
 ```

+```typescript TypeScript
+import { Memory } from 'mem0ai/oss';
+
+// Ensure your AWS credentials are configured in your environment
+// e.g., by setting AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, and AWS_DEFAULT_REGION
+
+const config = {
+  vectorStore: {
+    provider: 's3_vectors',
+    config: {
+      vectorBucketName: 'my-mem0-vector-bucket',
+      collectionName: 'my-memories-index',
+      embeddingModelDims: 1536,
+      distanceMetric: 'cosine',
+      region: 'us-east-1',
+    },
+  },
+};
+
+const memory = new Memory(config);
+const messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a thriller movie? They can be quite engaging."},
+    {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
+]
+await memory.add(messages, { userId: "alice", metadata: { category: "movies" } });
+```
+</CodeGroup>
+
 ### Config

 Here are the parameters available for configuring Amazon S3 Vectors:
@@ -6,7 +6,8 @@ description: "Use Turbopuffer as a serverless vector database in Mem0 for low-la

 ### Usage

-```python
+<CodeGroup>
+```python Python
 import os
 from mem0 import Memory

@@ -39,6 +40,36 @@ m.add(messages, user_id="alice", metadata={"category": "movies"})
 results = m.search(query="sci-fi recommendations", filters={"user_id": "alice"})
 ```

+```typescript TypeScript
+import { Memory } from "mem0ai/oss";
+
+// Set TURBOPUFFER_API_KEY in your environment, or pass it as config.apiKey below.
+const config = {
+  vectorStore: {
+    provider: "turbopuffer",
+    config: {
+      collectionName: "movie_preferences",
+      region: "gcp-us-central1",
+    },
+  },
+};
+
+const memory = new Memory(config);
+
+const messages = [
+  { role: "user", content: "I'm planning to watch a movie tonight. Any recommendations?" },
+  { role: "assistant", content: "How about thriller movies? They can be quite engaging." },
+  { role: "user", content: "I'm not a big fan of thrillers but I love sci-fi." },
+  { role: "assistant", content: "Got it! I'll suggest sci-fi movies instead." },
+];
+
+await memory.add(messages, { userId: "alice", metadata: { category: "movies" } });
+
+// Search memories
+const results = await memory.search("sci-fi recommendations", { userId: "alice" });
+```
+</CodeGroup>
+
 ### Config

 Here are the parameters available for configuring Turbopuffer:
@@ -53,6 +84,10 @@ Here are the parameters available for configuring Turbopuffer:
 | `batch_size` | Batch size for bulk operations | `100` |
 | `extra_params` | Additional parameters for the Turbopuffer client | `None` |

+<Note>
+**TypeScript (Node.js) config keys** are camelCase: `collectionName`, `apiKey`, `region`, `distanceMetric`, and `batchSize`. The TypeScript SDK infers the vector dimension from your embedder, so `embeddingModelDims` is not required.
+</Note>
+
 ### Regions

 | Region | Location |
@@ -62,7 +97,8 @@ Here are the parameters available for configuring Turbopuffer:

 ### Config Example

-```python
+<CodeGroup>
+```python Python
 config = {
    "vector_store": {
        "provider": "turbopuffer",
@@ -77,3 +113,19 @@ config = {
    }
 }
 ```
+
+```typescript TypeScript
+const config = {
+  vectorStore: {
+    provider: "turbopuffer",
+    config: {
+      collectionName: "my_memories",
+      apiKey: "tpuf_xxxxxxxxxxxx",
+      region: "aws-us-west-2",
+      distanceMetric: "cosine_distance",
+      batchSize: 200,
+    },
+  },
+};
+```
+</CodeGroup>
@@ -8,6 +8,10 @@ description: "Use Upstash Vector as a serverless vector database in Mem0 with op

 You can enable the built-in embedding models by setting `enable_embeddings` to `True`. This allows you to use Upstash's embedding models for vectorization.

+<Note>
+    Server-side Upstash embeddings (`enable_embeddings`) are available in the Python SDK only. The TypeScript SDK always embeds text with your configured embedder before writing to Upstash, so use the external embedding provider setup below.
+</Note>
+
 ```python
 import os
 from mem0 import Memory
@@ -34,7 +38,8 @@ m.add("Likes to play cricket on weekends", user_id="alice", metadata={"category"

 ### Usage with external embedding providers

-```python
+<CodeGroup>
+```python Python
 import os
 from mem0 import Memory

@@ -58,6 +63,36 @@ m = Memory.from_config(config)
 m.add("Likes to play cricket on weekends", user_id="alice", metadata={"category": "hobbies"})
 ```

+```typescript TypeScript
+import { Memory } from "mem0ai/oss";
+
+// Set OPENAI_API_KEY, UPSTASH_VECTOR_REST_URL, and UPSTASH_VECTOR_REST_TOKEN in your environment.
+const config = {
+  embedder: {
+    provider: "openai",
+    config: {
+      apiKey: process.env.OPENAI_API_KEY,
+      model: "text-embedding-3-large",
+    },
+  },
+  vectorStore: {
+    provider: "upstash_vector",
+    config: {
+      collectionName: "memories",
+      url: process.env.UPSTASH_VECTOR_REST_URL,
+      token: process.env.UPSTASH_VECTOR_REST_TOKEN,
+    },
+  },
+};
+
+const memory = new Memory(config);
+await memory.add("Likes to play cricket on weekends", {
+  userId: "alice",
+  metadata: { category: "hobbies" },
+});
+```
+</CodeGroup>
+
 ### Config

 Here are the parameters available for configuring Upstash Vector:
@@ -74,3 +109,7 @@ Here are the parameters available for configuring Upstash Vector:
  When `url` and `token` are not provided, the `UPSTASH_VECTOR_REST_URL` and
  `UPSTASH_VECTOR_REST_TOKEN` environment variables are used.
 </Note>
+
+<Note>
+  The TypeScript SDK uses camelCase config keys (`collectionName`, `url`, `token`), where `collectionName` is required. Pass `url` and `token` (or a preconfigured `client`) explicitly, since the TypeScript SDK does not read them from environment variables. `enable_embeddings` is not supported in TypeScript.
+</Note>
@@ -14,7 +14,8 @@ pip install mem0ai[vector-stores]

 ## Usage

-```python
+<CodeGroup>
+```python Python
 config = {
    "vector_store": {
        "provider": "valkey",
@@ -37,8 +38,36 @@ messages = [
 m.add(messages, user_id="alice", metadata={"category": "movies"})
 ```

+```typescript TypeScript
+import { Memory } from 'mem0ai/oss';
+
+const config = {
+  vectorStore: {
+    provider: 'valkey',
+    config: {
+      collectionName: 'test',
+      valkeyUrl: 'valkey://localhost:6379',
+      embeddingModelDims: 1536,
+      indexType: 'flat',
+    },
+  },
+};
+
+const memory = new Memory(config);
+const messages = [
+  { role: 'user', content: "I'm planning to watch a movie tonight. Any recommendations?" },
+  { role: 'assistant', content: 'How about thriller movies? They can be quite engaging.' },
+  { role: 'user', content: "I'm not a big fan of thriller movies but I love sci-fi movies." },
+  { role: 'assistant', content: "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future." },
+];
+await memory.add(messages, { userId: 'alice', metadata: { category: 'movies' } });
+```
+</CodeGroup>
+
 ## Parameters

+<Tabs>
+<Tab title="Python">
 Here are the parameters available for configuring Valkey:

 | Parameter | Description | Default Value |
@@ -52,6 +81,22 @@ Here are the parameters available for configuring Valkey:
 | `hnsw_ef_runtime` | Size of dynamic candidate list for search | `10` |
 | `cluster_mode` | Enable cluster mode for Valkey cluster (CME) deployments | `false` |
 | `timezone` | Timezone for timestamp handling | `UTC` |
+</Tab>
+<Tab title="TypeScript">
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `collectionName` | The name of the collection to store the vectors | `mem0` |
+| `valkeyUrl` | Connection URL for the Valkey server | `valkey://localhost:6379` |
+| `embeddingModelDims` | Dimensions of the embedding model | `1536` |
+| `indexType` | Vector index algorithm (`hnsw` or `flat`) | `hnsw` |
+| `hnswM` | Number of bi-directional links for HNSW | `16` |
+| `hnswEfConstruction` | Size of dynamic candidate list for HNSW | `200` |
+| `hnswEfRuntime` | Size of dynamic candidate list for search | `10` |
+| `clusterMode` | Enable cluster mode for Valkey cluster (CME) deployments | `false` |
+| `timezone` | Timezone for timestamp handling | `UTC` |
+</Tab>
+</Tabs>
+

 ## Cluster Mode

@@ -8,8 +8,8 @@ description: "Use Google Cloud Vertex AI Vector Search as a managed vector store

 To use Google Cloud Vertex AI Vector Search with `mem0`, you need to configure the `vector_store` in your `mem0` config:

-
-```python
+<CodeGroup>
+```python Python
 import os
 from mem0 import Memory

@@ -20,7 +20,7 @@ config = {
        "provider": "vertex_ai_vector_search",
        "config": {
            "endpoint_id": "YOUR_ENDPOINT_ID",            # Required: Vector Search endpoint ID
-            "index_id": "YOUR_INDEX_ID",                  # Required: Vector Search index ID 
+            "index_id": "YOUR_INDEX_ID",                  # Required: Vector Search index ID
            "deployment_index_id": "YOUR_DEPLOYMENT_INDEX_ID",  # Required: Deployment-specific ID
            "project_id": "YOUR_PROJECT_ID",              # Required: Google Cloud project ID
            "project_number": "YOUR_PROJECT_NUMBER",      # Required: Google Cloud project number
@@ -34,9 +34,40 @@ m = Memory.from_config(config)
 m.add("Your text here", user_id="user", metadata={"category": "example"})
 ```

+```typescript TypeScript
+import { Memory } from "mem0ai/oss";
+
+// Authenticate with GOOGLE_APPLICATION_CREDENTIALS in your environment,
+// or pass credentialsPath / serviceAccountJson in the config below.
+const config = {
+  vectorStore: {
+    provider: "vertex_ai_vector_search",
+    config: {
+      endpointId: "YOUR_ENDPOINT_ID", // Required: Vector Search endpoint ID
+      indexId: "YOUR_INDEX_ID", // Required: Vector Search index ID
+      deploymentIndexId: "YOUR_DEPLOYMENT_INDEX_ID", // Required: Deployment-specific ID
+      projectId: "YOUR_PROJECT_ID", // Required: Google Cloud project ID
+      projectNumber: "YOUR_PROJECT_NUMBER", // Required: Google Cloud project number
+      region: "YOUR_REGION", // Required: Google Cloud region
+      credentialsPath: "path/to/credentials.json", // Optional: defaults to GOOGLE_APPLICATION_CREDENTIALS
+      vectorSearchApiEndpoint: "YOUR_API_ENDPOINT", // Required for search/get operations
+    },
+  },
+};
+
+const memory = new Memory(config);
+await memory.add("Your text here", {
+  userId: "user",
+  metadata: { category: "example" },
+});
+```
+</CodeGroup>
+

 ### Required Parameters

+<Tabs>
+<Tab title="Python">
 | Parameter | Description | Required |
 |-----------|-------------|----------|
 | `endpoint_id` | Vector Search endpoint ID | Yes |
@@ -48,3 +79,18 @@ m.add("Your text here", user_id="user", metadata={"category": "example"})
 | `region` | Google Cloud region | Yes |
 | `credentials_path` | Path to service account credentials | No (defaults to GOOGLE_APPLICATION_CREDENTIALS) |
 | `service_account_json` | Service account credentials as a dictionary (alternative to `credentials_path`) | `None` |
+</Tab>
+<Tab title="TypeScript">
+| Parameter | Description | Required |
+|-----------|-------------|----------|
+| `endpointId` | Vector Search endpoint ID | Yes |
+| `indexId` | Vector Search index ID | Yes |
+| `deploymentIndexId` | Deployment-specific index ID | Yes |
+| `projectId` | Google Cloud project ID | Yes |
+| `projectNumber` | Google Cloud project number | Yes |
+| `vectorSearchApiEndpoint` | Vector search API endpoint | Yes (for get operations) |
+| `region` | Google Cloud region | Yes |
+| `credentialsPath` | Path to service account credentials | No (defaults to GOOGLE_APPLICATION_CREDENTIALS) |
+| `serviceAccountJson` | Service account credentials as an object (alternative to `credentialsPath`) | No |
+</Tab>
+</Tabs>
@@ -4,14 +4,21 @@ description: "Use Weaviate as an open-source vector search engine in Mem0 for st
 ---
 [Weaviate](https://weaviate.io/) is an open-source vector search engine. It allows efficient storage and retrieval of high-dimensional vector embeddings, enabling powerful search and retrieval capabilities.

-
 ### Installation
-```bash
+
+<CodeGroup>
+```bash Python
 pip install weaviate-client
 ```

+```bash TypeScript
+npm install weaviate-client
+```
+</CodeGroup>
+
 ### Usage

+<CodeGroup>
 ```python Python
 import os
 from mem0 import Memory
@@ -33,20 +40,73 @@ m = Memory.from_config(config)
 messages = [
    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
    {"role": "assistant", "content": "How about a thriller movie? They can be quite engaging."},
-    {"role": "user", "content": "I’m not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
 ]
 m.add(messages, user_id="alice", metadata={"category": "movies"})
 ```

+```typescript TypeScript
+import { Memory } from "mem0ai/oss";
+
+const config = {
+  vectorStore: {
+    provider: "weaviate",
+    config: {
+      collectionName: "test",
+      embeddingModelDims: 1536,
+      clusterUrl: "http://localhost:8080",
+    },
+  },
+};
+
+const memory = new Memory(config);
+
+const messages = [
+  {
+    role: "user",
+    content: "I'm planning to watch a movie tonight. Any recommendations?",
+  },
+  {
+    role: "assistant",
+    content: "How about a thriller movie? They can be quite engaging.",
+  },
+  {
+    role: "user",
+    content: "I'm not a big fan of thriller movies but I love sci-fi movies.",
+  },
+  {
+    role: "assistant",
+    content:
+      "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future.",
+  },
+];
+
+await memory.add(messages, {
+  userId: "alice",
+  metadata: {
+    category: "movies",
+  },
+});
+```
+</CodeGroup>
+
+The TypeScript SDK picks the connection mode from the config you pass:
+
+- `clusterUrl` pointing at `localhost` connects to a local instance.
+- `clusterUrl` plus `apiKey` connects to a Weaviate Cloud cluster (for example `https://my-cluster.weaviate.cloud`).
+- Any other `clusterUrl` without an `apiKey` connects to a custom deployment, using the host and port from the URL.
+
+You can also pass a pre-configured `client` (a `WeaviateClient` instance) to reuse an existing connection.
+
 ### Config

 Here are the parameters available for configuring Weaviate:

-| Parameter | Description | Default Value |
-| --- | --- | --- |
-| `collection_name` | The name of the collection to store the vectors | `mem0` |
-| `embedding_model_dims` | Dimensions of the embedding model | `1536` |
-| `cluster_url` | URL for the Weaviate server | `None` |
-| `auth_client_secret` | API key for Weaviate authentication | `None` |
-| `additional_headers` | Additional headers to include in requests (`Dict[str, str]`) | `None` |
+| Python | TypeScript | Description | Default Value |
+| --- | --- | --- | --- |
+| `collection_name` | `collectionName` | The name of the collection to store the vectors | `mem0` |
+| `embedding_model_dims` | `embeddingModelDims` | Dimensions of the embedding model | `1536` |
+| `cluster_url` | `clusterUrl` | URL for the Weaviate server | `None` |
+| `auth_client_secret` | `apiKey` | API key for Weaviate authentication | `None` |
+| `additional_headers` | `additionalHeaders` | Additional headers to include in requests | `None` |
@@ -10,30 +10,31 @@ Mem0 includes built-in support for various popular databases. Memory can utilize
 See the list of supported vector databases below.

 <Note>
-  The following vector databases are supported in the Python implementation. The TypeScript implementation currently supports Qdrant, Redis, PGVector, Supabase, LangChain, Azure AI Search, Vectorize, and an in-memory store.
+  The following vector databases are supported in the Python implementation. The TypeScript implementation currently supports Qdrant, Redis, PGVector, Supabase, LangChain, Azure AI Search, Vectorize, Amazon S3 Vectors, Milvus, Neptune Analytics, and an in-memory store.
 </Note>

 <CardGroup cols={3}>
-  <Card title="Qdrant" href="/components/vectordbs/dbs/qdrant"></Card>
-  <Card title="Chroma" href="/components/vectordbs/dbs/chroma"></Card>
-  <Card title="PGVector" href="/components/vectordbs/dbs/pgvector"></Card>
-  <Card title="Upstash Vector" href="/components/vectordbs/dbs/upstash-vector"></Card>
-  <Card title="Milvus" href="/components/vectordbs/dbs/milvus"></Card>
-  <Card title="Pinecone" href="/components/vectordbs/dbs/pinecone"></Card>
-  <Card title="MongoDB" href="/components/vectordbs/dbs/mongodb"></Card>
-  <Card title="Azure" href="/components/vectordbs/dbs/azure"></Card>
-  <Card title="Redis" href="/components/vectordbs/dbs/redis"></Card>
-  <Card title="Valkey" href="/components/vectordbs/dbs/valkey"></Card>
-  <Card title="Elasticsearch" href="/components/vectordbs/dbs/elasticsearch"></Card>
-  <Card title="OpenSearch" href="/components/vectordbs/dbs/opensearch"></Card>
-  <Card title="Supabase" href="/components/vectordbs/dbs/supabase"></Card>
-  <Card title="Vertex AI" href="/components/vectordbs/dbs/vertex_ai"></Card>
-  <Card title="Weaviate" href="/components/vectordbs/dbs/weaviate"></Card>
-  <Card title="FAISS" href="/components/vectordbs/dbs/faiss"></Card>
-  <Card title="LangChain" href="/components/vectordbs/dbs/langchain"></Card>
-  <Card title="Amazon S3 Vectors" href="/components/vectordbs/dbs/s3_vectors"></Card>
-  <Card title="Databricks" href="/components/vectordbs/dbs/databricks"></Card>
-  <Card title="Turbopuffer" href="/components/vectordbs/dbs/turbopuffer"></Card>
+  <Card title="Qdrant" icon="/images/provider-icons/qdrant.svg" href="/components/vectordbs/dbs/qdrant"></Card>
+  <Card title="Chroma" icon="/images/provider-icons/chroma.svg" href="/components/vectordbs/dbs/chroma"></Card>
+  <Card title="PGVector" icon="/images/provider-icons/postgresql.svg" href="/components/vectordbs/dbs/pgvector"></Card>
+  <Card title="Upstash Vector" icon="/images/provider-icons/upstash.svg" href="/components/vectordbs/dbs/upstash-vector"></Card>
+  <Card title="Milvus" icon="/images/provider-icons/milvus.svg" href="/components/vectordbs/dbs/milvus"></Card>
+  <Card title="Pinecone" icon="/images/provider-icons/pinecone.svg" href="/components/vectordbs/dbs/pinecone"></Card>
+  <Card title="MongoDB" icon="/images/provider-icons/mongodb.svg" href="/components/vectordbs/dbs/mongodb"></Card>
+  <Card title="Azure" icon="/images/provider-icons/azure-color.svg" href="/components/vectordbs/dbs/azure"></Card>
+  <Card title="Redis" icon="/images/provider-icons/redis.svg" href="/components/vectordbs/dbs/redis"></Card>
+  <Card title="Valkey" icon="/images/provider-icons/valkey.svg" href="/components/vectordbs/dbs/valkey"></Card>
+  <Card title="Elasticsearch" icon="/images/provider-icons/elasticsearch.svg" href="/components/vectordbs/dbs/elasticsearch"></Card>
+  <Card title="OpenSearch" icon="/images/provider-icons/opensearch.svg" href="/components/vectordbs/dbs/opensearch"></Card>
+  <Card title="Supabase" icon="/images/provider-icons/supabase.svg" href="/components/vectordbs/dbs/supabase"></Card>
+  <Card title="Vertex AI" icon="/images/provider-icons/vertexai.svg" href="/components/vectordbs/dbs/vertex_ai"></Card>
+  <Card title="Weaviate" icon="circle-nodes" href="/components/vectordbs/dbs/weaviate"></Card>
+  <Card title="FAISS" icon="layer-group" href="/components/vectordbs/dbs/faiss"></Card>
+  <Card title="LangChain" icon="/images/provider-icons/langchain-color.svg" href="/components/vectordbs/dbs/langchain"></Card>
+  <Card title="Amazon S3 Vectors" icon="/images/provider-icons/aws-color.svg" href="/components/vectordbs/dbs/s3_vectors"></Card>
+  <Card title="Neptune Analytics" icon="/images/provider-icons/aws-color.svg" href="/components/vectordbs/dbs/neptune_analytics"></Card>
+  <Card title="Databricks" icon="/images/provider-icons/databricks.svg" href="/components/vectordbs/dbs/databricks"></Card>
+  <Card title="Turbopuffer" icon="/images/provider-icons/turbopuffer.svg" href="/components/vectordbs/dbs/turbopuffer"></Card>
 </CardGroup>

 ## Usage
@@ -123,3 +123,5 @@ As the conversation progresses, Mem0's memory automatically updates based on the
    Build a travel companion that remembers preferences and past conversations.
  </Card>
 </CardGroup>
+
+<Snippet file="star-on-github.mdx" />
@@ -81,3 +81,5 @@ This local setup of Mem0 using Ollama provides a fully self-contained solution f
    Learn core companion patterns that work with any LLM provider.
  </Card>
 </CardGroup>
+
+<Snippet file="star-on-github.mdx" />
@@ -137,3 +137,5 @@ As users interact with the system, Mem0's memory system continuously learns and
    Run the full showcase app to see memory-powered companions in action.
  </Card>
 </CardGroup>
+
+<Snippet file="star-on-github.mdx" />
@@ -78,3 +78,5 @@ This setup demonstrates how to build an AI Companion that maintains memory acros
    Implement a command-line companion using the Node.js SDK.
  </Card>
 </CardGroup>
+
+<Snippet file="star-on-github.mdx" />
@@ -211,3 +211,5 @@ This Personalized AI Travel Assistant leverages Mem0's memory capabilities to pr
    Build an educational companion that remembers learning progress and preferences.
  </Card>
 </CardGroup>
+
+<Snippet file="star-on-github.mdx" />
@@ -156,7 +156,7 @@ def create_memory_voice_agent():
            """You're speaking to a human, so be polite and concise.
            Always respond in clear, natural English.
            You have the ability to remember information about the user.
-            Use the save_memories tool when the user shares an important information worth remembering.
+            Use the save_memories tool when the user shares important information worth remembering.
            Use the search_memories tool when you need context from past conversations or user asks you to recall something.
            """,
        ),
@@ -362,7 +362,7 @@ def create_memory_voice_agent():
            """You're speaking to a human, so be polite and concise.
            Always respond in clear, natural English.
            You have the ability to remember information about the user.
-            Use the save_memories tool when the user shares an important information worth remembering.
+            Use the save_memories tool when the user shares important information worth remembering.
            Use the search_memories tool when you need context from past conversations or user asks you to recall something.
            """,
        ),
@@ -544,3 +544,5 @@ async def save_memories(
    Master the core patterns for building memory-powered companions.
  </Card>
 </CardGroup>
+
+<Snippet file="star-on-github.mdx" />
@@ -66,3 +66,5 @@ Your API keys are stored locally in your browser. Your messages are sent to the
    Combine memory with search tools to conduct comprehensive research projects.
  </Card>
 </CardGroup>
+
+<Snippet file="star-on-github.mdx" />
@@ -588,9 +588,9 @@ mem0_client.project.update(
    Exclude: greetings, filler, casual chat
    """,
    custom_categories=[
-        {"name": "goals", "description": "Training targets"},
-        {"name": "constraints", "description": "Injuries and limitations"},
-        {"name": "preferences", "description": "Training style"}
+        {"goals": "Training targets"},
+        {"constraints": "Injuries and limitations"},
+        {"preferences": "Training style"}
    ]
 )
 ```
@@ -973,3 +973,5 @@ Before launching:
    Organize customer context to keep assistants responsive at scale.
  </Card>
 </CardGroup>
+
+<Snippet file="star-on-github.mdx" />
@@ -512,3 +512,5 @@ Start with conservative filters (only store confirmed facts) and iterate based o
 <Card title="Build a Mem0 Companion" icon="users" href="/cookbooks/essentials/building-ai-companion">
  Learn core memory patterns including temporary vs permanent data handling.
 </Card>
+
+<Snippet file="star-on-github.mdx" />
@@ -334,3 +334,5 @@ You learned how to:
    href="/cookbooks/essentials/controlling-memory-ingestion"
  />
 </CardGroup>
+
+<Snippet file="star-on-github.mdx" />
@@ -128,7 +128,7 @@ Dev works at TechCorp as a senior engineer (score: 0.89)

 ```

-Search works across all memory fields and ranks by relevance. Use it when you have a specific question, use `get_all()` when you need everything.
+Search works across all memory fields and ranks by relevance. Use it when you have a specific question; use `get_all()` when you need everything.

 ---

@@ -288,3 +288,5 @@ Use **`get_all()`** for bulk retrieval, **`search()`** for specific questions, a
    Ensure only verified insights make it into your export pipeline.
  </Card>
 </CardGroup>
+
+<Snippet file="star-on-github.mdx" />
@@ -19,7 +19,7 @@ client = MemoryClient(api_key="your-api-key")
 ```

 <Note>
-Define custom categories at the **project level** with `client.project.update()` before adding memories. Categories apply to all future memories: Mem0 auto-assigns them based on content semantics.
+Define custom categories at the **project level** with `client.project.update()` before adding memories. Categories apply to all future memories: Mem0 auto-assigns them based on content semantics. You can also pass `custom_categories` on a single `client.add()` call to override the project list for just those memories. See [Custom Categories](/platform/features/custom-categories).
 </Note>

 ---
@@ -96,6 +96,10 @@ Start with 3-5 clear categories that match how your team thinks. Too many catego

 These categories are now available project-wide. Every memory can be tagged with one or more categories.

+<Tip>
+Need a different vocabulary for one tenant or one kind of conversation? Pass `custom_categories=[...]` to `client.add()`. That list replaces the project list for the memories created by that call, and it does not change the project configuration.
+</Tip>
+
 ---

 ## Tagging Memories
@@ -249,3 +253,5 @@ Instead of searching through everything, agents jump directly to the information
    Use categories to drive audits, migrations, and compliance reports.
  </Card>
 </CardGroup>
+
+<Snippet file="star-on-github.mdx" />
@@ -83,3 +83,5 @@ This is a simple example of how to use Mem0 to create a personalized AI agent. Y
    Build another type of personalized companion with memory capabilities.
  </Card>
 </CardGroup>
+
+<Snippet file="star-on-github.mdx" />
@@ -238,17 +238,13 @@ You've successfully built a Gemini 3 agent with persistent memory using Mem0's M

 ## Next Steps

-<CardGroup cols={2}>
-  <Card
-    title="MCP Integration Feature"
-    description="Learn about MCP configuration options and deployment methods"
-    icon="plug"
-    href="/platform/features/mcp-integration"
-  />
+<CardGroup cols={1}>
  <Card
    title="MCP Quickstart"
    description="Get started with MCP for any AI client in minutes"
    icon="rocket"
    href="/platform/mem0-mcp"
  />
-</CardGroup>
+</CardGroup>
+
+<Snippet file="star-on-github.mdx" />
@@ -369,3 +369,5 @@ Based on our previous session, I remember we covered Vision Language Models and
    Learn how to scope memories across multiple agents, users, and sessions.
  </Card>
 </CardGroup>
+
+<Snippet file="star-on-github.mdx" />
@@ -197,3 +197,5 @@ I've ordered a pizza for you, and the bill has been sent to your email. Enjoy yo
    Master the core patterns for memory-powered agents across frameworks.
  </Card>
 </CardGroup>
+
+<Snippet file="star-on-github.mdx" />
@@ -41,3 +41,5 @@ Visit [multimodal-demo.mem0.ai](https://multimodal-demo.mem0.ai) to experience M
    Build voice-first companions that remember conversations.
  </Card>
 </CardGroup>
+
+<Snippet file="star-on-github.mdx" />
@@ -236,3 +236,5 @@ context = Mem0Context(user_id="user123")
    Learn the core patterns for memory-powered agents with any SDK.
  </Card>
 </CardGroup>
+
+<Snippet file="star-on-github.mdx" />
@@ -129,3 +129,5 @@ With Mem0 and AWS services like Bedrock and OpenSearch, you can build intelligen
    Understand how Mem0's memory system is benchmarked and evaluated.
  </Card>
 </CardGroup>
+
+<Snippet file="star-on-github.mdx" />
@@ -299,3 +299,5 @@ By storing and retrieving patient information intelligently, the assistant provi
    Apply similar memory patterns to customer support workflows.
  </Card>
 </CardGroup>
+
+<Snippet file="star-on-github.mdx" />
@@ -136,3 +136,5 @@ In the example above:
    Explore tool-calling patterns with the OpenAI Agents SDK.
  </Card>
 </CardGroup>
+
+<Snippet file="star-on-github.mdx" />
@@ -295,3 +295,5 @@ run().catch(console.error);
    Fine-tune what memories get stored during tool calls.
  </Card>
 </CardGroup>
+
+<Snippet file="star-on-github.mdx" />
@@ -39,7 +39,7 @@ Let’s break down the main components.

 ### 1: Initialize Mem0 with Custom Instructions

-We configure Mem0 with custom instructions that guide it to infer user memories tailored specifically for our usecase.
+We configure Mem0 with custom instructions that guide it to infer user memories tailored specifically for our use case.

 ```python
 from mem0 import MemoryClient
@@ -202,3 +202,5 @@ Full Code: [Personalized Search GitHub](https://github.com/mem0ai/mem0/blob/main
    Categorize search results and user preferences for better personalization.
  </Card>
 </CardGroup>
+
+<Snippet file="star-on-github.mdx" />
@@ -364,3 +364,5 @@ Mem0 enables a seamless, intelligent content-writing workflow, perfect for conte
    Automate email drafting with memory-powered context and tone matching.
  </Card>
 </CardGroup>
+
+<Snippet file="star-on-github.mdx" />
@@ -77,3 +77,5 @@ Watch Deep Research in action:
    Build a video research assistant that remembers insights from content.
  </Card>
 </CardGroup>
+
+<Snippet file="star-on-github.mdx" />
@@ -432,3 +432,5 @@ By combining Mem0's memory capabilities with email processing, you can create in
    Build customer support agents that remember context across tickets.
  </Card>
 </CardGroup>
+
+<Snippet file="star-on-github.mdx" />
@@ -121,3 +121,5 @@ As the conversation progresses, Mem0's memory automatically updates based on the
    Extend support capabilities with intelligent email processing and routing.
  </Card>
 </CardGroup>
+
+<Snippet file="star-on-github.mdx" />
@@ -134,3 +134,5 @@ Mem0 enables fast, transparent collaboration for teams and agents, with full att
    Apply collaborative memory patterns to customer support scenarios.
  </Card>
 </CardGroup>
+
+<Snippet file="star-on-github.mdx" />
@@ -9,10 +9,26 @@ With Mem0, you can create stateful LLM-based applications such as chatbots, virt
 - More reliable
 - Cost-effective by reducing the number of LLM interactions
 - More engaging
- Enables long-term memory
+- Enriched by long-term memory

 Here are some examples of how Mem0 can be integrated into various applications:

+## Start here
+
+The most popular cookbooks to get going fast:
+
+<CardGroup cols={3}>
+  <Card title="Build an AI companion" icon="users" href="/cookbooks/essentials/building-ai-companion">
+    The core memory lifecycle, end to end.
+  </Card>
+  <Card title="Self-host with Ollama" icon="server" href="/cookbooks/companions/local-companion-ollama">
+    Run Mem0 fully local with Ollama.
+  </Card>
+  <Card title="Partition memory by entity" icon="layer-group" href="/cookbooks/essentials/entity-partitioning-playbook">
+    Scope memories per user, agent, and app.
+  </Card>
+</CardGroup>
+
 ## Essentials

 <CardGroup cols={2}>
@@ -0,0 +1,101 @@
+---
+title: "How Mem0 Works"
+description: "What happens when you add, store, and search memories with Mem0."
+icon: "diagram-project"
+---
+
+Mem0 sits between your application and your model. You send conversation turns to `add`, then call `search` before the next model request to fetch relevant context. Your app decides which returned memories to include in the prompt.
+
+Use Mem0 when you want agents to remember useful facts across turns, sessions, or users without replaying the full transcript every time.
+
+<Frame caption="Memory extraction: Mem0 turns messages into stored facts with metadata, embeddings, and optional entity relationships.">
+  <img src="/images/memory-extraction.png" alt="Mem0 memory extraction pipeline: store new memories after the response, context lookup to find related memories, extract memories (ADD only) from input and context, deduplicate and embed, entity linking, written to a SQL database (facts and metadata), vector database (embeddings and similarity), and entity store (entities and relationships)." />
+</Frame>
+
+## The mental model
+
+| Without a memory layer | With Mem0 |
+|---|---|
+| Keep appending chat history to the prompt | Store facts once, then retrieve them by query |
+| Make the model re-read old turns | Give the model only the relevant memories |
+| Lose context when a session ends | Scope memory by `user_id`, `agent_id`, `run_id`, and metadata |
+
+## Messages vs memories
+
+You send Mem0 messages. By default, Mem0 stores extracted memories, not a verbatim transcript.
+
+| Input | Stored memory |
+|---|---|
+| `"I prefer aisle seats"` | `User prefers aisle seats` |
+| `"Let's use Postgres for this project"` | `Project decision: use Postgres` |
+| Message metadata | Filterable fields such as category, app, user, or run |
+
+Use `infer=False` when you need to store raw content exactly as provided. Otherwise, keep inference enabled so retrieval works on clean, deduplicated facts.
+
+## Two phases: extraction and retrieval
+
+Most applications use Mem0 in two places:
+
+1. **After a useful interaction**, call `add` to store what should be remembered.
+2. **Before a model call**, call `search` and pass the best results into your prompt.
+
+### 1. Extraction (writing memory)
+
+When new messages arrive, Mem0 extracts durable facts and stores them with the identifiers and metadata you provide.
+
+1. **Context lookup.** Mem0 checks related existing memories so it can avoid storing the same fact again.
+2. **Fact extraction.** An LLM extracts preferences, decisions, plans, and other details your agent can reuse.
+3. **Deduplication and embedding.** Redundant facts are removed, then each memory is embedded for semantic search.
+4. **Entity linking.** When configured, Mem0 links people, places, organizations, and concepts across memories.
+
+The automatic extraction path is additive. If a user says, "I moved from Austin to Seattle," Mem0 can store the new fact without silently rewriting the old one. Use explicit `update` or `delete` operations when your application needs to correct or remove a memory.
+
+### 2. Retrieval (reading memory)
+
+When you call `search`, Mem0 ranks stored memories against your query and filters.
+
+| Signal | What it does | Best for |
+|---|---|---|
+| **Semantic** | Vector similarity over embeddings | Conceptual questions |
+| **Keyword** | Term matching for exact words and phrases | Names, IDs, and factual lookups |
+| **Entity** | Boosts memories linked to entities in the query | Questions about a person, project, or account |
+| **Temporal** | Scores candidates on time metadata extracted at write time against the query's temporal intent | Temporal questions ("when did...", current state, recency) |
+
+Platform retrieval fuses these signals in the managed service. OSS retrieval depends on your configured vector store, optional reranker, and graph store.
+
+<Note>
+  Always scope searches with filters such as `user_id`, `agent_id`, or `run_id`. This keeps memories from different users, agents, or sessions from mixing.
+</Note>
+
+## Where memories live
+
+Mem0 stores different parts of a memory in stores built for different lookup patterns:
+
+| Store | Holds | Purpose |
+|---|---|---|
+| **SQL database** | Facts and metadata | The source of truth for each memory |
+| **Vector database** | Embeddings | Semantic similarity search |
+| **Entity or graph store** | Entities and relationships | Relationship-aware retrieval when graph memory is enabled |
+
+On Mem0 Platform, these stores are managed for you. In OSS, you choose and operate the backing stores through your configuration.
+
+## Build against this flow
+
+- Call `add` only for information worth reusing later: preferences, decisions, account facts, goals, and durable feedback.
+- Call `search` before the model response, then include only the returned memories that help answer the current request.
+- Use metadata for filters your product already cares about, such as workspace, feature area, tenant, or data source.
+- Avoid storing secrets, raw credentials, or unredacted sensitive data. Mem0 is designed to retrieve stored context.
+
+## Next steps
+
+<CardGroup cols={3}>
+  <Card title="Memory types" icon="brain" href="/core-concepts/memory-types">
+    Choose the right scope for user, agent, run, and session memory.
+  </Card>
+  <Card title="Memory operations" icon="database" href="/core-concepts/memory-operations/add">
+    Add, search, update, and delete memories from your app.
+  </Card>
+  <Card title="See the benchmarks" icon="chart-line" href="/core-concepts/memory-evaluation">
+    Review the evaluation setup and benchmark results.
+  </Card>
+</CardGroup>
@@ -9,7 +9,7 @@ iconType: "solid"

 Most AI agent memory systems retrieve information by maximizing context window size. That works on benchmarks but not in production, where every token adds cost. **Token efficiency** means achieving high accuracy with less context per query. It is what separates benchmark performance from production viability.

-The new Mem0 algorithm achieves competitive accuracy on LoCoMo, LongMemEval, and BEAM while averaging **under 7,000 tokens per retrieval call**. Full-context approaches on the same benchmarks routinely consume 25,000+ tokens per query.
+Mem0's algorithm achieves competitive accuracy on LoCoMo, LongMemEval, and BEAM while averaging **under 7,000 tokens per retrieval call**. Full-context approaches on the same benchmarks routinely consume 25,000+ tokens per query. Unless noted otherwise, scores are reported at a **top_200 retrieval budget** (the 200 highest-ranked memories per query).

 Evaluating a memory system at scale comes down to three parameters: **accuracy** (what the benchmarks measure), **cost** (context tokens per query), and **performance** (latency). Optimizing one is easy. Balancing all three at scale is the actual problem.

@@ -17,17 +17,18 @@ Some benchmarks today, particularly smaller ones like LoCoMo and LongMemEval, ca

 ## Architecture Overview

-Mem0's memory system operates across two phases, **extraction** (writing) and **retrieval** (reading), with a graph memory layer (entity linking) connecting them.
+Mem0's memory system operates across two phases, **extraction** (writing) and **retrieval** (reading), connected by a graph memory layer (entity linking) and a temporal reasoning layer (time metadata written during extraction and scored during retrieval).

 ### Memory Extraction (Distillation)

-When new conversations arrive, the extraction pipeline processes them through five stages:
+When new conversations arrive, the extraction pipeline processes them through six stages:

 1. **Store New Memories**: Conversation enters the pipeline asynchronously (after the agent responds)
 2. **Context Lookup**: Find related existing memories to avoid duplicates
 3. **Distill Memories**: Single-pass LLM extraction produces ADD-only facts from input + context
 4. **Deduplicate + Embed**: Hash-based deduplication, then vectorize new memories
 5. **Graph Memory (Entity Linking)**: Identify entities (proper nouns, quoted text, compound noun phrases) and link them across memories into a graph
+6. **Temporal Reasoning**: A separate temporal reasoning pass reads each new memory alongside the source conversation and its date, extracting temporal metadata: when the event occurred, whether it is ongoing or completed, how precise the timing is, and the memory type (event, state, plan, preference, relationship, absence). It is independent of extraction and can run asynchronously so writes stay fast; this metadata is stored with the memory and used later at retrieval.

 Memories are distributed across three storage layers, each tuned for a specific retrieval pattern:

@@ -43,20 +44,21 @@ The key architectural decision is **ADD-only extraction**. New facts are stored

 ### Multi-Signal Retrieval

-When a query arrives, the retrieval pipeline scores candidates across three signals in parallel:
+When a query arrives, the retrieval pipeline scores candidates across multiple signals in parallel:

 1. **Semantic Search**: Vector similarity scoring against memory embeddings
 2. **Keyword Search**: Normalized term matching via BM25 with verb-form lemmatization
 3. **Entity Search**: Entity matching boosts memories linked to query entities
+4. **Temporal Reasoning**: The query's temporal intent is classified (with no extra LLM call), then each candidate is scored by how well the temporal metadata extracted at write time matches that intent.

-Results are fused via rank scoring into a final top-K set. Different query types lean on different signals:
+These signals are fused via rank scoring into the final top-K set. The temporal score is additive and semantic relevance always dominates; it nudges ranking toward the correct dated instance without filtering candidates out or overriding a strong semantic match, so relevant memories are never dropped. Different query types lean on different signals:

 | Query Type | Primary Signal | Example |
 |---|---|---|
 | Conceptual | Semantic | "What does the user think about remote work?" |
 | Factual/exact | BM25 keyword | "What meetings did I attend last week?" |
 | Entity-centric | Entity matching | "What do we know about Alice?" |
-| Temporal | Semantic + keyword | "When did the user first mention the project?" |
+| Temporal | Temporal reasoning | "When did the user first mention the project?" |

 The combined score outperformed every individual signal across every category tested.

@@ -66,37 +68,35 @@ The combined score outperformed every individual signal across every category te

 [LoCoMo](https://github.com/snap-stanford/locomo) tests single-hop, multi-hop, open-domain, and temporal memory recall across conversational sessions.

-| Category | Old Algorithm | New Algorithm | Delta |
-|---|---|---|---|
-| **Overall** | **71.4** | **91.6** | **+20.2** |
-| Single-hop | 76.6 | 92.3 | +15.7 |
-| Multi-hop | 70.2 | 93.3 | +23.1 |
-| Open-domain | 57.3 | 76.0 | +18.7 |
-| Temporal | 63.2 | 92.8 | +29.6 |
+| Category | Score |
+|---|---|
+| **Overall** | **92.5** |
+| Single-hop | 91.2 |
+| Multi-hop | 91.3 |
+| Open-domain | 72.7 |
+| Temporal | 92.0 |

-*Mean tokens: 6,956*
+*Mean tokens: 6,956.*

-The two largest gains are **temporal queries (+29.6)** and **multi-hop reasoning (+23.1)**. Both categories directly test the ADD-only architecture (preserving temporal context) and graph memory / entity linking (connecting facts across memories).
+Temporal reasoning is on by default and helps most on temporal (92.0) and multi-hop (91.3) questions, where the system has to identify which dated instance applies, while open-domain (72.7) does not benefit and is actively being tuned.

 ### LongMemEval

 [LongMemEval](https://github.com/xiaowu0162/LongMemEval) evaluates memory across single-session and multi-session contexts, including knowledge updates and temporal reasoning.

-| Category | Old Algorithm | New Algorithm | Delta |
-|---|---|---|---|
-| **Overall** | **67.8** | **93.4** | **+25.6** |
-| Single-session (user) | 94.3 | 97.1 | +2.8 |
-| Single-session (assistant) | 46.4 | 100.0 | +53.6 |
-| Single-session (preference) | 76.7 | 96.7 | +20.0 |
-| Knowledge update | 79.5 | 96.2 | +16.7 |
-| Temporal reasoning | 51.1 | 93.2 | +42.1 |
-| Multi-session | 70.7 | 86.5 | +15.8 |
+| Category | Score |
+|---|---|
+| **Overall** | **94.4** |
+| Single-session (user) | 98.6 |
+| Single-session (assistant) | 98.2 |
+| Single-session (preference) | 96.7 |
+| Knowledge update | 93.6 |
+| Temporal reasoning | 97.0 |
+| Multi-session | 88.0 |

-*Mean tokens: 6,787*
+*Mean tokens: 6,787.*

-The biggest gain is **single-session assistant (+53.6)** because the previous algorithm had a blind spot for agent-generated facts. The new algorithm treats them as first-class memories.
-
-The **+42.1 on temporal reasoning** reflects the ADD-only architecture preserving chronological context that the previous UPDATE/DELETE model would destroy.
+Temporal reasoning is the standout at a top_200 budget, reaching **97.0** on the temporal-reasoning category, with single-session user and assistant both near-saturated (98.6 and 98.2). Knowledge update (93.6) remains the hardest category for an additive, ADD-only architecture: older facts are preserved rather than overwritten, so semantically similar prior facts can still surface alongside newer ones.

 ### BEAM

@@ -124,14 +124,14 @@ The **+42.1 on temporal reasoning** reflects the ADD-only architecture preservin

 ### Performance Summary

-All results use a single-pass retrieval setup: one retrieval call, one answer, no agentic loops.
+All results use a single-pass retrieval setup (one retrieval call, one answer, no agentic loops) at a top_200 retrieval budget.

-| Benchmark | Old Algorithm | New Algorithm | Average tokens / query |
-|---|---|---|---|
-| **LoCoMo** | 71.4 | **91.6** | 6,956 |
-| **LongMemEval** | 67.8 | **93.4** | 6,787 |
-| **BEAM (1M)** | N/A | **64.1** | 6,719 |
-| **BEAM (10M)** | N/A | **48.6** | 6,914 |
+| Benchmark | Score | Average tokens / query |
+|---|---|---|
+| **LoCoMo** | **92.5** | 6,956 |
+| **LongMemEval** | **94.4** | 6,787 |
+| **BEAM (1M)** | **64.1** | 6,719 |
+| **BEAM (10M)** | **48.6** | 6,914 |

 <Info>
 Scores reflect Mem0's managed platform, which includes proprietary optimizations not available in the open-source SDK. Open-source users should expect directionally similar gains but not identical numbers.
@@ -9,26 +9,20 @@ iconType: "solid"

 Adding memory is how Mem0 captures useful details from a conversation so your agents can reuse them later. Think of it as saving the important sentences from a chat transcript into a structured notebook your agent can search.

-<Info>
-  **Why it matters**
-  - Preserves user preferences, goals, and feedback across sessions.
-  - Powers personalization and decision-making in downstream conversations.
-  - Keeps context consistent between managed Platform and OSS deployments.
-</Info>
-
 ## Key terms

- **Messages** – The ordered list of user/assistant turns you send to `add`.
- **Infer** – Controls whether Mem0 extracts structured memories (`infer=True`, default) or stores raw messages.
- **Metadata** – Optional filters (e.g., `{"category": "movie_recommendations"}`) that improve retrieval later.
- **User / Session identifiers** – `user_id`, `agent_id`, `app_id`, or `run_id` that scope the memory for future searches.
+- **Messages**: The ordered list of user/assistant turns you send to `add`.
+- **Infer**: Controls whether Mem0 extracts structured memories (`infer=True`, default) or stores raw messages.
+- **Metadata**: Optional filters (e.g., `{"category": "movie_recommendations"}`) that improve retrieval later.
+- **User / Session identifiers**: `user_id`, `agent_id`, `app_id`, or `run_id` that scope the memory for future searches.
+- **expiration_date**: Optional `YYYY-MM-DD` date after which the memory is treated as expired. Use `expirationDate` in the JavaScript SDKs. Expired memories are hidden from `search` and `get_all` unless you pass `show_expired` (`showExpired` in JavaScript); fetching by ID still returns them.

 ## How does it work?

 Mem0 offers two flows:

- **Mem0 Platform** – Fully managed API with dashboard and scaling.
- **Mem0 Open Source** – Local SDK that you run in your own environment.
+- **Mem0 Platform**: Fully managed API with dashboard and scaling.
+- **Mem0 Open Source**: Local SDK that you run in your own environment.

 Both flows take the same payload and add memories through an additive pipeline.

@@ -89,6 +83,50 @@ await client.add(messages, {
  Expect a `status: "PENDING"` response with an `event_id`. Poll `GET /v1/event/{event_id}/` to confirm completion.
 </Info>

+### Automatic conversation context
+
+On the Platform, you only send new messages. Mem0 automatically pulls the earlier messages that share the same identifiers (`user_id`, and `run_id` if you use one) and uses them as context when extracting memories, so you never need to resend conversation history.
+
+This means a follow-up turn is understood against what came before it:
+
+<CodeGroup>
+```python Python
+# First interaction
+client.add(
+    [{"role": "user", "content": "My dog's name is Biscuit. He's a golden retriever."}],
+    user_id="alice",
+)
+
+# Later — send only the new turn, no history
+client.add(
+    [{"role": "user", "content": "He turned 5 today, and I'm taking him to the vet on Friday."}],
+    user_id="alice",
+)
+# Stored as: "User's dog Biscuit turned 5" — "He" is resolved against the earlier turn.
+```
+
+```javascript JavaScript
+// First interaction
+await client.add(
+  [{ role: "user", content: "My dog's name is Biscuit. He's a golden retriever." }],
+  { userId: "alice" },
+);
+
+// Later — send only the new turn, no history
+await client.add(
+  [{ role: "user", content: "He turned 5 today, and I'm taking him to the vet on Friday." }],
+  { userId: "alice" },
+);
+// Stored as: "User's dog Biscuit turned 5" — "He" is resolved against the earlier turn.
+```
+</CodeGroup>
+
+Without that earlier turn, the same message can only be stored as "User's male pet turned 5", because there is nothing to resolve "He" against. Scope each conversation with a consistent `user_id` (plus `run_id` for a distinct session) and Mem0 handles the rest.
+
+<Info>
+  This is default behavior and needs no configuration. Earlier SDK versions gated it behind a `version="v2"` argument on `add`; that argument no longer exists and is ignored if sent.
+</Info>
+
 ## Add with Mem0 Open Source

 <CodeGroup>
@@ -112,6 +150,9 @@ result = m.add(messages, user_id="alice", metadata={"category": "movie_recommend

 # Optionally store raw messages without inference
 result = m.add(messages, user_id="alice", metadata={"category": "movie_recommendations"}, infer=False)
+
+# Optionally set an expiration date (YYYY-MM-DD)
+result = m.add(messages, user_id="alice", expiration_date="2030-01-31")
 ```

 ```javascript JavaScript
@@ -130,6 +171,12 @@ const result = memory.add(messages, {
  userId: "alice",
  metadata: { category: "preferences" }
 });
+
+// Optionally set an expiration date (YYYY-MM-DD)
+const expiring = memory.add(messages, {
+  userId: "alice",
+  expirationDate: "2030-01-31",
+});
 ```
 </CodeGroup>

@@ -157,7 +204,6 @@ Add memory whenever your agent learns something useful:

 Storing this context allows the agent to reason better in future interactions.

-
 ### More Details

 For full list of supported fields, required formats, and advanced options, see the
@@ -18,10 +18,10 @@ Deleting memories is how you honor compliance requests, undo bad data, or clean

 ## Key terms

- **memory_id** – Unique ID returned by `add`/`search` identifying the record to delete.
- **batch_delete** – API call that removes up to 1000 memories in one request.
- **delete_all** – Filter-based deletion by user, agent, run, or metadata.
- **immutable** – Flagged memories that cannot be updated; delete + re-add instead.
+- **memory_id**: Unique ID returned by `add`/`search` identifying the record to delete.
+- **batch_delete**: API call that removes up to 1000 memories in one request.
+- **delete_all**: Filter-based deletion by user, agent, run, or metadata.
+- **immutable**: Flagged memories that cannot be updated; delete + re-add instead.

 ## How the delete flow works

@@ -188,11 +188,16 @@ memory = Memory()
 memory.delete(memory_id="mem_123")
 memory.delete_all(user_id="alice")
 ```
-</CodeGroup>

-<Note>
-  The OSS JavaScript SDK does not yet expose deletion helpers: use the REST API or Python SDK when self-hosting.
-</Note>
+```typescript TypeScript
+import { Memory } from "mem0ai/oss";
+
+const memory = new Memory();
+
+await memory.delete("mem_123");
+await memory.deleteAll({ userId: "alice" });
+```
+</CodeGroup>

 ## Use cases recap

@@ -216,7 +221,7 @@ memory.delete_all(user_id="alice")
 ## Put it into practice

 - Review the <Link href="/api-reference/memory/delete-memory">Delete Memory API reference</Link>, plus <Link href="/api-reference/memory/batch-delete">Batch Delete</Link> and <Link href="/api-reference/memory/delete-memories">Filtered Delete</Link>.
- Pair deletes with <Link href="/platform/features/platform-overview">Expiration Policies</Link> to automate retention.
+- Pair deletes with the <Link href="/api-reference/memory/update-memory">expiration date field</Link> to automate retention.

 ## See it live

@@ -233,9 +238,9 @@ memory.delete_all(user_id="alice")
    href="/core-concepts/memory-operations/add"
  />
  <Card
-    title="Enable Expiration Policies"
-    description="Automate retention with the platform’s expiration feature."
+    title="Set an Expiration Date"
+    description="Automate retention with the expiration date field on update."
    icon="clock"
-    href="/platform/features/platform-overview"
+    href="/api-reference/memory/update-memory"
  />
 </CardGroup>
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Kartik	5e7adc4d12	chore: update changelog, bump versions to Python 2.0.13, TypeScript 3.1.1, OpenCode plugin 0.2.2 (#6504 )	2026-07-22 23:27:47 +05:30
Ayaan Gazali	14393b5962	fix(llms/anthropic): find the text block in no-tools responses instead of indexing content[0] (#6481 )	2026-07-22 21:34:48 +05:30
Abhay Singh	f590c9596a	fix(ts-oss/baidu): convert L2 distance to similarity score in search() (#6485 ) Co-authored-by: kartik-mem0 <kartik.labhshetwar@mem0.ai>	2026-07-22 20:37:12 +05:30
Kartik	dd5f7e39a8	ci: infer component labels for issues filed without the form (#6471 )	2026-07-21 21:39:00 +05:30
Kartik	70ab76a053	ci: fix silently-broken issue labeling and add PR labeling (#6470 )	2026-07-21 18:47:39 +05:30
krishna soni	2af3a72f73	Remove redundant check for api_key attribute (#6460 ) Co-authored-by: kartik-mem0 <kartik.labhshetwar@mem0.ai>	2026-07-21 17:47:25 +05:30
freya0926	8005e18aec	fix(qdrant): actually clear points on reset() for local Qdrant (#6412 ) Co-authored-by: freya0926 <299410795+freya0926@users.noreply.github.com> Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com> Co-authored-by: kartik-mem0 <kartik.labhshetwar@mem0.ai>	2026-07-21 13:04:47 +05:30
Abhay Singh	39551145b8	fix(ts-oss): coerce non-string entity ids instead of crashing on trim() (#6263 ) Co-authored-by: kartik-mem0 <kartik.labhshetwar@mem0.ai>	2026-07-21 12:48:15 +05:30
Aditya Jethani	c2bc28e589	fix(memory): don't let update() metadata overwrite user_id/agent_id/run_id (#6278 ) Co-authored-by: kartik-mem0 <kartik.labhshetwar@mem0.ai>	2026-07-21 12:44:22 +05:30
Kartik	fec2fe6a2c	fix(vector-stores): scope Pinecone delete_col()/reset() to namespace (#6287 )	2026-07-21 12:24:57 +05:30
Abhinav Singh	d0c23a5950	fix(ts-oss): don't let update() metadata overwrite user_id/agent_id/run_id (#6343 ) Co-authored-by: kartik-mem0 <kartik.labhshetwar@mem0.ai>	2026-07-21 12:11:47 +05:30
Rod Boev	b05cce581b	fix(opencode-plugin): recover MEM0_API_KEY from shell profiles (#6404 )	2026-07-20 20:41:41 +05:30
Kartik	8a57967c8a	chore(labels): retire graph-memory, ollama, and benchmark from issue templates + labeler (#6447 )	2026-07-20 17:04:10 +05:30
Kartik	756b0b1b6d	fix(ts-sdk): lazy-load optional provider SDKs in mem0ai/oss (#6389 )	2026-07-20 15:53:35 +05:30
Abhinav Singh	726bcc80b2	fix(vector-stores/baidu): convert L2 distance to similarity score in search() (#6435 )	2026-07-20 12:44:26 +05:30
JainamShah-22	9383e9a255	fix(server): scope auth DB sessions to prevent connection-pool exhaustion (#6237 )	2026-07-20 00:07:50 +05:30
Jupiter	ddaa655edf	fix(llms): honor OPENAI_BASE_URL in structured provider (#6322 )	2026-07-17 20:45:58 +05:30
youneshima	739534c0a3	docs: use CLI commands for Claude Code plugin install steps (#6341 )	2026-07-16 11:00:50 +05:30
Kartik	633b035342	feat(ts-sdk): add AWS Bedrock embedding provider (#6185 )	2026-07-15 14:27:07 +05:30
Kartik	ccbe5861a1	docs: remove criteria retrieval docs for non-existent feature (#6282 )	2026-07-14 20:06:05 +05:30
Kartik	50c3cf44f1	refactor(sdk): remove dead retrieval_criteria parameter (#6313 )	2026-07-14 20:03:53 +05:30
Kartik	d6d2588ef5	fix(mem0-plugin): store assistant-authored summaries with role="assistant" (#6316 )	2026-07-14 20:03:36 +05:30
Kartik	6c1741e3a4	docs: fold contextual-add into the Add concept page and redirect (#6286 )	2026-07-14 20:02:47 +05:30
Kartik	42cf18c4e6	chore: update changelog, bump SDK versions to Python 2.0.12 and TypeScript 3.1.0 (#6281 )	2026-07-13 22:11:51 +05:30
Kartik	d89793b666	refactor(ts-sdk): lazy-load optional provider SDKs so importing mem0ai/oss never requires them (#6280 )	2026-07-13 15:23:12 +05:30
Rod Boev	17836748d7	feat(vector-stores): add Databricks provider to TypeScript OSS SDK (#5824 ) Co-authored-by: kartik-mem0 <kartik.labhshetwar@mem0.ai>	2026-07-11 16:35:47 +05:30
HJ Q.	c9af55986e	fix(anthropic): Remove sampling parameters when using new model. (#6211 ) Co-authored-by: HJ Qu <35272962+ChristopherQu@users.noreply.github.com>	2026-07-10 21:39:04 +05:30
Aditya Jethani	f69f8dcc7b	fix(weaviate): don't write OutputData model fields as properties on update (#6149 ) Co-authored-by: Kartik <kartik.labhshetwar@mem0.ai>	2026-07-10 20:47:59 +05:30
Shaurya	28e4d819f8	fix(ts-sdk): re-raise LLM extraction transport failures instead of returning [] (#6102 ) Co-authored-by: Kartik <kartik.labhshetwar@mem0.ai>	2026-07-10 20:46:08 +05:30
Qun	1d383c4ee2	fix(vector-stores): improve milvus wildcard search (#6187 )	2026-07-10 20:36:22 +05:30
Kartik	8488abe603	docs: correct custom categories, per-call custom_categories is supported (#6218 )	2026-07-10 20:08:32 +05:30
Kartik	49863e9a7a	docs: add a dedicated Memory Expiration page (#6194 )	2026-07-10 20:08:24 +05:30
Abhay Singh	770ce97bd9	fix(core): coerce non-string entity ids instead of crashing on .strip() (#6206 )	2026-07-10 20:00:33 +05:30
Abhay Singh	44bcfbe1f3	fix(core): don't require langchain-core for default async procedural memory (#6209 )	2026-07-10 19:59:21 +05:30
Rod Boev	33a0ed7559	feat(ts-sdk): add AWS Neptune Analytics vector store (#5797 ) Co-authored-by: kartik-mem0 <kartik.labhshetwar@mem0.ai>	2026-07-10 19:51:05 +05:30
Bartok	ba9054e0c8	feat(ts-sdk): add AWS Bedrock LLM provider (closes #5765 ) (#5890 ) Co-authored-by: kartik-mem0 <kartik.labhshetwar@mem0.ai>	2026-07-10 19:14:15 +05:30
Granis87	df9d5cc4b1	Fix stale Node SDK delete note and add TypeScript examples (#6159 )	2026-07-10 01:45:45 +05:30
Fahmid Arman	3b2357bfe0	feat(ts-sdk): add Vertex AI embedding provider (#5882 ) Co-authored-by: kartik-mem0 <kartik.labhshetwar@mem0.ai>	2026-07-09 23:56:46 +05:30
Aditya	573b20cec8	feat(mem0-ts): add Baidu vector store provider (#5790 ) Co-authored-by: kartik-mem0 <kartik.labhshetwar@mem0.ai>	2026-07-09 23:52:53 +05:30
Platon Sterkhov	a781800d3f	docs(ts-sdk): use dimension config option instead of embeddingModelDims in qdrant (#6192 )	2026-07-09 23:33:08 +05:30
Kartik	4470803fe5	docs: replace em-dashes in reranker docs with sentence-appropriate punctuation (#6193 )	2026-07-09 23:11:23 +05:30
Kartik	6a801bfe2f	feat(oss): add reranker + per-search rerank to the TypeScript OSS SDK (#6055 )	2026-07-09 22:18:38 +05:30
Kartik	2a4aa232b2	docs: replace em-dashes with sentence-appropriate punctuation (#6188 )	2026-07-09 21:46:51 +05:30
Kartik	99206f0c64	feat(oss): accept `text` in Memory.update(), deprecate `data` (#6044 )	2026-07-09 19:32:51 +05:30
Kartik	5dbf071356	docs: update README benchmarks to current temporal-reasoning results (#6182 )	2026-07-09 15:57:05 +05:30
Rod Boev	b26469e006	feat(vector-stores): add Weaviate adapter to TypeScript OSS SDK (#5800 ) Co-authored-by: kartik-mem0 <kartik.labhshetwar@mem0.ai>	2026-07-08 21:12:01 +05:30
Bartok	e72ae96ad4	feat(ts-sdk): add Milvus vector store provider (closes #5774 ) (#5889 ) Co-authored-by: kartik-mem0 <kartik.labhshetwar@mem0.ai>	2026-07-08 20:25:06 +05:30
Bartok	fbdbab805d	feat(ts-sdk): add HuggingFace embedding provider (#6027 ) Co-authored-by: kartik-mem0 <kartik.labhshetwar@mem0.ai>	2026-07-08 19:43:53 +05:30
sahithreddy05	22f70d50e1	feat(ts-sdk): add Chroma vector store provider (#6145 ) Co-authored-by: kartik-mem0 <kartik.labhshetwar@mem0.ai>	2026-07-08 19:14:05 +05:30
Saumya Kathuria	f89edb45dc	feat(ts-sdk): add Sarvam LLM provider to OSS SDK (#6130 ) Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com> Co-authored-by: kartik-mem0 <kartik.labhshetwar@mem0.ai>	2026-07-08 19:03:38 +05:30
Harsh Vardhan Gupta	846f25bd39	fix(mem0-ts): patch fast-xml-parser and tar transitive CVEs (#6160 )	2026-07-08 18:25:59 +05:30
张思孝	9b04509433	feat(ts-sdk): add Together LLM provider (#6049 ) Co-authored-by: zhangsixiao <zhangsixiao@bytedance.com> Co-authored-by: kartik-mem0 <kartik.labhshetwar@mem0.ai>	2026-07-07 21:08:26 +05:30
Diveyam Mishra	803ff13bb8	feat(mem0-ts): add MongoDB vector store provider to OSS TypeScript SDK (#5793 ) Co-authored-by: kartik-mem0 <kartik.labhshetwar@mem0.ai>	2026-07-07 17:13:51 +05:30
404 Ameyy	94e46526bc	feat(ts-sdk): add Elasticsearch vector store provider (#5866 ) Co-authored-by: kartik-mem0 <kartik.labhshetwar@mem0.ai>	2026-07-07 17:10:25 +05:30
Parteeksachdeva	d122479687	security: fix SQL and Cypher injection vulnerabilities in PGVector, Azure MySQL, and Neptune (#4878 ) Co-authored-by: kartik-mem0 <kartik.labhshetwar@mem0.ai>	2026-07-07 16:16:36 +05:30
VectorPeak	cc52f0e367	fix: encode dynamic URL path segments (#5963 ) Co-authored-by: kartik-mem0 <kartik.labhshetwar@mem0.ai>	2026-07-07 16:11:54 +05:30
AxelRay	87276ef968	feat(ts-sdk): add OpenSearch vector store (#5810 ) Co-authored-by: kartik-mem0 <kartik.labhshetwar@mem0.ai>	2026-07-07 15:40:20 +05:30
Kartik	002fe46ab3	feat(ts-sdk): add xAI (Grok) LLM provider to OSS SDK (#6115 )	2026-07-07 11:29:56 +05:30
AxelRay	9d36b2c94d	feat(ts-sdk): add Upstash Vector vector store (#5811 ) Co-authored-by: kartik-mem0 <kartik.labhshetwar@mem0.ai>	2026-07-06 23:41:05 +05:30
Rod Boev	c944bed460	feat(ts-sdk): add Azure MySQL vector store (#5827 ) Co-authored-by: kartik-mem0 <kartik.labhshetwar@mem0.ai>	2026-07-06 23:17:43 +05:30
Rod Boev	2cc060fd76	feat(vector-stores): add Turbopuffer provider to TypeScript OSS SDK (#5801 ) Co-authored-by: kartik-mem0 <kartik.labhshetwar@mem0.ai>	2026-07-06 22:57:00 +05:30
Div	2bc2f763d9	feat: add Google Vertex AI Vector Search support to vector store factory (#5791 ) Co-authored-by: kartik-mem0 <kartik.labhshetwar@mem0.ai> Co-authored-by: divyansh-1009 <divyansh-1009@users.noreply.github.com>	2026-07-06 22:54:24 +05:30
Rod Boev	7fb3feb5cd	feat(vector-stores): add Cassandra provider to TypeScript OSS SDK (#5823 ) Co-authored-by: kartik-mem0 <kartik.labhshetwar@mem0.ai>	2026-07-06 21:57:32 +05:30
Rod Boev	fec7cdf118	feat(ts-sdk): add FastEmbed embedding provider (#5862 ) Co-authored-by: kartik-mem0 <kartik.labhshetwar@mem0.ai>	2026-07-06 21:56:11 +05:30
Rod Boev	03b41ab00f	feat(vector-stores): add Pinecone provider to TypeScript SDK (#5802 ) Co-authored-by: kartik-mem0 <kartik.labhshetwar@mem0.ai>	2026-07-06 21:39:10 +05:30
Jaco-Ren	4c974c8fa8	Add Together embedder to TS SDK (#5989 ) Co-authored-by: kartik-mem0 <kartik.labhshetwar@mem0.ai>	2026-07-06 20:24:14 +05:30
Barry	b0bee551cb	feat(ts-sdk): add vLLM provider (#5805 ) Co-authored-by: kartik-mem0 <kartik.labhshetwar@mem0.ai>	2026-07-06 20:23:43 +05:30
Kartik	b8141aaea8	docs: remove duplicate multimodal page and normalize em/en-dashes (#6112 )	2026-07-06 20:22:20 +05:30
Yash	a7ecf781cd	Feat/valkey vector store (#5826 ) Co-authored-by: kartik-mem0 <kartik.labhshetwar@mem0.ai>	2026-07-06 20:20:59 +05:30
Rod Boev	6dc4606dcf	feat(vector-stores): add S3 Vectors provider to TypeScript OSS SDK (#5822 ) Co-authored-by: kartik-mem0 <kartik.labhshetwar@mem0.ai>	2026-07-06 20:08:13 +05:30
Harsh Vardhan Gupta	580d390e4d	fix(transformers): upgrade to >=5.3.0 (GHSA-29pf-2h5f-8g72 / CVE-2026-4372) (#6110 )	2026-07-06 17:56:39 +05:30
Kartik	2bd3ff1eff	fix(vector-stores): prevent unhandled promise rejection in Supabase & Redis constructors (#6111 )	2026-07-06 14:57:30 +05:30
Agam Pandey	cd79fa8914	docs: show current benchmark numbers on memory evaluation page (#6056 ) Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-02 22:38:33 +05:30
Hrushikesh Yadav	59484f066f	fix(elasticsearch): validate filter keys and values to prevent term injection (#5980 ) Signed-off-by: Hrushikesh Yadav <yadavhrushikesh65@gmail.com>	2026-07-02 18:35:02 +05:30
Kushagra Gupta	8a5c0729e5	fix(server): do not forward empty-string entity ids as filters (#5992 ) Co-authored-by: Kartik <kartik.labhshetwar@mem0.ai>	2026-07-02 18:33:16 +05:30
Trupti Agrawal	3b9aed866a	docs: fix typos and grammar errors across docs (#6033 )	2026-07-01 23:25:12 +05:30
Kartik	fb2593e10d	docs: add subtle GitHub star nudges at OSS win-moments (#5928 )	2026-07-01 23:13:51 +05:30
Kartik	207f65deda	docs: navigation (#5900 )	2026-07-01 22:48:23 +05:30