fix(form-data): upgrade to >=4.0.6 across pnpm workspaces (CVE-2026-12143)

Adds a pnpm override forcing form-data >=4.0.6 in all five workspaces that resolved the vulnerable transitive
  form-data@4.0.5 (CVE-2026-12143, GHSA-hmw2-7cc7-3qxx — CRLF injection via unescaped multipart field names/filenames). Override added to pnpm-workspace.yaml everywhere, and also to package.json pnpm.overrides for the workspaces whose CI pnpm version reads it (mem0-ts,
  openmemory/ui, pi-agent-plugin, openclaw). Lockfiles regenerated with each workspace's CI pnpm version; only form-data changes.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

.claude-plugin/marketplace.json

@@ -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.11"
+      "version": "0.2.10"
     }
   ]
 }

.cursor-plugin/marketplace.json

@@ -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.11"
+      "version": "0.2.10"
     }
   ]
 }

cli/node/CHANGELOG.md

@@ -5,15 +5,6 @@ All notable changes to `@mem0/cli` are documented here.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [0.2.9] — 2026-06-19
-
-### Security
-
-- Telemetry no longer passes the Mem0 API key to its child process via
-  command-line arguments. The context is now sent over stdin, so the key is no
-  longer visible in the process list (`ps`, `/proc/<pid>/cmdline`, Activity
-  Monitor). Fixes #4862.
-
 ## [0.2.8] — 2026-06-01
 
 ### Security

cli/node/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mem0/cli",
-  "version": "0.2.9",
+  "version": "0.2.8",
   "description": "The official CLI for mem0 — the memory layer for AI agents",
   "type": "module",
   "bin": {

cli/node/src/telemetry.ts

@@ -145,11 +145,11 @@ export function captureEvent(
 			anonDistinctIdToAlias: anonIdToAlias,
 		};
 
-		const child = spawn(process.execPath, [SENDER_SCRIPT], {
-			detached: true,
-			stdio: ["pipe", "ignore", "ignore"],
-		});
-		child.stdin?.end(JSON.stringify(context));
+		const child = spawn(
+			process.execPath,
+			[SENDER_SCRIPT, JSON.stringify(context)],
+			{ detached: true, stdio: "ignore" },
+		);
 		child.unref();
 	} catch {
 		/* silently swallow */

cli/node/telemetry-sender.cjs

@@ -1,8 +1,7 @@
 /**
  * Standalone telemetry sender — runs as a detached child process.
  *
- * Usage: node telemetry-sender.cjs   (JSON context is read from stdin; a single
- * argv argument is still accepted as a legacy fallback)
+ * Usage: node telemetry-sender.cjs '<json context>'
  *
  * This script is spawned by telemetry.captureEvent() and runs independently
  * of the parent CLI process. It:
@@ -20,31 +19,6 @@
 const https = require("https");
 const fs = require("fs");
 
-function loadContext() {
-	return new Promise((resolve, reject) => {
-		if (process.argv[2]) {
-			try {
-				resolve(JSON.parse(process.argv[2]));
-			} catch (err) {
-				reject(err);
-			}
-			return;
-		}
-
-		let data = "";
-		process.stdin.setEncoding("utf8");
-		process.stdin.on("data", (chunk) => (data += chunk));
-		process.stdin.on("end", () => {
-			try {
-				resolve(JSON.parse(data));
-			} catch (err) {
-				reject(err);
-			}
-		});
-		process.stdin.on("error", reject);
-	});
-}
-
 function httpsRequest(url, method, headers, body) {
 	return new Promise((resolve, reject) => {
 		const u = new URL(url);
@@ -134,7 +108,7 @@ async function sendIdentifyEvent(ctx, payload, anonId) {
 }
 
 async function main() {
-	const ctx = await loadContext();
+	const ctx = JSON.parse(process.argv[2]);
 	const payload = ctx.payload;
 
 	if (ctx.needsEmail && ctx.mem0ApiKey) {

cli/node/tests/telemetry.test.ts

@@ -1,59 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-const mockLoadConfig = vi.fn();
-const mockSaveConfig = vi.fn();
-const mockSpawn = vi.fn();
-
-vi.mock("../src/config.js", () => ({
-  CONFIG_FILE: "/tmp/mem0-config.json",
-  loadConfig: mockLoadConfig,
-  saveConfig: mockSaveConfig,
-}));
-
-vi.mock("node:child_process", () => ({
-  spawn: mockSpawn,
-}));
-
-describe("captureEvent", () => {
-  beforeEach(() => {
-    vi.resetModules();
-    mockLoadConfig.mockReset();
-    mockSaveConfig.mockReset();
-    mockSpawn.mockReset();
-    delete process.env.MEM0_TELEMETRY;
-  });
-
-  it("pipes the telemetry context through stdin instead of argv", async () => {
-    mockLoadConfig.mockReturnValue({
-      platform: {
-        apiKey: "m0-node-secret",
-        baseUrl: "https://api.mem0.ai",
-        userEmail: "",
-      },
-      telemetry: {
-        anonymousId: "cli-anon-node",
-      },
-    });
-
-    const stdin = { end: vi.fn() };
-    const child = { stdin, unref: vi.fn() };
-    mockSpawn.mockReturnValue(child);
-
-    const { captureEvent } = await import("../src/telemetry.js");
-    captureEvent("node_test_event", { case: "stdin-secret" });
-
-    expect(mockSpawn).toHaveBeenCalledTimes(1);
-    const [execPath, args, options] = mockSpawn.mock.calls[0];
-    expect(execPath).toBe(process.execPath);
-    expect(args).toHaveLength(1);
-    expect(String(args[0])).toContain("telemetry-sender.cjs");
-    expect(JSON.stringify(args)).not.toContain("m0-node-secret");
-    expect(options).toMatchObject({ detached: true, stdio: ["pipe", "ignore", "ignore"] });
-
-    expect(stdin.end).toHaveBeenCalledTimes(1);
-    const payload = JSON.parse(stdin.end.mock.calls[0][0]);
-    expect(payload.mem0ApiKey).toBe("m0-node-secret");
-    expect(payload.payload.event).toBe("node_test_event");
-    expect(child.unref).toHaveBeenCalledTimes(1);
-  });
-});

cli/python/CHANGELOG.md

@@ -5,19 +5,6 @@ All notable changes to `mem0-cli` (Python) are documented here.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [0.2.8] — 2026-06-19
-
-### Security
-
-- Telemetry no longer passes the Mem0 API key to its child process via
-  command-line arguments. The context is now sent over stdin, so the key is no
-  longer visible in the process list (`ps`, `/proc/<pid>/cmdline`, Activity
-  Monitor). Fixes #4862.
-
-### Fixed
-
-- `__version__` now matches the packaged version (was stale at 0.2.4).
-
 ## [0.2.7] — 2026-05-20
 
 ### Added

cli/python/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "mem0-cli"
-version = "0.2.8"
+version = "0.2.7"
 description = "The official CLI for mem0 — the memory layer for AI agents"
 readme = "README.md"
 license = "Apache-2.0"

cli/python/src/mem0_cli/__init__.py

@@ -1,3 +1,3 @@
 """mem0 CLI — the command-line interface for the mem0 memory layer."""
 
-__version__ = "0.2.8"
+__version__ = "0.2.4"

cli/python/src/mem0_cli/telemetry.py

@@ -137,19 +137,12 @@ def capture_event(
             "anon_distinct_id_to_alias": anon_id_to_alias,
         }
 
-        child = subprocess.Popen(
-            [sys.executable, "-m", "mem0_cli.telemetry_sender"],
-            stdin=subprocess.PIPE,
+        subprocess.Popen(
+            [sys.executable, "-m", "mem0_cli.telemetry_sender", json.dumps(context)],
             stdout=subprocess.DEVNULL,
             stderr=subprocess.DEVNULL,
             start_new_session=True,
             close_fds=True,
-            text=True,
         )
-        if child.stdin:
-            with contextlib.suppress(Exception):
-                child.stdin.write(json.dumps(context))
-            with contextlib.suppress(Exception):
-                child.stdin.close()
     except Exception:
         pass

cli/python/src/mem0_cli/telemetry_sender.py

@@ -1,7 +1,6 @@
 """Standalone telemetry sender — runs as a detached subprocess.
 
-Usage: python -m mem0_cli.telemetry_sender   (JSON context is read from stdin;
-a single argv argument is still accepted as a legacy fallback)
+Usage: python -m mem0_cli.telemetry_sender '<json context>'
 
 This module is spawned by telemetry.capture_event() and runs independently
 of the parent CLI process. It:
@@ -21,18 +20,8 @@ import sys
 import urllib.request
 
 
-def _load_context() -> dict:
-    """Load telemetry context from stdin, falling back to argv for compatibility."""
-    raw = ""
-    if not sys.stdin.isatty():
-        raw = sys.stdin.read().strip()
-    if not raw and len(sys.argv) > 1:
-        raw = sys.argv[1]
-    return json.loads(raw)
-
-
 def main() -> None:
-    ctx = _load_context()
+    ctx = json.loads(sys.argv[1])
     payload = ctx["payload"]
 
     if ctx.get("needs_email") and ctx.get("mem0_api_key"):

cli/python/tests/test_telemetry.py

@@ -1,80 +0,0 @@
-"""Tests for telemetry subprocess secret handling."""
-
-from __future__ import annotations
-
-import io
-import json
-import subprocess
-import sys
-
-from mem0_cli.config import Mem0Config, save_config
-from mem0_cli.telemetry import capture_event
-from mem0_cli.telemetry_sender import _load_context
-
-
-class _CaptureStdin:
-    def __init__(self):
-        self.buffer = ""
-        self.closed = False
-
-    def write(self, value: str) -> None:
-        self.buffer += value
-
-    def close(self) -> None:
-        self.closed = True
-
-
-class _DummyProcess:
-    def __init__(self):
-        self.stdin = _CaptureStdin()
-
-
-def test_capture_event_writes_context_to_stdin_not_argv(isolate_config, monkeypatch):
-    config = Mem0Config()
-    config.platform.api_key = "m0-test-secret"
-    config.telemetry.anonymous_id = "cli-anon-test"
-    save_config(config)
-
-    captured: dict[str, object] = {}
-    proc = _DummyProcess()
-
-    def fake_popen(args, **kwargs):
-        captured["args"] = args
-        captured["kwargs"] = kwargs
-        return proc
-
-    monkeypatch.setattr("mem0_cli.telemetry.subprocess.Popen", fake_popen)
-
-    capture_event("unit_test_event", {"case": "stdin-secret"})
-
-    argv = captured["args"]
-    assert argv == [sys.executable, "-m", "mem0_cli.telemetry_sender"]
-    assert all("m0-test-secret" not in arg for arg in argv)
-
-    kwargs = captured["kwargs"]
-    assert kwargs["stdin"] == subprocess.PIPE
-    assert kwargs["text"] is True
-
-    ctx = json.loads(proc.stdin.buffer)
-    assert ctx["mem0_api_key"] == "m0-test-secret"
-    assert ctx["payload"]["event"] == "unit_test_event"
-
-    assert proc.stdin.closed
-
-
-def test_load_context_reads_from_stdin(monkeypatch):
-    monkeypatch.setattr("sys.argv", ["telemetry_sender"])
-    monkeypatch.setattr("sys.stdin", io.StringIO('{"payload": {"event": "stdin"}}'))
-
-    ctx = _load_context()
-
-    assert ctx["payload"]["event"] == "stdin"
-
-
-def test_load_context_falls_back_to_argv(monkeypatch):
-    monkeypatch.setattr("sys.argv", ["telemetry_sender", '{"payload": {"event": "argv"}}'])
-    monkeypatch.setattr("sys.stdin", io.StringIO(""))
-
-    ctx = _load_context()
-
-    assert ctx["payload"]["event"] == "argv"

docs/changelog/highlights.mdx

@@ -113,7 +113,7 @@ Launched a unified Mem0 plugin across three major AI development environments
 
 Major expansion of the provider ecosystem:
 
-- **Apache AGE** — New graph store support, bringing the total to 4 graph store backends (Neo4j, Memgraph, Kuzu, Apache AGE). **Note:** All external graph store backends (Neo4j, Memgraph, Kuzu, Apache AGE) were subsequently removed in v2.0.0 (2026-04-14). Graph memory is now built-in entity linking with no external graph store required; see the [v2.0.0 entry above](#mem0-sdk-v2-0-0-v3-0-0).
+- **Apache AGE** — New graph store support, bringing the total to 4 graph store backends (Neo4j, Memgraph, Kuzu, Apache AGE)
 - **Turbopuffer** — New vector database provider for Python SDK
 - **MiniMax** — New LLM provider with dedicated AWS Bedrock support
 - **pgvector for Node.js** — PostgreSQL vector support added to the TypeScript OSS SDK

docs/changelog/sdk.mdx

@@ -7,65 +7,6 @@ mode: "wide"
 <Tabs>
 <Tab title="Python">
 
-<Update label="2026-06-24" description="v2.0.9">
-
-**Bug Fixes:**
-- **Memory (OSS):** Improve entity extraction precision by avoiding sentence-start common noun noise, preserving useful topic phrases, and exact-deduplicating entity links before semantic matching ([#5829](https://github.com/mem0ai/mem0/pull/5829))
-
-</Update>
-
-<Update label="2026-06-24" description="v2.0.8">
-
-**New Features:**
-- **Embeddings:** Add native `embed_batch` to five embedders — LM Studio, Together, HuggingFace, Vertex AI, and Google GenAI — for batched embedding requests ([#5609](https://github.com/mem0ai/mem0/pull/5609))
-
-**Bug Fixes:**
-- **Core:** Guard against malformed `image_url` entries in `parse_vision_messages` to prevent crashes ([#5631](https://github.com/mem0ai/mem0/pull/5631))
-- **Core:** Return `attributed_to` from `get()`, `get_all()`, and `search()` ([#5629](https://github.com/mem0ai/mem0/pull/5629))
-- **Core:** Fix `reset()` only dropping the history table and leaving stale messages behind ([#5541](https://github.com/mem0ai/mem0/pull/5541))
-- **Core:** Guard against an entity `embed_batch` count mismatch in the v3 add pipeline ([#5604](https://github.com/mem0ai/mem0/pull/5604))
-- **Core:** Fix an async `delete_all` race condition that corrupted the entity store's `linked_memory_ids` ([#5553](https://github.com/mem0ai/mem0/pull/5553))
-- **LLMs:** Skip the JSON `response_format` for Groq compound models that reject it ([#5513](https://github.com/mem0ai/mem0/pull/5513))
-- **LLMs:** Preserve reasoning fields during base-to-provider config conversion ([#5638](https://github.com/mem0ai/mem0/pull/5638))
-- **LLMs:** Pass the configured `anthropic_base_url` to the Anthropic client ([#5626](https://github.com/mem0ai/mem0/pull/5626))
-- **LLMs:** Stop the Azure provider from mutating and corrupting caller messages during content rewrite ([#5731](https://github.com/mem0ai/mem0/pull/5731))
-- **LLMs & Embeddings:** Repair HTTP proxy support for `httpx>=0.28` and preserve `proxies` in `LlmFactory` ([#5447](https://github.com/mem0ai/mem0/pull/5447))
-- **Embeddings:** Forward `embedding_dims` to Titan V2 in the AWS Bedrock embedder ([#5671](https://github.com/mem0ai/mem0/pull/5671))
-- **Rerankers:** Log reranking failures instead of swallowing them silently ([#5717](https://github.com/mem0ai/mem0/pull/5717))
-- **Rerankers:** Clamp out-of-range LLM scores instead of mis-parsing them ([#5635](https://github.com/mem0ai/mem0/pull/5635))
-- **Rerankers:** Export all five rerankers from the package root ([#5636](https://github.com/mem0ai/mem0/pull/5636))
-- **Vector Stores:** Point the FastEmbed-missing warning at `mem0ai[extras]` ([#5622](https://github.com/mem0ai/mem0/pull/5622))
-- **Vector Stores:** Preserve empty Azure AI Search update values ([#5524](https://github.com/mem0ai/mem0/pull/5524))
-- **Vector Stores:** Add an `auto_refresh` option for OpenSearch Serverless compatibility ([#3893](https://github.com/mem0ai/mem0/pull/3893))
-- **Vector Stores:** Wrap a scalar `vector_id` in a list for Chroma `delete()` ([#5703](https://github.com/mem0ai/mem0/pull/5703))
-- **Vector Stores:** Wrap Chroma `update()` ids, embeddings, and metadatas in lists ([#5757](https://github.com/mem0ai/mem0/pull/5757))
-- **Vector Stores:** Wrap a scalar `vector_id` in a list for Milvus `delete()` ([#5704](https://github.com/mem0ai/mem0/pull/5704))
-- **Vector Stores:** Map all comparison operators in the Pinecone `_create_filter()` ([#5707](https://github.com/mem0ai/mem0/pull/5707))
-- **Vector Stores:** Return `None` instead of `{}` from Chroma `_generate_where_clause` for empty filters ([#5713](https://github.com/mem0ai/mem0/pull/5713))
-- **Vector Stores:** Return `[[]]` from the OpenSearch `list()` error path to honor the `list()` contract ([#5727](https://github.com/mem0ai/mem0/pull/5727))
-- **Vector Stores:** Return `[[]]` from the Pinecone `list()` error path instead of a dict ([#5706](https://github.com/mem0ai/mem0/pull/5706))
-- **Vector Stores:** Return `[[]]` for an uninitialized FAISS index to honor the `list()` contract ([#5725](https://github.com/mem0ai/mem0/pull/5725))
-- **Vector Stores:** Wrap the MongoDB `list()` return in an outer list to match the interface contract ([#5729](https://github.com/mem0ai/mem0/pull/5729))
-- **Vector Stores:** Deep-copy Redis `DEFAULT_FIELDS` so instances keep distinct dims ([#5633](https://github.com/mem0ai/mem0/pull/5633))
-- **Vector Stores:** Pass the required `vectors` arg in Vertex AI `list()` and similarity search ([#5627](https://github.com/mem0ai/mem0/pull/5627))
-- **Vector Stores:** Return `None` from Redis `get()` for missing IDs ([#5625](https://github.com/mem0ai/mem0/pull/5625))
-- **Vector Stores:** Drop a stray `print` in Weaviate `list_cols` ([#5637](https://github.com/mem0ai/mem0/pull/5637))
-- **Graph:** Keep distinct entities that share a substring prefix ([#5630](https://github.com/mem0ai/mem0/pull/5630))
-- **Client:** Check the HTTP status before parsing the ping response in `_validate_api_key` ([#5639](https://github.com/mem0ai/mem0/pull/5639))
-- **Server:** Fetch filtered dashboard memories beyond the default page ([#5753](https://github.com/mem0ai/mem0/pull/5753))
-- **Server:** Return 404/400 instead of 502 for not-found and invalid input ([#5634](https://github.com/mem0ai/mem0/pull/5634))
-- **Server:** Return 404 instead of 500 for a malformed API key id on revoke ([#5640](https://github.com/mem0ai/mem0/pull/5640))
-- **Server:** Use `127.0.0.1` in the dashboard healthcheck to avoid IPv6 localhost resolution ([#5612](https://github.com/mem0ai/mem0/pull/5612))
-
-**Improvements:**
-- **Vector Stores:** Batch BM25 sparse encoding in Qdrant insert ([#5592](https://github.com/mem0ai/mem0/pull/5592))
-
-**Security:**
-- **Vector Stores:** Sanitize Milvus and Baidu filter values to prevent expression injection ([#5746](https://github.com/mem0ai/mem0/pull/5746))
-- **Vector Stores:** Reject dict filter values in MongoDB to prevent NoSQL operator injection ([#5748](https://github.com/mem0ai/mem0/pull/5748))
-
-</Update>
-
 <Update label="2026-06-17" description="v2.0.7">
 
 **New Features:**
@@ -121,7 +62,7 @@ mode: "wide"
 
 **New Features:**
 - **Memory:** Warn at init time when hybrid/BM25 search silently degrades to semantic-only because the configured vector store does not implement `keyword_search`. Affected stores: Chroma, FAISS, Cassandra, LangChain, Neptune Analytics, S3 Vectors, Supabase, TurboPuffer, Valkey ([#5444](https://github.com/mem0ai/mem0/pull/5444))
-- **Memory:** Add opt-in `explain=True` parameter to `Memory.search()` and `AsyncMemory.search()`. When enabled, each result includes a `score_details` dict with `semantic_score`, `bm25_score`, `entity_boost`, `raw_score`, `max_possible_score`, `final_score`, and `threshold` so callers can understand and tune retrieval ranking ([#5102](https://github.com/mem0ai/mem0/pull/5102))
+- **Memory:** Add opt-in `explain=True` parameter to `Memory.search()` and `AsyncMemory.search()`. When enabled, each result includes a `score_breakdown` dict with `semantic`, `keyword` (normalized BM25), `entity_boost`, and `temporal_boost` signals so callers can understand and tune retrieval ranking ([#5102](https://github.com/mem0ai/mem0/pull/5102))
 
 **Bug Fixes:**
 - **Vector Stores:** Normalize similarity scores to `[0, 1]` (higher = better) consistently across all backends. 11 adapters previously returned raw distance metrics (lower = better) — FAISS, Chroma, Milvus, Redis, Cassandra, PGVector, S3 Vectors, Supabase, Valkey, Azure MySQL, and Vertex AI Vector Search — causing incorrect ranking in multi-store setups ([#5391](https://github.com/mem0ai/mem0/pull/5391))
@@ -229,7 +170,7 @@ mode: "wide"
 **Improvements:**
 - **Telemetry:** Sample OSS hot-path events at 10% via PostHog `before_send` hook to reduce event volume ([#4771](https://github.com/mem0ai/mem0/pull/4771))
 
-See the [OSS v2 to v3 migration guide](https://docs.mem0.ai/migration/oss-v2-to-v3) and [Platform migration guide](https://docs.mem0.ai/migration/platform-v2-to-v3) for upgrade instructions.
+See the [OSS v1 to v2 migration guide](https://docs.mem0.ai/migration/oss-v1-to-v2) and [Platform migration guide](https://docs.mem0.ai/migration/platform-v2-to-v3) for upgrade instructions.
 
 </Update>
 
@@ -1070,31 +1011,6 @@ See the [OSS v2 to v3 migration guide](https://docs.mem0.ai/migration/oss-v2-to-
 
 <Tab title="TypeScript">
 
-<Update label="2026-06-24" description="v3.0.11">
-
-**Bug Fixes:**
-- **Memory (OSS):** Align entity extraction with Python by reducing generic entity noise, preserving useful topic phrases, and exact-deduplicating entity links before semantic matching ([#5829](https://github.com/mem0ai/mem0/pull/5829))
-
-</Update>
-
-<Update label="2026-06-24" description="v3.0.10">
-
-**Bug Fixes:**
-- **Memory (OSS):** Guard against malformed `image_url` entries in `parseVisionMessages` to prevent crashes ([#5631](https://github.com/mem0ai/mem0/pull/5631))
-- **Memory (OSS):** Return `attributedTo` from `get()`, `search()`, and `getAll()` ([#5675](https://github.com/mem0ai/mem0/pull/5675))
-- **Memory (OSS):** Preserve message roles in the extraction input so assistant facts aren't attributed to the user ([#5643](https://github.com/mem0ai/mem0/pull/5643))
-- **Memory (OSS):** Reject empty or blank messages in `Memory.add()` to prevent hallucinated memories ([#5545](https://github.com/mem0ai/mem0/pull/5545))
-- **Memory (OSS):** Check `message.role` instead of `content` when detecting system messages ([#3921](https://github.com/mem0ai/mem0/pull/3921))
-- **LLMs:** Honor the configured `baseURL` in `AnthropicLLM` ([#5740](https://github.com/mem0ai/mem0/pull/5740))
-- **Client:** Preserve `customCategories` names through key conversion ([#5741](https://github.com/mem0ai/mem0/pull/5741))
-- **Client:** Prevent hallucinated memories on an empty messages payload ([#5613](https://github.com/mem0ai/mem0/pull/5613))
-- **Client:** Preserve user metadata keys across the case-conversion round-trip ([#5515](https://github.com/mem0ai/mem0/pull/5515))
-
-**Security:**
-- **Dependencies:** Upgrade `form-data` to `>=4.0.6` across pnpm workspaces to remediate CVE-2026-12143 ([#5618](https://github.com/mem0ai/mem0/pull/5618))
-
-</Update>
-
 <Update label="2026-06-17" description="v3.0.9">
 
 **Bug Fixes:**

docs/components/llms/models/deepseek.mdx

@@ -7,8 +7,7 @@ To use DeepSeek LLM models, you have to set the `DEEPSEEK_API_KEY` environment v
 
 ## Usage
 
-<CodeGroup>
-```python Python
+```python
 import os
 from mem0 import Memory
 
@@ -37,32 +36,6 @@ messages = [
 m.add(messages, user_id="alice", metadata={"category": "movies"})
 ```
 
-```typescript TypeScript
-import { Memory } from 'mem0ai/oss';
-
-const config = {
-  llm: {
-    provider: 'deepseek',
-    config: {
-      apiKey: process.env.DEEPSEEK_API_KEY || '',
-      model: 'deepseek-chat',
-      temperature: 0.2,
-      maxTokens: 2000,
-      top_p: 1.0,
-    },
-  },
-};
-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:
 
 ```python

docs/components/vectordbs/dbs/opensearch.mdx

@@ -56,30 +56,6 @@ config = {
 }
 ```
 
-### Configuration Options
-
-| Parameter | Type | Default | Description |
-|-----------|------|---------|-------------|
-| `collection_name` | string | required | Name of the OpenSearch index |
-| `host` | string | required | OpenSearch endpoint URL |
-| `port` | int | 9200 | Port number |
-| `http_auth` | object | None | Authentication credentials (e.g., AWSV4SignerAuth) |
-| `embedding_model_dims` | int | 1536 | Dimension of embedding vectors |
-| `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. |
-
-<Note>
-  The defaults above match a local OpenSearch instance. The AWS OpenSearch Serverless
-  example earlier on this page intentionally overrides them with `port=443`, `use_ssl=True`,
-  and `verify_certs=True`, which are required when connecting to a Serverless collection.
-</Note>
-
-<Note>
-  For **AWS OpenSearch Serverless**, keep `auto_refresh=False` (the default).
-  The `indices.refresh()` API is not supported on Serverless collections.
-</Note>
-
 ### Add Memories
 
 ```python

docs/core-concepts/memory-evaluation.mdx

@@ -345,7 +345,7 @@ When evaluating memory systems, keep these considerations in mind:
   <Card title="Research" icon="flask" href="https://mem0.ai/research">
     Published research papers and technical reports
   </Card>
-  <Card title="Blog Post" icon="newspaper" href="https://mem0.ai/blog/the-token-efficient-memory-algorithm-now-has-temporal-reasoning">
+  <Card title="Blog Post" icon="newspaper" href="https://mem0.ai/blog/new-algorithm">
     Detailed writeup of the new algorithm design and results
   </Card>
   <Card title="Platform Migration" icon="arrow-right" href="/migration/platform-v2-to-v3">

docs/core-concepts/memory-operations/add.mdx

@@ -21,7 +21,7 @@ Adding memory is how Mem0 captures useful details from a conversation so your ag
 - **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.
+- **User / Session identifiers** – `user_id`, `agent_id`, or `run_id` that scope the memory for future searches.
 
 ## How does it work?
 
@@ -30,22 +30,22 @@ 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.
 
-Both flows take the same payload and add memories through an additive pipeline.
+Both flows take the same payload and pass it through the same pipeline.
 
 <Steps>
 <Step title="Information extraction">
 Mem0 sends the messages through an LLM that pulls out key facts, decisions, or preferences to remember.
 </Step>
-<Step title="Additive storage">
-New memories are added without overwriting or deleting existing memories.
+<Step title="Conflict resolution">
+Existing memories are checked for duplicates or contradictions so the latest truth wins.
 </Step>
-<Step title="Retrieval">
-Future searches rank the most relevant memories for the query.
+<Step title="Storage">
+The resulting memories land in managed vector storage so future searches return them quickly.
 </Step>
 </Steps>
 
 <Warning>
-When you switch to `infer=False`, Mem0 stores your payload exactly as provided, so duplicates can land. Mixing both modes for the same fact can save it twice.
+Duplicate protection only runs during that conflict-resolution step when you let Mem0 infer memories (`infer=True`, the default). If you switch to `infer=False`, Mem0 stores your payload exactly as provided, so duplicates will land. Mixing both modes for the same fact will save it twice.
 </Warning>
 
 You trigger this pipeline with a single `add` call—no manual orchestration needed.
@@ -80,13 +80,13 @@ const messages = [
 ];
 
 await client.add(messages, {
-  userId: "alice",
+  user_id: "alice",
 });
 ```
 </CodeGroup>
 
 <Info icon="check">
-  Expect a `status: "PENDING"` response with an `event_id`. Poll `GET /v1/event/{event_id}/` to confirm completion.
+  Expect a `memory_id` (or list of IDs) in the response. Check the Mem0 dashboard to confirm the new entry under the correct user.
 </Info>
 
 ## Add with Mem0 Open Source
@@ -138,7 +138,7 @@ const result = memory.add(messages, {
 </Tip>
 
 <Warning>
-If you do choose `infer=False`, keep it consistent. Raw inserts skip inference, so a later `infer=True` call with the same content can create a second memory.
+If you do choose `infer=False`, keep it consistent. Raw inserts skip conflict resolution, so a later `infer=True` call with the same content will create a second memory instead of updating the first.
 </Warning>
 
 ## When Should You Add Memory?
@@ -167,7 +167,7 @@ For full list of supported fields, required formats, and advanced options, see t
 
 | Capability | Mem0 Platform | Mem0 OSS |
 | --- | --- | --- |
-| Add behavior | ADD-only; memories accumulate | ADD-only; you control storage |
+| Conflict resolution | Automatic with dashboard visibility | SDK handles merges locally; you control storage |
 | Rate limits | Managed quotas per workspace | Limited by your hardware and provider APIs |
 | Dashboard visibility | Yes — inspect memories visually | Inspect via CLI, logs, or custom UI |
 

docs/docs.json

@@ -441,7 +441,7 @@
                       "integrations/flowise",
                       "integrations/langchain-tools",
                       "integrations/agentops",
-                      "integrations/respan",
+                      "integrations/keywords",
                       "integrations/raycast"
                     ]
                   }

docs/integrations.mdx

@@ -309,21 +309,19 @@ Here are the available integrations for Mem0:
   </Card>
 
   <Card
-    title="Respan"
+    title="Keywords AI"
     icon={
       <svg
         xmlns="http://www.w3.org/2000/svg"
         width="24"
         height="24"
-        viewBox="0 0 200 200"
+        viewBox="0 0 24 24"
         fill="none"
       >
-        <path d="M2.00635 190.234V9.76584H53.3558V29.5101H26.7223V170.562H53.3558V190.234H2.00635Z" fill="currentColor"></path>
-        <path d="M120.692 160.902C116.383 160.902 112.691 159.387 109.612 156.357C106.535 153.327 105.02 149.633 105.067 145.277C105.02 141.016 106.535 137.37 109.612 134.34C112.691 131.309 116.383 129.794 120.692 129.794C124.859 129.794 128.481 131.309 131.559 134.34C134.684 137.37 136.27 141.016 136.317 145.277C136.27 148.166 135.512 150.793 134.045 153.161C132.624 155.528 130.73 157.422 128.362 158.842C126.042 160.216 123.486 160.902 120.692 160.902Z" fill="currentColor"></path>
-        <path d="M197.993 9.76584V190.234H146.643V170.562H173.278V29.5101H146.643V9.76584H197.993Z" fill="currentColor"></path>
+        <path fill-rule="evenodd" clip-rule="evenodd" d="M9.07513 1.1863C9.21663 1.07722 9.39144 1.01009 9.56624 1.01009C9.83261 1.01009 10.0823 1.12756 10.2405 1.33734L15.0101 7.4964V12.4136L16.4335 13.8401C16.7582 14.1673 16.7582 14.7043 16.4335 15.0316C16.1089 15.3588 15.5762 15.3588 15.2515 15.0316L13.3453 13.1016V8.07538L8.92529 2.36944V2.36105C8.64228 2.00024 8.70887 1.4716 9.07513 1.1863ZM18.976 14.4133C18.8344 14.3778 18.7003 14.3042 18.5894 14.1925L16.9163 12.5059C16.7249 12.3129 16.6416 12.0528 16.6749 11.8094V6.88385H16.6499L11.8553 0.691225C11.7282 0.529117 11.6716 0.333133 11.6803 0.140562C11.134 0.0481292 10.5726 0 10 0C4.47715 0 0 4.47715 0 10C0 15.5228 4.47715 20 10 20C13.9387 20 17.3456 17.7229 18.976 14.4133Z" fill="currentColor"></path>
       </svg>
     }
-    href="/integrations/respan"
+    href="/integrations/keywords"
   >
     Build AI applications with persistent memory and comprehensive LLM observability.
   </Card>

docs/integrations/antigravity.mdx

@@ -65,7 +65,6 @@ The plugin uses the same shell scripts as Claude Code, Cursor, and Codex — hoo
 | **User prompt** | `UserPromptSubmit` | Searches relevant memories before each message |
 | **Pre-tool** | `PreToolUse` | Blocks MEMORY.md writes, enforces `user_id`/`app_id` on mem0 tools |
 | **Post-tool** | `PostToolUse` | Tracks stats, scans bash errors for related memories |
-| **Stop** | `Stop` | Stores a session summary when the session ends |
 
 ## Troubleshooting
 

docs/integrations/claude-code.mdx

@@ -64,7 +64,7 @@ Add the Mem0 MCP server directly with a single command:
 npx mcp-add \
   --name mem0-mcp \
   --type http \
-  --url "https://mcp.mem0.ai/mcp/" \
+  --url "https://mcp.mem0.ai/mcp" \
   --clients "claude code"
 ```
 
@@ -142,8 +142,7 @@ When installed via the plugin marketplace, Mem0 hooks into Claude Code's lifecyc
 | **User prompt** | `UserPromptSubmit` | Searches relevant memories before each message; skips short prompts |
 | **Pre-tool** | `PreToolUse` | Blocks MEMORY.md writes, enforces `user_id`/`app_id` on mem0 tool calls |
 | **Post-tool** | `PostToolUse` | Tracks stats, scans bash errors for related memories |
-| **Stop** | `Stop` | Stores a session summary when the session ends |
-| **Pre-compact** | `PreCompact` | Stores a summary before the context is compacted |
+| **Pre-compact** | `PreCompact` | Stores a session summary before context compaction |
 
 ## Example Workflow
 

docs/integrations/codex.mdx

@@ -41,17 +41,7 @@ Install the full plugin including MCP server, lifecycle hooks, and SDK skill.
    codex plugin marketplace add mem0ai/mem0
    ```
 
-2. Install the plugin:
-
-   ```bash
-   codex plugin add mem0@mem0-plugins
-   ```
-
-   Or, in the app: restart Codex, open the Plugin Directory, browse the **Mem0 Plugins** marketplace, and install **Mem0**.
-
-<Note>
-  Step 1 is required for the app UI. Mem0 isn't in OpenAI's curated directory yet, so **without `codex plugin marketplace add`, Mem0 won't appear in the Codex app's Plugin Directory** — searching for it returns nothing. Adding the marketplace surfaces it (under **Created by you**) and makes it installable.
-</Note>
+2. Restart Codex, open the Plugin Directory, browse the **Mem0 Plugins** marketplace, and install **Mem0**.
 
 <Info>
   Do not combine with Option B. The plugin manifest auto-registers the `mem0` MCP server, so adding both will create a duplicate registration.
@@ -59,30 +49,27 @@ Install the full plugin including MCP server, lifecycle hooks, and SDK skill.
 
 ### Option B — Direct MCP
 
-The fastest way to connect Codex to Mem0 — no plugin, no marketplace. Add the MCP server with a single command:
-
-```bash
-codex mcp add mem0 --url https://mcp.mem0.ai/mcp/ --bearer-token-env-var MEM0_API_KEY
-```
-
-Or add it manually to `~/.codex/config.toml`:
+The fastest way to connect Codex to Mem0 — no plugin, no marketplace. Add to `~/.codex/config.toml`:
 
 ```toml
 [mcp_servers.mem0]
-url = "https://mcp.mem0.ai/mcp/"
+url = "https://mcp.mem0.ai/mcp"
 bearer_token_env_var = "MEM0_API_KEY"
 ```
 
 Make sure `MEM0_API_KEY` is exported in the shell you launch Codex from, then restart Codex.
 
+<Info>
+  Codex's `codex mcp add` CLI only supports stdio MCP servers. Because Mem0's MCP is HTTP/streamable, you configure it by editing `config.toml` directly (or via the **Plugins → Connect to a custom MCP → Streamable HTTP** UI in the Codex app).
+</Info>
+
 This gives you the MCP tools but not the lifecycle hooks or SDK skill.
 
 ### Managing the Plugin
 
 ```bash
 codex plugin marketplace upgrade               # pull latest plugin versions
-codex plugin remove mem0@mem0-plugins          # uninstall the plugin (keeps the marketplace)
-codex plugin marketplace remove mem0-plugins   # unregister the marketplace entirely
+codex plugin marketplace remove mem0-plugins   # unregister the marketplace
 ```
 
 To update, run `codex plugin marketplace upgrade` to pull the latest from the Mem0 repo.
@@ -125,8 +112,7 @@ When installed via the plugin marketplace, Mem0 hooks into Codex's lifecycle to
 | **User prompt** | `UserPromptSubmit` | Searches relevant memories before each message |
 | **Pre-tool** | `PreToolUse` | Blocks MEMORY.md writes, enforces `user_id`/`app_id` on mem0 tool calls |
 | **Post-tool** | `PostToolUse` | Tracks stats, scans bash errors for related memories |
-| **Stop** | `Stop` | Stores a session summary when the session ends |
-| **Pre-compact** | `PreCompact` | Stores a summary before the context is compacted |
+| **Pre-compact** | `PreCompact` | Stores a session summary before context compaction |
 
 ## Example Workflow
 

docs/integrations/cursor.mdx

@@ -47,7 +47,7 @@ The fastest way to get started. Click the link below to install the Mem0 MCP ser
 npx mcp-add \
   --name mem0-mcp \
   --type http \
-  --url "https://mcp.mem0.ai/mcp/" \
+  --url "https://mcp.mem0.ai/mcp" \
   --clients "cursor"
 ```
 
@@ -110,8 +110,7 @@ When installed via the Cursor Marketplace, Mem0 hooks into Cursor's lifecycle:
 | **User prompt** | `beforeSubmitPrompt` | Searches relevant memories before each message; skips short prompts |
 | **Pre-tool (2 handlers)** | `preToolUse` | Blocks MEMORY.md writes, enforces `user_id`/`app_id` on mem0 tool calls |
 | **Post-tool (2 handlers)** | `postToolUse` | Tracks stats, scans bash errors for related memories |
-| **Stop** | `stop` | Stores a session summary when the session ends |
-| **Pre-compact** | `preCompact` | Stores a summary before the context is compacted |
+| **Pre-compact** | `preCompact` | Stores a session summary before context compaction |
 
 ## Example Workflow
 

docs/integrations/elevenlabs.mdx

@@ -100,12 +100,12 @@ This section:
 Initialize both the ElevenLabs and Mem0 clients:
 
 ```python
-# Initialize ElevenLabs client
-client = ElevenLabs(api_key=API_KEY)
+    # Initialize ElevenLabs client
+    client = ElevenLabs(api_key=API_KEY)
 
-# Initialize memory client and tools
-client_tools = ClientTools()
-mem0_client = AsyncMemoryClient()
+    # Initialize memory client and tools
+    client_tools = ClientTools()
+    mem0_client = AsyncMemoryClient()
 ```
 
 Here we:
@@ -118,36 +118,36 @@ Here we:
 Define the two key memory functions that will be registered as tools:
 
 ```python
-# Define memory-related functions for the agent
-async def add_memories(parameters):
-    """Add a message to the memory store"""
-    message = parameters.get("message")
-    await mem0_client.add(
-        messages=message,
-        user_id=USER_ID
-    )
-    return "Memory added successfully"
+    # Define memory-related functions for the agent
+    async def add_memories(parameters):
+        """Add a message to the memory store"""
+        message = parameters.get("message")
+        await mem0_client.add(
+            messages=message,
+            user_id=USER_ID
+        )
+        return "Memory added successfully"
 
-async def retrieve_memories(parameters):
-    """Retrieve relevant memories based on the input message"""
-    message = parameters.get("message")
+    async def retrieve_memories(parameters):
+        """Retrieve relevant memories based on the input message"""
+        message = parameters.get("message")
 
-    # For Platform API, user_id goes in filters
-    filters = {"user_id": USER_ID}
+        # For Platform API, user_id goes in filters
+        filters = {"user_id": USER_ID}
 
-    # Search for relevant memories using the message as a query
-    results = await mem0_client.search(
-        query=message,
-        filters=filters
-    )
+        # Search for relevant memories using the message as a query
+        results = await mem0_client.search(
+            query=message,
+            filters=filters
+        )
 
-    # Extract and join the memory texts
-    memories = ' '.join([result["memory"] for result in results.get('results', [])])
-    print("[ Memories ]", memories)
+        # Extract and join the memory texts
+        memories = ' '.join([result["memory"] for result in results.get('results', [])])
+        print("[ Memories ]", memories)
 
-    if memories:
-        return memories
-    return "No memories found"
+        if memories:
+            return memories
+        return "No memories found"
 ```
 
 These functions:
@@ -171,9 +171,9 @@ These functions:
 Register the memory functions with the ElevenLabs ClientTools system:
 
 ```python
-# Register the memory functions as tools for the agent
-client_tools.register("addMemories", add_memories, is_async=True)
-client_tools.register("retrieveMemories", retrieve_memories, is_async=True)
+    # Register the memory functions as tools for the agent
+    client_tools.register("addMemories", add_memories, is_async=True)
+    client_tools.register("retrieveMemories", retrieve_memories, is_async=True)
 ```
 
 This allows the ElevenLabs agent to:
@@ -186,19 +186,19 @@ This allows the ElevenLabs agent to:
 Configure the conversation with ElevenLabs:
 
 ```python
-# Initialize the conversation
-conversation = Conversation(
-    client,
-    AGENT_ID,
-    # Assume auth is required when API_KEY is set
-    requires_auth=bool(API_KEY),
-    audio_interface=DefaultAudioInterface(),
-    client_tools=client_tools,
-    callback_agent_response=lambda response: print(f"Agent: {response}"),
-    callback_agent_response_correction=lambda original, corrected: print(f"Agent: {original} -> {corrected}"),
-    callback_user_transcript=lambda transcript: print(f"User: {transcript}"),
-    # callback_latency_measurement=lambda latency: print(f"Latency: {latency}ms"),
-)
+    # Initialize the conversation
+    conversation = Conversation(
+        client,
+        AGENT_ID,
+        # Assume auth is required when API_KEY is set
+        requires_auth=bool(API_KEY),
+        audio_interface=DefaultAudioInterface(),
+        client_tools=client_tools,
+        callback_agent_response=lambda response: print(f"Agent: {response}"),
+        callback_agent_response_correction=lambda original, corrected: print(f"Agent: {original} -> {corrected}"),
+        callback_user_transcript=lambda transcript: print(f"User: {transcript}"),
+        # callback_latency_measurement=lambda latency: print(f"Latency: {latency}ms"),
+    )
 ```
 
 This sets up the conversation with:
@@ -217,16 +217,16 @@ This sets up the conversation with:
 Start and manage the conversation:
 
 ```python
-# Start the conversation
-print(f"Starting conversation with user_id: {USER_ID}")
-conversation.start_session()
+    # Start the conversation
+    print(f"Starting conversation with user_id: {USER_ID}")
+    conversation.start_session()
 
-# Handle Ctrl+C to gracefully end the session
-signal.signal(signal.SIGINT, lambda sig, frame: conversation.end_session())
+    # Handle Ctrl+C to gracefully end the session
+    signal.signal(signal.SIGINT, lambda sig, frame: conversation.end_session())
 
-# Wait for the conversation to end and get the conversation ID
-conversation_id = conversation.wait_for_session_end()
-print(f"Conversation ID: {conversation_id}")
+    # Wait for the conversation to end and get the conversation ID
+    conversation_id = conversation.wait_for_session_end()
+    print(f"Conversation ID: {conversation_id}")
 
 
 if __name__ == '__main__':
@@ -445,3 +445,4 @@ By integrating ElevenLabs Conversational AI with Mem0, you can create voice agen
     Create voice-first AI applications
   </Card>
 </CardGroup>
+

docs/integrations/hermes.mdx

@@ -1,42 +1,35 @@
 ---
 title: Hermes Agent
-description: "Add long-term memory to Hermes agents with Mem0, on managed Mem0 Cloud or fully self-hosted (OSS), with automatic background sync and zero-latency prefetch."
+description: "Add long-term memory to Hermes agents using Mem0 as a pluggable memory provider with automatic background sync and zero-latency prefetch."
 ---
 
-Add long-term memory to [Hermes Agent](https://github.com/NousResearch/hermes-agent), a self-improving AI agent CLI by Nous Research. Hermes has a pluggable memory system, and Mem0 is one of the supported providers. Once enabled, Mem0 learns facts from your conversations and surfaces relevant ones before each turn, without slowing down the chat.
+Add long-term memory to [Hermes Agent](https://github.com/NousResearch/hermes-agent) — a self-improving AI agent CLI by Nous Research. Hermes has a pluggable memory system, and Mem0 is one of the supported providers. Once enabled, Mem0 automatically learns facts from your conversations and surfaces relevant ones before each turn — all without slowing down the chat.
 
-You can run Mem0 in two ways:
+## Overview
 
-- **Platform mode** (default): managed Mem0 Cloud. Add your API key and you are ready.
-- **OSS mode**: fully self-hosted with your own LLM, embedder, and vector store. No data leaves your machine.
+Hermes runs a built-in memory system (file-based `MEMORY.md` and `USER.md`) alongside one external provider. When Mem0 is active, it works additively with the built-in system at three key moments in every conversation turn:
 
-## How It Works
+### 1. Before the Agent Responds (Prefetch)
 
-Hermes runs a built-in memory system (file-based `MEMORY.md` and `USER.md`) alongside one external provider. When Mem0 is active, it works additively with the built-in system at three points in every conversation turn.
+When you send a message, Hermes checks if it already has cached Mem0 search results from the previous turn. If so, those memories are injected into the system prompt so the LLM can see them. This is **zero-latency** — no waiting for an API call.
 
-### 1. Before the agent responds (prefetch)
+### 2. After the Agent Responds (Sync)
 
-When you send a message, Hermes checks for cached Mem0 search results from the previous turn. If they exist, those memories are injected into the system prompt so the model can see them. This is zero-latency, with no waiting on an API call.
+Once the LLM finishes responding, Hermes sends the `(user message, assistant response)` pair to Mem0's API in a **background thread**. Mem0's server-side LLM automatically extracts facts (e.g., "user prefers Python", "user works at Acme Corp") — you don't have to tell it what to remember.
 
-### 2. After the agent responds (sync)
+### 3. Background Prefetch for Next Turn
 
-Once the model finishes, Hermes sends the `(user message, assistant response)` pair to Mem0 in a background thread. Mem0 extracts facts automatically (for example, "user prefers Python" or "user works at Acme Corp"), so you never have to tell it what to remember. Each write is tagged with the gateway channel it came from.
-
-### 3. Background prefetch for the next turn
-
-At the same time, Hermes runs a background search to pre-load relevant memories for your next message. By the time you type, the results are already cached.
+At the same time as sync, Hermes kicks off a background search on Mem0 to pre-load relevant memories for the next turn. By the time you type your next message, the memories are already cached.
 
 ## Agent Tools
 
-When Mem0 is active, the model gets five tools it can call during a conversation:
+When Mem0 is active, the LLM gets three extra tools it can call during conversations:
 
-| Tool | Description | Parameters |
-|------|-------------|------------|
-| `mem0_list` | List all stored memories, for a full overview | `page`, `page_size` (default 100, max 200) |
-| `mem0_search` | Semantic search by meaning, ranked by relevance | `query` (required), `top_k` (default 10, max 50), `rerank` (default `true`, Platform mode only) |
-| `mem0_add` | Store a fact verbatim, with no LLM extraction | `content` (required) |
-| `mem0_update` | Update a memory's text by ID | `memory_id`, `text` (both required) |
-| `mem0_delete` | Delete a memory by ID | `memory_id` (required) |
+| Tool | Description |
+|------|-------------|
+| `mem0_profile` | Fetch all stored memories about the user |
+| `mem0_search` | Semantic search through memories (supports optional reranking via `rerank` and `top_k` parameters) |
+| `mem0_conclude` | Store a specific fact verbatim — uses `infer=False` so no server-side LLM extraction happens |
 
 ## Installation
 
@@ -47,19 +40,17 @@ curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scri
 source ~/.bashrc
 ```
 
-The `mem0ai` package is installed automatically when you enable the Mem0 provider, so there is no manual pip step. OSS providers may need extra packages (for example `qdrant-client`, `psycopg2-binary`, or `ollama`), which the setup flow installs for you when you pick them.
+The `mem0ai` Python package is automatically installed when you enable the Mem0 provider — no manual pip install needed.
 
-## Platform Setup
+## Setup
 
-Platform mode uses managed Mem0 Cloud and is the fastest way to start.
-
-### Option 1: Interactive wizard (recommended)
+### Option 1: Interactive Setup Wizard (Recommended)
 
 ```bash
 hermes memory setup
 ```
 
-Select **mem0**, choose **Platform**, and paste your API key when prompted. The wizard writes the non-secret settings to `~/.hermes/mem0.json` and keeps the key in `~/.hermes/.env`.
+Select **mem0** as the provider and enter your Mem0 API key when prompted. The wizard writes your config to `~/.hermes/mem0.json`.
 
 <Note>Get your API key from <a href="https://app.mem0.ai?utm_source=oss&utm_medium=integration-hermes" rel="nofollow">app.mem0.ai</a>.</Note>
 
@@ -77,151 +68,33 @@ memory:
   provider: mem0
 ```
 
-That's it. Mem0 runs automatically from here.
+That's it — Mem0 runs automatically from this point.
 
-## OSS (Self-Hosted) Setup
+## Configuration Options
 
-OSS mode runs Mem0 entirely on your own infrastructure: your LLM, your embedder, and your vector store. No data is sent to Mem0 Cloud, and no Mem0 API key is required.
+Configuration is stored in `~/.hermes/mem0.json`. Values can also be set via environment variables.
 
-### Interactive
-
-```bash
-hermes memory setup
-# Select "mem0", then "Open Source (self-hosted)"
-# Follow the prompts for LLM, embedder, and vector store
-```
-
-### With flags
-
-```bash
-hermes memory setup mem0 --mode oss \
-  --oss-llm openai --oss-llm-key sk-... \
-  --oss-vector qdrant
-```
-
-### Supported providers
-
-| Component | Providers |
-|-----------|-----------|
-| LLM | `openai` (default model `gpt-5-mini`), `ollama` (local, default `llama3.1:8b`) |
-| Embedder | `openai` (default `text-embedding-3-small`), `ollama` (local, default `nomic-embed-text`) |
-| Vector store | `qdrant` (local path or server), `pgvector` |
-
-### Flag reference
-
-| Flag | Description |
-|------|-------------|
-| `--mode` | `platform` or `oss` |
-| `--oss-llm` | LLM provider (`openai` or `ollama`, default `openai`) |
-| `--oss-llm-key` | LLM API key (for `openai`) |
-| `--oss-llm-model` | Override the LLM model |
-| `--oss-llm-url` | LLM base URL (for `ollama` or a custom endpoint) |
-| `--oss-embedder` | Embedder provider (default `openai`) |
-| `--oss-embedder-key` | Embedder API key |
-| `--oss-vector` | Vector store (`qdrant` or `pgvector`, default `qdrant`) |
-| `--oss-vector-path` | Local Qdrant storage path |
-| `--oss-vector-host`, `--oss-vector-port` | PGVector or remote Qdrant host and port |
-| `--oss-vector-user`, `--oss-vector-password`, `--oss-vector-dbname` | PGVector connection details |
-| `--user-id` | Canonical user identifier |
-| `--dry-run` | Preview the resolved config without writing it |
-
-## Switching Modes
-
-You can move between Platform and OSS at any time. Run the setup command again, or edit `~/.hermes/mem0.json` directly.
-
-```bash
-# Platform to OSS
-hermes memory setup mem0 --mode oss --oss-llm-key sk-...
-
-# OSS to Platform
-hermes memory setup mem0 --mode platform --api-key sk-...
-
-# Preview without writing anything
-hermes memory setup mem0 --mode oss --oss-llm-key sk-... --dry-run
-```
-
-A self-hosted `~/.hermes/mem0.json` looks like this:
-
-```json
-{
-  "mode": "oss",
-  "oss": {
-    "llm": {"provider": "openai", "config": {"model": "gpt-5-mini"}},
-    "embedder": {"provider": "openai", "config": {"model": "text-embedding-3-small"}},
-    "vector_store": {"provider": "qdrant", "config": {"path": "~/.hermes/mem0_qdrant"}}
-  }
-}
-```
-
-## Configuration
-
-Behavioral settings live in `~/.hermes/mem0.json` and are written for you by `hermes memory setup`. Only the secret `MEM0_API_KEY` belongs in `~/.hermes/.env`.
-
-| Key | Default | Description |
-|-----|---------|-------------|
-| `mode` | `platform` | `platform` (Mem0 Cloud) or `oss` (self-hosted) |
-| `api_key` | none | Mem0 Platform API key, required in Platform mode. Stored in `.env` as `MEM0_API_KEY` |
-| `user_id` | `hermes-user` | Identifier that scopes memories. See cross-channel behavior below |
-| `agent_id` | `hermes` | Agent identifier attached to writes |
-| `rerank` | `true` | Rerank search results for relevance (Platform mode only) |
-
-### Cross-channel memories
-
-Hermes can run from the CLI and from gateways like Telegram, Slack, and Discord. The `user_id` setting controls how memories are scoped across them:
-
-- **Set a `user_id`** and it applies to every gateway, so one person gets a single merged memory store no matter where they talk to the agent.
-- **Leave it unset** (or at the default `hermes-user`) and each gateway uses its own native id, keeping per-platform memories separate.
-
-Either way, every write is tagged with `metadata.channel` (for example `telegram` or `cli`), so per-channel views are still possible at query time.
+| Key | Env Variable | Default | Description |
+|-----|-------------|---------|-------------|
+| `api_key` | `MEM0_API_KEY` | — | **Required.** Mem0 Platform API key |
+| `user_id` | `MEM0_USER_ID` | `hermes-user` | User identifier for scoping memories |
+| `agent_id` | `MEM0_AGENT_ID` | `hermes` | Agent identifier |
+| `rerank` | — | `true` | Enable reranking for memory recall |
 
 
 ## Reliability
 
-- **Circuit breaker**: if Mem0 fails five times in a row, Hermes pauses calls for two minutes, then retries. The agent keeps working without memory during that window. Expected client errors, like a 404 on a missing memory id, do not count toward tripping the breaker.
-- **Non-blocking**: every Mem0 call runs in a background daemon thread, so a slow or failed call never blocks your conversation.
-- **Thread-safe**: the client uses lazy initialization with locking, and the background sync and prefetch threads are guarded so concurrent gateway messages cannot produce duplicate memories.
-
-## Troubleshooting
-
-### "Mem0 temporarily unavailable"
-
-The circuit breaker tripped after five consecutive failures and resets after two minutes.
-
-- **Platform mode**: check your API key and internet connection.
-- **OSS mode**: make sure your vector store (Qdrant or PGVector) is running and reachable.
-
-### OSS: vector store connection refused
-
-```bash
-# Local Qdrant: confirm the storage path is writable
-ls -la ~/.hermes/mem0_qdrant
-
-# Qdrant server: confirm it is reachable
-curl http://localhost:6333/healthz
-
-# PGVector: confirm PostgreSQL is accepting connections
-pg_isready -h localhost -p 5432
-```
-
-### OSS: Ollama not reachable
-
-```bash
-curl http://localhost:11434/api/tags
-```
-
-### Memories not appearing
-
-- `mem0_add` stores text verbatim with no extraction. Ordinary conversation turns are extracted automatically by the background sync.
-- Search is semantic, so try a broader query.
-- Confirm `user_id` is the same across sessions (check `~/.hermes/mem0.json`).
+- **Circuit Breaker** — If Mem0's API fails 5 times in a row, Hermes stops calling it for 2 minutes, then retries. The agent keeps working fine without memory during that time.
+- **Non-blocking** — All Mem0 API calls happen in background daemon threads. A slow or failed API call never blocks your conversation.
+- **Thread-safe** — The Mem0 client uses lazy initialization with locking, safe for concurrent access.
 
 ## Key Features
 
-1. **Two ways to run**: managed Platform or fully self-hosted OSS, switchable at any time.
-2. **Zero-latency recall**: memories are prefetched in the background and cached before you type.
-3. **Automatic extraction**: Mem0 extracts and deduplicates facts from each exchange for you.
-4. **Non-blocking and fault tolerant**: background threads plus a circuit breaker keep the agent responsive even when Mem0 is unreachable.
-5. **Additive memory**: works alongside Hermes' built-in file memory (`MEMORY.md`, `USER.md`).
+1. **Zero-Latency Recall** — Memories are prefetched in the background and cached, ready before you type
+2. **Server-side Extraction** — Mem0's API automatically extracts and deduplicates facts from each exchange
+3. **Non-blocking** — All API calls run in background daemon threads
+4. **Fault Tolerant** — Circuit breaker ensures the agent works even if Mem0 is temporarily unreachable
+5. **Additive Memory** — Works alongside Hermes' built-in file-based memory system (MEMORY.md, USER.md)
 
 <CardGroup cols={2}>
   <Card title="OpenClaw Integration" icon={<svg width="24" height="24" viewBox="0 0 500 500" fill="none" xmlns="http://www.w3.org/2000/svg"><path fill-rule="evenodd" d="m153.5 173.5q24.62 1.46 46 13.5 12.11 8.1 17.5 21.5 0.74 2.45 0.5 5 0.09 0.81 1 1 1.48-4.9 1-10 5.04 10.48 1.5 22-9.81 27.86-35.5 42.5-26.17 14.97-56 19.5-2.77-0.4-2 1 2.86 1.27 6 1 25.64 1.53 48.5-10 0.34 10.08 2 20 1.08 5.76 5 10 1 1.5 0 3-31.11 20.84-68.5 17.5-23.7-5.7-32.5-28.5-4.39-9.18-3.5-19 15.41 6.23 32 4.5-20.68-6.39-39-18-34.81-27.22-12.5-65.5 11.84-14.83 29-23 4.21 7.66 11.5 12.5 3 1 6 0-26.04-34.62-29-78-0.13-8.46 2-16.5 1 6.5 2 13 3.43 39.53 24.5 73 2.03 2.28 4.5 4 0.5-1.25 1-2.5-1.27-6.54-5-12 0.5-0.75 1-1.5 9.72-3.43 20-4 0.55 10.34 8 17.5 1.94 0.74 4 0.5-17.8-64.6 16.5-122 0.98-1.79 1.5 0-28.21 56.64-13.5 118 1.08 1.43 2.5 0.5 2.21-4.98 2-10.5z" fill="currentColor"/><path fill-rule="evenodd" d="m454.5 97.5q-1.33 11.18-8.5 20-21.81 26.28-55.5 32-1.11-0.2-2 0.5 2.31 2.82 5.5 4.5 1 2 0 4-9.56 11.3-19.5 20 19.71-8.72 31-27 2.68-0.43 5 1-14.24 30.97-48 36.5-9.93 1.71-20 1.5-6.8-0.48-13 1 5.81 6.92 14 11-10.78 16.03-27 26.5 27.16-7.4 38-33.5 4.34 1.35 9 1-9.08 23.84-33 33.5-18.45 6.41-38 7 22.59 8.92 45-1 12.05-5.52 24-11 9.01-1.79 17 2.5 5.28-4.38 11-8 12.8-6.07 27-5 0 0.5 0 1-19.34 2.69-34 15.5 0.5 0.25 1 0.5 17.79-8.09 36-15 2.71-0.79 5-2 2.5-1 5-2 5.53-4.04 11-8 11.7-4.18 24-6.5 7.78-1.36 15 1.5-2.97 18.45-13.5 34-34.92 49.37-94.5 62.5-59.27 12.45-108-23-15.53-12.52-21.5-31.5-2.47-14.26 4-27-3.15 24.41 14 42-4.92-10.28-7-22-1.97-17.63 7-33 47.28-69.5 125.5-100 15.86-3.42 32-5.5 18.63-1.47 37 1.5z" fill="currentColor"/><path fill-rule="evenodd" d="m231.5 238.5q1.31-0.2 2 1-3.13 28.62 15 51-16.25 6.75-27-7.5-1-1-2 0 14.73 29.34 46 18.5 1.79 0.52 0 1.5-37.63 16.82-50.5-22.5-5.1-26.48 16.5-42z" fill="currentColor"/><path fill-rule="evenodd" d="m203.5 266.5q1.31-0.2 2 1-2.48 22.08 12 39-6.99 1.35-14 0.5 4.59 4.08 10 7-8.71 0.28-14.5-6.5-16.98-22.76 4.5-41z" fill="currentColor"/><path fill-rule="evenodd" d="m58.5 284.5q9.6-2.17 14.5 6 5.15 14.18-1 28-11.05-13.14-27.5-17.5 5.15-9.9 14-16.5z" fill="currentColor"/><path fill-rule="evenodd" d="m56.5 313.5q3.43 5.43 8 10-4.88 0.44-8 4-1.11-0.2-2 0.5 28.91 1.65 38 28.5 0.45 3.16-1 6-11.02-7.01-23-12.5-4.75-3.75-9.5-7.5 1.47 7.42 7 13 8.34 27.18 32 43 0.99 2.41-1.5 3.5-40.25 5.58-66.5-25.5-15.67-22.01-8-48 10.46-23.87 34.5-15z" fill="currentColor"/><path fill-rule="evenodd" d="m198.5 319.5q1.44 0.68 2.5 2 2.41 8.23 6 16 1.2 2.64-0.5 5-30.65 21.41-68 18.5-25.16-6.17-32.5-30.5 6.96 4.99 15.5 6.5 8.99 0.75 18 0.5 16.25 2.38 32-2.5 15.9-3.94 27-15.5z" fill="currentColor"/><path fill-rule="evenodd" d="m239.5 342.5q7.02-0.25 14 0.5 4.46 1.06 8 3.5-5.2 2.35-10 5.5-3.88 4.65-9 7.5-9.89-3.09-9.5-13 2.36-3.63 6.5-4z" fill="currentColor"/><path fill-rule="evenodd" d="m214.5 349.5q5.96 7.2 13.5 13 1 1 0 2-28.58 23.34-65.5 20.5-18.15-4.24-27.5-19.5 1.13 0.94 2.5 1.5 14.7 1.42 29-1.5 26.57-0.52 48-16z" fill="currentColor"/><path fill-rule="evenodd" d="m302.5 373.5q0.21 2.44-2 3.5-28.69 7.6-50.5-12.5-0.06-6.71 6.5-9 4.45-0.75 9-1 22.26 2.27 37 19z" fill="currentColor"/><path fill-rule="evenodd" d="m232.5 365.5q17.6 6.19 10.5 23-10.6 10.42-25.5 11.5-25.94 3.21-49-9 36.75-1.65 64-25.5z" fill="currentColor"/><path fill-rule="evenodd" d="m113.5 367.5q7.7-0.01 9.5 7-9.69 7.19-18.5 15.5-7.23 5.76-5.5-3.5 3.12-12.84 14.5-19z" fill="currentColor"/><path fill-rule="evenodd" d="m126.5 380.5q7.88-0.4 12 6.5-8.5 7.25-17 14.5-5.62-12.55 5-21z" fill="currentColor"/><path fill-rule="evenodd" d="m283.5 385.5q3.22 2.95 7 5.5 2.8 4.03 6 7.5 0.42 2.77-2 4-15.5-9.75-31-19.5-1.79-0.98 0-1.5 9.96 2.49 20 4z" fill="currentColor"/></svg>} href="/integrations/openclaw">

docs/integrations/keywords.mdx

@@ -1,22 +1,22 @@
 ---
-title: Respan
-description: "Combine Mem0 persistent memory with Respan observability for tracked, cost-optimized AI applications."
+title: Keywords AI
+description: "Combine Mem0 persistent memory with Keywords AI observability for tracked, cost-optimized AI applications."
 ---
 
-Build AI applications with persistent memory and comprehensive LLM observability by integrating Mem0 with Respan.
+Build AI applications with persistent memory and comprehensive LLM observability by integrating Mem0 with Keywords AI.
 
 ## Overview
 
-Mem0 is a self-improving memory layer for LLM applications, enabling personalized AI experiences that save costs and delight users. Respan (formerly Keywords AI) provides complete LLM observability.
+Mem0 is a self-improving memory layer for LLM applications, enabling personalized AI experiences that save costs and delight users. Keywords AI provides complete LLM observability.
 
-Combining Mem0 with Respan allows you to:
+Combining Mem0 with Keywords AI allows you to:
 1. Add persistent memory to your AI applications
 2. Track interactions across sessions
-3. Monitor memory usage and retrieval with Respan observability
+3. Monitor memory usage and retrieval with Keywords AI observability
 4. Optimize token usage and reduce costs
 
 <Note>
-You can get your Mem0 API key from the <a href="https://app.mem0.ai/?utm_source=oss&utm_medium=integration-respan" rel="nofollow">Mem0 dashboard</a>.
+You can get your Mem0 API key from the <a href="https://app.mem0.ai/?utm_source=oss&utm_medium=integration-keywords" rel="nofollow">Mem0 dashboard</a>.
 </Note>
 
 ## Setup and Configuration
@@ -24,7 +24,7 @@ You can get your Mem0 API key from the <a href="https://app.mem0.ai/?utm_source=
 Install the necessary libraries:
 
 ```bash
-pip install mem0ai openai
+pip install mem0ai keywordsai-sdk
 ```
 
 Set up your environment variables:
@@ -34,13 +34,13 @@ import os
 
 # Set your API keys
 os.environ["MEM0_API_KEY"] = "your-mem0-api-key"
-os.environ["RESPAN_API_KEY"] = "your-respan-api-key"
-os.environ["RESPAN_BASE_URL"] = "https://api.respan.ai/api/"
+os.environ["KEYWORDSAI_API_KEY"] = "your-keywords-api-key"
+os.environ["KEYWORDSAI_BASE_URL"] = "https://api.keywordsai.co/api/"
 ```
 
 ## Basic Integration Example
 
-Here's a simple example of using Mem0 with Respan:
+Here's a simple example of using Mem0 with Keywords AI:
 
 ```python
 from mem0 import Memory
@@ -48,17 +48,17 @@ import os
 
 # Configuration
 api_key = os.getenv("MEM0_API_KEY")
-respan_api_key = os.getenv("RESPAN_API_KEY")
-base_url = os.getenv("RESPAN_BASE_URL") # "https://api.respan.ai/api/"
+keywordsai_api_key = os.getenv("KEYWORDSAI_API_KEY")
+base_url = os.getenv("KEYWORDSAI_BASE_URL") # "https://api.keywordsai.co/api/"
 
-# Set up Mem0 with Respan as the LLM provider
+# Set up Mem0 with Keywords AI as the LLM provider
 config = {
     "llm": {
         "provider": "openai",
         "config": {
             "model": "gpt-5-mini",
             "temperature": 0.0,
-            "api_key": respan_api_key,
+            "api_key": keywordsai_api_key,
             "openai_base_url": base_url,
         },
     }
@@ -79,7 +79,7 @@ print(result)
 
 ## Advanced Integration with OpenAI SDK
 
-For more advanced use cases, you can integrate Respan with Mem0 through the OpenAI SDK:
+For more advanced use cases, you can integrate Keywords AI with Mem0 through the OpenAI SDK:
 
 ```python
 from openai import OpenAI
@@ -88,8 +88,8 @@ import json
 
 # Initialize client
 client = OpenAI(
-    api_key=os.environ.get("RESPAN_API_KEY"),
-    base_url=os.environ.get("RESPAN_BASE_URL"),
+    api_key=os.environ.get("KEYWORDSAI_API_KEY"),
+    base_url=os.environ.get("KEYWORDSAI_BASE_URL"),
 )
 
 # Sample conversation messages
@@ -118,18 +118,18 @@ response = client.chat.completions.create(
 print(json.dumps(response.model_dump(), indent=4))
 ```
 
-For detailed information on this integration, refer to the official [Respan Mem0 integration documentation](https://www.respan.ai/docs/integrations/mem0).
+For detailed information on this integration, refer to the official [Keywords AI Mem0 integration documentation](https://docs.keywordsai.co/integration/development-frameworks/mem0).
 
 ## Key Features
 
 1. **Memory Integration**: Store and retrieve relevant information from past interactions
-2. **LLM Observability**: Track memory usage and retrieval patterns with Respan
+2. **LLM Observability**: Track memory usage and retrieval patterns with Keywords AI
 3. **Session Persistence**: Maintain context across multiple user sessions
 4. **Cost Optimization**: Reduce token usage through efficient memory retrieval
 
 ## Conclusion
 
-Integrating Mem0 with Respan provides a powerful combination for building AI applications with persistent memory and comprehensive observability. This integration enables more personalized user experiences while providing insights into your application's memory usage.
+Integrating Mem0 with Keywords AI provides a powerful combination for building AI applications with persistent memory and comprehensive observability. This integration enables more personalized user experiences while providing insights into your application's memory usage.
 
 <CardGroup cols={2}>
   <Card title="OpenAI Agents SDK" icon="cube" href="/integrations/openai-agents-sdk">
@@ -139,3 +139,4 @@ Integrating Mem0 with Respan provides a powerful combination for building AI app
     Monitor agent performance with AgentOps
   </Card>
 </CardGroup>
+

docs/llms.txt

@@ -286,7 +286,7 @@ If the user is on a pre-current major (Python < 2, TS < 3, or Platform `output_f
 - [Dify](https://docs.mem0.ai/integrations/dify) [Both]: Use when the user is on Dify LLMOps.
 - [Flowise](https://docs.mem0.ai/integrations/flowise) [Both]: Use when the user is on Flowise no-code.
 - [AgentOps](https://docs.mem0.ai/integrations/agentops) [Both]: Use when tracking agent observability with memory metadata.
-- [Respan](https://docs.mem0.ai/integrations/respan) [Both]: Use when monitoring Mem0 with Respan (formerly Keywords AI) LLM observability.
+- [Keywords AI](https://docs.mem0.ai/integrations/keywords) [Both]: Use when monitoring with Keywords AI.
 - [Raycast](https://docs.mem0.ai/integrations/raycast) [Both]: Use when the user wants quick memory access via Raycast.
 
 ## Cookbooks

docs/migration/api-changes.mdx

@@ -62,8 +62,7 @@ def add(
     filters: dict = None,
     output_format: str = None,  # ❌ REMOVED
     version: str = None         # ❌ REMOVED
-) -> Union[List[dict], dict]:
-    ...
+) -> Union[List[dict], dict]
 ```
 
 #### v1.0.0  Signature
@@ -77,8 +76,7 @@ def add(
     metadata: dict = None,
     filters: dict = None,
     infer: bool = True          # ✅ NEW: Control memory inference
-) -> dict:  # Always returns dict with "results" key
-    ...
+) -> dict  # Always returns dict with "results" key
 ```
 
 #### Changes Summary
@@ -149,8 +147,7 @@ def search(
     filters: dict = None,       # Basic key-value only
     output_format: str = None,  # ❌ REMOVED
     version: str = None         # ❌ REMOVED
-) -> Union[List[dict], dict]:
-    ...
+) -> Union[List[dict], dict]
 ```
 
 #### v1.0.0  Signature
@@ -164,8 +161,7 @@ def search(
     limit: int = 100,
     filters: dict = None,       # ✅ ENHANCED: Advanced operators
     rerank: bool = True         # ✅ NEW: Reranking support
-) -> dict:  # Always returns dict with "results" key
-    ...
+) -> dict  # Always returns dict with "results" key
 ```
 
 #### Enhanced Filtering
@@ -220,8 +216,7 @@ def get_all(
     filters: dict = None,
     output_format: str = None,  # ❌ REMOVED
     version: str = None         # ❌ REMOVED
-) -> Union[List[dict], dict]:
-    ...
+) -> Union[List[dict], dict]
 ```
 
 #### v1.0.0  Signature
@@ -232,8 +227,7 @@ def get_all(
     agent_id: str = None,
     run_id: str = None,
     filters: dict = None        # ✅ ENHANCED: Advanced operators
-) -> dict:  # Always returns dict with "results" key
-    ...
+) -> dict  # Always returns dict with "results" key
 ```
 
 ### update() Method
@@ -245,8 +239,7 @@ def update(
     self,
     memory_id: str,
     data: str
-) -> dict:
-    ...
+) -> dict
 ```
 
 ### delete() Method
@@ -257,8 +250,7 @@ def update(
 def delete(
     self,
     memory_id: str
-) -> dict:
-    ...
+) -> dict
 ```
 
 ### delete_all() Method
@@ -352,7 +344,7 @@ config = {
 ### New Configuration Options
 
 #### Reranker Configuration
-```text
+```python
 # Cohere reranker
 "reranker": {
     "provider": "cohere",
@@ -571,4 +563,4 @@ results = m.search(
 
 <Info>
 Use this reference to systematically update your codebase. Test each change thoroughly before deploying to production.
-</Info>
+</Info>

docs/platform/features/criteria-retrieval.mdx

@@ -117,7 +117,7 @@ results_without_criteria = client.search(
 ### Compare Results
 
 ### Search Results (with Criteria)
-```text
+```python
 [
     {"memory": "User feels refreshed and ready to take on anything on a beautiful sunny day", "score": 0.666, ...},
     {"memory": "User finally has time to draw something after a long time", "score": 0.616, ...},
@@ -128,7 +128,7 @@ results_without_criteria = client.search(
 ```
 
 ### Search Results (without Criteria)
-```text
+```python
 [
     {"memory": "User is happy today", "score": 0.607, ...},
     {"memory": "User feels refreshed and ready to take on anything on a beautiful sunny day", "score": 0.512, ...},

docs/platform/features/custom-categories.mdx

@@ -190,7 +190,7 @@ messages = [
 client.add(messages, user_id='alice')
 ```
 
-```text Memories with categories
+```python Memories with categories
 # Following categories will be created for the memories added
 Sometimes draws and sketches in free time (hobbies)
 Is quite athletic (sports)

docs/platform/features/memory-export.mdx

@@ -108,10 +108,10 @@ print(response)
 
 ```javascript JavaScript
 // Basic Export request
-const basicFilters = {"user_id": "alice"};
+const filters = {"user_id": "alice"};
 const response = await client.createMemoryExport({
     schema: json_schema,
-    filters: basicFilters
+    filters: filters
 });
 
 // Export with custom instructions and additional filters
@@ -124,16 +124,16 @@ const export_instructions = `
 `;
 
 // For create operation, using only user_id filter as requested
-const exportFilters = {
+const filters = {
     "AND": [
         {"user_id": "alex"},
         {"created_at": {"gte": "2024-01-01"}}
     ]
-};
+}
 
 const responseWithInstructions = await client.createMemoryExport({
     schema: json_schema,
-    filters: exportFilters,
+    filters: filters,
     exportInstructions: export_instructions
 });
 

examples/mem0-demo/package.json

@@ -23,7 +23,7 @@
     "@types/js-cookie": "^3.0.6",
     "@types/react-syntax-highlighter": "^15.5.13",
     "@types/uuid": "^10.0.0",
-    "ai": "^5.0.52",
+    "ai": "^4.1.46",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "js-cookie": "^3.0.6",

examples/multimodal-demo/package.json

@@ -18,7 +18,7 @@
     "@radix-ui/react-scroll-area": "^1.2.0",
     "@radix-ui/react-select": "^2.1.2",
     "@radix-ui/react-slot": "^1.1.0",
-    "ai": "^5.0.52",
+    "ai": "4.1.42",
     "buffer": "^6.0.3",
     "class-variance-authority": "^0.7.0",
     "clsx": "^2.1.1",

examples/vercel-ai-sdk-chat-app/package.json

@@ -18,7 +18,7 @@
       "@radix-ui/react-scroll-area": "^1.2.0",
       "@radix-ui/react-select": "^2.1.2",
       "@radix-ui/react-slot": "^1.1.0",
-      "ai": "^5.0.52",
+      "ai": "4.1.42",
       "buffer": "^6.0.3",
       "class-variance-authority": "^0.7.0",
       "clsx": "^2.1.1",

integrations/mem0-plugin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "mem0",
-  "version": "0.2.11",
+  "version": "0.2.10",
   "description": "Persistent memory for Claude Code. Remembers decisions, patterns, and preferences across sessions.",
   "author": {
     "name": "Mem0",

integrations/mem0-plugin/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "mem0",
-  "version": "0.2.11",
+  "version": "0.2.10",
   "description": "Persistent memory for Codex. Remembers decisions, patterns, and preferences across sessions.",
   "author": {
     "name": "Mem0",

integrations/mem0-plugin/.cursor-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "mem0",
-  "version": "0.2.11",
+  "version": "0.2.10",
   "description": "Mem0 memory layer for AI applications. Add persistent memory, personalization, and semantic search using the Mem0 Platform MCP server.",
   "author": {
     "name": "Mem0",

integrations/mem0-plugin/CHANGELOG.md

@@ -2,18 +2,6 @@
 
 All notable changes to the Mem0 plugin will be documented in this file.
 
-## 0.2.11 — Session-summary metadata fix + rerank auto-injected context by default
-
-> Versions: Claude Code / Cursor / Codex `0.2.11`; Antigravity `0.1.3`. All four editors share `scripts/`, so the fix below applies to every editor.
-
-### Fixed
-
-- **`files_touched` was double-JSON-encoded in session summaries (`scripts/capture_session_summary.py`):** the Stop-hook summary set `metadata["files_touched"] = json.dumps(files[:20])` — a pre-serialized JSON string — and then serialized the whole request body again with `json.dumps(body)`. The stored memory therefore carried an escaped string blob (`"[\"mem0/memory/main.py\", \"src/client/index.ts\"]"`) instead of a real array, so file paths surfaced as backslash- and slash-heavy escaped text when those memories were returned by `search_memories`/`get_memories` and shown in Claude Code, Cursor, Codex, and Antigravity. The fix stores the list directly (`metadata["files_touched"] = files[:20]`) so the body is encoded exactly once. New `tests/test_capture_session_summary.py` asserts the posted body contains a JSON array and no escaped-string artifact.
-
-### Changed
-
-- **Auto-injected memory context is now reranked by default (`scripts/_search.py`, `scripts/file_context.py`, `scripts/on_bash_output.sh`, `scripts/on_user_prompt.sh`):** the REST search endpoint does not rerank when `rerank` is omitted, so hook-injected context (file-context, bash-error lookup, session-resume prefetch) was ordered by raw vector similarity and the single most relevant memory could fall outside the injected `top_k` window. A new `should_rerank()` helper turns reranking on for every auto-injection path; the extra ~150–200 ms stays within the hook's curl budget. Opt out with `MEM0_RERANK=0` (also accepts `false`/`no`/`off`). (#5690)
-
 ## 0.2.10 — Accurate per-editor telemetry attribution
 
 ### Fixed

integrations/mem0-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "mem0",
   "name": "mem0",
-  "version": "0.1.3",
+  "version": "0.1.2",
   "description": "Persistent semantic memory for Antigravity agents. Cross-session, user-level recall via the Mem0 Platform MCP server. 16 slash commands, lifecycle hooks for auto-capture and metadata enforcement.",
   "author": { "name": "Mem0", "email": "support@mem0.ai" },
   "publisher": "mem0ai",

integrations/mem0-plugin/scripts/_search.py

@@ -7,31 +7,12 @@ All pre-fetch hooks use this instead of duplicating urllib boilerplate.
 from __future__ import annotations
 
 import json
-import os
 import urllib.request
 
 SEARCH_URL = "https://api.mem0.ai/v3/memories/search/"
 SEARCH_TIMEOUT = 5
 
 
-def should_rerank() -> bool:
-    """Whether auto-injection searches should request Platform reranking.
-
-    The REST search endpoint does not rerank when ``rerank`` is omitted, so
-    auto-injected context is ordered by raw vector similarity and the single
-    most relevant memory can fall outside the injected top_k window. We default
-    reranking ON for the hook-driven injection path (the extra ~150-200ms is
-    well within the hook's curl budget) and let users opt out via MEM0_RERANK.
-
-    MEM0_RERANK is read case-insensitively; ``0``, ``false``, ``no``, and
-    ``off`` disable reranking. Anything else (including unset) enables it.
-    """
-    raw = os.environ.get("MEM0_RERANK")
-    if raw is None:
-        return True
-    return raw.strip().lower() not in ("0", "false", "no", "off", "")
-
-
 def _do_search(api_key: str, payload: dict) -> list[dict]:
     body = json.dumps(payload).encode()
     req = urllib.request.Request(

integrations/mem0-plugin/scripts/capture_session_summary.py

@@ -173,7 +173,7 @@ def store_summary(
     if branch:
         metadata["branch"] = branch
     if files:
-        metadata["files_touched"] = files[:20]
+        metadata["files_touched"] = json.dumps(files[:20])
 
     body = {
         "messages": [{"role": "user", "content": summary_prompt}],

integrations/mem0-plugin/scripts/file_context.py

@@ -23,7 +23,7 @@ sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 from _formatting import TYPE_ICONS, format_age
 from _identity import resolve_api_key, resolve_user_id
 from _project import resolve_project_id
-from _search import search_memories, should_rerank
+from _search import search_memories
 
 FILE_READ_GATE_MIN_BYTES = 1500
 MAX_RESULTS = 5
@@ -93,7 +93,6 @@ def search_file_context(
         api_key, user_id, project_id, query,
         top_k=MAX_RESULTS, threshold=0.3,
         global_search=global_search,
-        rerank=should_rerank(),
     )
 
     results = results[:MAX_RESULTS]

integrations/mem0-plugin/scripts/on_bash_output.sh

@@ -77,16 +77,15 @@ RESULTS=$(PYTHONPATH="$SCRIPT_DIR" MEM0_SEARCH_QUERY="$ERROR_QUERY" MEM0_SEARCH_
   python3 -c "
 import os, sys
 sys.path.insert(0, os.environ.get('PYTHONPATH', '.'))
-from _search import search_memories, format_results_for_context, should_rerank
+from _search import search_memories, format_results_for_context
 
 api_key = os.environ.get('MEM0_API_KEY', '')
 user_id = os.environ.get('MEM0_SEARCH_USER', 'default')
 project_id = os.environ.get('MEM0_PROJECT_ID', 'unknown')
 query = os.environ.get('MEM0_SEARCH_QUERY', '')
-rerank = should_rerank()
 
-r1 = search_memories(api_key, user_id, project_id, query, metadata_type='anti_pattern', top_k=3, rerank=rerank)
-r2 = search_memories(api_key, user_id, project_id, query, metadata_type='bug_fix', top_k=3, rerank=rerank)
+r1 = search_memories(api_key, user_id, project_id, query, metadata_type='anti_pattern', top_k=3)
+r2 = search_memories(api_key, user_id, project_id, query, metadata_type='bug_fix', top_k=3)
 
 seen = set()
 combined = []

integrations/mem0-plugin/scripts/on_user_prompt.sh

@@ -120,15 +120,14 @@ if [ -n "$HAS_RESUME" ]; then
   RESUME_RESULTS=$(PYTHONPATH="$SCRIPT_DIR" MEM0_SEARCH_USER="$USER_ID" python3 -c "
 import os, sys
 sys.path.insert(0, os.environ.get('PYTHONPATH', '.'))
-from _search import search_memories, format_results_for_context, should_rerank
+from _search import search_memories, format_results_for_context
 
 api_key = os.environ.get('MEM0_API_KEY', '')
 user_id = os.environ.get('MEM0_SEARCH_USER', 'default')
 project_id = os.environ.get('MEM0_PROJECT_ID', 'unknown')
-rerank = should_rerank()
 
-state = search_memories(api_key, user_id, project_id, 'session state current task', metadata_type='session_state', top_k=3, rerank=rerank)
-decisions = search_memories(api_key, user_id, project_id, 'recent decisions and learnings', metadata_type='decision', top_k=3, rerank=rerank)
+state = search_memories(api_key, user_id, project_id, 'session state current task', metadata_type='session_state', top_k=3)
+decisions = search_memories(api_key, user_id, project_id, 'recent decisions and learnings', metadata_type='decision', top_k=3)
 
 all_r = state + decisions
 seen = set()

integrations/mem0-plugin/tests/test_capture_session_summary.py

@@ -1,79 +0,0 @@
-"""Regression tests for capture_session_summary.py request body construction.
-
-Guards against the double-JSON-encoding bug where ``files_touched`` was stored
-as a pre-serialized JSON string and then encoded a second time with the rest of
-the request body — surfacing as escaped, slash-heavy blobs in the memories shown
-inside Claude Code / Cursor / Codex / Antigravity (all four editors share this
-script).
-"""
-
-from __future__ import annotations
-
-import json
-
-
-class _FakeResp:
-    status = 200
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, *_):
-        return False
-
-
-def _capture_request_body(monkeypatch):
-    """Patch urlopen so store_summary posts nowhere; capture the request body."""
-    import capture_session_summary as css
-
-    captured: dict = {}
-
-    def fake_urlopen(req, timeout=0):
-        captured["raw"] = req.data.decode("utf-8")
-        captured["body"] = json.loads(captured["raw"])
-        return _FakeResp()
-
-    monkeypatch.setattr(css.urllib.request, "urlopen", fake_urlopen)
-    return captured, css
-
-
-def test_files_touched_is_json_array_not_double_encoded(monkeypatch):
-    """files_touched must be a real JSON array, encoded exactly once."""
-    captured, css = _capture_request_body(monkeypatch)
-    files = ["mem0/memory/main.py", "src/client/index.ts"]
-
-    css.store_summary(
-        api_key="test-key",
-        summary_prompt="did some work",
-        user_id="u1",
-        session_id="s1",
-        project_id="p1",
-        branch="main",
-        files=files,
-    )
-
-    files_touched = captured["body"]["metadata"]["files_touched"]
-    assert isinstance(files_touched, list), (
-        "files_touched must be a JSON array, not a double-encoded string; "
-        f"got {type(files_touched).__name__}: {files_touched!r}"
-    )
-    assert files_touched == files
-    # The file paths must not appear as an escaped JSON string inside the body.
-    assert '\\"' not in captured["raw"]
-
-
-def test_files_touched_omitted_when_no_files(monkeypatch):
-    """No files touched -> no files_touched key (unchanged behaviour)."""
-    captured, css = _capture_request_body(monkeypatch)
-
-    css.store_summary(
-        api_key="test-key",
-        summary_prompt="did some work",
-        user_id="u1",
-        session_id="s1",
-        project_id="p1",
-        branch="main",
-        files=[],
-    )
-
-    assert "files_touched" not in captured["body"]["metadata"]

integrations/mem0-plugin/tests/test_search.py

@@ -101,67 +101,6 @@ def test_search_memories_no_api_key_returns_empty():
     assert results == []
 
 
-def test_search_memories_omits_rerank_by_default():
-    """Regression for #5684: rerank must not be sent unless requested."""
-    from _search import search_memories
-
-    captured_body = {}
-
-    def mock_urlopen(req, timeout=None):
-        captured_body.update(json.loads(req.data.decode()))
-        resp = MagicMock()
-        resp.read.return_value = json.dumps({"results": []}).encode()
-        resp.__enter__ = lambda s: s
-        resp.__exit__ = MagicMock(return_value=False)
-        return resp
-
-    with patch("urllib.request.urlopen", side_effect=mock_urlopen):
-        search_memories("key", "user", "proj", "query")
-
-    assert "rerank" not in captured_body
-
-
-def test_search_memories_forwards_rerank_true():
-    """Regression for #5684: rerank=True must reach the request body so the
-    REST endpoint actually reranks (it does not rerank when omitted)."""
-    from _search import search_memories
-
-    captured_body = {}
-
-    def mock_urlopen(req, timeout=None):
-        captured_body.update(json.loads(req.data.decode()))
-        resp = MagicMock()
-        resp.read.return_value = json.dumps({"results": []}).encode()
-        resp.__enter__ = lambda s: s
-        resp.__exit__ = MagicMock(return_value=False)
-        return resp
-
-    with patch("urllib.request.urlopen", side_effect=mock_urlopen):
-        search_memories("key", "user", "proj", "query", rerank=True)
-
-    assert captured_body.get("rerank") is True
-
-
-def test_should_rerank_defaults_true(monkeypatch):
-    """Regression for #5684: auto-injection reranks by default."""
-    from _search import should_rerank
-
-    monkeypatch.delenv("MEM0_RERANK", raising=False)
-    assert should_rerank() is True
-
-
-def test_should_rerank_opt_out_values(monkeypatch):
-    from _search import should_rerank
-
-    for falsey in ("0", "false", "False", "NO", "off", ""):
-        monkeypatch.setenv("MEM0_RERANK", falsey)
-        assert should_rerank() is False, falsey
-
-    for truthy in ("1", "true", "yes", "on"):
-        monkeypatch.setenv("MEM0_RERANK", truthy)
-        assert should_rerank() is True, truthy
-
-
 def test_format_results_for_context():
     from _search import format_results_for_context
 

integrations/pi-agent-plugin/package.json

@@ -73,8 +73,7 @@
     "overrides": {
       "form-data@<4.0.6": ">=4.0.6",
       "uuid@<11.1.1": ">=11.1.1",
-      "esbuild": ">=0.28.1",
-      "undici@>=8.0.0 <8.5.0": ">=8.5.0"
+      "esbuild": ">=0.28.1"
     }
   }
 }

integrations/pi-agent-plugin/pnpm-lock.yaml

@@ -8,7 +8,6 @@ overrides:
   form-data@<4.0.6: '>=4.0.6'
   uuid@<11.1.1: '>=11.1.1'
   esbuild: '>=0.28.1'
-  undici@>=8.0.0 <8.5.0: '>=8.5.0'
 
 importers:
 
@@ -2355,8 +2354,8 @@ packages:
     resolution: {integrity: sha512-4yqz8a3n5HmGTlsbADNtr/dJlhkh/55Rq798G6ibiULcXbDtaLpTl1pvdqcbFfeoj3iSi52lePFM7h9H21cw/A==}
     engines: {node: '>=18.17'}
 
-  undici@8.5.0:
-    resolution: {integrity: sha512-xamtWoB1EshgjpmlXd7GGm2VfdDtw1+rD8uhry8pSNW3If6S8E0m2T2+orSKeZXEn/aPJMviCpDBA65WJt8zhg==}
+  undici@8.3.0:
+    resolution: {integrity: sha512-TkUDgb6tl7KOGZ+7e8E3d2FYgUQgF6z5YypqjWmixVQSQERFcVrVg0ySADm2LVLRh5ljAaHTCR5Fmz3Q34rB7Q==}
     engines: {node: '>=22.19.0'}
 
   util-deprecate@1.0.2:
@@ -2939,7 +2938,7 @@ snapshots:
       minimatch: 10.2.5
       proper-lockfile: 4.1.2
       typebox: 1.1.38
-      undici: 8.5.0
+      undici: 8.3.0
       yaml: 2.9.0
     optionalDependencies:
       '@mariozechner/clipboard': 0.3.9
@@ -4896,7 +4895,7 @@ snapshots:
 
   undici@6.26.0: {}
 
-  undici@8.5.0: {}
+  undici@8.3.0: {}
 
   util-deprecate@1.0.2: {}
 

integrations/pi-agent-plugin/pnpm-workspace.yaml

@@ -5,4 +5,3 @@ overrides:
   "form-data@<4.0.6": ">=4.0.6"
   "uuid@<11.1.1": ">=11.1.1"
   "esbuild": ">=0.28.1"
-  "undici@>=8.0.0 <8.5.0": ">=8.5.0"

integrations/vercel-ai-sdk/package.json

@@ -80,7 +80,6 @@
     ],
     "overrides": {
       "glob@>=10.2.0 <10.5.0": "^10.5.0",
-      "js-yaml@<=4.1.1": ">=4.2.0",
       "minimatch@<3.1.3": "^3.1.3",
       "minimatch@>=5.0.0 <5.1.8": "^5.1.8",
       "minimatch@>=9.0.0 <9.0.7": "^9.0.7",

integrations/vercel-ai-sdk/pnpm-lock.yaml

@@ -6,7 +6,6 @@ settings:
 
 overrides:
   glob@>=10.2.0 <10.5.0: ^10.5.0
-  js-yaml@<=4.1.1: '>=4.2.0'
   minimatch@<3.1.3: ^3.1.3
   minimatch@>=5.0.0 <5.1.8: ^5.1.8
   minimatch@>=9.0.0 <9.0.7: ^9.0.7
@@ -794,8 +793,8 @@ packages:
   arg@4.1.3:
     resolution: {integrity: sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==}
 
-  argparse@2.0.1:
-    resolution: {integrity: sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==}
+  argparse@1.0.10:
+    resolution: {integrity: sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==}
 
   babel-jest@29.7.0:
     resolution: {integrity: sha512-BrvGY3xZSwEcCzKvKsCi2GgHqDqsYkOP4/by5xCgIwGXQxIEh+8ew3gmrE1y7XRR6LHZIj6yLYnUi/mm2KXKBg==}
@@ -1026,6 +1025,11 @@ packages:
     resolution: {integrity: sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w==}
     engines: {node: '>=8'}
 
+  esprima@4.0.1:
+    resolution: {integrity: sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==}
+    engines: {node: '>=4'}
+    hasBin: true
+
   eventsource-parser@3.1.0:
     resolution: {integrity: sha512-kJezFj9YFAMLeORyi7aCLxLbD5/qWMQnoMVlVPyHIll7lgRJCc3JVln9Vgl9nwQi0YkMnhdGTMNn7CkRRAptMg==}
     engines: {node: '>=18.0.0'}
@@ -1347,8 +1351,8 @@ packages:
   js-tokens@4.0.0:
     resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==}
 
-  js-yaml@4.2.0:
-    resolution: {integrity: sha512-ePWsvanv0DWuDRsW8dnt+R4jQ31SCRCQ7hhNcPXZPsoBZiemuZNYGf7adZdqX2D86j6rvKp3RpCxVTSb8WQlOw==}
+  js-yaml@3.14.2:
+    resolution: {integrity: sha512-PMSmkqxr106Xa156c2M265Z+FTrPl+oxd/rgOQy2tijQeK5TxQ43psO1ZCwhVOSdnn+RzkzlRz/eY4BgJBYVpg==}
     hasBin: true
 
   jsesc@3.1.0:
@@ -1650,6 +1654,9 @@ packages:
     resolution: {integrity: sha512-i5uvt8C3ikiWeNZSVZNWcfZPItFQOsYTUAOkcUPGd8DqDy1uOUikjt5dG+uRlwyvR108Fb9DOd4GvXfT0N2/uQ==}
     engines: {node: '>= 12'}
 
+  sprintf-js@1.0.3:
+    resolution: {integrity: sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==}
+
   stack-utils@2.0.6:
     resolution: {integrity: sha512-XlkWvfIm6RmsWtNJx+uqtKLS8eqFbxUg0ZzLXqY0caEy9l7hruX8IpiDnjsLavoBgqCCR71TqWO8MaXYheJ3RQ==}
     engines: {node: '>=10'}
@@ -2219,7 +2226,7 @@ snapshots:
       camelcase: 5.3.1
       find-up: 4.1.0
       get-package-type: 0.1.0
-      js-yaml: 4.2.0
+      js-yaml: 3.14.2
       resolve-from: 5.0.0
 
   '@istanbuljs/schema@0.1.6': {}
@@ -2598,7 +2605,9 @@ snapshots:
 
   arg@4.1.3: {}
 
-  argparse@2.0.1: {}
+  argparse@1.0.10:
+    dependencies:
+      sprintf-js: 1.0.3
 
   babel-jest@29.7.0(@babel/core@7.29.7):
     dependencies:
@@ -2848,6 +2857,8 @@ snapshots:
 
   escape-string-regexp@2.0.0: {}
 
+  esprima@4.0.1: {}
+
   eventsource-parser@3.1.0: {}
 
   execa@5.1.1:
@@ -3344,9 +3355,10 @@ snapshots:
 
   js-tokens@4.0.0: {}
 
-  js-yaml@4.2.0:
+  js-yaml@3.14.2:
     dependencies:
-      argparse: 2.0.1
+      argparse: 1.0.10
+      esprima: 4.0.1
 
   jsesc@3.1.0: {}
 
@@ -3616,6 +3628,8 @@ snapshots:
 
   source-map@0.7.6: {}
 
+  sprintf-js@1.0.3: {}
+
   stack-utils@2.0.6:
     dependencies:
       escape-string-regexp: 2.0.0

integrations/vercel-ai-sdk/pnpm-workspace.yaml

@@ -7,7 +7,6 @@ onlyBuiltDependencies:
 
 overrides:
   "glob@>=10.2.0 <10.5.0": "^10.5.0"
-  "js-yaml@<=4.1.1": ">=4.2.0"
   "minimatch@<3.1.3": "^3.1.3"
   "minimatch@>=5.0.0 <5.1.8": "^5.1.8"
   "minimatch@>=9.0.0 <9.0.7": "^9.0.7"

mem0-ts/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mem0ai",
-  "version": "3.0.11",
+  "version": "3.0.9",
   "description": "The Memory Layer For Your AI Apps",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",

mem0-ts/src/client/mem0.ts

@@ -253,11 +253,6 @@ export default class MemoryClient {
     messages: Array<Message>,
     options: AddMemoryOptions & Record<string, any> = {},
   ): Promise<Array<Memory>> {
-    // Tightly scoped validation guard to resolve #5465
-    if (!messages || (Array.isArray(messages) && messages.length === 0)) {
-      throw new Error("Cannot process an empty messages payload.");
-    }
-
     if (this.telemetryId === "") await this.ping();
 
     const payload = this._preparePayload(messages, options);

mem0-ts/src/client/mem0.types.ts

@@ -169,9 +169,7 @@ export interface PaginatedMemories {
 
 export interface ProjectResponse {
   customInstructions?: string;
-  // The API returns category objects (`[{ "<name>": "<description>" }]`),
-  // not bare strings (see issue #5738).
-  customCategories?: custom_categories[];
+  customCategories?: string[];
   [key: string]: any;
 }
 

mem0-ts/src/client/tests/memoryClient.crud.test.ts

@@ -59,15 +59,16 @@ describe("MemoryClient - add()", () => {
     expect(getFetchBody(call!).user_id).toBe("user_1");
   });
 
-  test("throws an error when given an empty messages array", async () => {
-    setupMockFetch();
+  test("sends empty messages array without crashing", async () => {
+    const extra = new Map<string, { status: number; body: unknown }>();
+    extra.set("/v3/memories/add/", { status: 200, body: [] });
+    const mock = setupMockFetch(extra);
 
     const client = new MemoryClient({ apiKey: TEST_API_KEY });
+    await client.add([], { userId: "u1" });
 
-    //Asserts that the validation guard catches the empty input early
-    await expect(client.add([], { userId: "u1" })).rejects.toThrow(
-      "Cannot process an empty messages payload.",
-    );
+    const call = findFetchCall(mock, "/v3/memories/add/", "POST");
+    expect(getFetchBody(call!).messages).toEqual([]);
   });
 });
 

mem0-ts/src/client/tests/utils.test.ts

@@ -1,148 +0,0 @@
-import { camelToSnakeKeys, snakeToCamelKeys } from "../utils";
-
-describe("camelToSnakeKeys / snakeToCamelKeys", () => {
-  it("converts SDK-defined keys between camelCase and snake_case", () => {
-    expect(camelToSnakeKeys({ userId: "u1", agentId: "a1" })).toEqual({
-      user_id: "u1",
-      agent_id: "a1",
-    });
-    expect(snakeToCamelKeys({ user_id: "u1", agent_id: "a1" })).toEqual({
-      userId: "u1",
-      agentId: "a1",
-    });
-  });
-
-  it("preserves logical operator keys (OR/AND/NOT)", () => {
-    expect(camelToSnakeKeys({ OR: [{ userId: "u1" }] })).toEqual({
-      OR: [{ user_id: "u1" }],
-    });
-  });
-
-  describe("user-controlled metadata blob (issue #5055)", () => {
-    it("does not camelize snake_case keys inside metadata on read", () => {
-      const apiResponse = {
-        id: "mem-1",
-        user_id: "u1",
-        metadata: { message_id: "x", some_custom_key: "y" },
-      };
-
-      expect(snakeToCamelKeys(apiResponse)).toEqual({
-        id: "mem-1",
-        userId: "u1",
-        metadata: { message_id: "x", some_custom_key: "y" },
-      });
-    });
-
-    it("does not snake_case camelCase keys inside metadata on write", () => {
-      const payload = {
-        userId: "u1",
-        metadata: { messageId: "x", someCustomKey: "y" },
-      };
-
-      expect(camelToSnakeKeys(payload)).toEqual({
-        user_id: "u1",
-        metadata: { messageId: "x", someCustomKey: "y" },
-      });
-    });
-
-    it("round-trips arbitrary metadata keys losslessly", () => {
-      const metadata = {
-        message_id: "abc",
-        camelKey: 1,
-        nested: { deep_snake: true, deepCamel: false },
-        arr: [{ inner_key: 1 }],
-      };
-
-      const roundTripped = snakeToCamelKeys(
-        camelToSnakeKeys({ userId: "u1", metadata }),
-      );
-
-      expect(roundTripped.metadata).toEqual(metadata);
-    });
-
-    it("preserves metadata nested inside an array of results", () => {
-      const apiResponse = {
-        results: [
-          { id: "1", metadata: { message_id: "x" } },
-          { id: "2", metadata: { another_key: "z" } },
-        ],
-      };
-
-      expect(snakeToCamelKeys(apiResponse)).toEqual({
-        results: [
-          { id: "1", metadata: { message_id: "x" } },
-          { id: "2", metadata: { another_key: "z" } },
-        ],
-      });
-    });
-  });
-
-  describe("user-controlled structuredDataSchema blob (issue #5055)", () => {
-    it("converts the outer key but leaves user field names on write", () => {
-      expect(
-        camelToSnakeKeys({
-          structuredDataSchema: { firstName: "string", lastName: "string" },
-        }),
-      ).toEqual({
-        // outer SDK key is snake_cased, user-defined field names are not
-        structured_data_schema: { firstName: "string", lastName: "string" },
-      });
-    });
-
-    it("converts the outer key but leaves user field names on read", () => {
-      expect(
-        snakeToCamelKeys({
-          structured_data_schema: { first_name: "string", last_name: "string" },
-        }),
-      ).toEqual({
-        structuredDataSchema: { first_name: "string", last_name: "string" },
-      });
-    });
-  });
-
-  describe("user-controlled customCategories names (issue #5738)", () => {
-    it("converts the outer key but leaves multi-word category names on write", () => {
-      expect(
-        camelToSnakeKeys({
-          customCategories: [
-            { work_life_balance: "desc" },
-            { AIResearch: "desc" },
-          ],
-        }),
-      ).toEqual({
-        // outer SDK key is snake_cased, user-defined category names are not
-        custom_categories: [
-          { work_life_balance: "desc" },
-          { AIResearch: "desc" },
-        ],
-      });
-    });
-
-    it("converts the outer key but leaves category names verbatim on read", () => {
-      expect(
-        snakeToCamelKeys({
-          custom_categories: [
-            { work_life_balance: "desc" },
-            { AIResearch: "desc" },
-          ],
-        }),
-      ).toEqual({
-        customCategories: [
-          { work_life_balance: "desc" },
-          { AIResearch: "desc" },
-        ],
-      });
-    });
-
-    it("round-trips category names losslessly (write then read)", () => {
-      const customCategories = [
-        { work_life_balance: "balance between work and life" },
-        { AIResearch: "artificial intelligence research" },
-      ];
-      const roundTripped = snakeToCamelKeys(
-        camelToSnakeKeys({ customCategories }),
-      );
-      expect(roundTripped.customCategories).toEqual(customCategories);
-    });
-  });
-});

mem0-ts/src/client/utils.ts

@@ -14,32 +14,9 @@ function snakeToCamel(str: string): string {
   return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
 }
 
-/**
- * Keys whose values are user-controlled, opaque blobs. Their nested keys must
- * be passed through verbatim — converting them would silently rewrite the
- * user's own keys and break round-trips (see issue #5055).
- *
- * The check runs against the source key, so a multi-word key must be listed in
- * both casings to be covered in both directions: the camelCase form for the
- * outbound `camelToSnakeKeys` path and the snake_case form for the inbound
- * `snakeToCamelKeys` path. `metadata` is spelled identically in both, so one
- * entry suffices; `structuredDataSchema` needs both.
- */
-const OPAQUE_VALUE_KEYS = new Set([
-  "metadata",
-  "structuredDataSchema",
-  "structured_data_schema",
-  // Custom-category names are user-controlled keys (`[{ "<name>": "<desc>" }]`).
-  // Listed in both casings so they round-trip verbatim in both directions
-  // (see issue #5738; same class as `metadata`/`structuredDataSchema`).
-  "customCategories",
-  "custom_categories",
-]);
-
 /**
  * Recursively converts all keys of an object from camelCase to snake_case.
  * Used for converting user-facing camelCase params to API snake_case payloads.
- * Values under {@link OPAQUE_VALUE_KEYS} (e.g. `metadata`) are left untouched.
  */
 export function camelToSnakeKeys(obj: any): any {
   if (obj === null || obj === undefined || typeof obj !== "object") return obj;
@@ -49,7 +26,7 @@ export function camelToSnakeKeys(obj: any): any {
   return Object.fromEntries(
     Object.entries(obj).map(([key, value]) => [
       camelToSnake(key),
-      OPAQUE_VALUE_KEYS.has(key) ? value : camelToSnakeKeys(value),
+      camelToSnakeKeys(value),
     ]),
   );
 }
@@ -57,7 +34,6 @@ export function camelToSnakeKeys(obj: any): any {
 /**
  * Recursively converts all keys of an object from snake_case to camelCase.
  * Used for converting API snake_case responses to user-facing camelCase.
- * Values under {@link OPAQUE_VALUE_KEYS} (e.g. `metadata`) are left untouched.
  */
 export function snakeToCamelKeys(obj: any): any {
   if (obj === null || obj === undefined || typeof obj !== "object") return obj;
@@ -67,7 +43,7 @@ export function snakeToCamelKeys(obj: any): any {
   return Object.fromEntries(
     Object.entries(obj).map(([key, value]) => [
       snakeToCamel(key),
-      OPAQUE_VALUE_KEYS.has(key) ? value : snakeToCamelKeys(value),
+      snakeToCamelKeys(value),
     ]),
   );
 }

mem0-ts/src/oss/src/llms/anthropic.ts

@@ -14,13 +14,7 @@ export class AnthropicLLM implements LLM {
     if (!apiKey) {
       throw new Error("Anthropic API key is required");
     }
-    // Forward baseURL to the client when set so proxy/gateway users are
-    // honored (parity with the OpenAI provider and the Python fix in #5626).
-    const clientArgs: { apiKey: string; baseURL?: string } = { apiKey };
-    if (config.baseURL) {
-      clientArgs.baseURL = config.baseURL;
-    }
-    this.client = new Anthropic(clientArgs);
+    this.client = new Anthropic({ apiKey });
     this.model = config.model || "claude-sonnet-4-6";
     // Defaults mirror the Python provider's AnthropicConfig
     // (max_tokens=2000, temperature=0.1, top_p omitted).

mem0-ts/src/oss/src/memory/index.ts

@@ -296,44 +296,6 @@ export class Memory {
     return filters;
   }
 
-  private _normalizeEntityText(value: string): string {
-    return value.trim().toLowerCase().replace(/\s+/g, " ");
-  }
-
-  private async _existingEntitiesByText(
-    entityStore: VectorStore,
-    filters: Record<string, any>,
-  ): Promise<Map<string, { id: string; payload: Record<string, any> }>> {
-    const rowsByText = new Map<
-      string,
-      { id: string; payload: Record<string, any> }
-    >();
-    let rows: Array<{ id: string; payload: Record<string, any> }> = [];
-    try {
-      const listed = await entityStore.list(filters, 10000);
-      rows = (
-        Array.isArray(listed) && Array.isArray(listed[0])
-          ? listed[0]
-          : (listed as any)
-      ) as Array<{ id: string; payload: Record<string, any> }>;
-    } catch (e) {
-      console.debug(
-        `Exact entity lookup failed, falling back to semantic dedup: ${e}`,
-      );
-      return rowsByText;
-    }
-
-    for (const row of rows) {
-      const text = row.payload?.data;
-      if (typeof text !== "string") continue;
-      const key = this._normalizeEntityText(text);
-      if (key && !rowsByText.has(key)) {
-        rowsByText.set(key, row);
-      }
-    }
-    return rowsByText;
-  }
-
   /**
    * Remove `memoryId` from every entity record scoped to `filters`.
    * If an entity's `linkedMemoryIds` becomes empty after removal, the
@@ -431,10 +393,6 @@ export class Memory {
       if (entities.length === 0) return;
 
       const entityStore = await this.getEntityStore();
-      const exactMatches = await this._existingEntitiesByText(
-        entityStore,
-        filters,
-      );
 
       for (const entity of entities) {
         try {
@@ -451,21 +409,12 @@ export class Memory {
             score?: number;
             payload: Record<string, any>;
           }> = [];
-          const exactMatch = exactMatches.get(
-            this._normalizeEntityText(entity.text),
-          );
-          if (!exactMatch) {
-            try {
-              matches = await entityStore.search(entityVec, 1, filters);
-            } catch {}
-          }
+          try {
+            matches = await entityStore.search(entityVec, 1, filters);
+          } catch {}
 
-          const semanticMatch =
-            matches.length > 0 && (matches[0].score ?? 0) >= 0.95
-              ? matches[0]
-              : undefined;
-          const match = exactMatch ?? semanticMatch;
-          if (match) {
+          if (matches.length > 0 && (matches[0].score ?? 0) >= 0.95) {
+            const match = matches[0];
             const payload = match.payload || {};
             const linked = new Set<string>(
               Array.isArray(payload.linkedMemoryIds)
@@ -670,25 +619,6 @@ export class Memory {
         "messages is required and cannot be undefined or null. Provide a string or array of messages.",
       );
     }
-    if (Array.isArray(messages)) {
-      if (messages.length === 0) {
-        throw new Error(
-          "messages array cannot be empty. Provide at least one message with non-empty content.",
-        );
-      }
-      const allBlank = messages.every(
-        (m) => typeof m.content === "string" && m.content.trim() === "",
-      );
-      if (allBlank) {
-        throw new Error(
-          "messages array cannot contain only blank content. Provide at least one message with non-empty content.",
-        );
-      }
-    } else if (messages.trim() === "") {
-      throw new Error(
-        "messages string cannot be empty. Provide non-empty content.",
-      );
-    }
 
     const temporalUsageNotice = detectTemporalUsageFromMetadata(
       config?.metadata,
@@ -768,7 +698,7 @@ export class Memory {
     if (!infer) {
       const returnedMemories: MemoryItem[] = [];
       for (const message of messages) {
-        if (message.role === "system") {
+        if (message.content === "system") {
           continue;
         }
         const memoryId = await this.createMemory(
@@ -801,13 +731,7 @@ export class Memory {
         // getLastMessages not supported — proceed without context
       }
     }
-    // Preserve role on the messages being extracted so the prompt's role-aware
-    // logic and the required `attributed_to` output have the speaker to work
-    // with. Matches the Python oss `parse_messages` helper (`role: content`);
-    // without this, assistant statements get attributed to the user.
-    const parsedMessages = messages
-      .map((m) => `${m.role}: ${m.content}`)
-      .join("\n");
+    const parsedMessages = messages.map((m) => m.content).join("\n");
 
     // Phase 1: Existing memory retrieval
     const queryEmbedding = await this.embedder.embed(parsedMessages);
@@ -1113,10 +1037,6 @@ export class Memory {
 
         if (valid.length > 0) {
           const entityStore = await this.getEntityStore();
-          const exactMatches = await this._existingEntitiesByText(
-            entityStore,
-            filters,
-          );
 
           // 7c: Search for existing entities one by one (no batch search)
           const toInsertVectors: number[][] = [];
@@ -1132,20 +1052,13 @@ export class Memory {
               score?: number;
               payload: Record<string, any>;
             }> = [];
-            const exactMatch = exactMatches.get(key);
-            if (!exactMatch) {
-              try {
-                matches = await entityStore.search(entityVec, 1, filters);
-              } catch {}
-            }
+            try {
+              matches = await entityStore.search(entityVec, 1, filters);
+            } catch {}
 
-            const semanticMatch =
-              matches.length > 0 && (matches[0].score ?? 0) >= 0.95
-                ? matches[0]
-                : undefined;
-            const match = exactMatch ?? semanticMatch;
-            if (match) {
+            if (matches.length > 0 && (matches[0].score ?? 0) >= 0.95) {
               // Update existing entity
+              const match = matches[0];
               const payload = match.payload || {};
               const linked = new Set<string>(payload.linkedMemoryIds ?? []);
               for (const mid of memoryIds) linked.add(mid);
@@ -1251,13 +1164,7 @@ export class Memory {
       }
     }
 
-    const result = {
-      ...memoryItem,
-      ...filters,
-      ...(memory.payload.attributedTo && {
-        attributedTo: memory.payload.attributedTo,
-      }),
-    };
+    const result = { ...memoryItem, ...filters };
     await this._displayFirstRunNotice("get");
     return result;
   }
@@ -1521,7 +1428,6 @@ export class Memory {
           ...(payload.user_id && { user_id: payload.user_id }),
           ...(payload.agent_id && { agent_id: payload.agent_id }),
           ...(payload.run_id && { run_id: payload.run_id }),
-          ...(payload.attributedTo && { attributedTo: payload.attributedTo }),
           ...(scored.scoreDetails && { score_details: scored.scoreDetails }),
         };
       });
@@ -1756,9 +1662,6 @@ export class Memory {
       ...(mem.payload.user_id && { user_id: mem.payload.user_id }),
       ...(mem.payload.agent_id && { agent_id: mem.payload.agent_id }),
       ...(mem.payload.run_id && { run_id: mem.payload.run_id }),
-      ...(mem.payload.attributedTo && {
-        attributedTo: mem.payload.attributedTo,
-      }),
     }));
 
     const result = { results };

mem0-ts/src/oss/src/types/index.ts

@@ -82,7 +82,6 @@ export interface MemoryItem {
   updatedAt?: string;
   score?: number;
   metadata?: Record<string, any>;
-  attributedTo?: string;
 }
 
 export interface SearchFilters {

mem0-ts/src/oss/src/utils/entity_extraction.ts

@@ -4,8 +4,8 @@
  * Extracts four types of entities from text:
  * - PROPER:   Capitalized multi-word sequences (person names, places, brands)
  * - QUOTED:   Text in single or double quotes (titles, specific terms)
- * - TOPIC:    Multi-word noun/topic phrases with specific modifiers
- * - IDENTIFIER: Dotted technical identifiers such as person.properties.email
+ * - COMPOUND: Multi-word noun phrases with specific modifiers (e.g., "machine learning")
+ * - NOUN:     Single nouns from circumstantial compound patterns
  *
  * Uses the `compromise` npm package for NLP-based extraction when available.
  * Falls back to regex-only extraction if `compromise` is not installed.
@@ -196,25 +196,6 @@ const NON_SPECIFIC_ADJ: Set<string> = new Set([
   "final",
   "initial",
   "side",
-  "top",
-]);
-
-/** Leading words that frame a topic but are not part of the topic itself. */
-const TOPIC_PREFIX_WORDS: Set<string> = new Set([
-  "a",
-  "an",
-  "the",
-  "my",
-  "your",
-  "our",
-  "their",
-  "his",
-  "her",
-  "its",
-  "this",
-  "that",
-  "these",
-  "those",
 ]);
 
 /** Generic tail words to strip from compound entities. */
@@ -286,25 +267,6 @@ const GENERIC_CAPS: Set<string> = new Set([
   "disadvantages",
 ]);
 
-/** Generic role/title words that should not become single-token entities. */
-const GENERIC_SINGLE_ENTITY_TERMS: Set<string> = new Set([
-  "user",
-  "assistant",
-  "agent",
-  "customer",
-  "client",
-  "person",
-  "people",
-  "human",
-  "memory",
-  "message",
-  "conversation",
-  "chat",
-  "session",
-  "system",
-  "top",
-]);
-
 /** Markdown/formatting markers to skip during extraction. */
 const FORMATTING_MARKERS: Set<string> = new Set([
   "*",
@@ -325,7 +287,7 @@ const FORMATTING_MARKERS: Set<string> = new Set([
 // ---------------------------------------------------------------------------
 
 export interface ExtractedEntity {
-  type: "PROPER" | "QUOTED" | "TOPIC" | "IDENTIFIER";
+  type: "PROPER" | "QUOTED" | "COMPOUND" | "NOUN";
   text: string;
 }
 
@@ -376,96 +338,32 @@ function stripGenericEnding(words: string[]): string[] {
   return words;
 }
 
-function stripTopicPrefix(words: string[]): string[] {
-  let start = 0;
-  while (
-    start < words.length &&
-    TOPIC_PREFIX_WORDS.has(words[start].toLowerCase())
-  ) {
-    start++;
-  }
-  return words.slice(start);
-}
-
-function cleanToken(token: string): string {
-  return token.replace(/^[^\w.]+|[^\w.]+$/g, "");
-}
-
-function tokenize(text: string): string[] {
-  return (
-    text.match(
-      /[A-Za-z_][\w-]*(?:\.[A-Za-z_][\w-]*)*|\d[\d,]*(?:\.\d+)?|[,:;.!?&]/g,
-    ) ?? []
-  );
-}
-
-function isCapitalized(token: string): boolean {
-  return /^[A-Z]/.test(token) && /[A-Za-z]/.test(token);
-}
-
-function hasInternalCapOrDigit(token: string): boolean {
-  return (
-    /\d/.test(token) ||
-    /[A-Z]/.test(token.slice(1)) ||
-    /^[A-Z]{2,}$/.test(token)
-  );
-}
-
-function isBadSingleNameToken(token: string): boolean {
-  const lower = token.toLowerCase();
-  return GENERIC_SINGLE_ENTITY_TERMS.has(lower) || GENERIC_CAPS.has(lower);
-}
-
-function looksLikeMetricCount(token: string): boolean {
-  return /^\d[\d,]*(?:\.\d+)?$/.test(token);
-}
-
-function isMetricListContext(tokens: string[], idx: number): boolean {
-  const prev = idx > 0 ? tokens[idx - 1] : "";
-  const next = idx + 1 < tokens.length ? tokens[idx + 1] : "";
-  return [":", ",", ";"].includes(prev) || [",", ";"].includes(next);
-}
-
-function isSentenceStart(tokens: string[], idx: number): boolean {
-  if (idx === 0) return true;
-  return (
-    [".", "!", "?", ":"].includes(tokens[idx - 1]) ||
-    FORMATTING_MARKERS.has(tokens[idx - 1])
-  );
-}
-
-function isListItemNameToken(tokens: string[], idx: number): boolean {
-  const token = cleanToken(tokens[idx]);
-  if (!isCapitalized(token) || isBadSingleNameToken(token)) return false;
-  const next = idx + 1 < tokens.length ? cleanToken(tokens[idx + 1]) : "";
-  if (!looksLikeMetricCount(next)) return false;
-  return (
-    isMetricListContext(tokens, idx) || isMetricListContext(tokens, idx + 1)
-  );
-}
-
-function isNameToken(tokens: string[], idx: number): boolean {
-  const token = cleanToken(tokens[idx]);
-  if (!token || !isCapitalized(token) || isBadSingleNameToken(token))
-    return false;
-  if (hasInternalCapOrDigit(token) || isListItemNameToken(tokens, idx))
+/**
+ * Determine if a token position is at the start of a sentence.
+ * Simple heuristic: index 0, or preceded by sentence-ending punctuation
+ * or formatting markers.
+ */
+function isSentenceStart(
+  tokens: string[],
+  idx: number,
+  rawText: string,
+): boolean {
+  if (idx === 0) {
     return true;
-  return !isSentenceStart(tokens, idx);
-}
-
-function cleanEntityText(text: string): string {
-  return text
-    .replace(/^\*+\s*|\s*\*+$/g, "")
-    .replace(/\s*:+$/g, "")
-    .replace(/^\d+\s*\.\s*/, "")
-    .replace(/\s+\d[\d,]*(?:\.\d+)?$/g, "")
-    .replace(/[.,;!?]+$/, "")
-    .trim()
-    .replace(/\s+/g, " ");
-}
-
-function isCoordinatedNameTopic(text: string): boolean {
-  return /\b[A-Z][\w-]+\s+and\s+[A-Z][\w-]+\b/.test(text);
+  }
+  const prev = tokens[idx - 1];
+  if (/[.!?:]$/.test(prev)) {
+    return true;
+  }
+  if (FORMATTING_MARKERS.has(prev)) {
+    return true;
+  }
+  // Check for newline before this token in the raw text
+  const tokenStart = rawText.indexOf(tokens[idx]);
+  if (tokenStart > 0 && rawText.charAt(tokenStart - 1) === "\n") {
+    return true;
+  }
+  return false;
 }
 
 // ---------------------------------------------------------------------------
@@ -499,79 +397,86 @@ function extractQuoted(text: string): ExtractedEntity[] {
 }
 
 /**
- * Extract dotted technical identifiers such as person.properties.email.
- */
-function extractIdentifiers(text: string): ExtractedEntity[] {
-  const entities: ExtractedEntity[] = [];
-  const identifierRe = /\b[A-Za-z_][\w-]*(?:\.[A-Za-z_][\w-]*)+\b/g;
-  let match: RegExpExecArray | null;
-  while ((match = identifierRe.exec(text)) !== null) {
-    entities.push({ type: "IDENTIFIER", text: match[0] });
-  }
-  return entities;
-}
-
-/**
- * Extract proper names using capitalization and list-context heuristics.
+ * Extract proper noun sequences using capitalization heuristics.
+ * Finds sequences of capitalized words that are not at sentence starts.
  */
 function extractProper(text: string): ExtractedEntity[] {
   const entities: ExtractedEntity[] = [];
-  const tokens = tokenize(text);
-  const innerConnectors = new Set(["of", "the", "in", "for", "at"]);
+  // Tokenize on whitespace, preserving order
+  const tokens = text.split(/\s+/).filter(Boolean);
+  const functionWords = new Set([
+    "'s",
+    "of",
+    "the",
+    "in",
+    "and",
+    "for",
+    "at",
+    "is",
+  ]);
 
   let i = 0;
   while (i < tokens.length) {
-    const token = cleanToken(tokens[i]);
-    const next = i + 1 < tokens.length ? tokens[i + 1] : "";
-    const afterNext = i + 2 < tokens.length ? cleanToken(tokens[i + 2]) : "";
-    if (
-      token &&
-      next === "&" &&
-      afterNext &&
-      isCapitalized(token) &&
-      isCapitalized(afterNext) &&
-      !isBadSingleNameToken(token) &&
-      !isBadSingleNameToken(afterNext)
-    ) {
-      entities.push({
-        type: "PROPER",
-        text: cleanEntityText(`${token} & ${afterNext}`),
-      });
-      i += 3;
-      continue;
-    }
-
-    if (!isNameToken(tokens, i)) {
+    const tok = tokens[i];
+    // Skip formatting markers
+    if (FORMATTING_MARKERS.has(tok)) {
       i++;
       continue;
     }
 
-    const span = [cleanToken(tokens[i])];
-    let j = i + 1;
-    while (j < tokens.length) {
-      const current = cleanToken(tokens[j]);
-      if (isNameToken(tokens, j)) {
-        span.push(current);
-        j++;
-        continue;
-      }
-      if (
-        innerConnectors.has(current.toLowerCase()) &&
-        j + 1 < tokens.length &&
-        isNameToken(tokens, j + 1)
-      ) {
-        span.push(current, cleanToken(tokens[j + 1]));
-        j += 2;
-        continue;
-      }
-      break;
-    }
+    const isLabel = i + 1 < tokens.length && tokens[i + 1] === ":";
+    const isCap =
+      tok.length > 0 &&
+      tok.charAt(0) === tok.charAt(0).toUpperCase() &&
+      /[A-Z]/.test(tok.charAt(0));
 
-    const phrase = cleanEntityText(span.join(" "));
-    if (phrase.length > 2) {
-      entities.push({ type: "PROPER", text: phrase });
+    if (isCap && !isLabel) {
+      const seq: Array<{ token: string; idx: number }> = [
+        { token: tok, idx: i },
+      ];
+      let j = i + 1;
+      while (j < tokens.length) {
+        const t = tokens[j];
+        const tIsCap =
+          t.length > 0 &&
+          t.charAt(0) === t.charAt(0).toUpperCase() &&
+          /[A-Z]/.test(t.charAt(0));
+        if (tIsCap || functionWords.has(t.toLowerCase())) {
+          seq.push({ token: t, idx: j });
+          j++;
+        } else {
+          break;
+        }
+      }
+
+      // Strip trailing function words
+      while (
+        seq.length > 0 &&
+        functionWords.has(seq[seq.length - 1].token.toLowerCase())
+      ) {
+        seq.pop();
+      }
+
+      if (seq.length > 0) {
+        // Check for at least one mid-sentence capitalized word
+        const hasMidCap = seq.some(({ token, idx: tokenIdx }) => {
+          const isCapWord =
+            /[A-Z]/.test(token.charAt(0)) &&
+            !functionWords.has(token.toLowerCase());
+          return isCapWord && !isSentenceStart(tokens, tokenIdx, text);
+        });
+
+        if (hasMidCap) {
+          const phrase = seq.map((s) => s.token).join(" ");
+          if (phrase.length > 2) {
+            entities.push({ type: "PROPER", text: phrase });
+          }
+        }
+      }
+      i = j;
+    } else {
+      i++;
     }
-    i = Math.max(j, i + 1);
   }
 
   return entities;
@@ -579,7 +484,7 @@ function extractProper(text: string): ExtractedEntity[] {
 
 /**
  * Extract compound noun phrases using the `compromise` NLP library.
- * Returns TOPIC entities derived from noun chunks.
+ * Returns COMPOUND and NOUN entities derived from noun chunks.
  */
 function extractCompoundsWithNlp(text: string): ExtractedEntity[] {
   if (!nlp) {
@@ -619,12 +524,12 @@ function extractCompoundsWithNlp(text: string): ExtractedEntity[] {
     const filtered = words.filter(
       (w) => !NON_SPECIFIC_ADJ.has(w.toLowerCase()),
     );
-    const cleaned = stripGenericEnding(stripTopicPrefix(filtered));
+    const cleaned = stripGenericEnding(filtered);
 
     if (cleaned.length >= 2) {
-      const phrase = cleanEntityText(cleaned.join(" "));
+      const phrase = cleaned.join(" ");
       if (phrase.length > 3) {
-        entities.push({ type: "TOPIC", text: phrase });
+        entities.push({ type: "COMPOUND", text: phrase });
       }
     }
   }
@@ -642,7 +547,7 @@ function extractCompoundsRegex(text: string): ExtractedEntity[] {
   // Multi-word sequences with at least one non-trivial word
   // Match sequences like "machine learning", "New York", "data science"
   const compoundRe =
-    /\b([A-Z][a-z]+(?:\s+(?:of|the|for|in)\s+)?[A-Z][a-z]+(?:\s+[A-Z][a-z]+)*)\b/g;
+    /\b([A-Z][a-z]+(?:\s+(?:of|and|the|for|in)\s+)?[A-Z][a-z]+(?:\s+[A-Z][a-z]+)*)\b/g;
   let match: RegExpExecArray | null;
   while ((match = compoundRe.exec(text)) !== null) {
     const phrase = match[1].trim();
@@ -653,12 +558,9 @@ function extractCompoundsRegex(text: string): ExtractedEntity[] {
         const filtered = words.filter(
           (w) => !NON_SPECIFIC_ADJ.has(w.toLowerCase()),
         );
-        const cleaned = stripGenericEnding(stripTopicPrefix(filtered));
+        const cleaned = stripGenericEnding(filtered);
         if (cleaned.length >= 2) {
-          entities.push({
-            type: "TOPIC",
-            text: cleanEntityText(cleaned.join(" ")),
-          });
+          entities.push({ type: "COMPOUND", text: cleaned.join(" ") });
         }
       }
     }
@@ -688,12 +590,9 @@ function extractCompoundsRegex(text: string): ExtractedEntity[] {
           const filtered = words.filter(
             (w) => !NON_SPECIFIC_ADJ.has(w.toLowerCase()),
           );
-          const cleaned = stripGenericEnding(stripTopicPrefix(filtered));
+          const cleaned = stripGenericEnding(filtered);
           if (cleaned.length >= 2) {
-            entities.push({
-              type: "TOPIC",
-              text: cleanEntityText(cleaned.join(" ")),
-            });
+            entities.push({ type: "COMPOUND", text: cleaned.join(" ") });
           }
         }
       }
@@ -715,9 +614,9 @@ function extractCompoundsRegex(text: string): ExtractedEntity[] {
  *
  * Entity types (in priority order for deduplication):
  *   PROPER   - Capitalized multi-word sequences not at sentence start
- *   IDENTIFIER - Dotted technical identifiers
+ *   COMPOUND - Multi-word noun phrases with specific modifiers
  *   QUOTED   - Text in single or double quotes (min 3 chars)
- *   TOPIC    - Multi-word noun/topic phrases with specific modifiers
+ *   NOUN     - Single nouns from circumstantial patterns
  *
  * @param text - Input text to extract entities from.
  * @returns Deduplicated list of extracted entities.
@@ -731,10 +630,7 @@ export function extractEntities(text: string): ExtractedEntity[] {
   // 2. PROPER entities (capitalization heuristics)
   raw.push(...extractProper(text));
 
-  // 3. IDENTIFIER entities
-  raw.push(...extractIdentifiers(text));
-
-  // 4. TOPIC entities (NLP or regex fallback)
+  // 3. COMPOUND entities (NLP or regex fallback)
   if (nlp) {
     raw.push(...extractCompoundsWithNlp(text));
   } else {
@@ -758,17 +654,19 @@ export function extractEntities(text: string): ExtractedEntity[] {
   const cleaned: ExtractedEntity[] = [];
   for (const entity of deduped) {
     let txt = entity.text.trim();
-    txt = cleanEntityText(txt);
+    // Strip leading/trailing asterisks
+    txt = txt.replace(/^\*+\s*|\s*\*+$/g, "");
+    // Strip trailing colons
+    txt = txt.replace(/\s*:+$/, "");
+    // Strip leading numbered list markers
+    txt = txt.replace(/^\d+\s*\.\s*/, "");
+    // Strip trailing sentence punctuation (".", ",", ";", "!", "?") — otherwise
+    // "Paris." and "Paris" produce different embeddings and break entity dedup.
+    txt = txt.replace(/[.,;!?]+$/, "").trim();
 
     if (!txt || txt.length <= 2 || hasArtifacts(txt)) {
       continue;
     }
-    if (
-      entity.type === "TOPIC" &&
-      (/^\d/.test(txt) || isCoordinatedNameTopic(txt))
-    ) {
-      continue;
-    }
 
     // Filter generic single-word PROPER nouns
     if (
@@ -782,12 +680,12 @@ export function extractEntities(text: string): ExtractedEntity[] {
     cleaned.push({ type: entity.type, text: txt });
   }
 
-  // Keep best type per entity (PROPER > IDENTIFIER > QUOTED > TOPIC)
+  // Keep best type per entity (PROPER > COMPOUND > QUOTED > NOUN)
   const typePriority: Record<string, number> = {
     PROPER: 0,
-    IDENTIFIER: 1,
+    COMPOUND: 1,
     QUOTED: 2,
-    TOPIC: 3,
+    NOUN: 3,
   };
   const best = new Map<string, ExtractedEntity>();
   for (const entity of cleaned) {
@@ -802,17 +700,14 @@ export function extractEntities(text: string): ExtractedEntity[] {
   }
   const bestEntities = Array.from(best.values());
 
-  // Remove entities that are token substrings of longer entities.
+  // Remove entities that are substrings of longer entities
+  const allLower = bestEntities.map((e) => e.text.toLowerCase());
   return bestEntities.filter(
     (entity) =>
-      !bestEntities.some(
+      !allLower.some(
         (other) =>
-          entity.text.toLowerCase() !== other.text.toLowerCase() &&
-          (typePriority[entity.type] ?? 99) >=
-            (typePriority[other.type] ?? 99) &&
-          new RegExp(
-            `(^|\\s)${entity.text.toLowerCase().replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(\\s|$)`,
-          ).test(other.text.toLowerCase()),
+          entity.text.toLowerCase() !== other &&
+          other.includes(entity.text.toLowerCase()),
       ),
   );
 }

mem0-ts/src/oss/src/utils/memory.ts

@@ -31,11 +31,9 @@ const parse_vision_messages = async (messages: Message[]) => {
         typeof message.content === "object" &&
         message.content.type === "image_url"
       ) {
-        const imageUrl = message.content.image_url?.url;
-        if (!imageUrl) {
-          throw new Error("image_url content part is missing image_url.url");
-        }
-        const description = await get_image_description(imageUrl);
+        const description = await get_image_description(
+          message.content.image_url.url,
+        );
         new_message.content =
           typeof description === "string"
             ? description

mem0-ts/src/oss/tests/anthropic-llm.test.ts

@@ -4,46 +4,17 @@
  */
 
 const mockCreate = jest.fn();
-const mockConstructor = jest.fn();
 
 jest.mock("@anthropic-ai/sdk", () => {
-  return jest.fn().mockImplementation((args) => {
-    mockConstructor(args);
-    return { messages: { create: mockCreate } };
-  });
+  return jest.fn().mockImplementation(() => ({
+    messages: { create: mockCreate },
+  }));
 });
 
 import { AnthropicLLM } from "../src/llms/anthropic";
 
 describe("AnthropicLLM (unit)", () => {
-  beforeEach(() => {
-    mockCreate.mockClear();
-    mockConstructor.mockClear();
-  });
-
-  // Regression #5665: a configured baseURL must reach the Anthropic client so
-  // proxy/gateway users are not silently bypassed (TS parity with #5626).
-  it("forwards baseURL to the Anthropic client when set", () => {
-    new AnthropicLLM({
-      apiKey: "test-key",
-      baseURL: "https://proxy.example/v1",
-    });
-
-    expect(mockConstructor).toHaveBeenCalledTimes(1);
-    const ctorArgs = mockConstructor.mock.calls[0][0];
-    expect(ctorArgs.apiKey).toBe("test-key");
-    expect(ctorArgs.baseURL).toBe("https://proxy.example/v1");
-  });
-
-  // When no baseURL is configured the client must not receive a baseURL key
-  // (so the SDK default endpoint is used).
-  it("does NOT set baseURL when none is configured", () => {
-    new AnthropicLLM({ apiKey: "test-key" });
-
-    expect(mockConstructor).toHaveBeenCalledTimes(1);
-    const ctorArgs = mockConstructor.mock.calls[0][0];
-    expect(ctorArgs.baseURL).toBeUndefined();
-  });
+  beforeEach(() => mockCreate.mockClear());
 
   it("returns text when no tools are provided and model returns a text block", async () => {
     mockCreate.mockResolvedValueOnce({

mem0-ts/src/oss/tests/entity-extraction.test.ts

@@ -1,45 +0,0 @@
-import { extractEntities } from "../src/utils/entity_extraction";
-
-describe("extractEntities", () => {
-  it("handles product lists, coordinated names, and identifiers", () => {
-    const text =
-      "User reported top inbound integration pages: OpenClaw 25,443, " +
-      "Claude Code 8,916, Codex 2,573, Dify 656. " +
-      "User compared Cartesia and Deepgram. " +
-      "The email field for Mem0 lives at person.properties.email. " +
-      "The qwen endpoint uses person.properties.email. " +
-      "Johnson & Johnson was mentioned. " +
-      "Glasses around my window. " +
-      "On 2026-05-27 there were 90 days of stats.";
-
-    const entityTexts = new Set(
-      extractEntities(text).map((entity) => entity.text),
-    );
-    const normalized = new Set(
-      [...entityTexts].map((entityText) => entityText.toLowerCase()),
-    );
-
-    for (const expected of [
-      "OpenClaw",
-      "Claude Code",
-      "Codex",
-      "Dify",
-      "Cartesia",
-      "Deepgram",
-      "Mem0",
-    ]) {
-      expect(entityTexts.has(expected)).toBe(true);
-    }
-    expect(entityTexts.has("person.properties.email")).toBe(true);
-    expect(entityTexts.has("qwen endpoint")).toBe(true);
-    expect(entityTexts.has("Johnson & Johnson")).toBe(true);
-    expect(entityTexts.has("Johnson")).toBe(false);
-    expect(normalized.has("top")).toBe(false);
-    expect(normalized.has("glasses")).toBe(false);
-    expect(entityTexts.has("Cartesia and Deepgram")).toBe(false);
-    expect(entityTexts.has("Claude Code 8,916")).toBe(false);
-    for (const rejected of ["8,916", "2,573", "656", "2026-05-27", "90"]) {
-      expect(entityTexts.has(rejected)).toBe(false);
-    }
-  });
-});

mem0-ts/src/oss/tests/memory.add.test.ts

@@ -126,22 +126,6 @@ describe("Memory - add()", () => {
     expect(result.results.length).toBeGreaterThan(0);
   });
 
-  test("preserves message roles in the extraction prompt (## New Messages)", async () => {
-    // The OpenAI LLM mock echoes the `## New Messages` section of the prompt back
-    // as the extracted text, so the stored memory reveals what the LLM received.
-    // Roles must survive into that section, otherwise the prompt's role-aware
-    // logic and required `attributed_to` output have no speaker to attribute to
-    // and assistant statements get stored as user facts.
-    const messages = [
-      { role: "user", content: "I want to sleep earlier." },
-      { role: "assistant", content: "Aim for 00:30 sleep / 08:30 wake." },
-    ];
-    const result: SearchResult = await memory.add(messages, { userId });
-    const seen = result.results.map((r) => r.memory).join("\n");
-    expect(seen).toContain("user: I want to sleep earlier.");
-    expect(seen).toContain("assistant: Aim for 00:30 sleep / 08:30 wake.");
-  });
-
   test("works with agentId instead of userId", async () => {
     const result: SearchResult = await memory.add("test", {
       agentId: "agent_1",

mem0-ts/src/oss/tests/memory.crud.test.ts

@@ -361,45 +361,6 @@ describe("Memory - search()", () => {
   });
 });
 
-// ─── attributedTo (#5666) ────────────────────────────────
-
-describe("Memory - attributedTo round-trip (#5666)", () => {
-  let memory: Memory;
-  const userId = `attributed_test_${Date.now()}`;
-  let id: string;
-
-  beforeAll(async () => {
-    memory = createMemory();
-    // The mocked LLM tags every extracted fact with attributed_to: "user".
-    const addResult: SearchResult = await memory.add("I love AI", { userId });
-    id = addResult.results[0].id;
-  });
-
-  afterAll(async () => {
-    await memory.reset();
-  });
-
-  test("get() surfaces attributedTo", async () => {
-    const item: MemoryItem | null = await memory.get(id);
-    expect(item!.attributedTo).toBe("user");
-  });
-
-  test("getAll() surfaces attributedTo", async () => {
-    const result: SearchResult = await memory.getAll({
-      filters: { user_id: userId },
-    });
-    expect(result.results[0].attributedTo).toBe("user");
-  });
-
-  test("search() surfaces attributedTo", async () => {
-    const result: SearchResult = await memory.search("AI", {
-      filters: { user_id: userId },
-    });
-    expect(result.results.length).toBeGreaterThan(0);
-    expect(result.results[0].attributedTo).toBe("user");
-  });
-});
-
 // ─── history() ───────────────────────────────────────────
 
 describe("Memory - history()", () => {

mem0-ts/src/oss/tests/memory.validation.test.ts

@@ -84,24 +84,6 @@ describe("Memory Input Validation", () => {
         memory.add(null, { userId: testUserId }),
       ).rejects.toThrow("messages is required");
     });
-
-    it("should throw error when messages is an empty array", async () => {
-      await expect(memory.add([], { userId: testUserId })).rejects.toThrow(
-        "messages array cannot be empty",
-      );
-    });
-
-    it("should throw error when messages array contains only blank content", async () => {
-      await expect(
-        memory.add([{ role: "user", content: "   " }], { userId: testUserId }),
-      ).rejects.toThrow("messages array cannot contain only blank content");
-    });
-
-    it("should throw error when messages is an empty string", async () => {
-      await expect(memory.add("   ", { userId: testUserId })).rejects.toThrow(
-        "messages string cannot be empty",
-      );
-    });
   });
 
   describe("search() threshold validation", () => {

mem0/client/main.py

@@ -151,10 +151,10 @@ class MemoryClient:
         try:
             params = self._prepare_params()
             response = self.client.get("/v1/ping/", params=params)
-            response.raise_for_status()
-
             data = response.json()
 
+            response.raise_for_status()
+
             if data.get("org_id") and data.get("project_id"):
                 self.org_id = data.get("org_id")
                 self.project_id = data.get("project_id")
@@ -1044,10 +1044,10 @@ class AsyncMemoryClient:
                 },
                 params=params,
             )
-            response.raise_for_status()
-
             data = response.json()
 
+            response.raise_for_status()
+
             if data.get("org_id") and data.get("project_id"):
                 self.org_id = data.get("org_id")
                 self.project_id = data.get("project_id")

mem0/configs/embeddings/base.py

@@ -2,8 +2,9 @@ import os
 from abc import ABC
 from typing import Dict, Optional, Union
 
+import httpx
+
 from mem0.configs.base import AzureConfig
-from mem0.utils.http import build_http_client
 
 
 class BaseEmbedderConfig(ABC):
@@ -80,8 +81,7 @@ class BaseEmbedderConfig(ABC):
         self.embedding_dims = embedding_dims
 
         # AzureOpenAI specific
-        self.http_client_proxies = http_client_proxies
-        self.http_client = build_http_client(http_client_proxies)
+        self.http_client = httpx.Client(proxies=http_client_proxies) if http_client_proxies else None
 
         # Ollama specific
         self.ollama_base_url = ollama_base_url
@@ -109,3 +109,4 @@ class BaseEmbedderConfig(ABC):
         self.aws_secret_access_key = aws_secret_access_key
         self.aws_session_token = aws_session_token
         self.aws_region = aws_region or os.environ.get("AWS_REGION") or "us-west-2"
+

mem0/configs/llms/base.py

@@ -1,7 +1,7 @@
 from abc import ABC
 from typing import Dict, Optional, Union
 
-from mem0.utils.http import build_http_client
+import httpx
 
 
 class BaseLlmConfig(ABC):
@@ -74,5 +74,4 @@ class BaseLlmConfig(ABC):
         self.vision_details = vision_details
         self.reasoning_effort = reasoning_effort
         self.is_reasoning_model = is_reasoning_model
-        self.http_client_proxies = http_client_proxies
-        self.http_client = build_http_client(http_client_proxies)
+        self.http_client = httpx.Client(proxies=http_client_proxies) if http_client_proxies else None

mem0/configs/vector_stores/opensearch.py

@@ -18,12 +18,6 @@ class OpenSearchConfig(BaseModel):
         "RequestsHttpConnection", description="Connection class for OpenSearch"
     )
     pool_maxsize: int = Field(20, description="Maximum number of connections in the pool")
-    auto_refresh: bool = Field(
-        False,
-        description="Automatically refresh index after insert operations to make documents "
-        "immediately searchable. Disabled by default for OpenSearch Serverless compatibility. "
-        "OpenSearch automatically refreshes indices every ~1 second, so most users don't need this.",
-    )
 
     @model_validator(mode="before")
     @classmethod

mem0/embeddings/aws_bedrock.py

@@ -70,11 +70,6 @@ class AWSBedrockEmbedding(EmbeddingBase):
         else:
             # Amazon and other providers
             input_body["inputText"] = text
-            # Titan Text Embeddings V2 accepts an optional output dimension
-            # (256/512/1024). Only forward embedding_dims when the user set it,
-            # mirroring the OpenAI embedder's guarded `dimensions` pass-through.
-            if self.config.embedding_dims is not None and "v2" in self.config.model:
-                input_body["dimensions"] = self.config.embedding_dims
 
         body = json.dumps(input_body)
 

mem0/embeddings/gemini.py

@@ -37,20 +37,3 @@ class GoogleGenAIEmbedding(EmbeddingBase):
         response = self.client.models.embed_content(model=self.config.model, contents=text, config=config)
 
         return response.embeddings[0].values
-
-    def embed_batch(self, texts, memory_action="add"):
-        if not texts:
-            return []
-        config = types.EmbedContentConfig(output_dimensionality=self.config.embedding_dims)
-        MAX_BATCH = 100
-        all_embeddings = []
-        for i in range(0, len(texts), MAX_BATCH):
-            chunk = [t.replace("\n", " ") for t in texts[i : i + MAX_BATCH]]
-            response = self.client.models.embed_content(model=self.config.model, contents=chunk, config=config)
-            all_embeddings.extend(e.values for e in response.embeddings)
-        if len(all_embeddings) != len(texts):
-            raise ValueError(
-                f"Gemini embed_batch() returned {len(all_embeddings)} embeddings for {len(texts)} texts "
-                f"using model '{self.config.model}'"
-            )
-        return all_embeddings

mem0/embeddings/huggingface.py

@@ -42,25 +42,3 @@ class HuggingFaceEmbedding(EmbeddingBase):
             ).data[0].embedding
         else:
             return self.model.encode(text, convert_to_numpy=True).tolist()
-
-    def embed_batch(self, texts, memory_action="add"):
-        if not texts:
-            return []
-        if self.config.huggingface_base_url:
-            response = self.client.embeddings.create(input=texts, model=self.config.model, **self.config.model_kwargs)
-            sorted_data = sorted(response.data, key=lambda x: x.index)
-            embeddings = [item.embedding for item in sorted_data]
-            if len(embeddings) != len(texts):
-                raise ValueError(
-                    f"HuggingFace embed_batch() returned {len(embeddings)} embeddings for {len(texts)} texts"
-                    f" using model '{self.config.model}'"
-                )
-            return embeddings
-        else:
-            result = self.model.encode(texts, convert_to_numpy=True).tolist()
-            if len(result) != len(texts):
-                raise ValueError(
-                    f"HuggingFace embed_batch() returned {len(result)} embeddings for {len(texts)} texts"
-                    f" using model '{self.config.model}'"
-                )
-            return result

mem0/embeddings/lmstudio.py

@@ -27,17 +27,3 @@ class LMStudioEmbedding(EmbeddingBase):
         """
         text = text.replace("\n", " ")
         return self.client.embeddings.create(input=[text], model=self.config.model).data[0].embedding
-
-    def embed_batch(self, texts, memory_action="add"):
-        if not texts:
-            return []
-        cleaned = [t.replace("\n", " ") for t in texts]
-        response = self.client.embeddings.create(input=cleaned, model=self.config.model)
-        sorted_data = sorted(response.data, key=lambda x: x.index)
-        embeddings = [item.embedding for item in sorted_data]
-        if len(embeddings) != len(texts):
-            raise ValueError(
-                f"LM Studio embed_batch() returned {len(embeddings)} embeddings for {len(texts)} texts"
-                f" using model '{self.config.model}'"
-            )
-        return embeddings

mem0/embeddings/together.py

@@ -29,16 +29,3 @@ class TogetherEmbedding(EmbeddingBase):
         """
 
         return self.client.embeddings.create(model=self.config.model, input=text).data[0].embedding
-
-    def embed_batch(self, texts, memory_action="add"):
-        if not texts:
-            return []
-        response = self.client.embeddings.create(model=self.config.model, input=texts)
-        sorted_data = sorted(response.data, key=lambda x: x.index)
-        embeddings = [item.embedding for item in sorted_data]
-        if len(embeddings) != len(texts):
-            raise ValueError(
-                f"Together embed_batch() returned {len(embeddings)} embeddings for {len(texts)} texts"
-                f" using model '{self.config.model}'"
-            )
-        return embeddings

mem0/embeddings/vertexai.py

@@ -62,24 +62,3 @@ class VertexAIEmbedding(EmbeddingBase):
         embeddings = self.model.get_embeddings(texts=[text_input], output_dimensionality=self.config.embedding_dims)
 
         return embeddings[0].values
-
-    def embed_batch(self, texts, memory_action="add"):
-        if not texts:
-            return []
-        embedding_type = "SEMANTIC_SIMILARITY"
-        if memory_action is not None:
-            if memory_action not in self.embedding_types:
-                raise ValueError(f"Invalid memory action: {memory_action}")
-            embedding_type = self.embedding_types[memory_action]
-        all_embeddings = []
-        for i in range(0, len(texts), 250):
-            chunk = texts[i : i + 250]
-            inputs = [TextEmbeddingInput(text=t, task_type=embedding_type) for t in chunk]
-            results = self.model.get_embeddings(texts=inputs, output_dimensionality=self.config.embedding_dims)
-            all_embeddings.extend(r.values for r in results)
-        if len(all_embeddings) != len(texts):
-            raise ValueError(
-                f"Vertex AI embed_batch() returned {len(all_embeddings)} embeddings for {len(texts)} texts"
-                f" using model '{self.config.model}'"
-            )
-        return all_embeddings

mem0/llms/anthropic.py

@@ -29,7 +29,7 @@ class AnthropicLLM(LLMBase):
                 top_k=config.top_k,
                 enable_vision=config.enable_vision,
                 vision_details=config.vision_details,
-                http_client_proxies=config.http_client_proxies,
+                http_client_proxies=config.http_client,
             )
 
         super().__init__(config)
@@ -38,11 +38,7 @@ class AnthropicLLM(LLMBase):
             self.config.model = "claude-sonnet-4-6"
 
         api_key = self.config.api_key or os.getenv("ANTHROPIC_API_KEY")
-        base_url = self.config.anthropic_base_url or os.getenv("ANTHROPIC_BASE_URL")
-        client_kwargs = {"api_key": api_key}
-        if base_url:
-            client_kwargs["base_url"] = base_url
-        self.client = anthropic.Anthropic(**client_kwargs)
+        self.client = anthropic.Anthropic(api_key=api_key)
 
     def _get_common_params(self, **kwargs) -> Dict:
         """Get common parameters, avoiding sending both temperature and top_p together.

mem0/llms/azure_openai.py

@@ -1,4 +1,3 @@
-import copy
 import json
 import os
 from typing import Dict, List, Optional, Union
@@ -33,7 +32,7 @@ class AzureOpenAILLM(LLMBase):
                 enable_vision=config.enable_vision,
                 vision_details=config.vision_details,
                 reasoning_effort=getattr(config, 'reasoning_effort', None),
-                http_client_proxies=config.http_client_proxies,
+                http_client_proxies=config.http_client,
                 is_reasoning_model=getattr(config, 'is_reasoning_model', None),
             )
 
@@ -70,26 +69,6 @@ class AzureOpenAILLM(LLMBase):
             default_headers=default_headers,
         )
 
-    @staticmethod
-    def _rewrite_assistant_keyword(messages):
-        """
-        Return a copy of ``messages`` with the word "assistant" replaced by "ai"
-        in the last message's textual content.
-
-        Azure's content management policy can flag the literal word "assistant",
-        which makes ``add`` fail (see issue #2636). The rewrite targets that
-        trigger without mutating the caller's messages and without assuming the
-        content is a string, so multimodal (list) content passes through untouched.
-        """
-        if not messages:
-            return messages
-
-        messages = copy.deepcopy(messages)
-        last_content = messages[-1].get("content")
-        if isinstance(last_content, str):
-            messages[-1]["content"] = last_content.replace("assistant", "ai")
-        return messages
-
     def _parse_response(self, response, tools):
         """
         Process the response based on whether tools are used or not.
@@ -142,14 +121,14 @@ class AzureOpenAILLM(LLMBase):
             str: The generated response.
         """
 
-        # Azure's "Indirect Attacks" content filter can flag the literal word
-        # "assistant" in the prompt, so it is rewritten to "ai" before the request.
-        # Work on a copy so the caller's messages are left untouched and string-only
-        # content is handled without breaking multimodal (list) content.
-        messages = self._rewrite_assistant_keyword(messages)
+        user_prompt = messages[-1]["content"]
+
+        user_prompt = user_prompt.replace("assistant", "ai")
+
+        messages[-1]["content"] = user_prompt
 
         params = self._get_supported_params(messages=messages, **kwargs)
-
+        
         # Add model and messages
         params.update({
             "model": self.config.model,

mem0/llms/azure_openai_structured.py

@@ -1,4 +1,3 @@
-import copy
 import json
 import os
 from typing import Dict, List, Optional
@@ -67,11 +66,11 @@ class AzureOpenAIStructuredLLM(LLMBase):
             str: The generated response.
         """
 
-        # Azure's "Indirect Attacks" content filter can flag the literal word
-        # "assistant" in the prompt, so it is rewritten to "ai" before the request.
-        # Work on a copy so the caller's messages are left untouched and string-only
-        # content is handled without breaking multimodal (list) content.
-        messages = self._rewrite_assistant_keyword(messages)
+        user_prompt = messages[-1]["content"]
+
+        user_prompt = user_prompt.replace("assistant", "ai")
+
+        messages[-1]["content"] = user_prompt
 
         is_reasoning = self._is_reasoning_model(self.config.model)
         params = {
@@ -102,26 +101,6 @@ class AzureOpenAIStructuredLLM(LLMBase):
         response = self.client.chat.completions.create(**params)
         return self._parse_response(response, tools)
 
-    @staticmethod
-    def _rewrite_assistant_keyword(messages):
-        """
-        Return a copy of ``messages`` with the word "assistant" replaced by "ai"
-        in the last message's textual content.
-
-        Azure's content management policy can flag the literal word "assistant",
-        which makes ``add`` fail (see issue #2636). The rewrite targets that
-        trigger without mutating the caller's messages and without assuming the
-        content is a string, so multimodal (list) content passes through untouched.
-        """
-        if not messages:
-            return messages
-
-        messages = copy.deepcopy(messages)
-        last_content = messages[-1].get("content")
-        if isinstance(last_content, str):
-            messages[-1]["content"] = last_content.replace("assistant", "ai")
-        return messages
-
     def _parse_response(self, response, tools):
         """
         Process the response based on whether tools are used or not.

mem0/llms/deepseek.py

@@ -28,7 +28,7 @@ class DeepSeekLLM(LLMBase):
                 top_k=config.top_k,
                 enable_vision=config.enable_vision,
                 vision_details=config.vision_details,
-                http_client_proxies=config.http_client_proxies,
+                http_client_proxies=config.http_client,
             )
 
         super().__init__(config)

mem0/llms/groq.py

@@ -1,7 +1,6 @@
 import json
-import logging
 import os
-from typing import Dict, List, Optional, Union
+from typing import Dict, List, Optional
 
 try:
     from groq import Groq
@@ -12,8 +11,6 @@ from mem0.configs.llms.base import BaseLlmConfig
 from mem0.llms.base import LLMBase
 from mem0.memory.utils import extract_json
 
-logger = logging.getLogger(__name__)
-
 
 class GroqLLM(LLMBase):
     def __init__(self, config: Optional[BaseLlmConfig] = None):
@@ -25,24 +22,6 @@ class GroqLLM(LLMBase):
         api_key = self.config.api_key or os.getenv("GROQ_API_KEY")
         self.client = Groq(api_key=api_key)
 
-    @staticmethod
-    def _supports_json_mode(model: Optional[Union[str, Dict]]) -> bool:
-        """
-        Groq's compound agentic systems (e.g. ``groq/compound``, ``groq/compound-mini``)
-        do not support the JSON ``response_format`` and return empty or non-JSON content
-        when it is requested. See https://console.groq.com/docs/structured-outputs.
-
-        Non-string models (the config allows a dict) are assumed to support JSON mode,
-        preserving prior behavior.
-        """
-        if not isinstance(model, str):
-            return True
-        # Strip provider prefixes (e.g. "groq/compound-mini" -> "compound-mini"),
-        # mirroring the _is_reasoning_model heuristic in LLMBase, so the match
-        # targets the compound family rather than any name containing the substring.
-        base_model = model.lower().rsplit("/", 1)[-1]
-        return not base_model.startswith("compound")
-
     def _parse_response(self, response, tools):
         """
         Process the response based on whether tools are used or not.
@@ -100,17 +79,7 @@ class GroqLLM(LLMBase):
             "top_p": self.config.top_p,
         }
         if response_format:
-            requests_json = isinstance(response_format, dict) and response_format.get("type") in (
-                "json_object",
-                "json_schema",
-            )
-            if requests_json and not self._supports_json_mode(self.config.model):
-                logger.debug(
-                    f"Model '{self.config.model}' does not support JSON response_format; "
-                    "sending the request without it."
-                )
-            else:
-                params["response_format"] = response_format
+            params["response_format"] = response_format
         if tools:
             params["tools"] = tools
             params["tool_choice"] = tool_choice

mem0/llms/lmstudio.py

@@ -27,7 +27,7 @@ class LMStudioLLM(LLMBase):
                 top_k=config.top_k,
                 enable_vision=config.enable_vision,
                 vision_details=config.vision_details,
-                http_client_proxies=config.http_client_proxies,
+                http_client_proxies=config.http_client,
             )
 
         super().__init__(config)

mem0/llms/minimax.py

@@ -28,7 +28,7 @@ class MiniMaxLLM(LLMBase):
                 top_k=config.top_k,
                 enable_vision=config.enable_vision,
                 vision_details=config.vision_details,
-                http_client_proxies=config.http_client_proxies,
+                http_client_proxies=config.http_client,
             )
 
         super().__init__(config)

mem0/llms/ollama.py

@@ -30,7 +30,7 @@ class OllamaLLM(LLMBase):
                 top_k=config.top_k,
                 enable_vision=config.enable_vision,
                 vision_details=config.vision_details,
-                http_client_proxies=config.http_client_proxies,
+                http_client_proxies=config.http_client,
             )
 
         super().__init__(config)

mem0/llms/openai.py

@@ -30,7 +30,7 @@ class OpenAILLM(LLMBase):
                 enable_vision=config.enable_vision,
                 vision_details=config.vision_details,
                 reasoning_effort=getattr(config, 'reasoning_effort', None),
-                http_client_proxies=config.http_client_proxies,
+                http_client_proxies=config.http_client,
                 is_reasoning_model=getattr(config, 'is_reasoning_model', None),
             )
 

mem0/llms/vllm.py

@@ -28,7 +28,7 @@ class VllmLLM(LLMBase):
                 top_k=config.top_k,
                 enable_vision=config.enable_vision,
                 vision_details=config.vision_details,
-                http_client_proxies=config.http_client_proxies,
+                http_client_proxies=config.http_client,
             )
 
         super().__init__(config)

mem0/memory/main.py

@@ -81,14 +81,6 @@ warnings.filterwarnings("ignore", category=DeprecationWarning, message=".*swigva
 logger = logging.getLogger(__name__)
 
 
-def _vector_store_list_rows(listed):
-    if isinstance(listed, (list, tuple)) and listed and isinstance(listed[0], list):
-        return listed[0]
-    if isinstance(listed, (list, tuple)):
-        return listed
-    return []
-
-
 # Fields that hold runtime auth/connection objects and must be preserved.
 # These are non-serializable objects (e.g. AWSV4SignerAuth, RequestsHttpConnection)
 # needed by clients like OpenSearch — not sensitive strings to redact.
@@ -507,49 +499,22 @@ class Memory(MemoryBase):
             )
         return self._entity_store
 
-    @staticmethod
-    def _normalize_entity_text(value: str) -> str:
-        return " ".join(value.strip().lower().split())
-
-    def _existing_entities_by_text(self, filters):
-        """Return existing entity rows keyed by normalized payload data."""
-        try:
-            listed = self.entity_store.list(filters=filters, top_k=10000)
-        except Exception as e:
-            logger.debug(f"Exact entity lookup failed, falling back to semantic dedup: {e}")
-            return {}
-
-        rows_by_text = {}
-        for row in _vector_store_list_rows(listed):
-            payload = getattr(row, "payload", None) or {}
-            text = payload.get("data")
-            if not isinstance(text, str):
-                continue
-            normalized = self._normalize_entity_text(text)
-            if normalized and normalized not in rows_by_text:
-                rows_by_text[normalized] = row
-        return rows_by_text
-
     def _upsert_entity(self, entity_text, entity_type, memory_id, filters):
         """Upsert an entity into the entity store, linking it to a memory."""
         try:
             entity_embedding = self.embedding_model.embed(entity_text, "add")
             search_filters = {k: v for k, v in filters.items() if k in ("user_id", "agent_id", "run_id") and v}
-            exact_match = self._existing_entities_by_text(search_filters).get(self._normalize_entity_text(entity_text))
 
-            existing = []
-            if exact_match is None:
-                existing = self.entity_store.search(
-                    query=entity_text,
-                    vectors=entity_embedding,
-                    top_k=1,
-                    filters=search_filters,
-                )
+            existing = self.entity_store.search(
+                query=entity_text,
+                vectors=entity_embedding,
+                top_k=1,
+                filters=search_filters,
+            )
 
-            semantic_match = existing[0] if existing and existing[0].score >= 0.95 else None
-            match = exact_match or semantic_match
-            if match:
+            if existing and existing[0].score >= 0.95:
                 # Update existing entity's linked_memory_ids
+                match = existing[0]
                 payload = match.payload or {}
                 linked_ids = payload.get("linked_memory_ids", [])
                 if memory_id not in linked_ids:
@@ -644,7 +609,7 @@ class Memory(MemoryBase):
                 return
             seen = set()
             for entity_type, entity_text in entities:
-                key = self._normalize_entity_text(entity_text)
+                key = entity_text.strip().lower()
                 if not key or key in seen:
                     continue
                 seen.add(key)
@@ -1006,7 +971,7 @@ class Memory(MemoryBase):
             for idx, (memory_id, text, embedding, payload) in enumerate(records):
                 entities = all_entities[idx] if idx < len(all_entities) else []
                 for entity_type, entity_text in entities:
-                    key = self._normalize_entity_text(entity_text)
+                    key = entity_text.strip().lower()
                     if key in global_entities:
                         global_entities[key][2].add(memory_id)
                     else:
@@ -1028,23 +993,11 @@ class Memory(MemoryBase):
                         except Exception:
                             entity_embeddings.append(None)
 
-
-                if len(entity_embeddings) != len(ordered_keys):
-                    logger.warning(
-                        "embed_batch returned %d vectors for %d entity texts — "
-                        "padding/truncating to avoid dropping entity links",
-                        len(entity_embeddings),
-                        len(ordered_keys),
-                    )
-                    entity_embeddings = list(entity_embeddings[: len(ordered_keys)])
-                    entity_embeddings += [None] * (len(ordered_keys) - len(entity_embeddings))
-
                 # Filter out entities with failed embeddings
                 valid = [(i, k) for i, k in enumerate(ordered_keys) if entity_embeddings[i] is not None]
                 if valid:
                     valid_indices, valid_keys = zip(*valid)
                     valid_vectors = [entity_embeddings[i] for i in valid_indices]
-                    exact_matches = self._existing_entities_by_text(search_filters)
 
                     # 7c: Batch search for existing entities
                     valid_texts = [global_entities[k][1] for k in valid_keys]
@@ -1060,12 +1013,10 @@ class Memory(MemoryBase):
                     for j, key in enumerate(valid_keys):
                         entity_type, entity_text, memory_ids = global_entities[key]
                         matches = existing_matches[j] if j < len(existing_matches) else []
-                        exact_match = exact_matches.get(key)
 
-                        semantic_match = matches[0] if matches and matches[0].score >= 0.95 else None
-                        match = exact_match or semantic_match
-                        if match:
+                        if matches and matches[0].score >= 0.95:
                             # Update existing entity
+                            match = matches[0]
                             payload = match.payload or {}
                             linked = set(payload.get("linked_memory_ids", []))
                             linked |= memory_ids
@@ -1140,7 +1091,6 @@ class Memory(MemoryBase):
             "run_id",
             "actor_id",
             "role",
-            "attributed_to",
         ]
 
         core_and_promoted_keys = {"data", "hash", "created_at", "updated_at", "id", "text_lemmatized", "attributed_to", *promoted_payload_keys}
@@ -1254,7 +1204,6 @@ class Memory(MemoryBase):
             "run_id",
             "actor_id",
             "role",
-            "attributed_to",
         ]
         core_and_promoted_keys = {"data", "hash", "created_at", "updated_at", "id", "text_lemmatized", "attributed_to", *promoted_payload_keys}
 
@@ -1590,7 +1539,6 @@ class Memory(MemoryBase):
             "run_id",
             "actor_id",
             "role",
-            "attributed_to",
         ]
         core_and_promoted_keys = {"data", "hash", "created_at", "updated_at", "id", "text_lemmatized", "attributed_to", *promoted_payload_keys}
 
@@ -1641,7 +1589,7 @@ class Memory(MemoryBase):
         seen = set()
         deduped = []
         for entity_type, entity_text in query_entities[:8]:
-            key = self._normalize_entity_text(entity_text)
+            key = entity_text.strip().lower()
             if key and key not in seen:
                 seen.add(key)
                 deduped.append((entity_type, entity_text))
@@ -1883,9 +1831,8 @@ class Memory(MemoryBase):
         try:
             existing_memory = self.vector_store.get(vector_id=memory_id)
         except Exception:
-            # Backing-store failure, not a bad memory_id: re-raise the original so the REST layer maps it to 5xx, not 4xx.
             logger.error(f"Error getting memory with ID {memory_id} during update.")
-            raise
+            raise ValueError(f"Error getting memory with ID {memory_id}. Please provide a valid 'memory_id'")
 
         if existing_memory is None:
             raise ValueError(f"Memory with id {memory_id} not found. Please provide a valid 'memory_id'")
@@ -1976,8 +1923,10 @@ class Memory(MemoryBase):
         """
         logger.warning("Resetting all memories")
 
-        self.db.reset()
-        self.db.close()
+        if hasattr(self.db, "connection") and self.db.connection:
+            self.db.connection.execute("DROP TABLE IF EXISTS history")
+            self.db.connection.close()
+
         self.db = SQLiteManager(self.config.history_db_path)
 
         if hasattr(self.vector_store, "reset"):
@@ -2083,51 +2032,22 @@ class AsyncMemory(MemoryBase):
             )
         return self._entity_store
 
-    @staticmethod
-    def _normalize_entity_text(value: str) -> str:
-        return " ".join(value.strip().lower().split())
-
-    def _existing_entities_by_text(self, filters):
-        """Return existing entity rows keyed by normalized payload data."""
-        try:
-            listed = self.entity_store.list(filters=filters, top_k=10000)
-        except Exception as e:
-            logger.debug(f"Exact entity lookup failed, falling back to semantic dedup: {e}")
-            return {}
-
-        rows_by_text = {}
-        for row in _vector_store_list_rows(listed):
-            payload = getattr(row, "payload", None) or {}
-            text = payload.get("data")
-            if not isinstance(text, str):
-                continue
-            normalized = self._normalize_entity_text(text)
-            if normalized and normalized not in rows_by_text:
-                rows_by_text[normalized] = row
-        return rows_by_text
-
     async def _upsert_entity_async(self, entity_text, entity_type, memory_id, filters):
         """Async variant of `_upsert_entity` — per-entity search-then-update-or-insert."""
         try:
             entity_embedding = await asyncio.to_thread(self.embedding_model.embed, entity_text, "add")
             search_filters = {k: v for k, v in filters.items() if k in ("user_id", "agent_id", "run_id") and v}
-            exact_match = (
-                await asyncio.to_thread(self._existing_entities_by_text, search_filters)
-            ).get(self._normalize_entity_text(entity_text))
 
-            existing = []
-            if exact_match is None:
-                existing = await asyncio.to_thread(
-                    self.entity_store.search,
-                    query=entity_text,
-                    vectors=entity_embedding,
-                    top_k=1,
-                    filters=search_filters,
-                )
+            existing = await asyncio.to_thread(
+                self.entity_store.search,
+                query=entity_text,
+                vectors=entity_embedding,
+                top_k=1,
+                filters=search_filters,
+            )
 
-            semantic_match = existing[0] if existing and existing[0].score >= 0.95 else None
-            match = exact_match or semantic_match
-            if match:
+            if existing and existing[0].score >= 0.95:
+                match = existing[0]
                 payload = match.payload or {}
                 linked_ids = payload.get("linked_memory_ids", [])
                 if memory_id not in linked_ids:
@@ -2156,27 +2076,6 @@ class AsyncMemory(MemoryBase):
         except Exception as e:
             logger.warning(f"Entity upsert failed for '{entity_text}' (async): {e}")
 
-    async def _bulk_clear_entity_store(self, filters):
-        """Delete all entity records matching the given scope filters.
-
-        Used by delete_all to avoid the race condition that occurs when
-        concurrent _delete_memory coroutines each try to read-modify-write
-        the same entity rows' linked_memory_ids lists.
-        """
-        if self._entity_store is None:
-            return
-        search_filters = {k: v for k, v in filters.items() if k in ("user_id", "agent_id", "run_id") and v}
-        try:
-            listed = await asyncio.to_thread(self.entity_store.list, filters=search_filters, top_k=10000)
-            rows = listed[0] if isinstance(listed, (list, tuple)) and listed and isinstance(listed[0], list) else listed
-            for row in rows or []:
-                try:
-                    await asyncio.to_thread(self.entity_store.delete, vector_id=row.id)
-                except Exception as e:
-                    logger.debug(f"Bulk entity delete failed for id={row.id}: {e}")
-        except Exception as e:
-            logger.warning(f"Bulk entity store cleanup failed: {e}")
-
     async def _remove_memory_from_entity_store(self, memory_id, filters):
         """Async variant of `Memory._remove_memory_from_entity_store`."""
         if self._entity_store is None:
@@ -2230,7 +2129,7 @@ class AsyncMemory(MemoryBase):
                 return
             seen = set()
             for entity_type, entity_text in entities:
-                key = self._normalize_entity_text(entity_text)
+                key = entity_text.strip().lower()
                 if not key or key in seen:
                     continue
                 seen.add(key)
@@ -2579,7 +2478,7 @@ class AsyncMemory(MemoryBase):
             for idx, (memory_id, text, embedding, payload) in enumerate(records):
                 entities = all_entities[idx] if idx < len(all_entities) else []
                 for entity_type, entity_text in entities:
-                    key = self._normalize_entity_text(entity_text)
+                    key = entity_text.strip().lower()
                     if key in global_entities:
                         global_entities[key][2].add(memory_id)
                     else:
@@ -2600,21 +2499,10 @@ class AsyncMemory(MemoryBase):
                         except Exception:
                             entity_embeddings.append(None)
 
-                if len(entity_embeddings) != len(ordered_keys):
-                    logger.warning(
-                        "embed_batch returned %d vectors for %d entity texts — "
-                        "padding/truncating to avoid dropping entity links",
-                        len(entity_embeddings),
-                        len(ordered_keys),
-                    )
-                    entity_embeddings = list(entity_embeddings[: len(ordered_keys)])
-                    entity_embeddings += [None] * (len(ordered_keys) - len(entity_embeddings))
-
                 valid = [(i, k) for i, k in enumerate(ordered_keys) if entity_embeddings[i] is not None]
                 if valid:
                     valid_indices, valid_keys = zip(*valid)
                     valid_vectors = [entity_embeddings[i] for i in valid_indices]
-                    exact_matches = await asyncio.to_thread(self._existing_entities_by_text, search_filters)
 
                     # 7c: Batch search for existing entities
                     valid_texts = [global_entities[k][1] for k in valid_keys]
@@ -2631,11 +2519,9 @@ class AsyncMemory(MemoryBase):
                     for j, key in enumerate(valid_keys):
                         entity_type, entity_text, memory_ids = global_entities[key]
                         matches = existing_matches[j] if j < len(existing_matches) else []
-                        exact_match = exact_matches.get(key)
 
-                        semantic_match = matches[0] if matches and matches[0].score >= 0.95 else None
-                        match = exact_match or semantic_match
-                        if match:
+                        if matches and matches[0].score >= 0.95:
+                            match = matches[0]
                             payload = match.payload or {}
                             linked = set(payload.get("linked_memory_ids", []))
                             linked |= memory_ids
@@ -2711,7 +2597,6 @@ class AsyncMemory(MemoryBase):
             "run_id",
             "actor_id",
             "role",
-            "attributed_to",
         ]
 
         core_and_promoted_keys = {"data", "hash", "created_at", "updated_at", "id", "text_lemmatized", "attributed_to", *promoted_payload_keys}
@@ -2825,7 +2710,6 @@ class AsyncMemory(MemoryBase):
             "run_id",
             "actor_id",
             "role",
-            "attributed_to",
         ]
         core_and_promoted_keys = {"data", "hash", "created_at", "updated_at", "id", "text_lemmatized", "attributed_to", *promoted_payload_keys}
 
@@ -3167,7 +3051,6 @@ class AsyncMemory(MemoryBase):
             "run_id",
             "actor_id",
             "role",
-            "attributed_to",
         ]
         core_and_promoted_keys = {"data", "hash", "created_at", "updated_at", "id", "text_lemmatized", "attributed_to", *promoted_payload_keys}
 
@@ -3207,7 +3090,7 @@ class AsyncMemory(MemoryBase):
         seen = set()
         deduped = []
         for entity_type, entity_text in query_entities[:8]:
-            key = self._normalize_entity_text(entity_text)
+            key = entity_text.strip().lower()
             if key and key not in seen:
                 seen.add(key)
                 deduped.append((entity_type, entity_text))
@@ -3350,13 +3233,10 @@ class AsyncMemory(MemoryBase):
 
         delete_tasks = []
         for memory in memories[0]:
-            delete_tasks.append(self._delete_memory(memory.id, skip_entity_cleanup=True))
+            delete_tasks.append(self._delete_memory(memory.id))
 
         results = await asyncio.gather(*delete_tasks, return_exceptions=True)
 
-        if self._entity_store is not None:
-            await self._bulk_clear_entity_store(filters)
-
         errors = [r for r in results if isinstance(r, BaseException)]
         if errors:
             logger.warning("Failed to delete %d out of %d memories", len(errors), len(results))
@@ -3483,9 +3363,8 @@ class AsyncMemory(MemoryBase):
         try:
             existing_memory = await asyncio.to_thread(self.vector_store.get, vector_id=memory_id)
         except Exception:
-            # Backing-store failure, not a bad memory_id: re-raise the original so the REST layer maps it to 5xx, not 4xx.
             logger.error(f"Error getting memory with ID {memory_id} during update.")
-            raise
+            raise ValueError(f"Error getting memory with ID {memory_id}. Please provide a valid 'memory_id'")
 
         if existing_memory is None:
             raise ValueError(f"Memory with id {memory_id} not found. Please provide a valid 'memory_id'")
@@ -3539,7 +3418,7 @@ class AsyncMemory(MemoryBase):
 
         return memory_id
 
-    async def _delete_memory(self, memory_id, existing_memory=None, skip_entity_cleanup=False):
+    async def _delete_memory(self, memory_id, existing_memory=None):
         logger.info(f"Deleting memory with {memory_id=}")
         if existing_memory is None:
             existing_memory = await asyncio.to_thread(self.vector_store.get, vector_id=memory_id)
@@ -3565,8 +3444,9 @@ class AsyncMemory(MemoryBase):
             is_deleted=1,
         )
 
-        if not skip_entity_cleanup:
-            await self._remove_memory_from_entity_store(memory_id, session_filters)
+        # Entity-store cleanup: strip this memory's id from any entity records
+        # that linked to it. Non-fatal — the helper swallows errors.
+        await self._remove_memory_from_entity_store(memory_id, session_filters)
 
         return memory_id
 
@@ -3585,8 +3465,10 @@ class AsyncMemory(MemoryBase):
         if hasattr(self.vector_store, "client") and hasattr(self.vector_store.client, "close"):
             await asyncio.to_thread(self.vector_store.client.close)
 
-        await asyncio.to_thread(self.db.reset)
-        await asyncio.to_thread(self.db.close)
+        if hasattr(self.db, "connection") and self.db.connection:
+            await asyncio.to_thread(lambda: self.db.connection.execute("DROP TABLE IF EXISTS history"))
+            await asyncio.to_thread(self.db.connection.close)
+
         self.db = SQLiteManager(self.config.history_db_path)
 
         self.vector_store = VectorStoreFactory.create(

mem0/memory/storage.py

@@ -324,9 +324,7 @@ class SQLiteManager:
         ]
 
     def reset(self) -> None:
-        """Drop both tables. Caller is expected to replace this instance."""
-        if not self.connection:
-            raise RuntimeError("Cannot reset a closed SQLiteManager")
+        """Drop and recreate the history and messages tables."""
         with self._lock:
             try:
                 self.connection.execute("BEGIN")
@@ -337,6 +335,8 @@ class SQLiteManager:
                 self.connection.execute("ROLLBACK")
                 logger.error(f"Failed to reset tables: {e}")
                 raise
+        self._create_history_table()
+        self._create_messages_table()
 
     def close(self) -> None:
         if self.connection:

mem0/memory/utils.py

@@ -206,10 +206,7 @@ def parse_vision_messages(messages, llm=None, vision_details="auto"):
         elif isinstance(content, dict) and content.get("type") == "image_url":
             if llm is None:
                 continue
-            image_url_obj = content.get("image_url")
-            image_url = image_url_obj.get("url") if isinstance(image_url_obj, dict) else None
-            if not image_url:
-                raise ValueError("image_url content part is missing image_url.url")
+            image_url = content["image_url"]["url"]
             try:
                 description = get_image_description(image_url, llm, vision_details)
                 returned_messages.append({"role": role, "content": description})

mem0/reranker/__init__.py

@@ -4,16 +4,6 @@ Reranker implementations for mem0 search functionality.
 
 from .base import BaseReranker
 from .cohere_reranker import CohereReranker
-from .huggingface_reranker import HuggingFaceReranker
-from .llm_reranker import LLMReranker
 from .sentence_transformer_reranker import SentenceTransformerReranker
-from .zero_entropy_reranker import ZeroEntropyReranker
 
-__all__ = [
-    "BaseReranker",
-    "CohereReranker",
-    "HuggingFaceReranker",
-    "LLMReranker",
-    "SentenceTransformerReranker",
-    "ZeroEntropyReranker",
-]
+__all__ = ["BaseReranker", "CohereReranker", "SentenceTransformerReranker"]

mem0/reranker/cohere_reranker.py

@@ -1,4 +1,3 @@
-import logging
 import os
 from typing import List, Dict, Any
 
@@ -10,8 +9,6 @@ try:
 except ImportError:
     COHERE_AVAILABLE = False
 
-logger = logging.getLogger(__name__)
-
 
 class CohereReranker(BaseReranker):
     """Cohere-based reranker implementation."""
@@ -81,9 +78,8 @@ class CohereReranker(BaseReranker):
                 
             return reranked_docs
 
-        except Exception as e:
+        except Exception:
             # Fallback to original order if reranking fails
-            logger.warning("Cohere reranking failed, falling back to original order: %s", e)
             for doc in documents:
                 doc['rerank_score'] = 0.0
             final_top_k = top_k or self.config.top_k

mem0/reranker/huggingface_reranker.py

@@ -1,4 +1,3 @@
-import logging
 from typing import List, Dict, Any, Union
 import numpy as np
 
@@ -13,8 +12,6 @@ try:
 except ImportError:
     TRANSFORMERS_AVAILABLE = False
 
-logger = logging.getLogger(__name__)
-
 
 class HuggingFaceReranker(BaseReranker):
     """HuggingFace Transformers based reranker implementation."""
@@ -142,9 +139,8 @@ class HuggingFaceReranker(BaseReranker):
 
             return reranked_docs
 
-        except Exception as e:
+        except Exception:
             # Fallback to original order if reranking fails
-            logger.warning("HuggingFace reranking failed, falling back to original order: %s", e)
             for doc in documents:
                 doc['rerank_score'] = 0.0
             final_top_k = top_k or self.config.top_k

mem0/reranker/llm_reranker.py

@@ -1,4 +1,3 @@
-import logging
 import re
 from typing import Any, Dict, List, Union
 
@@ -7,8 +6,6 @@ from mem0.configs.rerankers.llm import LLMRerankerConfig
 from mem0.reranker.base import BaseReranker
 from mem0.utils.factory import LlmFactory
 
-logger = logging.getLogger(__name__)
-
 
 class LLMReranker(BaseReranker):
     """LLM-based reranker implementation."""
@@ -93,14 +90,14 @@ class LLMReranker(BaseReranker):
 
     def _extract_score(self, response_text: str) -> float:
         """Extract numerical score from LLM response."""
-        # Prefer a decimal, fall back to an integer, then clamp: out-of-range outputs
-        # like "2.0"/"5" become 1.0 instead of being mis-parsed into a stray 0/1 digit.
-        matches = re.findall(r'-?\d+\.\d+', response_text) or re.findall(r'-?\d+', response_text)
-
+        # Look for decimal numbers between 0.0 and 1.0
+        pattern = r'\b([01](?:\.\d+)?)\b'
+        matches = re.findall(pattern, response_text)
+        
         if matches:
             score = float(matches[0])
             return min(max(score, 0.0), 1.0)  # Clamp between 0.0 and 1.0
-
+        
         # Fallback: return 0.5 if no valid score found
         return 0.5
     
@@ -154,9 +151,8 @@ class LLMReranker(BaseReranker):
                 scored_doc['rerank_score'] = score
                 scored_docs.append(scored_doc)
 
-            except Exception as e:
+            except Exception:
                 # Fallback: assign neutral score if scoring fails
-                logger.warning("LLM reranking failed for a document, assigning neutral score: %s", e)
                 scored_doc = doc.copy()
                 scored_doc['rerank_score'] = 0.5
                 scored_docs.append(scored_doc)

mem0/reranker/sentence_transformer_reranker.py

@@ -1,4 +1,3 @@
-import logging
 from typing import List, Dict, Any, Union
 import numpy as np
 
@@ -12,8 +11,6 @@ try:
 except ImportError:
     SENTENCE_TRANSFORMERS_AVAILABLE = False
 
-logger = logging.getLogger(__name__)
-
 
 class SentenceTransformerReranker(BaseReranker):
     """Sentence Transformer based reranker implementation."""
@@ -105,9 +102,8 @@ class SentenceTransformerReranker(BaseReranker):
                 
             return reranked_docs
 
-        except Exception as e:
+        except Exception:
             # Fallback to original order if reranking fails
-            logger.warning("SentenceTransformer reranking failed, falling back to original order: %s", e)
             for doc in documents:
                 doc['rerank_score'] = 0.0
             final_top_k = top_k or self.config.top_k

mem0/reranker/zero_entropy_reranker.py

@@ -1,4 +1,3 @@
-import logging
 import os
 from typing import List, Dict, Any
 
@@ -10,8 +9,6 @@ try:
 except ImportError:
     ZERO_ENTROPY_AVAILABLE = False
 
-logger = logging.getLogger(__name__)
-
 
 class ZeroEntropyReranker(BaseReranker):
     """Zero Entropy-based reranker implementation."""
@@ -92,9 +89,8 @@ class ZeroEntropyReranker(BaseReranker):
                 
             return reranked_docs
 
-        except Exception as e:
+        except Exception:
             # Fallback to original order if reranking fails
-            logger.warning("Zero Entropy reranking failed, falling back to original order: %s", e)
             for doc in documents:
                 doc['rerank_score'] = 0.0
             final_top_k = top_k or self.config.top_k

mem0/utils/entity_extraction.py

@@ -1,352 +1,82 @@
 """
 Entity extraction from text using spaCy NLP.
 
-Extracts three types of entities from a spaCy-processed document:
+Extracts four types of entities from text:
 - **Proper nouns**: Capitalized multi-word sequences (person names, places, brands)
 - **Quoted text**: Text in single or double quotes (titles, specific terms)
 - **Noun compounds**: Multi-word noun phrases with specific modifiers (e.g., "machine learning")
+- **Noun fallback**: Single nouns from circumstantial compound patterns
 
 Public API:
-    ``extract_entities(text)`` accepts a string and owns spaCy model loading.
-    ``extract_entities_batch(texts)`` uses ``nlp.pipe`` for batched extraction.
+    extract_entities(text: str) -> List[Tuple[str, str]]
 
-Returns:
-    List of ``(entity_type, entity_text)`` tuples where entity_type is one of
-    PROPER, QUOTED, TOPIC, or IDENTIFIER. Returns ``[]`` if spaCy is unavailable.
+Internal:
+    _extract_entities_from_doc(doc) -> List[Tuple[str, str]]
 """
 
 from __future__ import annotations
 
-from dataclasses import dataclass
+import logging
 import re
+from typing import List, Tuple
 
-
-@dataclass(frozen=True)
-class _EntityCandidate:
-    entity_type: str
-    text: str
-    source: str
-    start: int
-    end: int
-    confidence: float
-    priority: int
-
+logger = logging.getLogger(__name__)
 
 # Words that are too generic to be useful as entity heads
 _GENERIC_HEADS = {
-    "thing",
-    "stuff",
-    "way",
-    "time",
-    "experience",
-    "situation",
-    "case",
-    "fact",
-    "matter",
-    "issue",
-    "idea",
-    "thought",
-    "feeling",
-    "place",
-    "area",
-    "part",
-    "kind",
-    "type",
-    "sort",
-    "lot",
-    "bit",
-    "day",
-    "year",
-    "week",
-    "month",
-    "moment",
-    "instance",
-    "example",
-    "technique",
-    "method",
-    "approach",
-    "process",
-    "step",
-    "tool",
-    "result",
-    "outcome",
-    "goal",
-    "task",
-    "item",
-    "topic",
-    "scale",
-    "size",
-    "level",
-    "degree",
-    "amount",
-    "number",
-    "style",
-    "look",
-    "color",
-    "colour",
-    "shape",
-    "form",
-    "piece",
-    "section",
-    "side",
-    "end",
-    "edge",
-    "surface",
-    "point",
-}
-
-# Entity labels emitted by spaCy that are usually safe to treat as named
-# entities. Numeric and temporal labels are intentionally excluded.
-_ACCEPTED_NER_LABELS = {
-    "PERSON",
-    "ORG",
-    "GPE",
-    "LOC",
-    "FAC",
-    "PRODUCT",
-    "WORK_OF_ART",
-    "EVENT",
-    "NORP",
-    "LAW",
-    "LANGUAGE",
-}
-
-_REJECTED_NER_LABELS = {
-    "DATE",
-    "TIME",
-    "CARDINAL",
-    "ORDINAL",
-    "QUANTITY",
-    "MONEY",
-    "PERCENT",
-}
-
-# Generic role words and title-cased English words that should not become
-# single-token named entities just because spaCy tagged them as PROPN.
-_GENERIC_SINGLE_ENTITY_TERMS = {
-    "user",
-    "assistant",
-    "agent",
-    "customer",
-    "client",
-    "person",
-    "people",
-    "human",
-    "memory",
-    "message",
-    "conversation",
-    "chat",
-    "session",
-    "system",
-    "top",
+    "thing", "stuff", "way", "time", "experience", "situation", "case",
+    "fact", "matter", "issue", "idea", "thought", "feeling", "place",
+    "area", "part", "kind", "type", "sort", "lot", "bit", "day", "year",
+    "week", "month", "moment", "instance", "example", "technique",
+    "method", "approach", "process", "step", "tool", "result", "outcome",
+    "goal", "task", "item", "topic", "scale", "size", "level", "degree",
+    "amount", "number", "style", "look", "color", "colour", "shape",
+    "form", "piece", "section", "side", "end", "edge", "surface", "point",
 }
 
 # Modifiers that describe circumstance, not content
 _CIRCUMSTANTIAL_MODS = {
-    "solo",
-    "individual",
-    "team",
-    "group",
-    "joint",
-    "collaborative",
-    "first",
-    "last",
-    "next",
-    "previous",
-    "final",
-    "initial",
-    "main",
-    "side",
-    "top",
+    "solo", "individual", "team", "group", "joint", "collaborative",
+    "first", "last", "next", "previous", "final", "initial", "main", "side",
 }
 
 # Adjectives too vague to make a compound entity specific
 _NON_SPECIFIC_ADJ = {
-    "many",
-    "few",
-    "several",
-    "some",
-    "any",
-    "all",
-    "most",
-    "more",
-    "less",
-    "much",
-    "little",
-    "enough",
-    "various",
-    "numerous",
-    "multiple",
-    "countless",
-    "great",
-    "good",
-    "bad",
-    "nice",
-    "terrible",
-    "awful",
-    "awesome",
-    "amazing",
-    "wonderful",
-    "horrible",
-    "excellent",
-    "poor",
-    "best",
-    "worst",
-    "fine",
-    "okay",
-    "new",
-    "old",
-    "recent",
-    "past",
-    "future",
-    "current",
-    "previous",
-    "next",
-    "last",
-    "first",
-    "latest",
-    "early",
-    "late",
-    "former",
-    "modern",
-    "ancient",
-    "big",
-    "small",
-    "large",
-    "tiny",
-    "huge",
-    "enormous",
-    "long",
-    "short",
-    "tall",
-    "high",
-    "low",
-    "wide",
-    "narrow",
-    "thick",
-    "thin",
-    "deep",
-    "shallow",
-    "similar",
-    "different",
-    "same",
-    "other",
-    "another",
-    "such",
-    "certain",
-    "important",
-    "main",
-    "major",
-    "minor",
-    "key",
-    "primary",
-    "real",
-    "actual",
-    "true",
-    "whole",
-    "entire",
-    "full",
-    "complete",
-    "total",
-    "basic",
-    "simple",
-    "interesting",
-    "boring",
-    "exciting",
-    "special",
-    "particular",
-    "general",
-    "common",
-    "unique",
-    "rare",
-    "typical",
-    "usual",
-    "normal",
-    "regular",
-    "possible",
-    "likely",
-    "potential",
-    "available",
-    "necessary",
-    "only",
-    "solo",
-    "individual",
-    "team",
-    "group",
-    "joint",
-    "collaborative",
-    "final",
-    "initial",
-    "side",
+    "many", "few", "several", "some", "any", "all", "most", "more",
+    "less", "much", "little", "enough", "various", "numerous", "multiple",
+    "countless", "great", "good", "bad", "nice", "terrible", "awful",
+    "awesome", "amazing", "wonderful", "horrible", "excellent", "poor",
+    "best", "worst", "fine", "okay", "new", "old", "recent", "past",
+    "future", "current", "previous", "next", "last", "first", "latest",
+    "early", "late", "former", "modern", "ancient", "big", "small",
+    "large", "tiny", "huge", "enormous", "long", "short", "tall", "high",
+    "low", "wide", "narrow", "thick", "thin", "deep", "shallow",
+    "similar", "different", "same", "other", "another", "such", "certain",
+    "important", "main", "major", "minor", "key", "primary", "real",
+    "actual", "true", "whole", "entire", "full", "complete", "total",
+    "basic", "simple", "interesting", "boring", "exciting", "special",
+    "particular", "general", "common", "unique", "rare", "typical",
+    "usual", "normal", "regular", "possible", "likely", "potential",
+    "available", "necessary", "only", "solo", "individual", "team",
+    "group", "joint", "collaborative", "final", "initial", "side",
 }
 
 # Generic tail words to strip from compound entities
 _GENERIC_ENDINGS = {
-    "work",
-    "works",
-    "job",
-    "jobs",
-    "task",
-    "tasks",
-    "stuff",
-    "things",
-    "thing",
-    "info",
-    "information",
-    "details",
-    "data",
-    "content",
-    "material",
-    "materials",
-    "activities",
-    "activity",
-    "efforts",
-    "effort",
-    "options",
-    "option",
-    "choices",
-    "choice",
-    "results",
-    "result",
-    "output",
-    "outputs",
-    "products",
-    "product",
-    "items",
-    "item",
+    "work", "works", "job", "jobs", "task", "tasks", "stuff", "things",
+    "thing", "info", "information", "details", "data", "content",
+    "material", "materials", "activities", "activity", "efforts", "effort",
+    "options", "option", "choices", "choice", "results", "result",
+    "output", "outputs", "products", "product", "items", "item",
 }
 
 # Capitalized single words that are too generic to be proper nouns
 _GENERIC_CAPS = {
-    "works",
-    "items",
-    "things",
-    "stuff",
-    "resources",
-    "options",
-    "tips",
-    "ideas",
-    "steps",
-    "ways",
-    "methods",
-    "tools",
-    "features",
-    "benefits",
-    "examples",
-    "details",
-    "notes",
-    "instructions",
-    "guidelines",
-    "recommendations",
-    "suggestions",
-    "overview",
-    "summary",
-    "conclusion",
-    "introduction",
-    "pros",
-    "cons",
-    "advantages",
-    "disadvantages",
+    "works", "items", "things", "stuff", "resources", "options", "tips",
+    "ideas", "steps", "ways", "methods", "tools", "features", "benefits",
+    "examples", "details", "notes", "instructions", "guidelines",
+    "recommendations", "suggestions", "overview", "summary", "conclusion",
+    "introduction", "pros", "cons", "advantages", "disadvantages",
 }
 
 # Markdown/formatting markers to skip during extraction
@@ -390,208 +120,121 @@ def _has_artifacts(txt: str) -> bool:
     )
 
 
-def _clean_text(txt: str) -> str:
-    txt = re.sub(r"^\*+\s*|\s*\*+$", "", txt.strip())
-    txt = re.sub(r"\s*:+$", "", txt)
-    txt = re.sub(r"^\d+\s*\.\s*", "", txt)
-    return " ".join(txt.split())
+def extract_entities(text: str) -> List[Tuple[str, str]]:
+    """Extract named entities, quoted text, and noun compounds from text.
+
+    This is the public API that accepts a string. It loads the spaCy model
+    internally and delegates to _extract_entities_from_doc().
+
+    Args:
+        text: Input text to extract entities from.
+
+    Returns:
+        Deduplicated list of (entity_type, entity_text) tuples.
+        Entity types: PROPER, QUOTED, COMPOUND, NOUN.
+        Returns empty list if spaCy is unavailable.
+    """
+    from mem0.utils.spacy_models import get_nlp_full
+
+    nlp = get_nlp_full()
+    if nlp is None:
+        return []
+
+    doc = nlp(text)
+    return _extract_entities_from_doc(doc)
 
 
-def _norm_text(txt: str) -> str:
-    return " ".join(txt.lower().split())
+def extract_entities_batch(texts: List[str], batch_size: int = 32) -> List[List[Tuple[str, str]]]:
+    """Extract entities from multiple texts using spaCy's nlp.pipe() for batched NER.
+
+    Uses spaCy's efficient batch processing pipeline instead of calling
+    nlp() individually per text. Significantly faster for multiple texts.
+
+    Args:
+        texts: List of input texts to extract entities from.
+        batch_size: Number of texts to process in each spaCy batch.
+
+    Returns:
+        List of entity lists, one per input text. Each entity list contains
+        (entity_type, entity_text) tuples. Returns list of empty lists if
+        spaCy is unavailable.
+    """
+    if not texts:
+        return []
+
+    from mem0.utils.spacy_models import get_nlp_full
+
+    nlp = get_nlp_full()
+    if nlp is None:
+        return [[] for _ in texts]
+
+    results = []
+    for doc in nlp.pipe(texts, batch_size=batch_size):
+        results.append(_extract_entities_from_doc(doc))
+    return results
 
 
-def _looks_like_technical_identifier(text: str) -> bool:
-    return bool(re.fullmatch(r"[A-Za-z_][\w-]*(?:\.[A-Za-z_][\w-]*)+", text))
+def _extract_entities_from_doc(doc) -> List[Tuple[str, str]]:
+    """Extract entities from a spaCy Doc object.
 
-
-def _has_internal_cap_or_digit(text: str) -> bool:
-    return any(ch.isdigit() for ch in text) or any(ch.isupper() for ch in text[1:])
-
-
-def _looks_like_metric_count_token(tok) -> bool:
-    return tok.pos_ == "NUM" and bool(re.fullmatch(r"\d[\d,]*(?:\.\d+)?", tok.text))
-
-
-def _is_metric_list_context(tokens: list, idx: int) -> bool:
-    prev_text = tokens[idx - 1].text if idx > 0 else ""
-    next_text = tokens[idx + 1].text if idx + 1 < len(tokens) else ""
-    return prev_text in {":", ",", ";"} or next_text in {",", ";"}
-
-
-def _strip_trailing_metric_counts(span_tokens: list, all_tokens: list) -> list:
-    while len(span_tokens) > 1 and _looks_like_metric_count_token(span_tokens[-1]):
-        tok = span_tokens[-1]
-        if "," not in tok.text and not _is_metric_list_context(all_tokens, tok.i):
-            break
-        span_tokens = span_tokens[:-1]
-    return span_tokens
-
-
-def _is_list_item_name_token(tokens: list, idx: int) -> bool:
-    tok = tokens[idx]
-    if not tok.text or tok.text in _FORMATTING_MARKERS or not tok.text[0].isupper():
-        return False
-    if not any(ch.isalpha() for ch in tok.text) or _is_bad_single_name_token(tok):
-        return False
-    next_tok = tokens[idx + 1] if idx + 1 < len(tokens) else None
-    if not next_tok or not _looks_like_metric_count_token(next_tok):
-        return False
-    return _is_metric_list_context(tokens, idx) or _is_metric_list_context(tokens, idx + 1)
-
-
-def _is_name_like_token(tok, tokens: list | None = None, idx: int | None = None) -> bool:
-    if not tok.text or tok.text in _FORMATTING_MARKERS:
-        return False
-    if not tok.text[0].isupper():
-        return False
-    if not any(ch.isalpha() for ch in tok.text):
-        return False
-    if _is_bad_single_name_token(tok):
-        return False
-    if tok.pos_ == "PROPN" or tok.tag_ in {"NNP", "NNPS"}:
-        return True
-    if tokens is not None and idx is not None and _is_list_item_name_token(tokens, idx):
-        return True
-    if _has_internal_cap_or_digit(tok.text):
-        return True
-    return (
-        tokens is not None
-        and idx is not None
-        and tok.pos_ == "NOUN"
-        and tok.dep_ not in {"compound", "amod"}
-        and not _is_sentence_start(tokens, idx)
-    )
-
-
-def _is_bad_single_name_token(tok) -> bool:
-    lower = tok.text.lower()
-    return lower in _GENERIC_SINGLE_ENTITY_TERMS or lower in _GENERIC_CAPS or tok.is_stop
-
-
-def _add_candidate(
-    candidates: list[_EntityCandidate],
-    entity_type: str,
-    text: str,
-    source: str,
-    start: int,
-    end: int,
-    confidence: float,
-    priority: int,
-) -> None:
-    cleaned = _clean_text(text)
-    if not cleaned or len(cleaned) <= 2 or _has_artifacts(cleaned):
-        return
-    candidates.append(
-        _EntityCandidate(
-            entity_type=entity_type,
-            text=cleaned,
-            source=source,
-            start=start,
-            end=end,
-            confidence=confidence,
-            priority=priority,
-        )
-    )
-
-
-def _add_ner_candidates(doc, candidates: list[_EntityCandidate]) -> None:
+    Ported from platform's shared.core.utils.entity_extraction.extract_entities().
+    """
+    entities: List[Tuple[str, str]] = []
+    text = doc.text
     tokens = list(doc)
-    for ent in doc.ents:
-        if ent.label_ in _REJECTED_NER_LABELS or ent.label_ not in _ACCEPTED_NER_LABELS:
-            continue
-        ent_tokens = _strip_trailing_metric_counts(list(ent), tokens)
-        if not ent_tokens:
-            continue
-        if any(tok.pos_ == "CCONJ" and tok.text.lower() == "and" for tok in ent_tokens):
-            continue
-        if len(ent_tokens) == 1 and _is_bad_single_name_token(ent_tokens[0]):
-            continue
-        if (
-            len(ent_tokens) == 1
-            and ent_tokens[0].dep_ in {"compound", "amod"}
-            and ent_tokens[0].head.pos_ in {"NOUN", "PROPN"}
-        ):
-            continue
-        _add_candidate(
-            candidates,
-            "PROPER",
-            "".join(tok.text_with_ws for tok in ent_tokens).strip(),
-            "spacy_ner",
-            ent_tokens[0].i,
-            ent_tokens[-1].i + 1,
-            0.95,
-            0,
-        )
 
-
-def _add_technical_identifier_candidates(tokens: list, candidates: list[_EntityCandidate]) -> None:
-    for tok in tokens:
-        if _looks_like_technical_identifier(tok.text):
-            _add_candidate(
-                candidates,
-                "IDENTIFIER",
-                tok.text,
-                "technical_identifier",
-                tok.i,
-                tok.i + 1,
-                0.9,
-                1,
-            )
-
-
-def _add_proper_name_candidates(tokens: list, candidates: list[_EntityCandidate]) -> None:
-    allowed_inner_connectors = {"of", "the", "for", "at", "in"}
+    # === PROPER NOUN SEQUENCES ===
     i = 0
     while i < len(tokens):
         tok = tokens[i]
-        if not _is_name_like_token(tok, tokens, i):
+        if tok.text in _FORMATTING_MARKERS:
             i += 1
             continue
+        is_cap = tok.text and tok.text[0].isupper()
+        is_label = i + 1 < len(tokens) and tokens[i + 1].text == ":"
 
-        span_tokens = [tok]
-        j = i + 1
-        while j < len(tokens):
-            current = tokens[j]
-            if _is_name_like_token(current, tokens, j):
-                span_tokens.append(current)
-                j += 1
-                continue
-            if (
-                current.text.lower() in allowed_inner_connectors
-                and j + 1 < len(tokens)
-                and _is_name_like_token(tokens[j + 1], tokens, j + 1)
-            ):
-                span_tokens.extend([current, tokens[j + 1]])
-                j += 2
-                continue
-            break
+        if is_cap and not is_label and tok.pos_ in {"PROPN", "NOUN", "ADJ"}:
+            seq = [(tok, i)]
+            j = i + 1
+            while j < len(tokens):
+                t = tokens[j]
+                if (t.text and t.text[0].isupper()) or t.text.lower() in {
+                    "'s", "of", "the", "in", "and", "for", "at", "is",
+                }:
+                    seq.append((t, j))
+                    j += 1
+                else:
+                    break
+            # Strip trailing function words
+            while seq and seq[-1][0].text.lower() in {"of", "the", "in", "and", "for", "at", "is", "'s"}:
+                seq.pop()
+            if seq:
+                has_mid_cap = any(
+                    not _is_sentence_start(tokens, idx)
+                    for (t, idx) in seq
+                    if t.text[0].isupper() and t.text.lower() not in {"'s", "of", "the", "in", "and", "for", "at", "is"}
+                )
+                if has_mid_cap:
+                    phrase = "".join(t.text_with_ws for (t, idx) in seq).strip()
+                    if len(phrase) > 2:
+                        entities.append(("PROPER", phrase))
+            i = j
+        else:
+            i += 1
 
-        name_tokens = [
-            t
-            for t in span_tokens
-            if _is_name_like_token(t, tokens, t.i) or (0 <= t.i < len(tokens) and _is_list_item_name_token(tokens, t.i))
-        ]
-        if len(name_tokens) > 1 or not _is_bad_single_name_token(name_tokens[0]):
-            text = "".join(t.text_with_ws for t in span_tokens).strip()
-            _add_candidate(candidates, "PROPER", text, "proper_name_span", i, j, 0.8, 2)
-        i = max(j, i + 1)
-
-
-def _add_quoted_candidates(text: str, candidates: list[_EntityCandidate]) -> None:
+    # === QUOTED TEXT ===
     for m in re.finditer(r'"([^"]+)"', text):
         if len(m.group(1).strip()) > 2:
-            _add_candidate(candidates, "QUOTED", m.group(1).strip(), "quoted", -1, -1, 0.75, 3)
+            entities.append(("QUOTED", m.group(1).strip()))
     for m in re.finditer(r"(?:^|[\s\(\[{,;])'([^']+)'(?=[\s\.,;:!?\)\]]|$)", text):
         if len(m.group(1).strip()) > 2:
-            _add_candidate(candidates, "QUOTED", m.group(1).strip(), "quoted", -1, -1, 0.75, 3)
+            entities.append(("QUOTED", m.group(1).strip()))
 
-
-def _add_topic_phrase_candidates(doc, candidates: list[_EntityCandidate]) -> None:
+    # === NOUN-NOUN COMPOUNDS ===
     for chunk in doc.noun_chunks:
         chunk_tokens = list(chunk)
-        split_indices: list[int] = []
-        poss_splits: list[int] = []
+        split_indices: list = []
+        poss_splits: list = []
         for idx, tok in enumerate(chunk_tokens):
             if tok.dep_ == "case" and tok.text in {"'s", "\u2019s", "'"}:
                 split_indices.append(idx)
@@ -600,14 +243,14 @@ def _add_topic_phrase_candidates(doc, candidates: list[_EntityCandidate]) -> Non
                 split_indices.append(idx)
 
         if split_indices:
-            groups: list[list] = []
+            groups: list = []
             prev = 0
             for split_idx in split_indices:
                 if split_idx > prev:
                     groups.append(chunk_tokens[prev:split_idx])
                 if split_idx in poss_splits:
                     next_split = next((s for s in split_indices if s > split_idx), None)
-                    owned = chunk_tokens[split_idx + 1 : next_split if next_split else len(chunk_tokens)]
+                    owned = chunk_tokens[split_idx + 1: next_split if next_split else len(chunk_tokens)]
                     if owned:
                         first_content = next((t for t in owned if t.pos_ not in {"PUNCT", "PART"}), None)
                         if not (first_content and first_content.text and first_content.text[0].isupper()):
@@ -629,8 +272,7 @@ def _add_topic_phrase_candidates(doc, candidates: list[_EntityCandidate]) -> Non
             content = [
                 t
                 for t in group
-                if t.pos_ not in {"DET", "PRON", "PUNCT", "PART", "ADP", "SCONJ", "NUM"}
-                and (t.pos_ == "ADJ" or not t.is_stop)
+                if t.pos_ not in {"DET", "PRON", "PUNCT", "PART", "ADP", "SCONJ", "NUM"} and (t.pos_ == "ADJ" or not t.is_stop)
             ]
             if not content:
                 continue
@@ -644,129 +286,72 @@ def _add_topic_phrase_candidates(doc, candidates: list[_EntityCandidate]) -> Non
             if compound_toks:
                 is_circ = any(t.lemma_.lower() in _CIRCUMSTANTIAL_MODS for t in compound_toks)
                 if is_circ:
-                    val = head.text
+                    val = head.lemma_ if head.pos_ == "NOUN" else head.text
                     if len(val) > 2:
-                        _add_candidate(
-                            candidates,
-                            "TOPIC",
-                            val,
-                            "topic_phrase",
-                            head.i,
-                            head.i + 1,
-                            0.45,
-                            4,
-                        )
+                        entities.append(("NOUN", val))
                 else:
                     filtered = _strip_generic_ending(
                         [t for t in content if not (t.pos_ == "ADJ" and t.lemma_.lower() in _NON_SPECIFIC_ADJ)]
                     )
                     if filtered:
-                        phrase = " ".join(t.text for t in filtered)
+                        phrase = _lemmatize_compound(filtered)
                         if len(phrase) > 3 and " " in phrase:
-                            _add_candidate(
-                                candidates,
-                                "TOPIC",
-                                phrase,
-                                "topic_phrase",
-                                filtered[0].i,
-                                filtered[-1].i + 1,
-                                0.45,
-                                4,
-                            )
+                            entities.append(("COMPOUND", phrase))
             elif len(content) > 1 and has_spec_adj:
                 filtered = _strip_generic_ending(
-                    [
-                        t
-                        for t in content
-                        if not ((t.pos_ == "ADJ" or t.dep_ == "amod") and t.lemma_.lower() in _NON_SPECIFIC_ADJ)
-                    ]
+                    [t for t in content if not ((t.pos_ == "ADJ" or t.dep_ == "amod") and t.lemma_.lower() in _NON_SPECIFIC_ADJ)]
                 )
                 if filtered:
-                    phrase = " ".join(t.text for t in filtered)
+                    phrase = _lemmatize_compound(filtered)
                     if len(phrase) > 3 and " " in phrase:
-                        _add_candidate(
-                            candidates,
-                            "TOPIC",
-                            phrase,
-                            "topic_phrase",
-                            filtered[0].i,
-                            filtered[-1].i + 1,
-                            0.45,
-                            4,
-                        )
+                        entities.append(("COMPOUND", phrase))
 
+    # === FALLBACK: Mis-tagged VERB heads ===
+    processed = {e[1].lower() for e in entities if e[0] == "COMPOUND"}
+    generic_verb_heads = _GENERIC_HEADS | {"find", "buy", "purchase", "sale", "deal", "trip", "visit"}
 
-def _spans_overlap(a: _EntityCandidate, b: _EntityCandidate) -> bool:
-    if a.start < 0 or b.start < 0:
-        return False
-    return a.start < b.end and b.start < a.end
+    def collect_compounds(head):
+        return [t for t in doc if t.head == head and t.dep_ == "compound"]
 
+    for tok in doc:
+        if tok.pos_ == "VERB" and tok.dep_ in {"pobj", "dobj", "nsubj"}:
+            comps = sorted(collect_compounds(tok), key=lambda t: t.i)
+            if comps:
+                phrase_toks = comps if tok.lemma_.lower() in generic_verb_heads else comps + [tok]
+                phrase = " ".join(t.text for t in phrase_toks)
+                if phrase.lower() not in processed and len(phrase) > 3 and " " in phrase:
+                    entities.append(("COMPOUND", phrase))
+                    processed.add(phrase.lower())
 
-def _resolve_candidates(candidates: list[_EntityCandidate]) -> list[tuple[str, str]]:
-    deduped_by_text: dict[str, _EntityCandidate] = {}
-    for candidate in candidates:
-        key = _norm_text(candidate.text)
-        current = deduped_by_text.get(key)
-        if current is None or (candidate.priority, -candidate.confidence) < (current.priority, -current.confidence):
-            deduped_by_text[key] = candidate
+    # === DEDUPLICATION & CLEANUP ===
+    seen: set = set()
+    deduped = []
+    for t, e in entities:
+        k = e.lower().strip()
+        if k not in seen and len(k) > 2:
+            seen.add(k)
+            deduped.append((t, e))
 
-    ordered = sorted(
-        deduped_by_text.values(),
-        key=lambda c: (c.priority, -c.confidence, -(c.end - c.start), c.start),
-    )
-    accepted: list[_EntityCandidate] = []
-    for candidate in ordered:
-        if any(
-            _spans_overlap(candidate, existing)
-            and not (candidate.entity_type == "TOPIC" and " " in candidate.text and existing.entity_type == "PROPER")
-            for existing in accepted
-        ):
+    cleaned: List[Tuple[str, str]] = []
+    for etype, etext in deduped:
+        txt = re.sub(r"^\*+\s*|\s*\*+$", "", etext.strip())
+        txt = re.sub(r"\s*:+$", "", txt)
+        txt = re.sub(r"^\d+\s*\.\s*", "", txt)
+        if not txt or len(txt) <= 2 or _has_artifacts(txt):
             continue
-        accepted.append(candidate)
+        if etype == "PROPER" and " " not in txt and txt.lower() in _GENERIC_CAPS:
+            continue
+        cleaned.append((etype, txt))
 
-    accepted.sort(key=lambda c: (c.start if c.start >= 0 else 10**9, c.end, c.priority))
-    return [(candidate.entity_type, candidate.text) for candidate in accepted]
+    # Keep best type per entity (PROPER > COMPOUND > QUOTED > NOUN)
+    type_pri = {"PROPER": 0, "COMPOUND": 1, "QUOTED": 2, "NOUN": 3, "VERB": 4}
+    best: dict = {}
+    for t, e in cleaned:
+        k = e.lower()
+        if k not in best or type_pri.get(t, 99) < type_pri.get(best[k][0], 99):
+            best[k] = (t, e)
+    deduped = list(best.values())
 
-
-def _extract_entities_from_doc(doc) -> list[tuple[str, str]]:
-    """Extract typed entity candidates from a spaCy Doc.
-
-    Args:
-        doc: A spaCy ``Doc`` object (from ``nlp(text)``).
-
-    Returns:
-        Deduplicated list of ``(entity_type, entity_text)`` tuples.
-        Entity types include PROPER, QUOTED, TOPIC, and IDENTIFIER.
-    """
-    tokens = list(doc)
-    candidates: list[_EntityCandidate] = []
-    _add_ner_candidates(doc, candidates)
-    _add_technical_identifier_candidates(tokens, candidates)
-    _add_proper_name_candidates(tokens, candidates)
-    _add_quoted_candidates(doc.text, candidates)
-    _add_topic_phrase_candidates(doc, candidates)
-    return _resolve_candidates(candidates)
-
-
-def extract_entities(text: str) -> list[tuple[str, str]]:
-    """Extract typed entity candidates from text."""
-    from mem0.utils.spacy_models import get_nlp_full
-
-    nlp = get_nlp_full()
-    if nlp is None:
-        return []
-    return _extract_entities_from_doc(nlp(text))
-
-
-def extract_entities_batch(texts: list[str], batch_size: int = 32) -> list[list[tuple[str, str]]]:
-    """Extract typed entity candidates from multiple texts."""
-    if not texts:
-        return []
-
-    from mem0.utils.spacy_models import get_nlp_full
-
-    nlp = get_nlp_full()
-    if nlp is None:
-        return [[] for _ in texts]
-
-    return [_extract_entities_from_doc(doc) for doc in nlp.pipe(texts, batch_size=batch_size)]
+    # Remove entities that are substrings of longer entities
+    all_lower = [e[1].lower() for e in deduped]
+    return [(t, e) for t, e in deduped if not any(e.lower() != o and e.lower() in o for o in all_lower)]