fix(pi-agent-plugin): correct repository.url for npm provenance validation (#5473)

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

.claude-plugin/marketplace.json

@@ -12,7 +12,7 @@
       "name": "mem0",
       "source": "./mem0-plugin",
       "description": "Mem0 memory layer for AI applications. Add persistent memory, personalization, and semantic search to Claude workflows.",
-      "version": "0.2.8"
+      "version": "0.2.9"
     }
   ]
 }

.cursor-plugin/marketplace.json

@@ -12,7 +12,7 @@
       "name": "mem0",
       "source": "./mem0-plugin",
       "description": "Mem0 memory layer for AI applications. Add persistent memory, personalization, and semantic search.",
-      "version": "0.2.8"
+      "version": "0.2.9"
     }
   ]
 }

.github/workflows/cd.yml

@@ -7,7 +7,9 @@ on:
 jobs:
   build-n-publish:
     name: Build and publish Python 🐍 distributions 📦 to PyPI and TestPyPI
-    if: startsWith(github.event.release.tag_name, 'v')
+    # Pure SDK version tags only (v1.2.3) — excludes package-prefixed tags
+    # like vercel-ai-v* that also start with 'v'
+    if: startsWith(github.event.release.tag_name, 'v') && !contains(github.event.release.tag_name, '-v')
     runs-on: ubuntu-latest
     permissions:
       id-token: write
@@ -39,7 +41,7 @@ jobs:
       #     packages_dir: dist/
 
       - name: Publish distribution 📦 to PyPI
-        if: startsWith(github.ref, 'refs/tags/v')
+        if: startsWith(github.ref, 'refs/tags/v') && !contains(github.ref, '-v')
         uses: pypa/gh-action-pypi-publish@release/v1
         with:
           packages_dir: dist/

.github/workflows/pi-agent-plugin-cd.yml

@@ -0,0 +1,46 @@
+name: Publish @mem0/pi-agent-plugin 📦 to npm
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  build-n-publish:
+    name: Build and publish @mem0/pi-agent-plugin 📦 to npm
+    if: startsWith(github.event.release.tag_name, 'pi-agent-v')
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+    defaults:
+      run:
+        working-directory: pi-agent-plugin
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          version: 9
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+          registry-url: 'https://registry.npmjs.org'
+          cache: 'pnpm'
+          cache-dependency-path: pi-agent-plugin/pnpm-lock.yaml
+
+      - name: Install dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: Build
+        run: pnpm build
+
+      - name: Publish to npm
+        run: |
+          if [ "${{ github.event.release.prerelease }}" = "true" ]; then
+            PREID=$(node -p "require('./package.json').version.split('-')[1].split('.')[0]")
+            npx npm@latest publish --provenance --access public --tag "$PREID"
+          else
+            npx npm@latest publish --provenance --access public
+          fi

.github/workflows/pi-agent-plugin-checks.yml

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

AGENTS.md

@@ -414,6 +414,7 @@ To add a new LLM, embedding, vector store, or reranker provider:
 | Node CLI | `cli-node-ci.yml` | Push to `cli/node/`, PRs, manual | Biome lint + tsc + vitest + tsup build on Node 20, 22 |
 | OpenClaw | `openclaw-checks.yml` | Push to `openclaw/`, PRs, manual | tsc + vitest (with Codecov) + tsup build on Node 20, 22 |
 | OpenCode Plugin | `opencode-plugin-checks.yml` | Push to `mem0-plugin/.opencode-plugin/`, PRs, manual | Bun: tsc type-check + build + dist artifact check |
+| Pi Agent Plugin | `pi-agent-plugin-checks.yml` | Push to `pi-agent-plugin/`, PRs, manual | tsc + vitest + tsup build (dist artifact check) on Node 20, 22 |
 
 ### CD Workflows (automated publishing)
 
@@ -426,6 +427,7 @@ To add a new LLM, embedding, vector store, or reranker provider:
 | Vercel AI SDK | `vercel-ai-cd.yml` | `vercel-ai-v*` | npm (`@mem0/vercel-ai-provider`) |
 | OpenClaw | `openclaw-cd.yml` | `openclaw-v*` | npm (`@mem0/openclaw-mem0`) |
 | OpenCode Plugin | `opencode-plugin-cd.yml` | `opencode-v*` | npm (`@mem0/opencode-plugin`) |
+| Pi Agent Plugin | `pi-agent-plugin-cd.yml` | `pi-agent-v*` | npm (`@mem0/pi-agent-plugin`) |
 
 - All publishing uses **OIDC trusted publishing** — no tokens or secrets required.
 - First publish of a new npm package must be done manually; OIDC works for subsequent versions.

cli/node/package.json

@@ -40,7 +40,8 @@
     "typescript": "^5.4.0",
     "tsup": "^8.0.0",
     "tsx": "^4.7.0",
-    "vitest": "^1.5.0",
+    "vite": "^6.0.0",
+    "vitest": "^4.1.0",
     "@biomejs/biome": "^1.7.0",
     "@types/node": "^20.0.0"
   }

docs/changelog/sdk.mdx

@@ -1489,6 +1489,29 @@ A full-featured command-line interface for Mem0, available in both Python and No
 
 </Update>
 
+<Update label="2026-06-10" description="Vercel AI SDK v3.0.0">
+
+**Major Release** — Migrated to Vercel AI SDK v6 (`LanguageModelV3` / `ProviderV3`) and Mem0 v3 API.
+
+**Breaking Changes:**
+- **AI SDK v6:** Upgraded from AI SDK v5 (`LanguageModelV2`) to v6 (`LanguageModelV3`). Users must upgrade `ai` to `^6.0.199` and all `@ai-sdk/*` provider packages to `^3.x` ([#4741](https://github.com/mem0ai/mem0/pull/4741))
+- **Mem0 v3 API:** Memory endpoints migrated from `/v1/memories/` and `/v2/memories/search/` to `/v3/memories/add/` and `/v3/memories/search/`. Entity IDs (`user_id`, `agent_id`, `run_id`) now go inside the `filters` object for search requests ([#4741](https://github.com/mem0ai/mem0/pull/4741))
+- **Graph memory removed:** All `enable_graph`, graph prompts, and relation-extraction code removed. Graph memory is now a project-level setting on the Platform ([#4741](https://github.com/mem0ai/mem0/pull/4741))
+- **Deprecated params removed:** `org_id`, `project_id`, `org_name`, `project_name`, `output_format`, `filter_memories`, `async_mode`, `enable_graph`, `version`, `api_version` removed from `Mem0ConfigSettings` ([#4741](https://github.com/mem0ai/mem0/pull/4741))
+
+**New Features:**
+- **V3 provider contract:** `specificationVersion: 'v3'`, `supportedUrls` property, V3 content array in `doGenerate`, V3 stream lifecycle events in `doStream` ([#4741](https://github.com/mem0ai/mem0/pull/4741))
+- **Mem0 source in responses:** Memories are attached as a `source` in `generateText`/`streamText` responses with `providerMetadata.mem0.memories` for programmatic access ([#4741](https://github.com/mem0ai/mem0/pull/4741))
+
+**Bug Fixes:**
+- **Async memory storage:** `addMemories` is now properly `await`ed — memories no longer silently fail to store ([#4741](https://github.com/mem0ai/mem0/pull/4741))
+- **Prompt mutation:** Prompt array is now cloned before injecting memory context, preventing side effects on the caller's array ([#4741](https://github.com/mem0ai/mem0/pull/4741))
+- **Null guard on content:** `doGenerate` guards against null `content` from upstream providers ([#4741](https://github.com/mem0ai/mem0/pull/4741))
+- **Stream response:** `doStream` now returns the full `LanguageModelV3StreamResult` object preserving all V3 fields ([#4741](https://github.com/mem0ai/mem0/pull/4741))
+- **Response normalization:** `getMemories` and `retrieveMemories` now handle both array and `{results: [...]}` envelope responses from the v3 API ([#4741](https://github.com/mem0ai/mem0/pull/4741))
+
+</Update>
+
 <Update label="2026-06-01" description="Vercel AI SDK v2.0.6">
 
 **Security:**

docs/components/vectordbs/dbs/neon.mdx

@@ -0,0 +1,156 @@
+---
+title: "Neon"
+description: "Use Neon as a vector store in Mem0, powered by PostgreSQL and pgvector."
+---
+
+Use [Neon](https://neon.com/) as a vector store in Mem0, powered by PostgreSQL and the
+[pgvector extension](https://neon.com/docs/extensions/pgvector).
+
+Neon is a serverless Postgres platform. Since Mem0 supports Postgres through the
+`pgvector` provider, Neon can be used with a standard Postgres connection string.
+
+## Usage
+
+<CodeGroup>
+```python Python
+import os
+
+from dotenv import load_dotenv
+from mem0 import Memory
+
+load_dotenv()
+
+config = {
+    "vector_store": {
+        "provider": "pgvector",
+        "config": {
+            "connection_string": os.environ["DATABASE_URL"],
+            "collection_name": "memories",
+            "embedding_model_dims": 1536,
+            "hnsw": True,
+        },
+    },
+}
+
+m = Memory.from_config(config)
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
+    {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
+    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."},
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
+
+results = m.search(
+    "What movies should I recommend?",
+    filters={"user_id": "alice"},
+)
+
+print(results)
+```
+
+```typescript TypeScript
+import "dotenv/config";
+import { Memory } from "mem0ai/oss";
+
+const databaseUrl = new URL(process.env.DATABASE_URL!);
+
+const m = new Memory({
+  vectorStore: {
+    provider: "pgvector",
+    config: {
+      user: decodeURIComponent(databaseUrl.username),
+      password: decodeURIComponent(databaseUrl.password),
+      host: databaseUrl.hostname,
+      port: Number(databaseUrl.port || 5432),
+      dbname: databaseUrl.pathname.slice(1) || "neondb",
+      collectionName: "memories",
+      dimension: 1536,
+      embeddingModelDims: 1536,
+      hnsw: true,
+    },
+  },
+});
+
+const messages = [
+  { role: "user" as const, content: "I'm planning to watch a movie tonight. Any recommendations?" },
+  { role: "assistant" as const, content: "How about thriller movies? They can be quite engaging." },
+  { role: "user" as const, content: "I'm not a big fan of thriller movies but I love sci-fi movies." },
+  { role: "assistant" as const, content: "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future." },
+];
+
+await m.add(messages, {
+  userId: "alice",
+  metadata: { category: "movies" },
+});
+
+const results = await m.search("What movies should I recommend?", {
+  filters: { user_id: "alice" },
+});
+
+console.log(results);
+```
+</CodeGroup>
+
+## SQL Migration
+
+You don't need to run any SQL migrations. Mem0 creates the collection table when it initializes the `pgvector` store.
+
+## Environment
+
+```env
+OPENAI_API_KEY=sk-xx...
+DATABASE_URL=postgresql://user:password@ep-example.us-east-2.aws.neon.tech/neondb?sslmode=require
+```
+
+## Config
+
+<Tabs>
+<Tab title="Python">
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `connection_string` | Neon Postgres connection string. | Required |
+| `collection_name` | Name for the vector collection. | `mem0` |
+| `embedding_model_dims` | Embedding model dimensions. | `1536` |
+| `hnsw` | Enables HNSW indexing. | `False` |
+| `sslmode` | PostgreSQL SSL mode. Use `require` for Neon. | Driver default |
+</Tab>
+<Tab title="TypeScript">
+The current Mem0 TypeScript `pgvector` adapter takes individual Postgres fields,
+so parse `DATABASE_URL` before creating `Memory`.
+
+| Parameter | Description | Default |
+| --- | --- | --- |
+| `user` | Database user. | Required |
+| `password` | Database password. | Required |
+| `host` | Database host. | Required |
+| `port` | Database port. | `5432` |
+| `dbname` | Database name. | `vector_store` |
+| `collectionName` | Name for the vector collection. | `memories` |
+| `dimension` | Vector dimension for Mem0 config. | Auto-detected |
+| `embeddingModelDims` | Embedding model dimensions for table creation. | Required |
+| `hnsw` | Enables HNSW indexing. | `false` |
+</Tab>
+</Tabs>
+
+### Indexing
+
+The `pgvector` provider can create an HNSW index for faster vector search.
+
+- Set `hnsw` to `true` to enable a Hierarchical Navigable Small World index.
+- Leave `hnsw` as `false` if you want to create or manage indexes yourself.
+
+### Similarity Search
+
+The `pgvector` provider uses cosine similarity for vector search. Make sure your
+embedding dimensions match the configured `embedding_model_dims` value.
+
+### Best Practices
+
+1. **Index Selection**:
+   - Use `hnsw` for faster search performance when memory usage is not a constraint
+   - Manage indexes manually if you need a different pgvector index strategy
+
+2. **Connection String**:
+   - Always use environment variables or even better, a secret manager for sensitive information in the connection string
+   - Format: `postgresql://user:password@host:port/database`

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

@@ -156,6 +156,33 @@ const memories = memory.search("food preferences", {
   On Mem0 Platform v3, time-aware queries use Temporal Reasoning internally while preserving the normal search response shape. See <Link href="/platform/features/temporal-reasoning">Temporal Reasoning</Link>.
 </Note>
 
+### Explain OSS search scores
+
+OSS search combines semantic similarity with optional keyword and entity signals. Pass `explain=True` when tuning retrieval quality or debugging why a memory ranked where it did:
+
+<CodeGroup>
+```python Python
+results = m.search(
+    "food preferences",
+    filters={"user_id": "alice"},
+    explain=True,
+)
+
+print(results["results"][0]["score_details"])
+```
+
+```javascript JavaScript
+const results = await memory.search("food preferences", {
+    filters: { user_id: "alice" },
+    explain: true,
+});
+
+console.log(results.results[0].score_details);
+```
+</CodeGroup>
+
+Each result includes `score_details` with the semantic score, normalized BM25 score, entity boost, raw combined score, maximum possible score, final score, and threshold used for filtering. The field is omitted unless `explain` is enabled, so existing response shapes stay unchanged.
+
 ## Filter patterns
 
 Filters help narrow down search results. Common use cases:

docs/docs.json

@@ -143,7 +143,8 @@
                     "icon": "robot",
                     "pages": [
                       "integrations/openclaw",
-                      "integrations/hermes"
+                      "integrations/hermes",
+                      "integrations/pi-agent"
                     ]
                   }
                 ]
@@ -245,6 +246,7 @@
                               "components/vectordbs/dbs/cassandra",
                               "components/vectordbs/dbs/s3_vectors",
                               "components/vectordbs/dbs/databricks",
+                              "components/vectordbs/dbs/neon",
                               "components/vectordbs/dbs/neptune_analytics",
                               "components/vectordbs/dbs/turbopuffer"
                             ]
@@ -302,7 +304,8 @@
                     "group": "Migration",
                     "icon": "arrow-right",
                     "pages": [
-                      "migration/oss-v2-to-v3"
+                      "migration/oss-v2-to-v3",
+                      "migration/server-pgvector-upgrade"
                     ]
                   },
                   {
@@ -462,7 +465,8 @@
                     "icon": "robot",
                     "pages": [
                       "integrations/openclaw",
-                      "integrations/hermes"
+                      "integrations/hermes",
+                      "integrations/pi-agent"
                     ]
                   }
                 ]

docs/integrations/google-ai-adk.mdx

@@ -7,285 +7,338 @@ Integrate [**Mem0**](https://github.com/mem0ai/mem0) with [Google ADK (Agent Dev
 
 ## Overview
 
-1. Store and retrieve memories from Mem0 within Google ADK agents
-2. Multi-agent workflows with shared memory across hierarchies
-3. Retrieve relevant memories from past conversations
-4. Personalized responses based on user history
+In this guide, we'll create a Google ADK agent that:
+1. Uses ADK's native `MemoryService` interface to connect Mem0
+2. Automatically injects relevant memories using ADK's built-in `load_memory` tool
+3. Persists session history to Mem0 after each turn via an after-agent callback
+4. Shares memory seamlessly across multi-agent hierarchies
 
-## Prerequisites
+## Setup and Configuration
 
-Before setting up Mem0 with Google ADK, ensure you have:
+Install the necessary libraries:
 
-1. Installed the required packages:
 ```bash
 pip install google-adk mem0ai python-dotenv
 ```
 
-2. Valid API keys:
+Set up your API keys:
    - <a href="https://app.mem0.ai/dashboard/api-keys?utm_source=oss&utm_medium=integration-google-ai-adk" rel="nofollow">Mem0 API Key</a>
    - Google AI Studio API Key
 
-## Basic Integration Example
-
-The following example demonstrates how to create a Google ADK agent with Mem0 memory integration:
+<Note>Remember to get your API key from <a href="https://app.mem0.ai" rel="nofollow">Mem0 Platform</a> and set up a [Google AI Studio API Key](https://aistudio.google.com/apikey).</Note>
 
 ```python
 import os
-import asyncio
-from google.adk.agents import Agent
-from google.adk.runners import Runner
-from google.adk.sessions import InMemorySessionService
-from google.genai import types
-from mem0 import MemoryClient
 from dotenv import load_dotenv
 
 load_dotenv()
 
-# Set up environment variables
 # os.environ["GOOGLE_API_KEY"] = "your-google-api-key"
 # os.environ["MEM0_API_KEY"] = "your-mem0-api-key"
+```
 
-# Initialize Mem0 client
-mem0 = MemoryClient()
+## Implement Mem0MemoryService
 
-# Define memory function tools
-def search_memory(query: str, user_id: str) -> dict:
-    """Search through past conversations and memories"""
-    # For Platform API, user_id goes in filters
-    filters = {"user_id": user_id}
-    memories = mem0.search(query, filters=filters)
-    if memories.get('results', []):
-        memory_list = memories['results']
-        memory_context = "\n".join([f"- {mem['memory']}" for mem in memory_list])
-        return {"status": "success", "memories": memory_context}
-    return {"status": "no_memories", "message": "No relevant memories found"}
+Create a custom `MemoryService` by implementing ADK's `BaseMemoryService`. Save the following as **`mem0_memory_service.py`**:
 
-def save_memory(content: str, user_id: str) -> dict:
-    """Save important information to memory"""
+```python
+import asyncio
+import os
+from typing import Optional
+from typing_extensions import override
+
+from google.adk.memory.base_memory_service import BaseMemoryService, SearchMemoryResponse
+from google.adk.memory.memory_entry import MemoryEntry
+from google.adk.sessions import Session
+from google.genai.types import Content, Part
+from mem0 import MemoryClient
+
+
+class Mem0MemoryService(BaseMemoryService):
+    """MemoryService implementation backed by the Mem0 Platform."""
+
+    def __init__(self, api_key: Optional[str] = None):
+        super().__init__()
+        api_key = api_key or os.environ.get("MEM0_API_KEY")
+        self._client: Optional[MemoryClient] = MemoryClient(api_key=api_key) if api_key else None
+
+    @override
+    async def search_memory(
+        self, *, app_name: str, user_id: str, query: str
+    ) -> SearchMemoryResponse:
+        """Search for memories relevant to the current user and query."""
+        if not self._client:
+            return SearchMemoryResponse(memories=[])
+
+        try:
+            results = await asyncio.to_thread(
+                self._client.search,
+                query,
+                filters={"AND": [{"user_id": user_id}, {"app_id": app_name}]},
+                top_k=5,
+            )
+
+            entries = []
+            for mem in results.get("results", []):
+                text = mem.get("memory", "")
+                if not text:
+                    continue
+
+                raw_ts = mem.get("created_at") or mem.get("updated_at")
+                entries.append(
+                    MemoryEntry(
+                        content=Content(parts=[Part(text=text)]),
+                        author=mem.get("metadata", {}).get("author", "user"),
+                        timestamp=str(raw_ts) if raw_ts else None,
+                    )
+                )
+
+            return SearchMemoryResponse(memories=entries)
+
+        except Exception as e:
+            print(f"[Mem0MemoryService] search_memory error: {e}")
+            return SearchMemoryResponse(memories=[])
+
+    @override
+    async def add_session_to_memory(self, session: Session) -> None:
+        """Persist a completed ADK session into Mem0."""
+        if not self._client:
+            return
+
+        user_id = session.user_id
+        if not user_id:
+            return
+
+        app_name = getattr(session, "app_name", None)
+
+        try:
+            messages = []
+            for event in session.events:
+                if not (event.content and event.content.parts):
+                    continue
+                role = getattr(event.content, "role", None) or "user"
+                if role == "model":
+                    role = "assistant"
+                elif role not in ("user", "assistant"):
+                    continue
+                text_parts = [
+                    p.text for p in event.content.parts if hasattr(p, "text") and p.text
+                ]
+                if text_parts:
+                    messages.append({"role": role, "content": " ".join(text_parts)})
+
+            if messages:
+                metadata = {"app_id": app_name} if app_name else {}
+                await asyncio.to_thread(
+                    self._client.add, messages, user_id=user_id, metadata=metadata
+                )
+
+        except Exception as e:
+            print(f"[Mem0MemoryService] add_session_to_memory error: {e}")
+```
+
+## Add Auto-Save Callback
+
+This after-agent callback fires at the end of every turn and saves the session to Mem0. Save as **`memory_callbacks.py`**:
+
+```python
+async def save_session_to_memory(callback_context) -> None:
+    """Persist the completed session to Mem0 after each agent turn."""
     try:
-        result = mem0.add([{"role": "user", "content": content}], user_id=user_id)
-        return {"status": "success", "message": "Information saved to memory", "result": result}
+        await callback_context.add_session_to_memory()
+    except ValueError:
+        pass
     except Exception as e:
-        return {"status": "error", "message": f"Failed to save memory: {str(e)}"}
+        print(f"[save_session_to_memory] error: {e}")
+```
 
-# Create agent with memory capabilities
-personal_assistant = Agent(
+## Basic Integration Example
+
+The following example demonstrates creating an ADK agent with automatic Mem0 memory:
+
+```python
+import asyncio
+from google.adk.agents import LlmAgent
+from google.adk.runners import Runner
+from google.adk.sessions import InMemorySessionService
+from google.adk.tools import load_memory
+from google.genai.types import Content, Part
+
+from mem0_memory_service import Mem0MemoryService
+from memory_callbacks import save_session_to_memory
+
+memory_service = Mem0MemoryService()
+session_service = InMemorySessionService()
+
+agent = LlmAgent(
     name="personal_assistant",
     model="gemini-2.0-flash",
-    instruction="""You are a helpful personal assistant with memory capabilities.
-    Use the search_memory function to recall past conversations and user preferences.
-    Use the save_memory function to store important information about the user.
-    Always personalize your responses based on available memory.""",
+    instruction="""You are a helpful personal assistant.
+    Relevant memories from past conversations are provided to you automatically.
+    Use them to personalize your responses.""",
     description="A personal assistant that remembers user preferences and past interactions",
-    tools=[search_memory, save_memory]
+    tools=[load_memory],
+    after_agent_callback=save_session_to_memory,
 )
 
-async def chat_with_agent(user_input: str, user_id: str) -> str:
-    """
-    Handle user input with automatic memory integration.
+runner = Runner(
+    agent=agent,
+    session_service=session_service,
+    memory_service=memory_service,
+    app_name="memory_assistant",
+)
 
-    Args:
-        user_input: The user's message
-        user_id: Unique identifier for the user
 
-    Returns:
-        The agent's response
-    """
-    # Set up session and runner
-    session_service = InMemorySessionService()
+async def chat(user_input: str, user_id: str) -> str:
     session = await session_service.create_session(
         app_name="memory_assistant",
         user_id=user_id,
-        session_id=f"session_{user_id}"
     )
-    runner = Runner(agent=personal_assistant, app_name="memory_assistant", session_service=session_service)
-
-    # Create content and run agent
-    content = types.Content(role='user', parts=[types.Part(text=user_input)])
-    events = runner.run(user_id=user_id, session_id=session.id, new_message=content)
-
-    # Extract final response
-    for event in events:
-        if event.is_final_response():
-            response = event.content.parts[0].text
-
-            return response
-
+    content = Content(role="user", parts=[Part(text=user_input)])
+    async for event in runner.run_async(user_id=user_id, session_id=session.id, new_message=content):
+        if event.is_final_response() and event.content and event.content.parts:
+            return event.content.parts[0].text
     return "No response generated"
 
-# Example usage
+
 if __name__ == "__main__":
-    response = asyncio.run(chat_with_agent(
+    print(asyncio.run(chat(
         "I love Italian food and I'm planning a trip to Rome next month",
-        user_id="alice"
-    ))
-    print(response)
+        user_id="alice",
+    )))
+
+    print(asyncio.run(chat(
+        "Any food recommendations for my trip?",
+        user_id="alice",
+    )))
 ```
 
 ## Multi-Agent Hierarchy with Shared Memory
 
-Create specialized agents in a hierarchy that share memory:
+Because `memory_service` is passed to the `Runner`, every agent in the hierarchy shares the same memory automatically. Only the root coordinator needs the auto-save callback — ADK fires it once when the full turn completes:
 
 ```python
+import asyncio
+from google.adk.agents import LlmAgent
+from google.adk.runners import Runner
+from google.adk.sessions import InMemorySessionService
 from google.adk.tools.agent_tool import AgentTool
+from google.adk.tools import load_memory
+from google.genai.types import Content, Part
 
-# Travel specialist agent
-travel_agent = Agent(
+from mem0_memory_service import Mem0MemoryService
+from memory_callbacks import save_session_to_memory
+
+memory_service = Mem0MemoryService()
+session_service = InMemorySessionService()
+
+travel_agent = LlmAgent(
     name="travel_specialist",
     model="gemini-2.0-flash",
-    instruction="""You are a travel planning specialist. Use search_memory to
-    understand the user's travel preferences and history before making recommendations.
-    After providing advice, use save_memory to save travel-related information.""",
+    instruction="""You are a travel planning specialist.
+    Relevant memories about the user's travel preferences are provided automatically.
+    Use them to make personalized recommendations.""",
     description="Specialist in travel planning and recommendations",
-    tools=[search_memory, save_memory]
+    tools=[load_memory],
 )
 
-# Health advisor agent
-health_agent = Agent(
+health_agent = LlmAgent(
     name="health_advisor",
     model="gemini-2.0-flash",
-    instruction="""You are a health and wellness advisor. Use search_memory to
-    understand the user's health goals and dietary preferences.
-    After providing advice, use save_memory to save health-related information.""",
+    instruction="""You are a health and wellness advisor.
+    Relevant memories about the user's health goals are provided automatically.
+    Use them to give personalized advice.""",
     description="Specialist in health and wellness advice",
-    tools=[search_memory, save_memory]
+    tools=[load_memory],
 )
 
-# Coordinator agent that delegates to specialists
-coordinator_agent = Agent(
+coordinator = LlmAgent(
     name="coordinator",
     model="gemini-2.0-flash",
     instruction="""You are a coordinator that delegates requests to specialist agents.
-    For travel-related questions (trips, hotels, flights, destinations), delegate to the travel specialist.
-    For health-related questions (fitness, diet, wellness, exercise), delegate to the health advisor.
-    Use search_memory to understand the user before delegation.""",
+    For travel-related questions, delegate to the travel specialist.
+    For health-related questions, delegate to the health advisor.
+    Relevant memories about the user are provided automatically.""",
     description="Coordinates requests between specialist agents",
     tools=[
+        load_memory,
         AgentTool(agent=travel_agent, skip_summarization=False),
-        AgentTool(agent=health_agent, skip_summarization=False)
-    ]
+        AgentTool(agent=health_agent, skip_summarization=False),
+    ],
+    after_agent_callback=save_session_to_memory,
 )
 
-def chat_with_specialists(user_input: str, user_id: str) -> str:
-    """
-    Handle user input with specialist agent delegation and memory.
+runner = Runner(
+    agent=coordinator,
+    session_service=session_service,
+    memory_service=memory_service,
+    app_name="specialist_system",
+)
 
-    Args:
-        user_input: The user's message
-        user_id: Unique identifier for the user
 
-    Returns:
-        The specialist agent's response
-    """
-    session_service = InMemorySessionService()
-    session = session_service.create_session(
+async def chat_with_specialists(user_input: str, user_id: str) -> str:
+    session = await session_service.create_session(
         app_name="specialist_system",
         user_id=user_id,
-        session_id=f"session_{user_id}"
     )
-    runner = Runner(agent=coordinator_agent, app_name="specialist_system", session_service=session_service)
-
-    content = types.Content(role='user', parts=[types.Part(text=user_input)])
-    events = runner.run(user_id=user_id, session_id=session.id, new_message=content)
-
-    for event in events:
-        if event.is_final_response():
-            response = event.content.parts[0].text
-
-            # Store the conversation in shared memory
-            conversation = [
-                {"role": "user", "content": user_input},
-                {"role": "assistant", "content": response}
-            ]
-            mem0.add(conversation, user_id=user_id)
-
-            return response
-
+    content = Content(role="user", parts=[Part(text=user_input)])
+    async for event in runner.run_async(user_id=user_id, session_id=session.id, new_message=content):
+        if event.is_final_response() and event.content and event.content.parts:
+            return event.content.parts[0].text
     return "No response generated"
 
-# Example usage
-response = chat_with_specialists("Plan a healthy meal for my Italy trip", user_id="alice")
-print(response)
-```
-
-
-
-## Quick Start Chat Interface
-
-Simple interactive chat with memory and Google ADK:
-
-```python
-def interactive_chat():
-    """Interactive chat interface with memory and ADK"""
-    user_id = input("Enter your user ID: ") or "demo_user"
-    print(f"Chat started for user: {user_id}")
-    print("Type 'quit' to exit")
-    print("=" * 50)
-
-    while True:
-        user_input = input("\nYou: ")
-
-        if user_input.lower() == 'quit':
-            print("Goodbye! Your conversation has been saved to memory.")
-            break
-        else:
-            response = chat_with_specialists(user_input, user_id)
-            print(f"Assistant: {response}")
 
 if __name__ == "__main__":
-    interactive_chat()
+    response = asyncio.run(chat_with_specialists("Plan a healthy meal for my Italy trip", user_id="alice"))
+    print(response)
 ```
 
 ## Key Features
 
-### 1. Memory-Enhanced Function Tools
-- **Function Tools**: Standard Python functions that can search and save memories
-- **Tool Context**: Access to session state and memory through function parameters
-- **Structured Returns**: Dictionary-based returns with status indicators for better LLM understanding
-
-### 2. Multi-Agent Memory Sharing
-- **Agent-as-a-Tool**: Specialists can be called as tools while maintaining shared memory
-- **Hierarchical Delegation**: Coordinator agents route to specialists based on context
-- **Memory Categories**: Store interactions with metadata for better organization
-
-### 3. Flexible Memory Operations
-- **Search Capabilities**: Retrieve relevant memories through conversation history
-- **User Segmentation**: Organize memories by user ID
-- **Memory Management**: Built-in tools for saving and retrieving information
+1. **Automatic Memory Injection**: ADK's built-in `load_memory` tool searches Mem0 at the start of each turn and injects relevant memories directly into the agent context — no prompt instructions needed.
+2. **Automatic Session Saving**: The `save_session_to_memory` callback persists every completed turn to Mem0 without any manual calls.
+3. **Native ADK Integration**: `Mem0MemoryService` implements ADK's `BaseMemoryService` and integrates via the `Runner` — works natively across the entire agent hierarchy.
+4. **User Scoping**: `user_id` is passed automatically from the ADK session context, ensuring memories are always scoped to the correct user.
+5. **Multi-Agent Support**: A single `Mem0MemoryService` instance shared through the `Runner` gives all agents — coordinators and specialists — access to the same user memory.
 
 ## Configuration Options
 
-Customize memory behavior and agent setup:
+### Using Vertex AI
+
+To use Google Cloud Vertex AI instead of AI Studio, set the following environment variables before creating agents:
 
 ```python
-# Configure memory search with filters
-# For Platform API, all filters including user_id go in filters object
-memories = mem0.search(
-    query="travel preferences",
-    filters={
-        "AND": [
-            {"user_id": "alice"},
-            {"categories": {"contains": "travel"}}
-        ]
-    },
-    top_k=5
-)
-
-# Configure agent with custom model settings
-agent = Agent(
-    name="custom_agent",
-    model="gemini-2.0-flash",  # or use LiteLLM for other models
-    instruction="Custom agent behavior",
-    tools=[memory_tools],
-    # Additional ADK configurations
-)
-
-# Use Google Cloud Vertex AI instead of AI Studio
+import os
 os.environ["GOOGLE_GENAI_USE_VERTEXAI"] = "True"
 os.environ["GOOGLE_CLOUD_PROJECT"] = "your-project-id"
 os.environ["GOOGLE_CLOUD_LOCATION"] = "us-central1"
 ```
 
+### Advanced Memory Filtering
+
+You can customize how memories are searched by modifying `Mem0MemoryService.search_memory`. For example, to filter by category:
+
+```python
+results = await asyncio.to_thread(
+    self._client.search,
+    query,
+    filters={
+        "AND": [
+            {"user_id": user_id},
+            {"app_id": app_name},
+            {"categories": {"contains": "travel"}}
+        ]
+    },
+    top_k=10,
+)
+```
+
+<Note>`InMemorySessionService` stores sessions in memory and is intended for prototyping. For production, use a persistent session service and clean up sessions when they are no longer needed.</Note>
+
+## Conclusion
+
+By implementing `Mem0MemoryService` as an ADK `BaseMemoryService`, you get persistent, user-scoped memory across single agents and complex multi-agent hierarchies with minimal code. Memory injection and session saving happen automatically, keeping your agent prompts clean and your token usage efficient.
+
 <CardGroup cols={2}>
   <Card title="Healthcare Agent Cookbook" icon="heart-pulse" href="/cookbooks/integrations/healthcare-google-adk">
     Build HIPAA-compliant healthcare agents with Google ADK
@@ -294,4 +347,3 @@ os.environ["GOOGLE_CLOUD_LOCATION"] = "us-central1"
     Compare with OpenAI's agent framework
   </Card>
 </CardGroup>
-

docs/integrations/pi-agent.mdx

@@ -0,0 +1,181 @@
+---
+title: Pi Agent
+description: "Add persistent memory to Pi Agent with the Mem0 plugin semantic search, auto-capture, and dream consolidation."
+---
+
+Add persistent memory to [**Pi Agent**](https://pi.dev) with `@mem0/pi-agent-plugin`. Your agent forgets everything between sessions — this plugin fixes that by automatically capturing knowledge from conversations, storing it in Mem0's cloud memory layer, and retrieving relevant context before every response.
+
+## Overview
+
+The plugin provides:
+1. **Auto-capture** — Extracts durable facts from both user and assistant messages automatically
+2. **Semantic recall** — Retrieves relevant memories via the `mem0_memory` tool before each response
+3. **Dream consolidation** — Periodic maintenance: merges duplicates, resolves contradictions, prunes stale entries
+4. **Monorepo-aware scoping** — Uses git root for project detection, consistent across subdirectories
+5. **Confirmation dialogs** — Destructive commands ask before acting via Pi's built-in UI
+6. **8 skills + 8 commands** — Essential memory management from slash commands and agent-guided workflows
+
+## Prerequisites
+
+1. A Mem0 Platform account and API key:
+   - <a href="https://app.mem0.ai?utm_source=oss&utm_medium=integration-pi-agent" rel="nofollow">Sign up at app.mem0.ai</a>
+   - <a href="https://app.mem0.ai/dashboard/api-keys?utm_source=oss&utm_medium=integration-pi-agent" rel="nofollow">Get your API key</a> (starts with `m0-`)
+
+2. Pi Agent installed ([pi.dev](https://pi.dev))
+
+3. Your API key added to your shell profile:
+
+<CodeGroup>
+```bash zsh
+echo 'export MEM0_API_KEY="m0-your-api-key"' >> ~/.zshrc
+source ~/.zshrc
+```
+
+```bash bash
+echo 'export MEM0_API_KEY="m0-your-api-key"' >> ~/.bashrc
+source ~/.bashrc
+```
+</CodeGroup>
+
+## Installation
+
+```bash
+pi install npm:@mem0/pi-agent-plugin
+```
+
+That's it. The extension loads automatically on every Pi session. No config files needed — `MEM0_API_KEY` from your environment is picked up automatically.
+
+<Info>
+  Start a new Pi session and run `/mem0-status` to verify the connection. You should see your user ID, detected project, and memory count.
+</Info>
+
+### Optional Configuration
+
+For advanced settings, create `~/.pi/agent/mem0-config.json`:
+
+```json
+{
+  "apiKey": "m0-your-key-here",
+  "userId": "your-username",
+  "autoCapture": true,
+  "defaultScope": "project",
+  "dream": {
+    "enabled": true,
+    "auto": true,
+    "minHours": 24,
+    "minSessions": 5,
+    "minMemories": 20
+  }
+}
+```
+
+| Key | Type | Default | Description |
+|-----|------|---------|-------------|
+| `apiKey` | `string` | `$MEM0_API_KEY` | Mem0 API key. Environment variable takes precedence. |
+| `userId` | `string` | `$MEM0_USER_ID` or `"default"` | User identity for memory scoping |
+| `autoCapture` | `boolean` | `true` | Store facts from conversations automatically |
+| `defaultScope` | `string` | `"project"` | Default memory scope: `project`, `session`, or `global` |
+| `dream.enabled` | `boolean` | `true` | Enable dream consolidation |
+| `dream.auto` | `boolean` | `true` | Auto-trigger dreams when thresholds are met |
+| `dream.minHours` | `number` | `24` | Minimum hours between auto-dreams |
+| `dream.minSessions` | `number` | `5` | Minimum sessions before first auto-dream |
+| `dream.minMemories` | `number` | `20` | Minimum memories before auto-dream triggers |
+
+## What's Included
+
+| Component | Description |
+|-----------|-------------|
+| `mem0_memory` tool | Agent-callable tool for search, add, get_all, delete, delete_all |
+| 8 slash commands | Essential memory management from the command line |
+| 8 skills | Guide the agent on how to use each capability |
+| Auto-capture | Extracts and stores facts on every `agent_end` event |
+| System prompt | Appends memory policy to every agent turn |
+| Dream consolidation | Automated memory maintenance with session/time/count gates |
+
+## Agent Tool
+
+The `mem0_memory` tool is registered with Pi and callable by the agent during conversations:
+
+| Action | Required Params | Description |
+|--------|----------------|-------------|
+| `search` | `query` | Semantic search across memories |
+| `add` | `content` | Store a new memory |
+| `get_all` | — | List all memories in scope |
+| `delete` | `memory_id` | Delete a specific memory |
+| `delete_all` | — | Delete all memories in scope |
+
+All actions accept an optional `scope` parameter: `project` (default), `session`, or `global`.
+
+Tool output is truncated to 200 lines / 50KB to prevent context overflow.
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `/mem0-remember <text>` | Store a memory verbatim (no inference) |
+| `/mem0-forget <query>` | Search and delete memories (with confirmation dialog) |
+| `/mem0-search <query>` | Semantic search across memories |
+| `/mem0-tour [scope]` | Browse all memories grouped by category |
+| `/mem0-dream` | Consolidate — merge duplicates, prune stale, resolve contradictions |
+| `/mem0-pin <query>` | Pin a memory to protect from dream pruning (preserves memory ID) |
+| `/mem0-scope <scope>` | Change default scope for this session (project, session, global) |
+| `/mem0-status` | Connection health, identity, and memory count |
+
+## Memory Scopes
+
+Memories are scoped using Mem0's `user_id`, `app_id`, and `run_id` parameters:
+
+| Scope | Filters | Use Case |
+|-------|---------|----------|
+| `project` | user_id + app_id (git root) | **Default.** Project-specific knowledge — decisions, architecture, config |
+| `session` | user_id + app_id + run_id | Ephemeral context for the current session only |
+| `global` | user_id only | All memories across all your projects |
+
+The `app_id` is auto-detected from the git repository root (`git rev-parse --show-toplevel`), so all subdirectories within a monorepo share the same memory pool. Falls back to the working directory name for non-git directories. The `run_id` is derived from Pi's session file path.
+
+## Dream Consolidation
+
+### Confirmation Dialogs
+
+Destructive and mutating commands use Pi's built-in `ctx.ui.confirm()` dialog before acting:
+
+- `/mem0-forget` asks "Delete this memory?" before deleting a single match
+- `/mem0-pin` asks "Pin this memory?" before modifying it
+- Cancelling either operation is always safe — no changes are made
+
+### Pin
+
+`/mem0-pin` uses Mem0's `update()` API to prepend `[PINNED]` to the memory text. This preserves the original memory ID — no add+delete cycle that would lose history or change the UUID.
+
+### Dream Consolidation
+
+The plugin includes automated memory maintenance ("dream") that merges duplicates, resolves contradictions, and prunes stale entries. When enabled, dreams auto-trigger after enough sessions, time, and memories accumulate (configurable via `dream.*` settings). Run `/mem0-dream` to trigger consolidation manually at any time. Pinned memories (via `/mem0-pin`) are protected from pruning.
+
+## Example Workflow
+
+```text
+# Session 1
+You: I prefer dark mode and concise answers.
+# Mem0 auto-captures preferences
+
+# Session 2 (days later)
+You: What do you know about my preferences?
+# Pi retrieves stored memories — no re-explaining needed
+```
+
+## Troubleshooting
+
+- **"No API key found"** — Verify `MEM0_API_KEY` is set: `echo $MEM0_API_KEY`. If empty, add it to your shell profile (see Prerequisites)
+- **Extension not loading** — Check Pi startup output for errors. Run `pi -e ./src/entry.ts` from the plugin directory for verbose output
+- **Memories not capturing** — Verify `autoCapture` is `true` (default). Check `/mem0-status` for connection health
+- **Wrong project detected** — The plugin uses the git repository root as `app_id`. If not in a git repo, it falls back to the working directory name. Run `/mem0-status` to see the detected project
+- **Dream not triggering** — All three gates must pass (time, sessions, memories). Use `/mem0-dream` to force it manually
+
+<CardGroup cols={2}>
+  <Card title="Claude Code Integration" icon="terminal" href="/integrations/claude-code">
+    Add Mem0 memory to Claude Code
+  </Card>
+  <Card title="OpenClaw Integration" icon="plug" href="/integrations/openclaw">
+    Add Mem0 memory to OpenClaw agents
+  </Card>
+</CardGroup>

docs/integrations/vercel-ai-sdk.mdx

@@ -6,25 +6,33 @@ description: "Use the Mem0 AI SDK Provider with Vercel AI SDK for persistent mem
 The [**Mem0 AI SDK Provider**](https://www.npmjs.com/package/@mem0/vercel-ai-provider) is a library developed by **Mem0** to integrate with the Vercel AI SDK. This library brings enhanced AI interaction capabilities to your applications by introducing persistent memory functionality.
 
 <Note type="info">
-  Mem0 AI SDK now supports <strong>Vercel AI SDK V5</strong>.
+  Mem0 AI SDK Provider v3.0.0 supports <strong>Vercel AI SDK v6</strong> (<code>LanguageModelV3</code> / <code>ProviderV3</code>). If you are upgrading from v2.x, see the <a href="https://ai-sdk.dev/docs/migration-guides/migration-guide-6-0">AI SDK v6 migration guide</a>.
 </Note>
 
 ## Overview
 
 1. Offers persistent memory storage for conversational AI
-2. Enables smooth integration with the Vercel AI SDK
-3. Ensures compatibility with multiple LLM providers
+2. Enables smooth integration with the Vercel AI SDK v6
+3. Ensures compatibility with multiple LLM providers (OpenAI, Anthropic, Google, Groq, Cohere)
 4. Supports structured message formats for clarity
 5. Facilitates streaming response capabilities
+6. Attaches Mem0 memories as sources in responses for programmatic access
 
 ## Setup and Configuration
 
-Install the SDK provider using npm:
+Install the SDK provider and AI SDK:
 
 ```bash
-npm install @mem0/vercel-ai-provider
+npm install @mem0/vercel-ai-provider ai@^6
 ```
 
+### Peer Dependencies
+
+`@mem0/vercel-ai-provider` v3.0.0 requires:
+- `ai` v6+ (`^6.0.199`)
+- `@ai-sdk/provider` v3+ (`^3.0.10`)
+- Provider packages at v3+: `@ai-sdk/openai@^3`, `@ai-sdk/anthropic@^3`, `@ai-sdk/google@^3`, `@ai-sdk/groq@^3`, `@ai-sdk/cohere@^3`
+
 ## Getting Started
 
 ### Setting Up Mem0
@@ -41,7 +49,7 @@ npm install @mem0/vercel-ai-provider
       mem0ApiKey: "m0-xxx",
       apiKey: "provider-api-key",
       config: {
-        // Options for LLM Provider
+        // Options for the upstream LLM provider (e.g. baseURL)
       },
       // Optional Mem0 Global Config
       mem0Config: {
@@ -57,154 +65,153 @@ npm install @mem0/vercel-ai-provider
 3. Add Memories to Enhance Context:
 
     ```typescript
-    import { LanguageModelV2Prompt } from "@ai-sdk/provider";
     import { addMemories } from "@mem0/vercel-ai-provider";
 
-    const messages: LanguageModelV2Prompt = [
+    const messages = [
       { role: "user", content: [{ type: "text", text: "I love red cars." }] },
     ];
 
     await addMemories(messages, { user_id: "borat" });
     ```
 
-### Standalone Features:
+### Standalone Features
 
-    ```typescript
-    await addMemories(messages, { user_id: "borat", mem0ApiKey: "m0-xxx" });
-    await retrieveMemories(prompt, { user_id: "borat", mem0ApiKey: "m0-xxx" });
-    await getMemories(prompt, { user_id: "borat", mem0ApiKey: "m0-xxx" });
-    ```
-     > For standalone features, such as `addMemories`, `retrieveMemories`, and `getMemories`, you must either set `MEM0_API_KEY` as an environment variable or pass it directly in the function call.
+```typescript
+await addMemories(messages, { user_id: "borat", mem0ApiKey: "m0-xxx" });
+await retrieveMemories(prompt, { user_id: "borat", mem0ApiKey: "m0-xxx" });
+await getMemories(prompt, { user_id: "borat", mem0ApiKey: "m0-xxx" });
+```
 
-     > `getMemories` will return raw memories in the form of an array of objects, while `retrieveMemories` will return a response in string format with a system prompt ingested with the retrieved memories.
+> For standalone features, such as `addMemories`, `retrieveMemories`, and `getMemories`, you must either set `MEM0_API_KEY` as an environment variable or pass it directly in the function call.
 
-     > `getMemories` returns an array of memory objects.
+> `getMemories` will return raw memories in the form of an array of objects, while `retrieveMemories` will return a response in string format with a system prompt ingested with the retrieved memories.
 
 ### 1. Basic Text Generation with Memory Context
 
-    ```typescript
-    import { generateText } from "ai";
-    import { createMem0 } from "@mem0/vercel-ai-provider";
+```typescript
+import { generateText } from "ai";
+import { createMem0 } from "@mem0/vercel-ai-provider";
 
-    const mem0 = createMem0();
+const mem0 = createMem0();
 
-    const { text } = await generateText({
-      model: mem0("gpt-4-turbo", { user_id: "borat" }),
-      prompt: "Suggest me a good car to buy!",
-    });
-    ```
+const { text } = await generateText({
+  model: mem0("gpt-5-mini", { user_id: "borat" }),
+  prompt: "Suggest me a good car to buy!",
+});
+```
 
 ### 2. Combining OpenAI Provider with Memory Utils
 
-    ```typescript
-    import { generateText } from "ai";
-    import { openai } from "@ai-sdk/openai";
-    import { retrieveMemories } from "@mem0/vercel-ai-provider";
+```typescript
+import { generateText } from "ai";
+import { openai } from "@ai-sdk/openai";
+import { retrieveMemories } from "@mem0/vercel-ai-provider";
 
-    const prompt = "Suggest me a good car to buy.";
-    const memories = await retrieveMemories(prompt, { user_id: "borat" });
+const prompt = "Suggest me a good car to buy.";
+const memories = await retrieveMemories(prompt, { user_id: "borat" });
 
-    const { text } = await generateText({
-      model: openai("gpt-4-turbo"),
-      prompt: prompt,
-      system: memories,
-    });
-    ```
+const { text } = await generateText({
+  model: openai("gpt-5-mini"),
+  prompt: prompt,
+  system: memories,
+});
+```
 
 ### 3. Structured Message Format with Memory
 
-    ```typescript
-    import { generateText } from "ai";
-    import { createMem0 } from "@mem0/vercel-ai-provider";
+```typescript
+import { generateText } from "ai";
+import { createMem0 } from "@mem0/vercel-ai-provider";
 
-    const mem0 = createMem0();
+const mem0 = createMem0();
 
-    const { text } = await generateText({
-      model: mem0("gpt-4-turbo", { user_id: "borat" }),
-      messages: [
-        {
-          role: "user",
-          content: [
-            { type: "text", text: "Suggest me a good car to buy." },
-            { type: "text", text: "Why is it better than the other cars for me?" },
-          ],
-        },
+const { text } = await generateText({
+  model: mem0("gpt-5-mini", { user_id: "borat" }),
+  messages: [
+    {
+      role: "user",
+      content: [
+        { type: "text", text: "Suggest me a good car to buy." },
+        { type: "text", text: "Why is it better than the other cars for me?" },
       ],
-    });
-    ```
+    },
+  ],
+});
+```
 
-### 3. Streaming Responses with Memory Context
+### 4. Streaming Responses with Memory Context
 
-    ```typescript
-    import { streamText } from "ai";
-    import { createMem0 } from "@mem0/vercel-ai-provider";
+```typescript
+import { streamText } from "ai";
+import { createMem0 } from "@mem0/vercel-ai-provider";
 
-    const mem0 = createMem0();
+const mem0 = createMem0();
 
-    const { textStream } = streamText({
-        model: mem0("gpt-4-turbo", {
-            user_id: "borat",
-        }),
-        prompt: "Suggest me a good car to buy! Why is it better than the other cars for me? Give options for every price range.",
-    });
+const { textStream } = streamText({
+  model: mem0("gpt-5-mini", {
+    user_id: "borat",
+  }),
+  prompt: "Suggest me a good car to buy! Why is it better than the other cars for me? Give options for every price range.",
+});
 
-    for await (const textPart of textStream) {
-        process.stdout.write(textPart);
-    }
-    ```
+for await (const textPart of textStream) {
+  process.stdout.write(textPart);
+}
+```
 
-### 4. Generate Responses with Tools Call
+### 5. Generate Responses with Tools Call
 
-    ```typescript
-    import { generateText } from "ai";
-    import { createMem0 } from "@mem0/vercel-ai-provider";
-    import { z } from "zod";
+```typescript
+import { generateText, tool } from "ai";
+import { createMem0 } from "@mem0/vercel-ai-provider";
+import { z } from "zod";
 
-    const mem0 = createMem0({
-      provider: "anthropic",
-      apiKey: "anthropic-api-key",
-      mem0Config: {
-        // Global User ID
-        user_id: "borat"
-      }
-    });
+const mem0 = createMem0({
+  provider: "anthropic",
+  apiKey: "anthropic-api-key",
+  mem0Config: {
+    user_id: "borat"
+  }
+});
 
-    const prompt = "What the temperature in the city that I live in?"
+const result = await generateText({
+  model: mem0('claude-sonnet-4-20250514'),
+  tools: {
+    weather: tool({
+      description: 'Get the weather in a location',
+      parameters: z.object({
+        location: z.string().describe('The location to get the weather for'),
+      }),
+      execute: async ({ location }) => ({
+        location,
+        temperature: 72 + Math.floor(Math.random() * 21) - 10,
+      }),
+    }),
+  },
+  prompt: "What the temperature in the city that I live in?",
+});
 
-    const result = await generateText({
-      model: mem0('claude-3-5-sonnet-20240620'),
-      tools: {
-        weather: tool({
-          description: 'Get the weather in a location',
-          parameters: z.object({
-            location: z.string().describe('The location to get the weather for'),
-          }),
-          execute: async ({ location }) => ({
-            location,
-            temperature: 72 + Math.floor(Math.random() * 21) - 10,
-          }),
-        }),
-      },
-      prompt: prompt,
-    });
+console.log(result);
+```
 
-    console.log(result);
-    ```
+### 6. Get Sources from Memory
 
-### 5. Get sources from memory
+`generateText` and `streamText` responses include Mem0 memories as a source, giving you programmatic access to the memories that influenced the response:
 
 ```typescript
 const { text, sources } = await generateText({
-    model: mem0("gpt-4-turbo"),
-    prompt: "Suggest me a good car to buy!",
+  model: mem0("gpt-5-mini", { user_id: "borat" }),
+  prompt: "Suggest me a good car to buy!",
 });
 
+// sources[0].title === "Mem0 Memories"
+// sources[0].providerMetadata.mem0.memories — array of memory objects
 console.log(sources);
 ```
 
 The same can be done for `streamText` as well.
 
-### 6. File Support with Memory Context
+### 7. File Support with Memory Context
 
 Mem0 AI SDK supports file processing with memory context. Here's an example of analyzing a PDF file:
 
@@ -226,15 +233,11 @@ const mem0 = createMem0({
 });
 
 async function main() {
-  // Read the PDF file
   const filePath = join(process.cwd(), 'my_pdf.pdf');
   const fileBuffer = readFileSync(filePath);
 
-  // Convert the file's arrayBuffer to a Base64 data URL
   const arrayBuffer = fileBuffer.buffer.slice(fileBuffer.byteOffset, fileBuffer.byteOffset + fileBuffer.byteLength);
   const uint8Array = new Uint8Array(arrayBuffer);
-
-  // Convert Uint8Array to an array of characters
   const charArray = Array.from(uint8Array, byte => String.fromCharCode(byte));
   const binaryString = charArray.join('');
   const base64Data = Buffer.from(binaryString, 'binary').toString('base64');
@@ -274,24 +277,56 @@ main();
 
 | Provider | Configuration Value |
 |----------|-------------------|
-| OpenAI | openai |
-| Anthropic | anthropic |
-| Google | google |
-| Groq | groq |
+| OpenAI | `openai` |
+| Anthropic | `anthropic` |
+| Google / Gemini | `google` or `gemini` |
+| Groq | `groq` |
+| Cohere | `cohere` |
 
-> **Note**: You can use `google` as provider for Gemini (Google) models. They are same and internally they use `@ai-sdk/google` package.
+> **Note**: You can use either `google` or `gemini` as the provider value for Google Gemini models. Both map to the `@ai-sdk/google` package internally.
+
+## Configuration Options
+
+### Mem0ConfigSettings
+
+These options can be passed per-request when creating a model instance:
+
+| Option | Type | Description |
+|--------|------|-------------|
+| `user_id` | `string` | User identifier for memory scoping |
+| `agent_id` | `string` | Agent identifier |
+| `app_id` | `string` | Application identifier |
+| `run_id` | `string` | Run/session identifier |
+| `metadata` | `object` | Custom metadata for memories |
+| `filters` | `object` | Filters for memory search |
+| `infer` | `boolean` | Enable inference-based retrieval |
+| `top_k` | `number` | Number of memories to retrieve (default: 10) |
+| `threshold` | `number` | Relevance threshold for search |
+| `rerank` | `boolean` | Enable reranking of results |
+| `page` | `number` | Page number for pagination |
+| `page_size` | `number` | Results per page |
 
 ## Key Features
 
-- `createMem0()`: Initializes a new Mem0 provider instance.
-- `retrieveMemories()`: Retrieves memory context for prompts.
+- `createMem0()`: Initializes a new Mem0 provider instance implementing `ProviderV3`.
+- `retrieveMemories()`: Retrieves memory context for prompts as a formatted system prompt string.
 - `getMemories()`: Get memories from your profile in array format.
 - `addMemories()`: Adds user memories to enhance contextual responses.
 
+## Migrating from v2.x
+
+If you're upgrading from `@mem0/vercel-ai-provider` v2.x:
+
+1. **Upgrade AI SDK**: `npm install ai@^6` and update all `@ai-sdk/*` provider packages to `^3.x`
+2. **Remove deprecated params**: Remove `org_id`, `project_id`, `output_format`, `filter_memories`, `async_mode`, `enable_graph` from your config
+3. **Remove graph memory**: All graph-related options (`enable_graph`, graph prompts) have been removed. Graph memory is now a project-level setting on the Mem0 Platform
+4. **Update imports**: `LanguageModelV2Prompt` is now `LanguageModelV3Prompt` if you import types directly
+
 ## Best Practices
 
 1. **User Identification**: Use a unique `user_id` for consistent memory retrieval.
 2. **Memory Cleanup**: Regularly clean up unused memory data.
+3. **Sources**: Access `result.sources` to inspect which memories influenced the response.
 
     > **Note**: We also have support for `agent_id`, `app_id`, and `run_id`. Refer [Docs](/api-reference/memory/add-memories).
 

docs/llms.txt

@@ -228,6 +228,7 @@ If the user is on a pre-current major (Python < 2, TS < 3, or Platform `output_f
 - [OSS v2 to v3 Migration](https://docs.mem0.ai/migration/oss-v2-to-v3) [OSS]: Use when upgrading a self-hosted deployment across major versions.
 - [Platform v2 to v3 Migration](https://docs.mem0.ai/migration/platform-v2-to-v3) [Platform]: Use when upgrading a Platform integration across major versions.
 - [API Changes](https://docs.mem0.ai/migration/api-changes) [Both]: Use when the upgrade involves API surface changes.
+- [Server pgvector Image Upgrade](https://docs.mem0.ai/migration/server-pgvector-upgrade) [OSS]: Use when upgrading the self-hosted server Docker image from ankane/pgvector to pgvector/pgvector.
 - [Changelog](https://docs.mem0.ai/changelog/highlights) [Both]: Use when the user asks what shipped recently.
 
 ## Open Source
@@ -258,6 +259,7 @@ If the user is on a pre-current major (Python < 2, TS < 3, or Platform `output_f
 - [Camel AI](https://docs.mem0.ai/integrations/camel-ai) [Both]: Use when the user is on Camel AI.
 - [ChatDev](https://docs.mem0.ai/integrations/chatdev) [Both]: Use when the user is on ChatDev.
 - [Hermes](https://docs.mem0.ai/integrations/hermes) [Both]: Use when the user is on Hermes.
+- [Pi Agent](https://docs.mem0.ai/integrations/pi-agent) [Platform]: Use when adding persistent memory to Pi Agent with the Mem0 plugin.
 - [OpenAI Agents SDK](https://docs.mem0.ai/integrations/openai-agents-sdk) [Both]: Use when the user is on the OpenAI Agents SDK.
 - [Google AI ADK](https://docs.mem0.ai/integrations/google-ai-adk) [Both]: Use when the user is on Google's Agent Development Kit.
 - [Mastra](https://docs.mem0.ai/integrations/mastra) [Both]: Use when the user is on Mastra (TypeScript).
@@ -474,6 +476,7 @@ Everything below is OSS-only provider configuration. Skip this entire section wh
 - [Elasticsearch](https://docs.mem0.ai/components/vectordbs/dbs/elasticsearch) [OSS]: Use when Elasticsearch is the backing store.
 - [OpenSearch](https://docs.mem0.ai/components/vectordbs/dbs/opensearch) [OSS]: Use when OpenSearch is the backing store.
 - [Supabase](https://docs.mem0.ai/components/vectordbs/dbs/supabase) [OSS]: Use when Supabase with pgvector is the backing store.
+- [Neon](https://docs.mem0.ai/components/vectordbs/dbs/neon) [OSS]: Use when Neon Postgres with pgvector is the backing store.
 - [Upstash Vector](https://docs.mem0.ai/components/vectordbs/dbs/upstash-vector) [OSS]: Use for serverless Upstash Vector.
 - [Vectorize](https://docs.mem0.ai/components/vectordbs/dbs/vectorize) [OSS]: Use when the store is Cloudflare Vectorize.
 - [Vertex AI Vector Search](https://docs.mem0.ai/components/vectordbs/dbs/vertex_ai) [OSS]: Use when the store is Google Cloud Vertex Vector Search.

docs/migration/oss-to-platform.mdx

@@ -14,9 +14,9 @@ Move your Mem0 implementation to managed infrastructure with enterprise features
 | --------------------- | -------------- | ---------------------------- |
 | Infrastructure & Code | Low (~30 mins) | None (Parallel run possible) |
 
-<Info>
+<Note>
   Using Mem0 Open Source with **hosted Qdrant**? You can migrate your existing memories to Mem0 Platform with a one-line script below.
-</Info>
+</Note>
 
 <Info>
   **Why migrate to Platform?**

docs/migration/server-pgvector-upgrade.mdx

@@ -0,0 +1,158 @@
+---
+title: "Server: Upgrading the pgvector Docker Image"
+description: "Migrate your self-hosted Mem0 server from the archived ankane/pgvector image to the official pgvector/pgvector image."
+icon: "arrow-right"
+iconType: "solid"
+---
+
+## Overview
+
+The self-hosted Mem0 server has upgraded its PostgreSQL Docker image:
+
+| | Before | After |
+| --- | --- | --- |
+| Docker image | `ankane/pgvector:v0.5.1` | `pgvector/pgvector:pg17` |
+| PostgreSQL | 15 | 17 |
+| pgvector | 0.5.1 | 0.8.0 |
+| Credentials | Hardcoded `postgres` / `postgres` | Set via `POSTGRES_USER` / `POSTGRES_PASSWORD` env vars |
+
+<Warning>
+The `ankane/pgvector` image is **archived and no longer maintained**. The new `pgvector/pgvector` image is the official distribution maintained by the pgvector project.
+</Warning>
+
+<Info>
+**Should you migrate?**
+- You are running the Mem0 server via `docker-compose.yaml` in the `server/` directory.
+- You want to stay on a maintained, actively-patched PostgreSQL + pgvector image.
+- You want pgvector 0.8.0 features (improved HNSW performance, parallel index builds).
+</Info>
+
+## Fresh Installs
+
+No migration is needed. Copy the example env file, set your password, and start the stack:
+
+```bash
+cd server
+cp .env.example .env
+# Edit .env — set POSTGRES_PASSWORD (required) and OPENAI_API_KEY at minimum
+make up
+```
+
+## Migrating an Existing Install
+
+PostgreSQL 17 cannot read data files created by PostgreSQL 15 directly. You need to export your data from the old container and import it into the new one.
+
+### 1. Back Up Your Data
+
+With the **old** stack still running:
+
+```bash
+cd server
+docker compose exec -T postgres pg_dumpall -U postgres > mem0_backup.sql
+```
+
+Verify the dump is non-empty:
+
+```bash
+ls -lh mem0_backup.sql
+```
+
+<Warning>
+Do not skip this step. The next step permanently deletes your Postgres data volume.
+</Warning>
+
+### 2. Stop the Old Stack and Remove the Volume
+
+```bash
+docker compose down
+docker compose down -v
+```
+
+### 3. Update Your `.env`
+
+Postgres credentials are no longer hardcoded in `docker-compose.yaml`. Add them to your `.env`:
+
+```bash
+POSTGRES_HOST=postgres
+POSTGRES_PORT=5432
+POSTGRES_DB=postgres
+POSTGRES_USER=postgres
+POSTGRES_PASSWORD=<your-password>    # required — compose will refuse to start without it
+POSTGRES_COLLECTION_NAME=memories
+```
+
+<Info>
+`POSTGRES_PASSWORD` is **required** — `docker compose up` will refuse to start without it. If you previously relied on the hardcoded default, set `POSTGRES_PASSWORD=postgres`.
+</Info>
+
+### 4. Start Only Postgres
+
+Start **only** the Postgres container first — do **not** start the mem0 API yet.
+The API runs `alembic upgrade head` on startup, which creates empty tables that
+would conflict with the restore.
+
+```bash
+docker compose up -d postgres
+```
+
+Wait for Postgres to become healthy:
+
+```bash
+docker compose exec -T postgres pg_isready -q && echo "ready" || echo "not ready"
+```
+
+### 5. Restore Your Data
+
+```bash
+docker compose exec -T postgres psql -U postgres < mem0_backup.sql
+```
+
+You may see notices like `role "postgres" already exists` — these are safe to ignore.
+
+<Warning>
+You must restore **before** starting the mem0 API container. The API runs
+database migrations on startup which create empty tables — restoring after
+that would fail with duplicate-key errors and lose your API keys and settings.
+</Warning>
+
+### 6. Start the API
+
+Now start the mem0 API container. Alembic will detect the existing tables and
+only apply any new migrations:
+
+```bash
+docker compose up -d mem0
+```
+
+### 7. Verify
+
+```bash
+# Check service health
+cd server && make health
+
+# Confirm memories are accessible
+curl -s http://localhost:8888/memories?user_id=<your-user-id> \
+  -H "X-API-Key: <your-api-key>"
+```
+
+## Rollback
+
+If something goes wrong, revert the image tag in `docker-compose.yaml`:
+
+```yaml
+postgres:
+    image: ankane/pgvector:v0.5.1
+```
+
+Then destroy the new volume, start the old image, and restore from your backup:
+
+```bash
+docker compose down -v
+docker compose up -d --build
+docker compose exec -T postgres psql -U postgres < mem0_backup.sql
+```
+
+## Need Help?
+
+- Join our [Discord community](https://mem0.ai/discord) for real-time support
+- Open an issue on [GitHub](https://github.com/mem0ai/mem0/issues)

docs/open-source/features/rest-api.mdx

@@ -226,6 +226,20 @@ curl -X POST http://localhost:8888/search \
   }'
 ```
 
+Set `explain` to inspect the scoring signals used by OSS hybrid search:
+
+```bash
+curl -X POST http://localhost:8888/search \
+  -H "Content-Type: application/json" \
+  -d '{
+    "query": "vegetable pizza",
+    "user_id": "alice",
+    "explain": true
+  }'
+```
+
+Each returned memory includes `score_details` only when explanation mode is enabled.
+
 ### Explore with OpenAPI docs
 
 1. Navigate to `http://localhost:8888/docs` (Compose) or `http://localhost:8000/docs` (raw Docker / uvicorn).

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

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

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

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

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

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

mem0-plugin/.opencode-plugin/CHANGELOG.md

@@ -0,0 +1,47 @@
+# Changelog
+
+All notable changes to the `@mem0/opencode-plugin` will be documented in this file.
+
+## 0.1.3 — File-context injection, session summaries & activity timeline
+
+### Added
+
+- **File-context injection (`tool.execute.before` / Read):** Before the agent reads a file, the plugin searches mem0 for memories referencing that file path and injects prior work as system context. Gates on file size (>= 1,500 bytes). Gives the agent "I've worked on this file before" awareness automatically.
+- **Stop hook session summary (`experimental.session.compacting`):** Enhanced session compaction to store a structured `session_summary` memory with `infer=True`, letting the mem0 backend AI extract key facts (request, decisions, learnings, next steps). Previously only stored a raw stats string.
+- **SessionStart activity timeline:** The initial memory loading now formats recent memories with type icons (⚖️ decision, 🔴 bug_fix, 🔵 task_learning, etc.) and relative age indicators (2h ago, 1d ago) instead of bare text. Provides a visual "Recent Activity" timeline on first message.
+
+### Changed
+
+- **`experimental.session.compacting` handler:** Now stores `metadata.type=session_summary` with `metadata.source=opencode-stop` instead of `metadata.type=session_state` with `metadata.source=pre-compaction`. Includes a structured prompt that instructs mem0's AI to extract request, decisions, learnings, and next steps.
+- **Initial context formatting:** Memories shown on first message now include type icons and age labels for quick scanning.
+
+## 0.1.2 — Automatic coding categories & global search
+
+### Added
+
+- **Auto-configured coding categories:** The plugin now automatically sets up 17 coding categories (e.g. `architecture_decisions`, `api_design`, `security`, `debugging_notes`) on the Mem0 project at startup. Runs in the background on every session start via `autoSetupCategories()`, is fully idempotent, and never blocks initialization. Uses SHA-256 fingerprints of the category list and API key — stored in `~/.mem0/categories_setup.json` — to skip redundant API calls on subsequent sessions.
+- **Global search mode (`global_search` setting):** New `global_search` toggle in `~/.mem0/settings.json` (default: `false`). When enabled, all `search_memories` and `get_memories` calls use `{"OR": [{"user_id": "*"}]}` instead of the per-user per-project `AND` filter — returning all memories across all users and all `app_id` scopes. Writes (`add_memory`) still tag with the current `user_id` and `app_id`. Applies to all plugin search paths: initial load, per-message recall, resume detection, error-pattern lookup, and compaction context.
+- **`/mem0:switch-project --global` / `--no-global`:** Enables or disables global search via the switch-project skill. Persists to `~/.mem0/settings.json`. No manual config editing needed.
+- **`MEM0_GLOBAL_SEARCH` environment variable:** Exported to child shells via the `shell.env` hook (`"true"` or `"false"`).
+
+### Changed
+
+- **Search filters are now dynamic:** All search paths throughout the plugin construct filters based on the `global_search` setting instead of always using `AND [user_id, app_id]`.
+- **Resume-context searches broadened:** Resume and error-pattern searches no longer include `metadata.type` sub-filters (`session_state`, `decision`, `anti_pattern`, `bug_fix`), broadening recall.
+- **System context message updated:** Informs the model when global search is active (`"Global search is ON — searches return all memories across all users and projects. Writes still use user_id=..., app_id=..."`).
+- **`/mem0:onboard` Step 5 is no longer interactive:** Removed the manual category installation prompt. Categories now configure automatically in the background; the onboarding step only verifies status and stores a fallback `project_profile` memory if the background run hasn't finished yet.
+- **`/mem0:switch-project` skill expanded:** Description and execution updated to document the `--global` and `--no-global` flags alongside the existing project-name argument.
+
+## 0.1.1
+
+- CI/CD publish flow test (`#5288`).
+- Fixed tsconfig, added `publishConfig` and bun lockfile (`#5273`).
+- Renamed package to `@mem0/opencode-plugin` (`#5272`).
+- Added plugin array to bundled `opencode.json` (`#5271`).
+
+## 0.1.0 — Initial release
+
+- **OpenCode plugin** (`@mem0/opencode-plugin` on npm): Pure TypeScript plugin using the `mem0ai` TS SDK — no Python, no shell scripts. Hooks into all 6 OpenCode events (`chat.message`, `tool.execute.before`, `tool.execute.after`, `experimental.chat.system.transform`, `experimental.session.compacting`, `shell.env`). Features: session start memory loading, per-prompt semantic search, error pattern detection with memory lookup, resume/remember intent detection, auto-capture every 3rd message, periodic save nudges, full metadata defaults injection (confidence, source, type, session_id, files, branch), identity injection for search/get/delete filters, type-filtered error pre-fetch (anti_pattern + bug_fix), pre-compaction memory capture, MEMORY.md write blocking, and secret redaction.
+- **16 OpenCode-native skills** bundled in `opencode-skills/`: `context-loader`, `dream`, `export`, `forget`, `health`, `import`, `list-projects`, `mem0` (SDK reference), `memory-reviewer`, `onboard`, `peek`, `pin`, `remember`, `stats`, `switch-project`, `tour`. All skills are pure MCP-tool-based — no Python scripts, no shell scripts, no Claude Code dependencies.
+- **Auto-install skills and commands (`installSkills()`):** On plugin load, copies all 16 skills to `.opencode/skills/` and creates command wrapper files in `.opencode/commands/` so they appear in the OpenCode `/` palette.
+- **CLI installer (`cli.ts`):** `bunx @mem0/opencode-plugin install` auto-configures plugin and MCP server in `~/.config/opencode/opencode.json`.

mem0-plugin/.opencode-plugin/opencode-mem0.ts

@@ -66,6 +66,38 @@ function redact(text: string): string {
   return out;
 }
 
+function formatAge(createdAt: string): string {
+  try {
+    const dt = new Date(createdAt);
+    const now = Date.now();
+    const seconds = Math.floor((now - dt.getTime()) / 1000);
+    if (seconds < 3600) return `${Math.floor(seconds / 60)}m ago`;
+    if (seconds < 86400) return `${Math.floor(seconds / 3600)}h ago`;
+    const days = Math.floor(seconds / 86400);
+    if (days === 1) return "1d ago";
+    if (days < 30) return `${days}d ago`;
+    return `${Math.floor(days / 30)}mo ago`;
+  } catch {
+    return "";
+  }
+}
+
+const TYPE_ICONS: Record<string, string> = {
+  decision: "⚖️",
+  anti_pattern: "🔴",
+  bug_fix: "🔴",
+  convention: "🔄",
+  task_learning: "🔵",
+  user_preference: "🟣",
+  session_summary: "📋",
+  session_state: "📋",
+  project_profile: "📖",
+  compact_summary: "📋",
+  auto_capture: "✅",
+};
+
+const FILE_READ_GATE_MIN_BYTES = 1500;
+
 function loadGlobalSearch(): boolean {
   try {
     const settingsPath = join(homedir(), ".mem0", "settings.json");
@@ -308,9 +340,16 @@ const Mem0Plugin: Plugin = async (ctx) => {
               const memories = extractMemories(res);
               if (memories.length > 0) {
                 const memLines = memories
-                  .map((m) => `- ${m.memory}`)
+                  .map((m) => {
+                    const meta = (m as any).metadata ?? {};
+                    const cat = meta.type ?? "unknown";
+                    const icon = TYPE_ICONS[cat] ?? "❓";
+                    const age = (m as any).created_at ? formatAge((m as any).created_at) : "";
+                    const ageStr = age ? ` (${age})` : "";
+                    return `- ${icon} [${cat}]${ageStr} ${m.memory.slice(0, 120)}`;
+                  })
                   .join("\n");
-                systemContext.push(`Prior context from mem0:\n${memLines}`);
+                systemContext.push(`### Recent Activity\n\n${memLines}`);
               }
             } catch {}
           }
@@ -445,6 +484,41 @@ const Mem0Plugin: Plugin = async (ctx) => {
     "tool.execute.before": async (input: any, output: any) => {
       const toolName: string = input?.tool ?? "";
 
+      // File-context injection: before reading a file, search mem0 for prior work on it
+      if (toolName === "read" || toolName === "Read") {
+        const filePath = String(output?.args?.file_path ?? output?.args?.filePath ?? "");
+        if (filePath && filePath.length > 0) {
+          try {
+            const absPath = filePath.startsWith("/") ? filePath : resolve(process.cwd(), filePath);
+            const { statSync } = await import("fs");
+            const stat = statSync(absPath);
+            if (stat.isFile() && stat.size >= FILE_READ_GATE_MIN_BYTES) {
+              const searchFilters = globalSearch
+                ? { OR: [{ user_id: "*" }] }
+                : { AND: [{ user_id: userId }, { app_id: appId }] };
+              const relPath = filePath.startsWith("/")
+                ? filePath.replace(process.cwd() + "/", "")
+                : filePath;
+              const res = await mem0.search(relPath, {
+                filters: searchFilters,
+                topK: 5,
+              });
+              stats.searches++;
+              const memories = extractMemories(res);
+              if (memories.length > 0) {
+                const lines = memories.map((m) => {
+                  const text = m.memory.slice(0, 150).replace(/\n/g, " ");
+                  return `- ${text} [mem0:${m.id.slice(0, 8)}]`;
+                });
+                systemContext.push(
+                  `Prior work on \`${relPath}\`:\n${lines.join("\n")}`,
+                );
+              }
+            }
+          } catch {}
+        }
+      }
+
       if (WRITE_TOOLS.has(toolName)) {
         const fp = String(
           output?.args?.file_path ?? output?.args?.filePath ?? "",
@@ -611,15 +685,22 @@ const Mem0Plugin: Plugin = async (ctx) => {
     ) => {
       try {
         const compactSessionId = input?.sessionID ?? sessionId;
-        const summaryContent = `Session compacting. Project: ${appId}. Branch: ${branch}. Session: ${compactSessionId}. Stats: ${stats.adds} memories stored, ${stats.searches} searches, ${stats.messages} messages.`;
+
+        // Session summary capture: store a structured summary of the session
+        const summaryPrompt = [
+          `Session summary for project ${appId} (branch: ${branch}).`,
+          `Session: ${compactSessionId}.`,
+          `Stats: ${stats.adds} memories stored, ${stats.searches} searches, ${stats.messages} messages.`,
+          `Extract and remember: what was requested, what was investigated, key decisions made, what was completed, and what needs to happen next.`,
+        ].join(" ");
         Promise.resolve().then(async () => {
           try {
-            await mem0.add([{ role: "user", content: summaryContent }], {
+            await mem0.add([{ role: "user", content: summaryPrompt }], {
               user_id: userId,
               app_id: appId,
               metadata: {
-                type: "session_state",
-                source: "pre-compaction",
+                type: "session_summary",
+                source: "opencode-stop",
                 session_id: compactSessionId,
                 branch,
               },

mem0-plugin/.opencode-plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mem0/opencode-plugin",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "type": "module",
   "description": "Mem0 persistent memory plugin for OpenCode — add, search, and manage memories across sessions",
   "main": "dist/index.js",

mem0-plugin/CHANGELOG.md

@@ -2,11 +2,29 @@
 
 All notable changes to the Mem0 plugin will be documented in this file.
 
+## 0.2.9 — File-context injection, session summaries & activity timeline
+
+### Added
+
+- **File-context injection (`PreToolUse/Read` hook):** Before Claude reads a file, the new `on_file_read.sh` hook searches mem0 for memories that reference that file path and injects a compact timeline of prior work as `additionalContext`. Gives Claude "I've seen this file before and here's what I remember" context automatically. Gates on file size (>= 1,500 bytes), 5-second hard timeout, silent skip on any failure. Applies to Claude Code, Codex, and Cursor (`on_file_read_cursor.sh`).
+- **Stop hook session summary (`on_stop.sh`):** On session end, parses the transcript JSONL, extracts the last assistant message and files touched, builds a structured prompt, and stores it via the mem0 API with `infer=True` — letting the platform's backend AI extract structured facts (request, decisions, learnings, next steps). Memories are stored as `metadata.type=session_summary` with 90-day expiry. Guards: skips subagent sessions (`agent_id` present), dedup via marker file, always exits 0. Applies to Claude Code, Codex, and Cursor (`on_stop_cursor.sh`).
+- **SessionStart activity timeline (`session_timeline.py`):** On startup (when project has existing memories), fetches the 10 most recent memories and renders a compact timeline with type icons, age indicators, and short text below the existing banner. Shows recent decisions, bug fixes, and session summaries at a glance. 5-second timeout — if the API is slow, the timeline silently skips while the banner still displays.
+- **`scripts/file_context.py`:** Core Python module for file-context injection. Searches mem0 cloud API with both relative and absolute file paths, deduplicates results, formats as compact timeline with type icons and memory age.
+- **`scripts/capture_session_summary.py`:** Core Python module for Stop hook. Reads transcript JSONL (tail 3,000 lines), extracts last assistant message, extracts file paths from tool_input fields, strips system tags and `<private>` blocks, stores via mem0 API.
+- **`scripts/session_timeline.py`:** Core Python module for SessionStart timeline. Fetches recent memories from mem0 API, formats with type icons, relative age, and short text.
+
+### Changed
+
+- **`on_session_start.sh`:** On startup (when memories > 0), calls `session_timeline.py` to inject a compact recent activity timeline below the existing banner and rubric instructions.
+- **`hooks/hooks.json`:** Added `PreToolUse` matcher for `Read` (5s timeout) and `Stop` hook (30s timeout).
+- **`hooks/codex-hooks.json`:** Added `PreToolUse` matcher for `Read` (5s timeout) and `Stop` hook (30s timeout).
+- **`hooks/cursor-hooks.json`:** Added `preToolUse` matcher for `Read` (5s timeout) and `stop` hook (30s timeout).
+
 ## 0.2.8 — Automatic coding categories & global search
 
 ### Added
 
-- **Global search mode (`global_search` setting):** New `global_search` toggle in `~/.mem0/settings.json` (default: `false`). When enabled, `search_memories` and `get_memories` calls use `{"OR": [{"user_id": "*"}]}` instead of the per-user per-project `AND` filter — returning all memories across all users and all `app_id` scopes in the platform project. Writes (`add_memory`) still tag with the current `user_id` and `app_id`. Solves the team-shared-memory use case where multiple team members need access to all memories regardless of which repo or user created them. Works on Claude Code, Cursor, and Codex (not OpenCode, which has its own TypeScript identity logic).
+- **Global search mode (`global_search` setting):** New `global_search` toggle in `~/.mem0/settings.json` (default: `false`). When enabled, `search_memories` and `get_memories` calls use `{"OR": [{"user_id": "*"}]}` instead of the per-user per-project `AND` filter — returning all memories across all users and all `app_id` scopes in the platform project. Writes (`add_memory`) still tag with the current `user_id` and `app_id`. Solves the team-shared-memory use case where multiple team members need access to all memories regardless of which repo or user created them. Works on Claude Code, Cursor, and Codex.
 - **`/mem0:switch-project --global` / `--no-global`:** Enables or disables global search via the switch-project skill. Persists to `~/.mem0/settings.json`. No manual config editing needed.
 - **Session banner scope indicator:** Banner shows `scope=global` when global search is active instead of `project=<app_id>`.
 - **Global-aware memory count:** Session start memory count query uses the global filter when `global_search` is enabled.
@@ -20,17 +38,10 @@ All notable changes to the Mem0 plugin will be documented in this file.
 - **`/mem0:onboard` Step 5 is no longer interactive:** Removed the `Install coding categories? [Y/n]` prompt. Categories now configure automatically in the background; the onboarding step only verifies status and applies them if the background run hasn't finished yet — mirroring how Step 4 (project-file import) already works.
 - **Session-start "new project" hint** now notes that coding categories install automatically in the background.
 
-## 0.1.0 — OpenCode & Antigravity
+## 0.1.0 — Antigravity
 
 ### Added
 
-- **OpenCode plugin** (`@mem0/opencode-plugin` on npm): Pure TypeScript plugin using the `mem0ai` TS SDK — no Python, no shell scripts. Hooks into all 6 OpenCode events (`chat.message`, `tool.execute.before`, `tool.execute.after`, `experimental.chat.system.transform`, `experimental.session.compacting`, `shell.env`). Features: session start memory loading, per-prompt semantic search, error pattern detection with memory lookup, resume/remember intent detection, auto-capture every 3rd message, periodic save nudges, full metadata defaults injection (confidence, source, type, session_id, files, branch), identity injection for search/get/delete filters, type-filtered error pre-fetch (anti_pattern + bug_fix), pre-compaction memory capture, MEMORY.md write blocking, and secret redaction.
-- **16 OpenCode-native skills** bundled in `opencode-skills/`: `context-loader`, `dream`, `export`, `forget`, `health`, `import`, `list-projects`, `mem0` (SDK reference), `memory-reviewer`, `onboard`, `peek`, `pin`, `remember`, `stats`, `switch-project`, `tour`. All skills are pure MCP-tool-based — no Python scripts, no shell scripts, no Claude Code dependencies.
-- **Auto-install skills and commands (`installSkills()`):** On plugin load, copies all 16 skills to `.opencode/skills/` and creates command wrapper files in `.opencode/commands/` so they appear in the OpenCode `/` palette. No manual setup needed.
-- **`extractUserText()` handler:** Robust text extraction from OpenCode response shapes — handles `parts[]` array, `content[]` array, `message.content`, and plain string responses.
-- **Identity resolution:** `getUserId()` uses `os.userInfo().username` (matching Claude Code's `${USER}` convention) with `MEM0_USER_ID` env override. `getProjectId()` uses git remote with `MEM0_APP_ID` env override.
-- **Context injection via `experimental.chat.system.transform`:** All memory context (session start memories, per-prompt search results, error-related memories, compaction context) injected as system context.
-- **CLI installer (`cli.ts`):** `bunx @mem0/opencode-plugin install` auto-configures plugin and MCP server in `~/.config/opencode/opencode.json`.
 - **Antigravity plugin** (`.antigravity/`): Restructured to follow the same shared-infrastructure pattern as Claude Code, Cursor, and Codex. Self-contained plugin directory with `plugin.json`, `mcp_config.json`, `hooks/hooks.json` (own file), `scripts/` (symlink → `../scripts/`), and `skills/` (symlink → `../skills/`). Installable via `agy plugin install .antigravity` or `npx degit mem0ai/mem0/mem0-plugin/.antigravity ~/.gemini/config/plugins/mem0`. Uses `contextFileName: "AGENTS.md"` per Antigravity convention.
 - **Codex hooks parity:** Added missing `PreToolUse` Write/Edit/MultiEdit block and `PreCompact` hook to Codex hooks config, bringing it to full parity with Claude Code.
 

mem0-plugin/hooks.json

@@ -51,6 +51,29 @@
             "timeout": 3
           }
         ]
+      },
+      {
+        "matcher": "Read",
+        "hooks": [
+          {
+            "name": "mem0-file-context",
+            "type": "command",
+            "command": "ANTIGRAVITY_PLUGIN_ROOT=${extensionPath} CLAUDE_PLUGIN_ROOT=${extensionPath} bash ${extensionPath}/scripts/on_file_read.sh",
+            "timeout": 5
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "name": "mem0-session-summary",
+            "type": "command",
+            "command": "ANTIGRAVITY_PLUGIN_ROOT=${extensionPath} CLAUDE_PLUGIN_ROOT=${extensionPath} bash ${extensionPath}/scripts/on_stop.sh",
+            "timeout": 30
+          }
+        ]
       }
     ],
     "PostToolUse": [

mem0-plugin/hooks/codex-hooks.json

@@ -20,6 +20,16 @@
             "timeout": 3
           }
         ]
+      },
+      {
+        "matcher": "Read",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${PLUGIN_ROOT}/scripts/on_file_read.sh",
+            "timeout": 5
+          }
+        ]
       }
     ],
     "SessionStart": [
@@ -68,6 +78,17 @@
         ]
       }
     ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${PLUGIN_ROOT}/scripts/on_stop.sh",
+            "timeout": 30
+          }
+        ]
+      }
+    ],
     "PreCompact": [
       {
         "hooks": [

mem0-plugin/hooks/cursor-hooks.json

@@ -16,6 +16,11 @@
         "command": "${CURSOR_PLUGIN_ROOT}/scripts/enforce_metadata_defaults.sh",
         "matcher": "mcp__mem0__add_memory|mcp__plugin_mem0_mem0__add_memory|mcp__mem0__search_memories|mcp__plugin_mem0_mem0__search_memories|mcp__mem0__get_memories|mcp__plugin_mem0_mem0__get_memories|mcp__mem0__delete_all_memories|mcp__plugin_mem0_mem0__delete_all_memories",
         "timeout": 3
+      },
+      {
+        "command": "${CURSOR_PLUGIN_ROOT}/scripts/on_file_read_cursor.sh",
+        "matcher": "Read",
+        "timeout": 5
       }
     ],
     "postToolUse": [
@@ -30,6 +35,12 @@
         "timeout": 12
       }
     ],
+    "stop": [
+      {
+        "command": "${CURSOR_PLUGIN_ROOT}/scripts/on_stop_cursor.sh",
+        "timeout": 30
+      }
+    ],
     "preCompact": [
       {
         "command": "${CURSOR_PLUGIN_ROOT}/scripts/on_pre_compact_cursor.sh"

mem0-plugin/hooks/hooks.json

@@ -54,6 +54,16 @@
             "timeout": 3
           }
         ]
+      },
+      {
+        "matcher": "Read",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${CLAUDE_PLUGIN_ROOT}/scripts/on_file_read.sh",
+            "timeout": 5
+          }
+        ]
       }
     ],
     "PostToolUse": [
@@ -78,6 +88,17 @@
         ]
       }
     ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${CLAUDE_PLUGIN_ROOT}/scripts/on_stop.sh",
+            "timeout": 30
+          }
+        ]
+      }
+    ],
     "PreCompact": [
       {
         "hooks": [

mem0-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "mem0",
   "name": "mem0",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "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",

mem0-plugin/scripts/_formatting.py

@@ -0,0 +1,51 @@
+"""Shared formatting helpers for mem0 plugin hooks.
+
+Constants and utilities used by file_context.py, session_timeline.py,
+and any future hook that displays memories.
+"""
+
+from __future__ import annotations
+
+TYPE_ICONS = {
+    "decision": "⚖️",
+    "anti_pattern": "\U0001f534",
+    "bug_fix": "\U0001f534",
+    "convention": "\U0001f504",
+    "task_learning": "\U0001f535",
+    "user_preference": "\U0001f7e3",
+    "session_summary": "\U0001f4cb",
+    "session_state": "\U0001f4cb",
+    "project_profile": "\U0001f4d6",
+    "compact_summary": "\U0001f4cb",
+    "auto_capture": "✅",
+    "environmental": "🌐",
+    "health_check": "🩺",
+}
+
+
+def format_age(memory: dict) -> str:
+    """Format how long ago a memory was created, e.g. '2h ago', '3d ago'."""
+    created = memory.get("created_at", "")
+    if not created:
+        return ""
+    try:
+        from datetime import datetime, timezone
+
+        if created.endswith("Z"):
+            created = created[:-1] + "+00:00"
+        dt = datetime.fromisoformat(created)
+        now = datetime.now(timezone.utc)
+        delta = now - dt
+        seconds = int(delta.total_seconds())
+        if seconds < 3600:
+            return f"{seconds // 60}m ago"
+        if seconds < 86400:
+            return f"{seconds // 3600}h ago"
+        days = seconds // 86400
+        if days == 1:
+            return "1d ago"
+        if days < 30:
+            return f"{days}d ago"
+        return f"{days // 30}mo ago"
+    except Exception:
+        return ""

mem0-plugin/scripts/_search.py

@@ -37,23 +37,28 @@ def search_memories(
     min_score: float = 0.0,
     rerank: bool = False,
     threshold: float = 0.3,
+    global_search: bool = False,
 ) -> list[dict]:
     if not api_key:
         return []
 
-    base_clauses: list[dict] = [{"user_id": user_id}, {"app_id": project_id}]
-    if metadata_type:
-        base_clauses.append({"metadata": {"type": metadata_type}})
-    if metadata_filters:
-        for key, value in metadata_filters.items():
-            base_clauses.append({"metadata": {key: value}})
+    if global_search:
+        filters: dict = {"OR": [{"user_id": "*"}]}
+    else:
+        base_clauses: list[dict] = [{"user_id": user_id}, {"app_id": project_id}]
+        if metadata_type:
+            base_clauses.append({"metadata": {"type": metadata_type}})
+        if metadata_filters:
+            for key, value in metadata_filters.items():
+                base_clauses.append({"metadata": {key: value}})
+        filters = {"AND": base_clauses}
 
     base_payload: dict = {"query": query, "top_k": top_k, "threshold": threshold}
     if rerank:
         base_payload["rerank"] = True
 
     try:
-        payload = {**base_payload, "filters": {"AND": list(base_clauses)}}
+        payload = {**base_payload, "filters": filters}
         results = _do_search(api_key, payload)[:top_k]
 
         if min_score > 0:

mem0-plugin/scripts/capture_session_summary.py

@@ -0,0 +1,264 @@
+#!/usr/bin/env python3
+"""Capture a structured session summary on Stop hook.
+
+Runs on every Stop (end of each assistant turn). Each invocation reads
+the transcript JSONL, extracts the latest assistant message and all
+files touched so far, then stores via mem0 API with infer=True. Uses
+run_id=session_id to scope infer dedup to the session, so the final
+stored summary reflects the most recent turn — not just the first.
+
+Input:  JSON on stdin with transcript_path, session_id, cwd, agent_id
+Output: stderr logs only (exit 0 always — must not block)
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import re
+import sys
+import urllib.error
+import urllib.request
+from datetime import date, timedelta
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from _identity import resolve_api_key, resolve_user_id
+from _project import resolve_branch, resolve_project_id
+
+log = logging.getLogger("mem0-session-summary")
+log.setLevel(logging.DEBUG)
+_handler = logging.StreamHandler(sys.stderr)
+_handler.setFormatter(logging.Formatter("[mem0-session-summary] %(message)s"))
+log.addHandler(_handler)
+
+if os.environ.get("MEM0_DEBUG"):
+    _log_dir = os.path.expanduser("~/.mem0")
+    try:
+        os.makedirs(_log_dir, exist_ok=True)
+        _fh = logging.FileHandler(os.path.join(_log_dir, "hooks.log"))
+        _fh.setFormatter(logging.Formatter("[mem0-session-summary] %(asctime)s %(message)s"))
+        log.addHandler(_fh)
+    except OSError:
+        pass
+
+API_URL = "https://api.mem0.ai"
+MAX_TAIL_LINES = 3000
+MAX_SUMMARY_CHARS = 50000
+SUMMARY_EXPIRY_DAYS = 90
+
+SYSTEM_TAG_RE = re.compile(
+    r"<(?:system-reminder|private|claude-mem-context|persisted-output|system_instruction)>"
+    r".*?"
+    r"</(?:system-reminder|private|claude-mem-context|persisted-output|system_instruction)>",
+    re.DOTALL,
+)
+
+
+def tail_lines(filepath: str, n: int) -> list[str]:
+    try:
+        with open(filepath, "rb") as f:
+            f.seek(0, 2)
+            file_size = f.tell()
+            if file_size == 0:
+                return []
+            chunk_size = min(file_size, n * 4096)
+            f.seek(max(0, file_size - chunk_size))
+            data = f.read().decode("utf-8", errors="replace")
+            return data.splitlines()[-n:]
+    except OSError:
+        return []
+
+
+def extract_last_assistant_message(lines: list[str]) -> str:
+    """Walk transcript backwards, return text content of the last assistant message."""
+    for line in reversed(lines):
+        line = line.strip()
+        if not line:
+            continue
+        if '"type":"assistant"' not in line and '"type": "assistant"' not in line:
+            continue
+        try:
+            entry = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        if entry.get("type") != "assistant":
+            continue
+        message = entry.get("message", {})
+        content = message.get("content", [])
+        if isinstance(content, str):
+            return content
+        if isinstance(content, list):
+            parts = []
+            for block in content:
+                if isinstance(block, str):
+                    parts.append(block)
+                elif isinstance(block, dict) and block.get("type") == "text":
+                    parts.append(block.get("text", ""))
+            return "\n".join(parts).strip()
+    return ""
+
+
+def extract_files_touched(lines: list[str]) -> list[str]:
+    """Extract unique file paths from tool_use content blocks in transcript."""
+    files = set()
+    file_ext_re = re.compile(
+        r"[a-zA-Z0-9_./-]+\.(?:py|ts|tsx|js|jsx|rs|go|rb|java|sh|yaml|yml|json|toml|md|sql|css|html)"
+    )
+    for line in lines:
+        line = line.strip()
+        if not line:
+            continue
+        if '"tool_use"' not in line and '"file_path"' not in line:
+            continue
+        try:
+            entry = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        content = entry.get("message", {}).get("content", [])
+        if not isinstance(content, list):
+            continue
+        for block in content:
+            if not isinstance(block, dict) or block.get("type") != "tool_use":
+                continue
+            inp = block.get("input", {})
+            if not isinstance(inp, dict):
+                continue
+            fp = inp.get("file_path", "")
+            if fp:
+                files.add(fp)
+            command = inp.get("command", "")
+            if command:
+                for match in file_ext_re.findall(command):
+                    files.add(match)
+    return sorted(files)[:20]
+
+
+def strip_tags(text: str) -> str:
+    return SYSTEM_TAG_RE.sub("", text).strip()
+
+
+def build_summary_prompt(assistant_msg: str, files: list[str]) -> str:
+    """Build a structured prompt that helps mem0's AI extract a good summary."""
+    files_section = ""
+    if files:
+        file_list = ", ".join(files[:10])
+        files_section = f"\n\nFiles touched during this session: {file_list}"
+
+    return (
+        f"Session summary — store the following as a structured session summary.\n\n"
+        f"What the assistant accomplished in this session:\n"
+        f"{assistant_msg[:MAX_SUMMARY_CHARS]}"
+        f"{files_section}\n\n"
+        f"Extract and remember: what was requested, what was investigated, "
+        f"key decisions made, what was completed, and what needs to happen next."
+    )
+
+
+def store_summary(
+    api_key: str,
+    summary_prompt: str,
+    user_id: str,
+    session_id: str,
+    project_id: str,
+    branch: str,
+    files: list[str],
+) -> bool:
+    expires = (date.today() + timedelta(days=SUMMARY_EXPIRY_DAYS)).isoformat()
+    metadata = {
+        "type": "session_summary",
+        "source": "stop-hook",
+        "session_id": session_id,
+    }
+    if branch:
+        metadata["branch"] = branch
+    if files:
+        metadata["files_touched"] = json.dumps(files[:20])
+
+    body = {
+        "messages": [{"role": "user", "content": summary_prompt}],
+        "user_id": user_id,
+        "app_id": project_id,
+        "run_id": session_id,
+        "metadata": metadata,
+        "infer": True,
+        "expiration_date": expires,
+    }
+
+    data = json.dumps(body).encode("utf-8")
+    req = urllib.request.Request(
+        f"{API_URL}/v3/memories/add/",
+        data=data,
+        headers={
+            "Content-Type": "application/json",
+            "Authorization": f"Token {api_key}",
+        },
+        method="POST",
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=15) as resp:
+            if resp.status in (200, 201):
+                log.info("Session summary stored")
+                return True
+            log.warning("API returned status %d", resp.status)
+            return False
+    except urllib.error.URLError as e:
+        log.warning("API call failed: %s", e)
+        return False
+
+
+def main():
+    api_key = resolve_api_key()
+    if not api_key:
+        log.debug("MEM0_API_KEY not set, skipping")
+        return
+
+    try:
+        hook_input = json.loads(sys.stdin.read())
+    except (json.JSONDecodeError, OSError):
+        log.debug("No valid JSON on stdin")
+        return
+
+    # Guard: skip subagent sessions (only root sessions get summaries)
+    agent_id = hook_input.get("agent_id", "")
+    if agent_id:
+        log.debug("Subagent session (agent_id=%s), skipping", agent_id)
+        return
+
+    transcript_path = hook_input.get("transcript_path", "")
+    if not transcript_path:
+        log.debug("No transcript_path provided")
+        return
+
+    session_id = hook_input.get("session_id", "")
+    cwd = hook_input.get("cwd") or None
+
+    user_id = resolve_user_id()
+    project_id = resolve_project_id(cwd)
+    branch = resolve_branch(cwd)
+
+    lines = tail_lines(transcript_path, MAX_TAIL_LINES)
+    if not lines:
+        log.debug("Transcript empty or unreadable: %s", transcript_path)
+        return
+
+    assistant_msg = extract_last_assistant_message(lines)
+    if not assistant_msg or len(assistant_msg.strip()) < 100:
+        log.debug("Assistant message too short (%d chars) — skipping", len(assistant_msg.strip()))
+        return
+
+    assistant_msg = strip_tags(assistant_msg)
+    files = extract_files_touched(lines)
+
+    summary_prompt = build_summary_prompt(assistant_msg, files)
+
+    log.info("Capturing session summary (%d chars, %d files)", len(assistant_msg), len(files))
+    store_summary(api_key, summary_prompt, user_id, session_id, project_id, branch, files)
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception as e:
+        log.error("Unexpected error: %s", e)
+    sys.exit(0)

mem0-plugin/scripts/file_context.py

@@ -0,0 +1,133 @@
+#!/usr/bin/env python3
+"""File-context injection for PreToolUse/Read hook.
+
+When Claude is about to read a file, this script searches mem0 for
+memories that reference that file path and returns a compact timeline
+of prior work. This gives Claude context like "last time you fixed a
+null pointer here" before it reads the file.
+
+Modeled after claude-mem's file-context handler but adapted for mem0's
+cloud API architecture.
+
+Input:  file_path (positional arg), env vars for identity
+Output: JSON to stdout with hookSpecificOutput.additionalContext
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+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
+
+FILE_READ_GATE_MIN_BYTES = 1500
+MAX_RESULTS = 5
+SEARCH_TIMEOUT = 5
+
+
+def gate_file(file_path: str, cwd: str) -> str | None:
+    """Return the resolved absolute path if the file passes gating, else None."""
+    if not file_path:
+        return None
+    p = Path(file_path)
+    if not p.is_absolute():
+        p = Path(cwd) / p
+    try:
+        p = p.resolve()
+        if not p.is_file():
+            return None
+        if p.stat().st_size < FILE_READ_GATE_MIN_BYTES:
+            return None
+        return str(p)
+    except OSError:
+        return None
+
+
+def relative_path(abs_path: str, cwd: str) -> str:
+    try:
+        return os.path.relpath(abs_path, cwd)
+    except ValueError:
+        return abs_path
+
+
+def format_timeline(memories: list[dict], file_path: str) -> str:
+    """Format memories into a compact timeline for context injection."""
+    if not memories:
+        return ""
+
+    rel = file_path
+    lines = [
+        f"Prior work on `{rel}` — {len(memories)} memories found.",
+        "Need details? Use `search_memories` with the memory ID.",
+        "",
+    ]
+
+    for m in memories:
+        mid = m.get("id", "?")[:8]
+        text = (m.get("memory", "") or "")[:150].replace("\n", " ").strip()
+        meta = m.get("metadata") or {}
+        cat = meta.get("type", "unknown")
+        icon = TYPE_ICONS.get(cat, "❓")
+        age = format_age(m)
+        age_str = f" ({age})" if age else ""
+        lines.append(f"- {icon} [{cat}]{age_str} {text} [mem0:{mid}]")
+
+    return "\n".join(lines)
+
+
+def search_file_context(
+    api_key: str, user_id: str, project_id: str, file_path: str, cwd: str
+) -> str:
+    """Search mem0 for memories related to a file path."""
+    global_search = os.environ.get("MEM0_GLOBAL_SEARCH", "false") == "true"
+    rel = relative_path(file_path, cwd)
+    basename = os.path.basename(file_path)
+
+    query = f"{rel} {basename}" if rel != basename else rel
+    results = search_memories(
+        api_key, user_id, project_id, query,
+        top_k=MAX_RESULTS, threshold=0.3,
+        global_search=global_search,
+    )
+
+    results = results[:MAX_RESULTS]
+
+    return format_timeline(results, rel)
+
+
+def main():
+    if len(sys.argv) < 2:
+        sys.exit(0)
+
+    file_path = sys.argv[1]
+    cwd = sys.argv[2] if len(sys.argv) > 2 else os.getcwd()
+
+    api_key = resolve_api_key()
+    if not api_key:
+        sys.exit(0)
+
+    resolved = gate_file(file_path, cwd)
+    if not resolved:
+        sys.exit(0)
+
+    user_id = resolve_user_id()
+    project_id = resolve_project_id(cwd)
+
+    timeline = search_file_context(api_key, user_id, project_id, resolved, cwd)
+    if not timeline:
+        sys.exit(0)
+
+    print(timeline, end="")
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception:
+        pass
+    sys.exit(0)

mem0-plugin/scripts/on_file_read.sh

@@ -0,0 +1,51 @@
+#!/usr/bin/env bash
+# Hook: PreToolUse (matcher: Read)
+#
+# Injects prior work context before Claude reads a file. Searches mem0
+# for memories referencing the file path and returns a compact timeline.
+#
+# Modeled after claude-mem's file-context handler, adapted for mem0 cloud API.
+#
+# Input:  JSON on stdin with tool_name, tool_input (file_path), cwd
+# Output: JSON with hookSpecificOutput.additionalContext + permissionDecision
+#
+# Must never block the Read — silent exit on any failure.
+
+set -uo pipefail
+
+INPUT=$(cat)
+
+# Extract file path from tool_input
+FILE_PATH=$(echo "$INPUT" | jq -r '.tool_input.file_path // ""' 2>/dev/null || echo "")
+if [ -z "$FILE_PATH" ]; then
+  exit 0
+fi
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+
+# Resolve API key (covers Desktop app users who set it in shell profile)
+if [ -z "${MEM0_API_KEY:-}" ]; then
+  . "$SCRIPT_DIR/_identity.sh" 2>/dev/null || true
+fi
+if [ -z "${MEM0_API_KEY:-}" ]; then
+  exit 0
+fi
+CWD=$(echo "$INPUT" | jq -r '.cwd // "."' 2>/dev/null || echo ".")
+
+# Call the Python worker — it handles gating (file size, existence)
+TIMELINE=$(python3 "$SCRIPT_DIR/file_context.py" "$FILE_PATH" "$CWD" 2>/dev/null || echo "")
+
+if [ -z "$TIMELINE" ]; then
+  exit 0
+fi
+
+# Return context injection with permissionDecision: allow
+jq -cn --arg ctx "$TIMELINE" '{
+  hookSpecificOutput: {
+    hookEventName: "PreToolUse",
+    additionalContext: $ctx,
+    permissionDecision: "allow"
+  }
+}' 2>/dev/null || true
+
+exit 0

mem0-plugin/scripts/on_file_read_cursor.sh

@@ -0,0 +1,41 @@
+#!/usr/bin/env bash
+# Hook: preToolUse (matcher: Read) — Cursor variant
+#
+# Same as on_file_read.sh but uses CURSOR_PLUGIN_ROOT for path resolution
+# and sources Cursor-specific identity.
+
+set -uo pipefail
+
+INPUT=$(cat)
+
+FILE_PATH=$(echo "$INPUT" | jq -r '.tool_input.file_path // ""' 2>/dev/null || echo "")
+if [ -z "$FILE_PATH" ]; then
+  exit 0
+fi
+
+if [ -z "${MEM0_API_KEY:-}" ]; then
+  SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+  . "$SCRIPT_DIR/_identity.sh" 2>/dev/null || true
+fi
+if [ -z "${MEM0_API_KEY:-}" ]; then
+  exit 0
+fi
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+CWD=$(echo "$INPUT" | jq -r '.cwd // "."' 2>/dev/null || echo ".")
+
+TIMELINE=$(python3 "$SCRIPT_DIR/file_context.py" "$FILE_PATH" "$CWD" 2>/dev/null || echo "")
+
+if [ -z "$TIMELINE" ]; then
+  exit 0
+fi
+
+jq -cn --arg ctx "$TIMELINE" '{
+  hookSpecificOutput: {
+    hookEventName: "PreToolUse",
+    additionalContext: $ctx,
+    permissionDecision: "allow"
+  }
+}' 2>/dev/null || true
+
+exit 0

mem0-plugin/scripts/on_session_start.sh

@@ -156,6 +156,14 @@ if [ "$SOURCE" = "startup" ]; then
     echo "New project with 0 memories. Invoke the mem0:onboard skill to import project files. Coding categories install automatically in the background."
   else
     echo "Search mem0 for recent decisions and task learnings before responding. Run 2 parallel searches: one for decision type, one for task_learning type."
+
+    # Inject compact recent activity timeline (non-blocking, 5s timeout)
+    # Use perl alarm as portable timeout (macOS lacks GNU timeout)
+    _TIMELINE=$(MEM0_CWD="$MEM0_CWD_RESOLVED" perl -e 'alarm 5; exec @ARGV' python3 "$SCRIPT_DIR/session_timeline.py" 2>/dev/null || echo "")
+    if [ -n "$_TIMELINE" ]; then
+      echo ""
+      echo "$_TIMELINE"
+    fi
   fi
 
   _PROJ_KEY=$(printf '%s' "$MEM0_CWD_RESOLVED" | tr '/' '-')
@@ -181,7 +189,9 @@ elif [ "$SOURCE" = "resume" ]; then
 
 elif [ "$SOURCE" = "compact" ]; then
   echo "Context compacted. Search mem0 for session_state and decision memories to recover context. Run 2 parallel searches."
-  printf '%s' "$INPUT" | python3 "$SCRIPT_DIR/capture_compact_summary.py" 2>/dev/null &
+  if [ "${MEM0_AUTO_SAVE:-true}" != "false" ]; then
+    printf '%s' "$INPUT" | python3 "$SCRIPT_DIR/capture_compact_summary.py" 2>/dev/null &
+  fi
 fi
 
 python3 "$SCRIPT_DIR/telemetry.py" session_start --source="$SOURCE" --memory_count="${MEM0_COUNT:-0}" 2>/dev/null &

mem0-plugin/scripts/on_stop.sh

@@ -0,0 +1,55 @@
+#!/usr/bin/env bash
+# Hook: Stop
+#
+# Captures a structured session summary when a Claude Code session ends.
+# Parses the transcript, extracts the last assistant message and files
+# touched, then stores via mem0 API with infer=True for AI extraction.
+#
+# Guards:
+#   - Skips subagent sessions (agent_id present)
+#   - Skips if no API key
+#   - Skips if no transcript_path
+#   - Dedup via marker file
+#
+# Input:  JSON on stdin with transcript_path, session_id, agent_id, cwd
+# Output: Nothing to stdout (background capture). Always exits 0.
+
+set -uo pipefail
+
+if [ -n "${MEM0_DEBUG:-}" ]; then
+  mkdir -p "$HOME/.mem0" && exec 2>>"$HOME/.mem0/hooks.log"
+fi
+
+INPUT=$(cat)
+
+# Guard: skip subagent sessions
+AGENT_ID=$(echo "$INPUT" | jq -r '.agent_id // ""' 2>/dev/null || echo "")
+if [ -n "$AGENT_ID" ]; then
+  exit 0
+fi
+
+# Resolve identity if needed
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+. "$SCRIPT_DIR/_identity.sh" 2>/dev/null || true
+
+# Honor auto_save=false in ~/.mem0/settings.json
+if [ "${MEM0_AUTO_SAVE:-true}" = "false" ]; then
+  exit 0
+fi
+
+if [ -z "${MEM0_API_KEY:-}" ]; then
+  exit 0
+fi
+
+TRANSCRIPT_PATH=$(echo "$INPUT" | jq -r '.transcript_path // ""' 2>/dev/null || echo "")
+if [ -z "$TRANSCRIPT_PATH" ]; then
+  exit 0
+fi
+
+# Run capture in the background — fires every turn now, so avoid blocking
+echo "$INPUT" | python3 "$SCRIPT_DIR/capture_session_summary.py" 2>/dev/null &
+
+# Telemetry
+python3 "$SCRIPT_DIR/telemetry.py" session_stop 2>/dev/null &
+
+exit 0

mem0-plugin/scripts/on_stop_cursor.sh

@@ -0,0 +1,36 @@
+#!/usr/bin/env bash
+# Hook: stop — Cursor variant
+#
+# Same as on_stop.sh but uses CURSOR_PLUGIN_ROOT and Cursor-specific
+# identity resolution.
+
+set -uo pipefail
+
+if [ -n "${MEM0_DEBUG:-}" ]; then
+  mkdir -p "$HOME/.mem0" && exec 2>>"$HOME/.mem0/hooks.log"
+fi
+
+INPUT=$(cat)
+
+AGENT_ID=$(echo "$INPUT" | jq -r '.agent_id // ""' 2>/dev/null || echo "")
+if [ -n "$AGENT_ID" ]; then
+  exit 0
+fi
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+. "$SCRIPT_DIR/_identity.sh" 2>/dev/null || true
+
+if [ -z "${MEM0_API_KEY:-}" ]; then
+  exit 0
+fi
+
+TRANSCRIPT_PATH=$(echo "$INPUT" | jq -r '.transcript_path // ""' 2>/dev/null || echo "")
+if [ -z "$TRANSCRIPT_PATH" ]; then
+  exit 0
+fi
+
+echo "$INPUT" | python3 "$SCRIPT_DIR/capture_session_summary.py" 2>/dev/null || true
+
+python3 "$SCRIPT_DIR/telemetry.py" session_stop 2>/dev/null &
+
+exit 0

mem0-plugin/scripts/on_user_prompt.sh

@@ -174,7 +174,7 @@ fi
 # overlapping window ensures the next batch (MSG_COUNT=6) picks up the
 # exchange that was incomplete in the previous batch.
 TRANSCRIPT_PATH=$(echo "$INPUT" | jq -r '.transcript_path // ""' 2>/dev/null || echo "")
-if [ $((MSG_COUNT % 3)) -eq 0 ] && [ "$MSG_COUNT" -gt 0 ] && [ -n "$TRANSCRIPT_PATH" ]; then
+if [ "${MEM0_AUTO_SAVE:-true}" != "false" ] && [ $((MSG_COUNT % 3)) -eq 0 ] && [ "$MSG_COUNT" -gt 0 ] && [ -n "$TRANSCRIPT_PATH" ]; then
   python3 "$SCRIPT_DIR/auto_capture.py" "$TRANSCRIPT_PATH" 2>/dev/null &
 fi
 

mem0-plugin/scripts/session_timeline.py

@@ -0,0 +1,106 @@
+#!/usr/bin/env python3
+"""Fetch recent memories and format a compact timeline for SessionStart.
+
+Searches mem0 cloud API for the most recent memories in the project
+and formats them as a compact activity timeline injected below the
+existing SessionStart banner.
+
+Input:  env vars for identity (MEM0_API_KEY, MEM0_RESOLVED_USER_ID, etc.)
+Output: Compact timeline text to stdout (empty if nothing found)
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+import urllib.request
+
+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
+
+API_URL = "https://api.mem0.ai"
+MAX_RECENT = 10
+MAX_SUMMARIES = 3
+FETCH_TIMEOUT = 5
+
+
+def fetch_recent_memories(api_key: str, user_id: str, project_id: str) -> list[dict]:
+    """Fetch the most recent memories for this project via GET list endpoint."""
+    global_search = os.environ.get("MEM0_GLOBAL_SEARCH", "false") == "true"
+
+    if global_search:
+        filters = {"OR": [{"user_id": "*"}]}
+    else:
+        filters = {"AND": [{"user_id": user_id}, {"app_id": project_id}]}
+
+    body = json.dumps({"filters": filters}).encode()
+    req = urllib.request.Request(
+        f"{API_URL}/v3/memories/?page=1&page_size={MAX_RECENT}",
+        data=body,
+        headers={
+            "Authorization": f"Token {api_key}",
+            "Content-Type": "application/json",
+        },
+        method="POST",
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=FETCH_TIMEOUT) as r:
+            result = json.loads(r.read())
+            if isinstance(result, dict) and "results" in result:
+                return result["results"][:MAX_RECENT]
+            if isinstance(result, list):
+                return result[:MAX_RECENT]
+            return []
+    except Exception:
+        return []
+
+
+def format_timeline(memories: list[dict]) -> str:
+    """Format memories into a compact recent activity timeline."""
+    if not memories:
+        return ""
+
+    lines = ["### Recent Activity", ""]
+
+    for m in memories:
+        mid = m.get("id", "?")[:8]
+        text = (m.get("memory", "") or "")[:120].replace("\n", " ").strip()
+        meta = m.get("metadata") or {}
+        cat = meta.get("type", "unknown")
+        icon = TYPE_ICONS.get(cat, "❓")
+        age = format_age(m)
+        age_str = f" ({age})" if age else ""
+        lines.append(f"- {icon} [{cat}]{age_str} {text} [mem0:{mid}]")
+
+    lines.append("")
+    lines.append("Search mem0 for details on any of these, or for past decisions and task learnings relevant to the current task.")
+
+    return "\n".join(lines)
+
+
+def main():
+    api_key = resolve_api_key()
+    if not api_key:
+        return
+
+    user_id = resolve_user_id()
+    project_id = resolve_project_id(os.environ.get("MEM0_CWD"))
+
+    memories = fetch_recent_memories(api_key, user_id, project_id)
+    if not memories:
+        return
+
+    timeline = format_timeline(memories)
+    if timeline:
+        print(timeline, end="")
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception:
+        pass
+    sys.exit(0)

mem0-ts/src/oss/src/embeddings/lmstudio.ts

@@ -44,7 +44,9 @@ export class LMStudioEmbedder implements Embedder {
         input: normalized,
         encoding_format: "float",
       });
-      return response.data.map((item) => item.embedding);
+      return response.data
+        .sort((a, b) => a.index - b.index)
+        .map((item) => item.embedding);
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       throw new Error(`LM Studio embedder failed: ${message}`);

mem0-ts/src/oss/src/embeddings/openai.ts

@@ -20,6 +20,7 @@ export class OpenAIEmbedder implements Embedder {
     const response = await this.openai.embeddings.create({
       model: this.model,
       input: text,
+      encoding_format: "float",
       ...(this.embeddingDims !== undefined && {
         dimensions: this.embeddingDims,
       }),
@@ -35,6 +36,7 @@ export class OpenAIEmbedder implements Embedder {
       const response = await this.openai.embeddings.create({
         model: this.model,
         input: chunk,
+        encoding_format: "float",
         ...(this.embeddingDims !== undefined && {
           dimensions: this.embeddingDims,
         }),

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

@@ -1064,7 +1064,7 @@ export class Memory {
       : {};
 
     await this._ensureInitialized();
-    const { topK = 20, threshold = 0.1 } = config;
+    const { topK = 20, threshold = 0.1, explain = false } = config;
 
     await this._captureEvent("search", {
       query_length: query.length,
@@ -1169,17 +1169,35 @@ export class Memory {
 
         if (deduped.length > 0) {
           const entityStore = await this.getEntityStore();
+          const entitySearchFilters: Record<string, any> = {};
+          for (const k of ["user_id", "agent_id", "run_id"] as const) {
+            if (effectiveFilters[k])
+              entitySearchFilters[k] = effectiveFilters[k];
+          }
+          const entityTexts = deduped.map((e) => e.text);
+          const embeddings = await this.embedder.embedBatch(entityTexts);
 
-          for (const entity of deduped) {
-            try {
-              const entityEmbedding = await this.embedder.embed(entity.text);
-              const matches = await entityStore.search(
-                entityEmbedding,
-                500,
-                effectiveFilters,
-              );
+          if (embeddings.length !== entityTexts.length) {
+            console.warn(
+              `embedBatch returned ${embeddings.length} vectors for ${entityTexts.length} texts — skipping entity boost`,
+            );
+          } else {
+            const searchResults = await Promise.allSettled(
+              deduped.map((_, i) =>
+                entityStore.search(embeddings[i], 500, entitySearchFilters),
+              ),
+            );
 
-              for (const match of matches) {
+            for (const result of searchResults) {
+              if (result.status === "rejected") {
+                console.warn(
+                  "Entity boost search failed for one entity:",
+                  result.reason,
+                );
+                continue;
+              }
+
+              for (const match of result.value) {
                 const similarity = match.score ?? 0;
                 if (similarity < 0.5) continue;
 
@@ -1187,7 +1205,6 @@ export class Memory {
                 const linkedMemoryIds = payload.linkedMemoryIds ?? [];
                 if (!Array.isArray(linkedMemoryIds)) continue;
 
-                // Spread-attenuated boost
                 const numLinked = Math.max(linkedMemoryIds.length, 1);
                 const memoryCountWeight =
                   1.0 / (1.0 + 0.001 * (numLinked - 1) ** 2);
@@ -1204,8 +1221,6 @@ export class Memory {
                   }
                 }
               }
-            } catch (e) {
-              // Individual entity boost failed — continue
             }
           }
         }
@@ -1228,6 +1243,7 @@ export class Memory {
       entityBoosts,
       threshold ?? 0.1,
       topK,
+      explain,
     );
 
     // Step 9: Format results
@@ -1260,6 +1276,7 @@ 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 }),
+          ...(scored.scoreDetails && { score_details: scored.scoreDetails }),
         };
       });
 

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

@@ -17,6 +17,7 @@ export interface SearchMemoryOptions {
   topK?: number;
   filters?: SearchFilters;
   threshold?: number;
+  explain?: boolean;
 }
 
 export interface GetAllMemoryOptions {

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

@@ -56,10 +56,21 @@ export function normalizeBm25(
   return 1.0 / (1.0 + Math.exp(-steepness * (rawScore - midpoint)));
 }
 
+export interface ScoreDetails {
+  semanticScore: number;
+  bm25Score: number;
+  entityBoost: number;
+  rawScore: number;
+  maxPossibleScore: number;
+  finalScore: number;
+  threshold: number;
+}
+
 export interface ScoredResult {
   id: string;
   score: number;
   payload: Record<string, any>;
+  scoreDetails?: ScoreDetails;
 }
 
 /**
@@ -82,6 +93,7 @@ export interface ScoredResult {
  * @param entityBoosts - Map of memory ID to entity boost score.
  * @param threshold - Minimum semantic score to include a candidate.
  * @param topK - Maximum number of results to return.
+ * @param explain - Include scoreDetails in each result when true.
  * @returns Sorted list of scored results, highest score first.
  */
 export function scoreAndRank(
@@ -94,6 +106,7 @@ export function scoreAndRank(
   entityBoosts: Record<string, number>,
   threshold: number,
   topK: number,
+  explain: boolean = false,
 ): ScoredResult[] {
   const hasBm25 = Object.keys(bm25Scores).length > 0;
   const hasEntity = Object.keys(entityBoosts).length > 0;
@@ -126,11 +139,23 @@ export function scoreAndRank(
     const rawCombined = semanticScore + bm25Score + entityBoost;
     const combined = Math.min(rawCombined / maxPossible, 1.0);
 
-    scored.push({
+    const entry: ScoredResult = {
       id: memIdStr,
       score: combined,
       payload: result.payload,
-    });
+    };
+    if (explain) {
+      entry.scoreDetails = {
+        semanticScore,
+        bm25Score,
+        entityBoost,
+        rawScore: rawCombined,
+        maxPossibleScore: maxPossible,
+        finalScore: combined,
+        threshold,
+      };
+    }
+    scored.push(entry);
   }
 
   scored.sort((a, b) => b.score - a.score);

mem0-ts/src/oss/src/vector_stores/redis.ts

@@ -444,7 +444,7 @@ export class RedisDB implements VectorStore {
         return {
           id: doc.value.memory_id,
           payload: toCamelCase(resultPayload),
-          score: Number(doc.value.__vector_score) ?? 0,
+          score: Math.max(0, 1 - (Number(doc.value.__vector_score) ?? 0)),
         };
       });
     } catch (error) {

mem0-ts/src/oss/tests/memory.entity-boost.test.ts

@@ -0,0 +1,276 @@
+/**
+ * Entity boost parallelism tests (#5214).
+ *
+ * Verifies that entity boost searches run concurrently via Promise.allSettled,
+ * scoring is preserved, and individual entity failures don't abort others.
+ */
+/// <reference types="jest" />
+import { Memory } from "../src/memory";
+import { ENTITY_BOOST_WEIGHT } from "../src/utils/scoring";
+import type { VectorStoreResult } from "../src/types";
+
+jest.setTimeout(15000);
+
+jest.mock("../src/embeddings/google", () => ({
+  GoogleEmbedder: jest.fn(),
+}));
+jest.mock("../src/llms/google", () => ({
+  GoogleLLM: jest.fn(),
+}));
+
+jest.mock("../src/llms/openai", () => ({
+  OpenAILLM: jest.fn().mockImplementation(() => ({
+    generateResponse: jest.fn().mockResolvedValue(
+      JSON.stringify({
+        memory: [{ id: "0", text: "fact", attributed_to: "user" }],
+      }),
+    ),
+  })),
+}));
+
+const mockEmbedding = new Array(1536).fill(0.1);
+jest.mock("../src/embeddings/openai", () => ({
+  OpenAIEmbedder: jest.fn().mockImplementation(() => ({
+    embed: jest.fn().mockResolvedValue(mockEmbedding),
+    embedBatch: jest
+      .fn()
+      .mockImplementation((texts: string[]) =>
+        Promise.resolve(texts.map(() => mockEmbedding)),
+      ),
+    embeddingDims: 1536,
+  })),
+}));
+
+function makeMatch(
+  id: string,
+  score: number,
+  linkedMemoryIds: string[],
+): VectorStoreResult {
+  return { id, score, payload: { linkedMemoryIds } };
+}
+
+function createMemory(): Memory {
+  return new Memory({
+    version: "v1.1",
+    embedder: {
+      provider: "openai",
+      config: { apiKey: "test-key", model: "text-embedding-3-small" },
+    },
+    vectorStore: {
+      provider: "memory",
+      config: {
+        collectionName: `test-entity-${Date.now()}-${Math.random()}`,
+        dimension: 1536,
+        dbPath: ":memory:",
+      },
+    },
+    llm: {
+      provider: "openai",
+      config: { apiKey: "test-key", model: "gpt-5-mini" },
+    },
+    historyDbPath: ":memory:",
+  });
+}
+
+describe("Entity boost parallelism (#5214)", () => {
+  let memory: Memory;
+
+  beforeEach(() => {
+    memory = createMemory();
+  });
+
+  afterEach(async () => {
+    await memory.reset();
+  });
+
+  it("should use Promise.allSettled for concurrent entity searches", async () => {
+    // Spy on Promise.allSettled to confirm it's being used
+    const allSettledSpy = jest.spyOn(Promise, "allSettled");
+
+    // Access internals to inject a mock entity store
+    const m = memory as any;
+    await m._ensureInitialized();
+
+    const mockEntityStore = {
+      search: jest.fn().mockResolvedValue([makeMatch("e1", 0.9, ["mem-1"])]),
+      initialize: jest.fn().mockResolvedValue(undefined),
+    };
+    m._entityStore = mockEntityStore;
+
+    m.embedder = {
+      embed: jest.fn().mockResolvedValue(mockEmbedding),
+      embedBatch: jest
+        .fn()
+        .mockImplementation((texts: string[]) =>
+          Promise.resolve(texts.map(() => mockEmbedding)),
+        ),
+    };
+
+    // Mock the vector store to return a semantic result
+    m.vectorStore.search = jest
+      .fn()
+      .mockResolvedValue([
+        { id: "mem-1", score: 0.8, payload: { data: "test" } },
+      ]);
+    m.vectorStore.keywordSearch = jest.fn().mockResolvedValue(null);
+
+    await m.search("alice and bob", { filters: { user_id: "u1" } });
+
+    expect(allSettledSpy).toHaveBeenCalled();
+    allSettledSpy.mockRestore();
+  });
+
+  it("should preserve scoring math with parallel execution", async () => {
+    const m = memory as any;
+    await m._ensureInitialized();
+
+    // Two entities: "alice" links to mem-1, "bob" links to mem-1 and mem-2
+    // mem-1 should get max(alice_boost, bob_boost)
+    const mockEntityStore = {
+      search: jest
+        .fn()
+        .mockImplementation(
+          (_embedding: number[], _topK: number, _filters: any) => {
+            // We need to differentiate by embedding content — but since all
+            // embeddings are identical mocks, we'll use call order
+            const callCount = mockEntityStore.search.mock.calls.length;
+            if (callCount <= 1) {
+              // First entity: "alice"
+              return Promise.resolve([makeMatch("e-alice", 0.9, ["mem-1"])]);
+            }
+            // Second entity: "bob"
+            return Promise.resolve([
+              makeMatch("e-bob", 0.6, ["mem-1", "mem-2"]),
+            ]);
+          },
+        ),
+      initialize: jest.fn().mockResolvedValue(undefined),
+    };
+    m._entityStore = mockEntityStore;
+    m.embedder = {
+      embed: jest.fn().mockResolvedValue(mockEmbedding),
+      embedBatch: jest
+        .fn()
+        .mockImplementation((texts: string[]) =>
+          Promise.resolve(texts.map(() => mockEmbedding)),
+        ),
+    };
+
+    // Semantic results include mem-1 and mem-2
+    m.vectorStore.search = jest.fn().mockResolvedValue([
+      { id: "mem-1", score: 0.85, payload: { data: "alice memory" } },
+      { id: "mem-2", score: 0.75, payload: { data: "bob memory" } },
+    ]);
+    m.vectorStore.keywordSearch = jest.fn().mockResolvedValue(null);
+
+    const result = await m.search("alice and bob", {
+      filters: { user_id: "u1" },
+    });
+
+    // Entity store was called (parallelized via Promise.allSettled)
+    expect(mockEntityStore.search).toHaveBeenCalled();
+
+    // Results should exist and have scores
+    expect(result.results.length).toBeGreaterThan(0);
+    for (const item of result.results) {
+      expect(typeof item.score).toBe("number");
+      expect(item.score).toBeGreaterThan(0);
+    }
+  });
+
+  it("should survive one entity search failure without losing other boosts", async () => {
+    const m = memory as any;
+    await m._ensureInitialized();
+
+    let callIndex = 0;
+    const mockEntityStore = {
+      search: jest.fn().mockImplementation(() => {
+        callIndex++;
+        if (callIndex === 1) {
+          return Promise.reject(new Error("provider timeout"));
+        }
+        return Promise.resolve([makeMatch("e-ok", 0.8, ["mem-9"])]);
+      }),
+      initialize: jest.fn().mockResolvedValue(undefined),
+    };
+    m._entityStore = mockEntityStore;
+    m.embedder = {
+      embed: jest.fn().mockResolvedValue(mockEmbedding),
+      embedBatch: jest
+        .fn()
+        .mockImplementation((texts: string[]) =>
+          Promise.resolve(texts.map(() => mockEmbedding)),
+        ),
+    };
+    m.vectorStore.search = jest
+      .fn()
+      .mockResolvedValue([
+        { id: "mem-9", score: 0.85, payload: { data: "surviving memory" } },
+      ]);
+    m.vectorStore.keywordSearch = jest.fn().mockResolvedValue(null);
+
+    const warnSpy = jest.spyOn(console, "warn").mockImplementation(() => {});
+
+    // "John Smith met Jane Doe" extracts two proper entities
+    const result = await m.search("John Smith met Jane Doe", {
+      filters: { user_id: "u1" },
+    });
+
+    expect(result.results.length).toBeGreaterThan(0);
+    expect(result.results[0].id).toBe("mem-9");
+    // Should log the failure like Python does
+    expect(warnSpy).toHaveBeenCalledWith(
+      "Entity boost search failed for one entity:",
+      expect.any(Error),
+    );
+    warnSpy.mockRestore();
+  });
+
+  it("should call entity searches concurrently, not sequentially", async () => {
+    const m = memory as any;
+    await m._ensureInitialized();
+
+    const concurrency = { current: 0, peak: 0 };
+
+    const mockEntityStore = {
+      search: jest.fn().mockImplementation(() => {
+        concurrency.current++;
+        concurrency.peak = Math.max(concurrency.peak, concurrency.current);
+        return new Promise<VectorStoreResult[]>((resolve) => {
+          setTimeout(() => {
+            concurrency.current--;
+            resolve([makeMatch("e1", 0.7, ["mem-1"])]);
+          }, 100);
+        });
+      }),
+      initialize: jest.fn().mockResolvedValue(undefined),
+    };
+    m._entityStore = mockEntityStore;
+    m.embedder = {
+      embed: jest.fn().mockResolvedValue(mockEmbedding),
+      embedBatch: jest
+        .fn()
+        .mockImplementation((texts: string[]) =>
+          Promise.resolve(texts.map(() => mockEmbedding)),
+        ),
+    };
+    m.vectorStore.search = jest
+      .fn()
+      .mockResolvedValue([
+        { id: "mem-1", score: 0.8, payload: { data: "test" } },
+      ]);
+    m.vectorStore.keywordSearch = jest.fn().mockResolvedValue(null);
+
+    const start = performance.now();
+    await m.search("entity1 and entity2 and entity3 and entity4", {
+      filters: { user_id: "u1" },
+    });
+    const elapsed = performance.now() - start;
+
+    // With 4 entities at 100ms each, sequential would be ~400ms+.
+    // Parallel should be well under that. Use generous bound for CI.
+    expect(elapsed).toBeLessThan(500);
+    // At least 2 searches should have overlapped
+    expect(concurrency.peak).toBeGreaterThanOrEqual(2);
+  });
+});

mem0-ts/src/oss/tests/openai-embedder.test.ts

@@ -2,7 +2,8 @@
 /**
  * OpenAI Embedder — unit tests (mocked OpenAI client).
  * Verifies that the `dimensions` parameter is only passed to the API
- * when the user explicitly configures `embeddingDims`.
+ * when the user explicitly configures `embeddingDims`, and that
+ * embeddings are requested as floats for OpenAI-compatible proxies.
  */
 
 const mockEmbeddingsCreate = jest.fn();
@@ -42,6 +43,7 @@ describe("OpenAIEmbedder (unit)", () => {
       expect(callArgs).toEqual({
         model: "text-embedding-3-small",
         input: "hello",
+        encoding_format: "float",
       });
     });
 
@@ -58,6 +60,7 @@ describe("OpenAIEmbedder (unit)", () => {
       expect(callArgs).toEqual({
         model: "text-embedding-3-small",
         input: "hello",
+        encoding_format: "float",
         dimensions: 1024,
       });
     });
@@ -87,6 +90,7 @@ describe("OpenAIEmbedder (unit)", () => {
 
       const callArgs = mockEmbeddingsCreate.mock.calls[0][0];
       expect(callArgs).not.toHaveProperty("dimensions");
+      expect(callArgs).toHaveProperty("encoding_format", "float");
     });
 
     it("passes dimensions in embedBatch when embeddingDims is explicitly set", async () => {
@@ -105,6 +109,7 @@ describe("OpenAIEmbedder (unit)", () => {
       expect(callArgs).toEqual({
         model: "text-embedding-3-small",
         input: ["hello", "world"],
+        encoding_format: "float",
         dimensions: 512,
       });
     });

mem0-ts/src/oss/tests/scoring.test.ts

@@ -0,0 +1,49 @@
+/// <reference types="jest" />
+
+import { scoreAndRank } from "../src/utils/scoring";
+
+describe("scoreAndRank", () => {
+  const results = [
+    { id: "a", score: 0.8, payload: { data: "mem a" } },
+    { id: "b", score: 0.5, payload: { data: "mem b" } },
+  ];
+
+  it("omits scoreDetails by default", () => {
+    const scored = scoreAndRank(results, {}, {}, 0.1, 10);
+    expect(scored[0].scoreDetails).toBeUndefined();
+    expect(scored[1].scoreDetails).toBeUndefined();
+  });
+
+  it("omits scoreDetails when explain is false", () => {
+    const scored = scoreAndRank(results, {}, {}, 0.1, 10, false);
+    expect(scored[0].scoreDetails).toBeUndefined();
+  });
+
+  it("includes scoreDetails when explain is true", () => {
+    const bm25 = { a: 0.6 };
+    const entity = { a: 0.3 };
+    const scored = scoreAndRank(results, bm25, entity, 0.1, 10, true);
+
+    const details = scored[0].scoreDetails!;
+    expect(details).toBeDefined();
+    expect(details.semanticScore).toBe(0.8);
+    expect(details.bm25Score).toBe(0.6);
+    expect(details.entityBoost).toBe(0.3);
+    expect(details.rawScore).toBeCloseTo(1.7);
+    expect(details.maxPossibleScore).toBe(2.5);
+    expect(details.finalScore).toBeCloseTo(0.68);
+    expect(details.threshold).toBe(0.1);
+  });
+
+  it("includes scoreDetails for results without bm25/entity signals", () => {
+    const scored = scoreAndRank(results, {}, {}, 0.1, 10, true);
+
+    const details = scored[0].scoreDetails!;
+    expect(details.semanticScore).toBe(0.8);
+    expect(details.bm25Score).toBe(0);
+    expect(details.entityBoost).toBe(0);
+    expect(details.rawScore).toBe(0.8);
+    expect(details.maxPossibleScore).toBe(1.0);
+    expect(details.finalScore).toBe(0.8);
+  });
+});

mem0/client/main.py

@@ -33,6 +33,15 @@ setup_config()
 ENTITY_PARAMS = frozenset({"user_id", "agent_id", "app_id", "run_id"})
 
 
+def _validate_and_trim_search_query(query: str) -> str:
+    if not isinstance(query, str):
+        raise ValueError("Invalid query: must be a non-empty string.")
+    trimmed = query.strip()
+    if not trimmed:
+        raise ValueError("Invalid query: cannot be empty or whitespace-only.")
+    return trimmed
+
+
 def _maybe_alias_anon_to_email(user_email):
     """Fire $identify per prior anon ID so PostHog merges them into email.
 
@@ -306,6 +315,7 @@ class MemoryClient:
 
         kwargs = {**(options.model_dump(exclude_unset=True) if options else {}), **kwargs}
         params = self._prepare_params(kwargs)
+        query = _validate_and_trim_search_query(query)
         payload = {"query": query, **params}
 
         response = self.client.post("/v3/memories/search/", json=payload)
@@ -1221,6 +1231,7 @@ class AsyncMemoryClient:
 
         kwargs = {**(options.model_dump(exclude_unset=True) if options else {}), **kwargs}
         params = self._prepare_params(kwargs)
+        query = _validate_and_trim_search_query(query)
         payload = {"query": query, **params}
 
         response = await self.async_client.post("/v3/memories/search/", json=payload)

mem0/configs/embeddings/base.py

@@ -25,7 +25,7 @@ class BaseEmbedderConfig(ABC):
         model_kwargs: Optional[dict] = None,
         huggingface_base_url: Optional[str] = None,
         # AzureOpenAI specific
-        azure_kwargs: Optional[AzureConfig] = {},
+        azure_kwargs: Optional[AzureConfig] = None,
         http_client_proxies: Optional[Union[Dict, str]] = None,
         # VertexAI specific
         vertex_credentials_json: Optional[str] = None,
@@ -89,7 +89,7 @@ class BaseEmbedderConfig(ABC):
         self.model_kwargs = model_kwargs or {}
         self.huggingface_base_url = huggingface_base_url
         # AzureOpenAI specific
-        self.azure_kwargs = AzureConfig(**azure_kwargs) or {}
+        self.azure_kwargs = AzureConfig(**(azure_kwargs or {})) or {}
 
         # VertexAI specific
         self.vertex_credentials_json = vertex_credentials_json

mem0/configs/llms/azure.py

@@ -23,6 +23,7 @@ class AzureOpenAIConfig(BaseLlmConfig):
         vision_details: Optional[str] = "auto",
         reasoning_effort: Optional[str] = None,
         http_client_proxies: Optional[dict] = None,
+        is_reasoning_model: Optional[bool] = None,
         # Azure OpenAI-specific parameters
         azure_kwargs: Optional[Dict[str, Any]] = None,
     ):
@@ -40,6 +41,10 @@ class AzureOpenAIConfig(BaseLlmConfig):
             vision_details: Vision detail level, defaults to "auto"
             reasoning_effort: Effort level for reasoning models ("low", "medium", "high"), defaults to None
             http_client_proxies: HTTP client proxy settings, defaults to None
+            is_reasoning_model: Explicit override for reasoning-model detection.
+                None (default) uses the name-based heuristic. Set True to drop
+                max_tokens/temperature (e.g. for versioned Azure deployments like
+                "gpt-5.4-nano-2026-03-17"), or False to force standard params.
             azure_kwargs: Azure-specific configuration, defaults to None
         """
         # Initialize base parameters
@@ -54,6 +59,7 @@ class AzureOpenAIConfig(BaseLlmConfig):
             vision_details=vision_details,
             reasoning_effort=reasoning_effort,
             http_client_proxies=http_client_proxies,
+            is_reasoning_model=is_reasoning_model,
         )
 
         # Azure OpenAI-specific parameters

mem0/configs/llms/base.py

@@ -25,6 +25,7 @@ class BaseLlmConfig(ABC):
         vision_details: Optional[str] = "auto",
         reasoning_effort: Optional[str] = None,
         http_client_proxies: Optional[Union[Dict, str]] = None,
+        is_reasoning_model: Optional[bool] = None,
     ):
         """
         Initialize a base configuration class instance for the LLM.
@@ -54,6 +55,14 @@ class BaseLlmConfig(ABC):
                 Defaults to None (uses the model's default reasoning effort)
             http_client_proxies: Proxy settings for HTTP client.
                 Can be a dict or string. Defaults to None
+            is_reasoning_model: Explicit override for reasoning-model detection.
+                When None (default), the model is classified automatically from its
+                name (preserving existing behavior). Set to True to force the
+                reasoning-model parameter set (drop max_tokens and temperature),
+                or False to force the standard parameter set. Useful for
+                deployments with custom/versioned model names (e.g. Azure
+                "gpt-5.4-nano-2026-03-17") that the name-based heuristic cannot
+                recognize. Defaults to None
         """
         self.model = model
         self.temperature = temperature
@@ -64,4 +73,5 @@ class BaseLlmConfig(ABC):
         self.enable_vision = enable_vision
         self.vision_details = vision_details
         self.reasoning_effort = reasoning_effort
+        self.is_reasoning_model = is_reasoning_model
         self.http_client = httpx.Client(proxies=http_client_proxies) if http_client_proxies else None

mem0/configs/llms/openai.py

@@ -22,6 +22,7 @@ class OpenAIConfig(BaseLlmConfig):
         vision_details: Optional[str] = "auto",
         reasoning_effort: Optional[str] = None,
         http_client_proxies: Optional[dict] = None,
+        is_reasoning_model: Optional[bool] = None,
         # OpenAI-specific parameters
         openai_base_url: Optional[str] = None,
         models: Optional[List[str]] = None,
@@ -47,6 +48,9 @@ class OpenAIConfig(BaseLlmConfig):
             vision_details: Vision detail level, defaults to "auto"
             reasoning_effort: Effort level for reasoning models ("low", "medium", "high"), defaults to None
             http_client_proxies: HTTP client proxy settings, defaults to None
+            is_reasoning_model: Explicit override for reasoning-model detection.
+                None (default) uses the name-based heuristic. Set True to drop
+                max_tokens/temperature, or False to force standard params.
             openai_base_url: OpenAI API base URL, defaults to None
             models: List of models for OpenRouter, defaults to None
             route: OpenRouter route strategy, defaults to "fallback"
@@ -72,6 +76,7 @@ class OpenAIConfig(BaseLlmConfig):
             vision_details=vision_details,
             reasoning_effort=reasoning_effort,
             http_client_proxies=http_client_proxies,
+            is_reasoning_model=is_reasoning_model,
         )
 
         # OpenAI-specific parameters

mem0/configs/llms/xai.py

@@ -0,0 +1,55 @@
+from typing import Optional
+
+from mem0.configs.llms.base import BaseLlmConfig
+
+
+class XAIConfig(BaseLlmConfig):
+    """
+    Configuration class for X.AI (Grok) provider parameters.
+    Inherits from BaseLlmConfig and adds X.AI-specific settings.
+    """
+
+    def __init__(
+        self,
+        # Base parameters
+        model: Optional[str] = None,
+        temperature: float = 0.1,
+        api_key: Optional[str] = None,
+        max_tokens: int = 2000,
+        top_p: float = 0.1,
+        top_k: int = 1,
+        enable_vision: bool = False,
+        vision_details: Optional[str] = "auto",
+        http_client_proxies: Optional[dict] = None,
+        # X.AI-specific parameters
+        xai_base_url: Optional[str] = None,
+    ):
+        """
+        Initialize X.AI configuration.
+
+        Args:
+            model: X.AI / Grok model to use, defaults to None
+            temperature: Controls randomness, defaults to 0.1
+            api_key: X.AI API key, defaults to None
+            max_tokens: Maximum tokens to generate, defaults to 2000
+            top_p: Nucleus sampling parameter, defaults to 0.1
+            top_k: Top-k sampling parameter, defaults to 1
+            enable_vision: Enable vision capabilities, defaults to False
+            vision_details: Vision detail level, defaults to "auto"
+            http_client_proxies: HTTP client proxy settings, defaults to None
+            xai_base_url: X.AI API base URL, defaults to None
+        """
+        super().__init__(
+            model=model,
+            temperature=temperature,
+            api_key=api_key,
+            max_tokens=max_tokens,
+            top_p=top_p,
+            top_k=top_k,
+            enable_vision=enable_vision,
+            vision_details=vision_details,
+            http_client_proxies=http_client_proxies,
+        )
+
+        # X.AI-specific parameters
+        self.xai_base_url = xai_base_url

mem0/llms/azure_openai.py

@@ -33,6 +33,7 @@ class AzureOpenAILLM(LLMBase):
                 vision_details=config.vision_details,
                 reasoning_effort=getattr(config, 'reasoning_effort', None),
                 http_client_proxies=config.http_client,
+                is_reasoning_model=getattr(config, 'is_reasoning_model', None),
             )
 
         super().__init__(config)

mem0/llms/base.py

@@ -43,13 +43,23 @@ class LLMBase(ABC):
     def _is_reasoning_model(self, model: str) -> bool:
         """
         Check if the model is a reasoning model or GPT-5 series that doesn't support certain parameters.
-        
+
+        An explicit ``is_reasoning_model`` on the config takes precedence over the
+        name-based heuristic. This lets deployments with custom/versioned model
+        names (e.g. Azure ``gpt-5.4-nano-2026-03-17``) opt in or out without
+        relying on string matching. When the config value is ``None`` (default),
+        classification falls back to the name-based heuristic below.
+
         Args:
             model: The model name to check
-            
+
         Returns:
             bool: True if the model is a reasoning model or GPT-5 series
         """
+        explicit = getattr(self.config, "is_reasoning_model", None)
+        if explicit is not None:
+            return explicit
+
         reasoning_models = {
             "o1", "o1-preview", "o3-mini", "o3",
             "gpt-5", "gpt-5o", "gpt-5o-mini", "gpt-5o-micro",

mem0/llms/openai.py

@@ -31,6 +31,7 @@ class OpenAILLM(LLMBase):
                 vision_details=config.vision_details,
                 reasoning_effort=getattr(config, 'reasoning_effort', None),
                 http_client_proxies=config.http_client,
+                is_reasoning_model=getattr(config, 'is_reasoning_model', None),
             )
 
         super().__init__(config)

mem0/llms/xai.py

@@ -1,14 +1,36 @@
+import json
 import os
-from typing import Dict, List, Optional
+from typing import Dict, List, Optional, Union
 
 from openai import OpenAI
 
 from mem0.configs.llms.base import BaseLlmConfig
+from mem0.configs.llms.xai import XAIConfig
 from mem0.llms.base import LLMBase
+from mem0.memory.utils import extract_json
 
 
 class XAILLM(LLMBase):
-    def __init__(self, config: Optional[BaseLlmConfig] = None):
+    def __init__(self, config: Optional[Union[BaseLlmConfig, XAIConfig, Dict]] = None):
+        # Convert to XAIConfig if needed
+        if config is None:
+            config = XAIConfig()
+        elif isinstance(config, dict):
+            config = XAIConfig(**config)
+        elif isinstance(config, BaseLlmConfig) and not isinstance(config, XAIConfig):
+            # Convert BaseLlmConfig to XAIConfig so xai_base_url is available
+            config = XAIConfig(
+                model=config.model,
+                temperature=config.temperature,
+                api_key=config.api_key,
+                max_tokens=config.max_tokens,
+                top_p=config.top_p,
+                top_k=config.top_k,
+                enable_vision=config.enable_vision,
+                vision_details=config.vision_details,
+                http_client_proxies=config.http_client,
+            )
+
         super().__init__(config)
 
         if not self.config.model:
@@ -18,35 +40,71 @@ class XAILLM(LLMBase):
         base_url = self.config.xai_base_url or os.getenv("XAI_API_BASE") or "https://api.x.ai/v1"
         self.client = OpenAI(api_key=api_key, base_url=base_url)
 
+    def _parse_response(self, response, tools):
+        """
+        Process the response based on whether tools are used or not.
+
+        Args:
+            response: The raw response from API.
+            tools: The list of tools provided in the request.
+
+        Returns:
+            str or dict: The processed response.
+        """
+        if tools:
+            processed_response = {
+                "content": response.choices[0].message.content,
+                "tool_calls": [],
+            }
+
+            if response.choices[0].message.tool_calls:
+                for tool_call in response.choices[0].message.tool_calls:
+                    processed_response["tool_calls"].append(
+                        {
+                            "name": tool_call.function.name,
+                            "arguments": json.loads(extract_json(tool_call.function.arguments)),
+                        }
+                    )
+
+            return processed_response
+        else:
+            return response.choices[0].message.content
+
     def generate_response(
         self,
         messages: List[Dict[str, str]],
         response_format=None,
         tools: Optional[List[Dict]] = None,
         tool_choice: str = "auto",
+        **kwargs,
     ):
         """
-        Generate a response based on the given messages using XAI.
+        Generate a response based on the given messages using X.AI (Grok).
 
         Args:
             messages (list): List of message dicts containing 'role' and 'content'.
-            response_format (str or object, optional): Format of the response. Defaults to "text".
+            response_format (str or object, optional): Format of the response. Defaults to None.
             tools (list, optional): List of tools that the model can call. Defaults to None.
             tool_choice (str, optional): Tool choice method. Defaults to "auto".
+            **kwargs: Additional X.AI-specific parameters.
 
         Returns:
-            str: The generated response.
+            str or dict: The generated response. A string when tools are not requested;
+            a dict ``{"content": ..., "tool_calls": [...]}`` when tools are requested.
         """
-        params = {
-            "model": self.config.model,
-            "messages": messages,
-            "temperature": self.config.temperature,
-            "max_tokens": self.config.max_tokens,
-            "top_p": self.config.top_p,
-        }
+        params = self._get_supported_params(messages=messages, **kwargs)
+        params.update(
+            {
+                "model": self.config.model,
+                "messages": messages,
+            }
+        )
 
         if response_format:
             params["response_format"] = response_format
+        if tools:
+            params["tools"] = tools
+            params["tool_choice"] = tool_choice
 
         response = self.client.chat.completions.create(**params)
-        return response.choices[0].message.content
+        return self._parse_response(response, tools)

mem0/memory/main.py

@@ -1,4 +1,5 @@
 import asyncio
+import concurrent.futures
 import gc
 import hashlib
 import json
@@ -46,6 +47,7 @@ from mem0.utils.scoring import (
     normalize_bm25,
     score_and_rank,
 )
+from mem0.vector_stores.base import VectorStoreBase
 
 # Suppress SWIG deprecation warnings globally
 warnings.filterwarnings("ignore", category=DeprecationWarning, message=".*SwigPy.*")
@@ -168,6 +170,21 @@ def _validate_search_params(threshold: Optional[float] = None, top_k: Optional[i
             )
 
 
+def _validate_and_trim_search_query(query: str) -> str:
+    """
+    Validates and normalizes a search query before embedding/vector search.
+
+    Raises:
+        ValueError: If query is not a string or is empty/whitespace-only.
+    """
+    if not isinstance(query, str):
+        raise ValueError("Invalid query: must be a non-empty string.")
+    trimmed = query.strip()
+    if not trimmed:
+        raise ValueError("Invalid query: cannot be empty or whitespace-only.")
+    return trimmed
+
+
 def _is_sensitive_field(field_name: str) -> bool:
     """Check if a field should be redacted for telemetry safety.
 
@@ -384,6 +401,15 @@ class Memory(MemoryBase):
             self._telemetry_vector_store = VectorStoreFactory.create(
                 self.config.vector_store.provider, telemetry_config
             )
+        if getattr(type(self.vector_store), "keyword_search", None) is VectorStoreBase.keyword_search:
+            logger.warning(
+                "The '%s' vector store does not support keyword search. "
+                "Hybrid (BM25) scoring will be disabled and search will use "
+                "semantic similarity only. To enable hybrid search, switch to a "
+                "store with keyword_search support (e.g. qdrant, elasticsearch, pgvector).",
+                self.config.vector_store.provider,
+            )
+
         capture_event("mem0.init", self, {"sync_type": "sync"})
 
     @property
@@ -1131,6 +1157,7 @@ class Memory(MemoryBase):
         filters: Optional[Dict[str, Any]] = None,
         threshold: float = 0.1,
         rerank: bool = False,
+        explain: bool = False,
         **kwargs,
     ):
         """
@@ -1161,6 +1188,7 @@ class Memory(MemoryBase):
                 - {"NOT": [filter1]} - logical NOT
             threshold (float, optional): Minimum score for a memory to be included. Defaults to 0.1.
             rerank (bool, optional): Whether to rerank results. Defaults to False.
+            explain (bool, optional): Whether to include score_details for each result. Defaults to False.
 
         Returns:
             dict: A dictionary containing the search results under a "results" key.
@@ -1175,6 +1203,7 @@ class Memory(MemoryBase):
 
         # Validate search parameters (before applying defaults)
         _validate_search_params(threshold=threshold, top_k=top_k)
+        query = _validate_and_trim_search_query(query)
 
         # Validate and trim entity IDs in filters
         effective_filters = filters.copy() if filters else {}
@@ -1220,11 +1249,12 @@ class Memory(MemoryBase):
                 "encoded_ids": encoded_ids,
                 "sync_type": "sync",
                 "threshold": threshold,
+                "explain": explain,
                 "advanced_filters": bool(filters and self._has_advanced_operators(filters)),
             },
         )
 
-        original_memories = self._search_vector_store(query, effective_filters, limit, threshold)
+        original_memories = self._search_vector_store(query, effective_filters, limit, threshold, explain=explain)
 
         # Apply reranking if enabled and reranker is available
         if rerank and self.reranker and original_memories:
@@ -1340,7 +1370,7 @@ class Memory(MemoryBase):
                 return True
         return False
 
-    def _search_vector_store(self, query, filters, limit, threshold=0.1):
+    def _search_vector_store(self, query, filters, limit, threshold=0.1, explain=False):
         # Guard against None threshold (backward compat)
         if threshold is None:
             threshold = 0.1
@@ -1395,6 +1425,7 @@ class Memory(MemoryBase):
             entity_boosts=entity_boosts,
             threshold=threshold,
             top_k=limit,
+            explain=explain,
         )
 
         # Step 9: Format results
@@ -1432,6 +1463,8 @@ class Memory(MemoryBase):
                 if not memory_item_dict.get("metadata"):
                     memory_item_dict["metadata"] = {}
                 memory_item_dict["metadata"].update(additional_metadata)
+            if explain and "score_details" in scored:
+                memory_item_dict["score_details"] = scored["score_details"]
 
             original_memories.append(memory_item_dict)
 
@@ -1464,34 +1497,55 @@ class Memory(MemoryBase):
         memory_boosts = {}
 
         try:
-            for _, entity_text in deduped:
-                entity_embedding = self.embedding_model.embed(entity_text, "search")
-                matches = self.entity_store.search(
-                    query=entity_text,
-                    vectors=entity_embedding,
-                    top_k=500,
-                    filters=search_filters,
+            entity_texts = [text for _, text in deduped]
+            embeddings = self.embedding_model.embed_batch(entity_texts, "search")
+
+            if len(embeddings) != len(entity_texts):
+                logger.warning(
+                    "embed_batch returned %d vectors for %d texts — skipping entity boost",
+                    len(embeddings),
+                    len(entity_texts),
+                )
+                return memory_boosts
+
+            entity_store = self.entity_store
+
+            def _search_entity(entity_text, embedding):
+                return entity_store.search(
+                    query=entity_text, vectors=embedding, top_k=500, filters=search_filters
                 )
 
-                for match in matches:
-                    similarity = match.score if hasattr(match, 'score') else 0.0
-                    if similarity < 0.5:
+            with concurrent.futures.ThreadPoolExecutor(max_workers=4) as pool:
+                futures = {
+                    pool.submit(_search_entity, text, emb): text
+                    for text, emb in zip(entity_texts, embeddings)
+                }
+
+                for future in concurrent.futures.as_completed(futures):
+                    try:
+                        matches = future.result()
+                    except Exception as e:
+                        logger.warning("Entity boost search failed for one entity: %s", e)
                         continue
 
-                    payload = match.payload if hasattr(match, 'payload') else {}
-                    linked_memory_ids = payload.get("linked_memory_ids", [])
-                    if not isinstance(linked_memory_ids, list):
-                        continue
+                    for match in matches:
+                        similarity = match.score if hasattr(match, 'score') else 0.0
+                        if similarity < 0.5:
+                            continue
 
-                    # Spread-attenuated boost: entities linking to many memories get attenuated
-                    num_linked = max(len(linked_memory_ids), 1)
-                    memory_count_weight = 1.0 / (1.0 + 0.001 * ((num_linked - 1) ** 2))
-                    boost = similarity * ENTITY_BOOST_WEIGHT * memory_count_weight
+                        payload = match.payload if hasattr(match, 'payload') else {}
+                        linked_memory_ids = payload.get("linked_memory_ids", [])
+                        if not isinstance(linked_memory_ids, list):
+                            continue
 
-                    for memory_id in linked_memory_ids:
-                        if memory_id:
-                            memory_key = str(memory_id)
-                            memory_boosts[memory_key] = max(memory_boosts.get(memory_key, 0.0), boost)
+                        num_linked = max(len(linked_memory_ids), 1)
+                        memory_count_weight = 1.0 / (1.0 + 0.001 * ((num_linked - 1) ** 2))
+                        boost = similarity * ENTITY_BOOST_WEIGHT * memory_count_weight
+
+                        for memory_id in linked_memory_ids:
+                            if memory_id:
+                                memory_key = str(memory_id)
+                                memory_boosts[memory_key] = max(memory_boosts.get(memory_key, 0.0), boost)
 
         except Exception as e:
             logger.warning(f"Entity boost computation failed: {e}")
@@ -1828,6 +1882,15 @@ class AsyncMemory(MemoryBase):
                 os.makedirs(telemetry_config.path, exist_ok=True)
             self._telemetry_vector_store = VectorStoreFactory.create(self.config.vector_store.provider, telemetry_config)
 
+        if getattr(type(self.vector_store), "keyword_search", None) is VectorStoreBase.keyword_search:
+            logger.warning(
+                "The '%s' vector store does not support keyword search. "
+                "Hybrid (BM25) scoring will be disabled and search will use "
+                "semantic similarity only. To enable hybrid search, switch to a "
+                "store with keyword_search support (e.g. qdrant, elasticsearch, pgvector).",
+                self.config.vector_store.provider,
+            )
+
         capture_event("mem0.init", self, {"sync_type": "async"})
 
     @property
@@ -2546,6 +2609,7 @@ class AsyncMemory(MemoryBase):
         filters: Optional[Dict[str, Any]] = None,
         threshold: float = 0.1,
         rerank: bool = False,
+        explain: bool = False,
         **kwargs,
     ):
         """
@@ -2576,6 +2640,7 @@ class AsyncMemory(MemoryBase):
                 - {"NOT": [filter1]} - logical NOT
             threshold (float, optional): Minimum score for a memory to be included. Defaults to 0.1.
             rerank (bool, optional): Whether to rerank results. Defaults to False.
+            explain (bool, optional): Whether to include score_details for each result. Defaults to False.
 
         Returns:
             dict: A dictionary containing the search results under a "results" key.
@@ -2590,6 +2655,7 @@ class AsyncMemory(MemoryBase):
 
         # Validate search parameters (before applying defaults)
         _validate_search_params(threshold=threshold, top_k=top_k)
+        query = _validate_and_trim_search_query(query)
 
         # Validate and trim entity IDs in filters
         effective_filters = filters.copy() if filters else {}
@@ -2637,11 +2703,12 @@ class AsyncMemory(MemoryBase):
                 "encoded_ids": encoded_ids,
                 "sync_type": "async",
                 "threshold": threshold,
+                "explain": explain,
                 "advanced_filters": bool(filters and self._has_advanced_operators(filters)),
             },
         )
 
-        original_memories = await self._search_vector_store(query, effective_filters, limit, threshold)
+        original_memories = await self._search_vector_store(query, effective_filters, limit, threshold, explain=explain)
 
         # Apply reranking if enabled and reranker is available
         if rerank and self.reranker and original_memories:
@@ -2760,7 +2827,7 @@ class AsyncMemory(MemoryBase):
                 return True
         return False
 
-    async def _search_vector_store(self, query, filters, limit, threshold=0.1):
+    async def _search_vector_store(self, query, filters, limit, threshold=0.1, explain=False):
         if threshold is None:
             threshold = 0.1
 
@@ -2814,6 +2881,7 @@ class AsyncMemory(MemoryBase):
             entity_boosts=entity_boosts,
             threshold=threshold,
             top_k=limit,
+            explain=explain,
         )
 
         # Step 9: Format results
@@ -2850,6 +2918,8 @@ class AsyncMemory(MemoryBase):
                 if not memory_item_dict.get("metadata"):
                     memory_item_dict["metadata"] = {}
                 memory_item_dict["metadata"].update(additional_metadata)
+            if explain and "score_details" in scored:
+                memory_item_dict["score_details"] = scored["score_details"]
 
             original_memories.append(memory_item_dict)
 
@@ -2872,15 +2942,38 @@ class AsyncMemory(MemoryBase):
         memory_boosts = {}
 
         try:
-            for _, entity_text in deduped:
-                entity_embedding = await asyncio.to_thread(self.embedding_model.embed, entity_text, "search")
-                matches = await asyncio.to_thread(
-                    self.entity_store.search,
-                    query=entity_text,
-                    vectors=entity_embedding,
-                    top_k=500,
-                    filters=search_filters,
+            entity_texts = [text for _, text in deduped]
+            embeddings = await asyncio.to_thread(self.embedding_model.embed_batch, entity_texts, "search")
+
+            if len(embeddings) != len(entity_texts):
+                logger.warning(
+                    "embed_batch returned %d vectors for %d texts — skipping entity boost",
+                    len(embeddings),
+                    len(entity_texts),
                 )
+                return memory_boosts
+
+            sem = asyncio.Semaphore(4)
+
+            async def _search_entity(entity_text, embedding):
+                async with sem:
+                    return await asyncio.to_thread(
+                        self.entity_store.search,
+                        query=entity_text,
+                        vectors=embedding,
+                        top_k=500,
+                        filters=search_filters,
+                    )
+
+            results = await asyncio.gather(
+                *(_search_entity(text, emb) for text, emb in zip(entity_texts, embeddings)),
+                return_exceptions=True,
+            )
+
+            for matches in results:
+                if isinstance(matches, BaseException):
+                    logger.warning("Entity boost search failed for one entity: %s", matches)
+                    continue
 
                 for match in matches:
                     similarity = match.score if hasattr(match, 'score') else 0.0

mem0/proxy/main.py

@@ -52,7 +52,7 @@ class Completions:
     def create(
         self,
         model: str,
-        messages: List = [],
+        messages: Optional[List] = None,
         # Mem0 arguments
         user_id: Optional[str] = None,
         agent_id: Optional[str] = None,
@@ -92,6 +92,8 @@ class Completions:
         api_key: Optional[str] = None,
         model_list: Optional[list] = None,  # pass in a list of api_base,keys, etc.
     ):
+        if messages is None:
+            messages = []
         if not any([user_id, agent_id, run_id]):
             raise ValueError("One of user_id, agent_id, run_id must be provided")
 

mem0/utils/factory.py

@@ -7,17 +7,18 @@ from mem0.configs.llms.aws_bedrock import AWSBedrockConfig
 from mem0.configs.llms.azure import AzureOpenAIConfig
 from mem0.configs.llms.base import BaseLlmConfig
 from mem0.configs.llms.deepseek import DeepSeekConfig
-from mem0.configs.llms.minimax import MinimaxConfig
 from mem0.configs.llms.lmstudio import LMStudioConfig
+from mem0.configs.llms.minimax import MinimaxConfig
 from mem0.configs.llms.ollama import OllamaConfig
 from mem0.configs.llms.openai import OpenAIConfig
 from mem0.configs.llms.vllm import VllmConfig
+from mem0.configs.llms.xai import XAIConfig
 from mem0.configs.rerankers.base import BaseRerankerConfig
 from mem0.configs.rerankers.cohere import CohereRerankerConfig
+from mem0.configs.rerankers.huggingface import HuggingFaceRerankerConfig
+from mem0.configs.rerankers.llm import LLMRerankerConfig
 from mem0.configs.rerankers.sentence_transformer import SentenceTransformerRerankerConfig
 from mem0.configs.rerankers.zero_entropy import ZeroEntropyRerankerConfig
-from mem0.configs.rerankers.llm import LLMRerankerConfig
-from mem0.configs.rerankers.huggingface import HuggingFaceRerankerConfig
 from mem0.embeddings.mock import MockEmbeddings
 
 
@@ -48,7 +49,7 @@ class LlmFactory:
         "gemini": ("mem0.llms.gemini.GeminiLLM", BaseLlmConfig),
         "deepseek": ("mem0.llms.deepseek.DeepSeekLLM", DeepSeekConfig),
         "minimax": ("mem0.llms.minimax.MiniMaxLLM", MinimaxConfig),
-        "xai": ("mem0.llms.xai.XAILLM", BaseLlmConfig),
+        "xai": ("mem0.llms.xai.XAILLM", XAIConfig),
         "sarvam": ("mem0.llms.sarvam.SarvamLLM", BaseLlmConfig),
         "lmstudio": ("mem0.llms.lmstudio.LMStudioLLM", LMStudioConfig),
         "vllm": ("mem0.llms.vllm.VllmLLM", VllmConfig),
@@ -209,7 +210,6 @@ class VectorStoreFactory:
         return instance
 
 
-
 class RerankerFactory:
     """
     Factory for creating reranker instances with appropriate configurations.
@@ -219,7 +219,10 @@ class RerankerFactory:
     # Provider mappings with their config classes
     provider_to_class = {
         "cohere": ("mem0.reranker.cohere_reranker.CohereReranker", CohereRerankerConfig),
-        "sentence_transformer": ("mem0.reranker.sentence_transformer_reranker.SentenceTransformerReranker", SentenceTransformerRerankerConfig),
+        "sentence_transformer": (
+            "mem0.reranker.sentence_transformer_reranker.SentenceTransformerReranker",
+            SentenceTransformerRerankerConfig,
+        ),
         "zero_entropy": ("mem0.reranker.zero_entropy_reranker.ZeroEntropyReranker", ZeroEntropyRerankerConfig),
         "llm_reranker": ("mem0.reranker.llm_reranker.LLMReranker", LLMRerankerConfig),
         "huggingface": ("mem0.reranker.huggingface_reranker.HuggingFaceReranker", HuggingFaceRerankerConfig),

mem0/utils/scoring.py

@@ -63,6 +63,7 @@ def score_and_rank(
     entity_boosts: Dict[str, float],
     threshold: float,
     top_k: int,
+    explain: bool = False,
 ) -> List[Dict[str, Any]]:
     """Score candidates additively and return top-k results.
 
@@ -79,6 +80,14 @@ def score_and_rank(
         - Semantic + BM25 + entity: max_possible = 2.5
         - Semantic + entity (no BM25): max_possible = 1.5
 
+    Args:
+        semantic_results: Candidate memories from vector search.
+        bm25_scores: Normalized keyword scores keyed by memory ID.
+        entity_boosts: Entity-link boosts keyed by memory ID.
+        threshold: Minimum semantic score required before hybrid scoring.
+        top_k: Maximum number of results to return.
+        explain: Include score_details in each result when true.
+
     Returns:
         List of scored result dicts sorted by combined score descending.
     """
@@ -109,13 +118,22 @@ def score_and_rank(
         raw_combined = semantic_score + bm25_score + entity_boost
         combined = min(raw_combined / max_possible, 1.0)
 
-        scored.append(
-            {
-                "id": mem_id_str,
-                "score": combined,
-                "payload": result.get("payload"),
+        scored_result = {
+            "id": mem_id_str,
+            "score": combined,
+            "payload": result.get("payload"),
+        }
+        if explain:
+            scored_result["score_details"] = {
+                "semantic_score": semantic_score,
+                "bm25_score": bm25_score,
+                "entity_boost": entity_boost,
+                "raw_score": raw_combined,
+                "max_possible_score": max_possible,
+                "final_score": combined,
+                "threshold": threshold,
             }
-        )
+        scored.append(scored_result)
 
     scored.sort(key=lambda x: x["score"], reverse=True)
     return scored[:top_k]

mem0/vector_stores/azure_mysql.py

@@ -313,13 +313,10 @@ class AzureMySQL(VectorStoreBase):
 
         for row in results:
             vec = np.array(json.loads(row['vector']))
-            # Cosine similarity
-            similarity = np.dot(query_vec, vec) / (np.linalg.norm(query_vec) * np.linalg.norm(vec))
-            distance = 1 - similarity
-            scored_results.append((row['id'], distance, row['payload']))
+            similarity = float(np.dot(query_vec, vec) / (np.linalg.norm(query_vec) * np.linalg.norm(vec)))
+            scored_results.append((row['id'], similarity, row['payload']))
 
-        # Sort by distance and apply limit
-        scored_results.sort(key=lambda x: x[1])
+        scored_results.sort(key=lambda x: x[1], reverse=True)
         scored_results = scored_results[:top_k]
 
         return [

mem0/vector_stores/base.py

@@ -14,7 +14,15 @@ class VectorStoreBase(ABC):
 
     @abstractmethod
     def search(self, query, vectors, top_k=5, filters=None):
-        """Search for similar vectors."""
+        """Search for similar vectors.
+
+        All implementations must return similarity scores where higher values
+        indicate greater similarity (range [0, 1] preferred). Implementations
+        using distance metrics must convert to similarity before returning:
+        - Cosine distance: score = max(0.0, 1.0 - distance)
+        - L2 distance: score = 1.0 / (1.0 + distance)
+        - Inner product: score = value (already higher = better)
+        """
         pass
 
     @abstractmethod

mem0/vector_stores/cassandra.py

@@ -258,10 +258,8 @@ class CassandraDB(VectorStoreBase):
                     continue
 
                 vec = np.array(row.vector)
-                
-                # Cosine similarity
-                similarity = np.dot(query_vec, vec) / (np.linalg.norm(query_vec) * np.linalg.norm(vec))
-                distance = 1 - similarity
+
+                similarity = float(np.dot(query_vec, vec) / (np.linalg.norm(query_vec) * np.linalg.norm(vec)))
 
                 # Apply filters if provided
                 if filters:
@@ -273,10 +271,9 @@ class CassandraDB(VectorStoreBase):
                     except json.JSONDecodeError:
                         continue
 
-                scored_results.append((row.id, distance, row.payload))
+                scored_results.append((row.id, similarity, row.payload))
 
-            # Sort by distance and apply limit
-            scored_results.sort(key=lambda x: x[1])
+            scored_results.sort(key=lambda x: x[1], reverse=True)
             scored_results = scored_results[:top_k]
 
             return [

mem0/vector_stores/chroma.py

@@ -97,9 +97,11 @@ class ChromaDB(VectorStoreBase):
 
         result = []
         for i in range(max_length):
+            raw_distance = distances[i] if isinstance(distances, list) and distances and i < len(distances) else None
+            score = 1.0 / (1.0 + raw_distance) if raw_distance is not None else None
             entry = OutputData(
                 id=ids[i] if isinstance(ids, list) and ids and i < len(ids) else None,
-                score=(distances[i] if isinstance(distances, list) and distances and i < len(distances) else None),
+                score=score,
                 payload=(metadatas[i] if isinstance(metadatas, list) and metadatas and i < len(metadatas) else None),
             )
             result.append(entry)

mem0/vector_stores/faiss.py

@@ -279,7 +279,11 @@ class FAISS(VectorStoreBase):
 
             payload_copy = payload.copy()
 
-            score = float(scores[i])
+            raw_score = float(scores[i])
+            if self.distance_strategy.lower() == "euclidean":
+                score = 1.0 / (1.0 + raw_score)
+            else:
+                score = raw_score
             entry = OutputData(
                 id=vector_id,
                 score=score,

mem0/vector_stores/milvus.py

@@ -11,7 +11,14 @@ try:
 except ImportError:
     raise ImportError("The 'pymilvus' library is required. Please install it using 'pip install pymilvus'.")
 
-from pymilvus import CollectionSchema, DataType, FieldSchema, Function, FunctionType, MilvusClient
+from pymilvus import (
+    CollectionSchema,
+    DataType,
+    FieldSchema,
+    Function,
+    FunctionType,
+    MilvusClient,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -167,11 +174,14 @@ class MilvusDB(VectorStoreBase):
         memory = []
 
         for value in data:
-            uid, score, metadata = (
-                value.get("id"),
-                value.get("distance"),
-                value.get("entity", {}).get("metadata"),
-            )
+            uid = value.get("id")
+            raw_distance = value.get("distance")
+            metadata = value.get("entity", {}).get("metadata")
+
+            if raw_distance is not None and self.metric_type in (MetricType.L2, "L2"):
+                score = 1.0 / (1.0 + raw_distance)
+            else:
+                score = raw_distance
 
             memory_obj = OutputData(id=uid, score=score, payload=metadata)
             memory.append(memory_obj)

mem0/vector_stores/pgvector.py

@@ -1,7 +1,9 @@
 import json
 import logging
+import re
 from contextlib import contextmanager
 from typing import Any, List, Optional
+from urllib.parse import parse_qsl, urlencode, urlsplit
 
 from pydantic import BaseModel
 
@@ -113,6 +115,24 @@ def _build_filter_conditions(filters):
     return conditions, params
 
 
+def _with_sslmode(connection_string: str, sslmode: str) -> str:
+    """Add or replace sslmode in URI and keyword conninfo strings.
+
+    Keyword conninfo values are assumed not to contain nested ``sslmode=``
+    substrings, such as inside an ``options`` value.
+    """
+    if "://" in connection_string:
+        parsed = urlsplit(connection_string)
+        query = [(key, value) for key, value in parse_qsl(parsed.query, keep_blank_values=True) if key != "sslmode"]
+        query.append(("sslmode", sslmode))
+        return parsed._replace(query=urlencode(query)).geturl()
+
+    if re.search(r"(^|\s)sslmode=", connection_string):
+        return re.sub(r"(^|\s)sslmode=\S+", lambda match: f"{match.group(1)}sslmode={sslmode}", connection_string)
+
+    return f"{connection_string} sslmode={sslmode}"
+
+
 class OutputData(BaseModel):
     id: Optional[str]
     score: Optional[float]
@@ -161,6 +181,7 @@ class PGVector(VectorStoreBase):
         self.use_hnsw = hnsw
         self.embedding_model_dims = embedding_model_dims
         self.connection_pool = None
+        self._collection_ensured = False
 
         # Connection setup with priority: connection_pool > connection_string > individual parameters
         if connection_pool is not None:
@@ -168,30 +189,33 @@ class PGVector(VectorStoreBase):
             self.connection_pool = connection_pool
         elif connection_string:
             if sslmode:
-                # Append sslmode to connection string if provided
-                if 'sslmode=' in connection_string:
-                    # Replace existing sslmode
-                    import re
-                    connection_string = re.sub(r'sslmode=[^ ]*', f'sslmode={sslmode}', connection_string)
-                else:
-                    # Add sslmode to connection string
-                    connection_string = f"{connection_string} sslmode={sslmode}"
+                connection_string = _with_sslmode(connection_string, sslmode)
         else:
             connection_string = f"postgresql://{user}:{password}@{host}:{port}/{dbname}"
             if sslmode:
-                connection_string = f"{connection_string} sslmode={sslmode}"
+                connection_string = _with_sslmode(connection_string, sslmode)
         
         if self.connection_pool is None:
             if PSYCOPG_VERSION == 3:
-                # psycopg3 ConnectionPool
-                self.connection_pool = ConnectionPool(conninfo=connection_string, min_size=minconn, max_size=maxconn, open=True)
+                # open=False avoids blocking when DB DNS is not yet resolvable (e.g. Docker startup)
+                self.connection_pool = ConnectionPool(
+                    conninfo=connection_string,
+                    min_size=minconn,
+                    max_size=maxconn,
+                    open=False,
+                )
+                self.connection_pool.open(wait=False)
             else:
                 # psycopg2 ThreadedConnectionPool
                 self.connection_pool = ConnectionPool(minconn=minconn, maxconn=maxconn, dsn=connection_string)
 
+    def _ensure_collection(self):
+        if self._collection_ensured:
+            return
         collections = self.list_cols()
-        if collection_name not in collections:
+        if self.collection_name not in collections:
             self.create_col()
+        self._collection_ensured = True
 
     @contextmanager
     def _get_cursor(self, commit: bool = False):
@@ -281,6 +305,7 @@ class PGVector(VectorStoreBase):
             )
 
     def insert(self, vectors: list[list[float]], payloads=None, ids=None) -> None:
+        self._ensure_collection()
         logger.info(f"Inserting {len(vectors)} vectors into collection {self.collection_name}")
         json_payloads = [json.dumps(payload) for payload in payloads]
 
@@ -318,6 +343,7 @@ class PGVector(VectorStoreBase):
         Returns:
             list: Search results.
         """
+        self._ensure_collection()
         filter_conditions, filter_params = _build_filter_conditions(filters)
         filter_clause = sql.SQL("WHERE " + " AND ".join(filter_conditions)) if filter_conditions else sql.SQL("")
 
@@ -334,7 +360,7 @@ class PGVector(VectorStoreBase):
             )
 
             results = cur.fetchall()
-        return [OutputData(id=str(r[0]), score=float(r[1]), payload=r[2]) for r in results]
+        return [OutputData(id=str(r[0]), score=max(0.0, 1.0 - float(r[1])), payload=r[2]) for r in results]
 
     def keyword_search(self, query, top_k=5, filters=None):
         """
@@ -348,6 +374,7 @@ class PGVector(VectorStoreBase):
         Returns:
             List[OutputData]: Search results ranked by text relevance.
         """
+        self._ensure_collection()
         filter_conditions, filter_params = _build_filter_conditions(filters)
         filter_clause = sql.SQL("AND " + " AND ".join(filter_conditions)) if filter_conditions else sql.SQL("")
 
@@ -378,6 +405,7 @@ class PGVector(VectorStoreBase):
         Args:
             vector_id (str): ID of the vector to delete.
         """
+        self._ensure_collection()
         with self._get_cursor(commit=True) as cur:
             cur.execute(sql.SQL("DELETE FROM {} WHERE id = %s").format(self._col()), (vector_id,))
 
@@ -395,6 +423,7 @@ class PGVector(VectorStoreBase):
             vector (List[float], optional): Updated vector.
             payload (Dict, optional): Updated payload.
         """
+        self._ensure_collection()
         with self._get_cursor(commit=True) as cur:
             if vector:
                cur.execute(
@@ -427,6 +456,7 @@ class PGVector(VectorStoreBase):
         Returns:
             OutputData: Retrieved vector.
         """
+        self._ensure_collection()
         with self._get_cursor() as cur:
             cur.execute(
                 sql.SQL("SELECT id, vector, payload FROM {} WHERE id = %s").format(self._col()),
@@ -460,6 +490,7 @@ class PGVector(VectorStoreBase):
         Returns:
             Dict[str, Any]: Collection information.
         """
+        self._ensure_collection()
         with self._get_cursor() as cur:
             cur.execute(
                 sql.SQL("""
@@ -490,6 +521,7 @@ class PGVector(VectorStoreBase):
         Returns:
             List[OutputData]: List of vectors.
         """
+        self._ensure_collection()
         filter_conditions, filter_params = _build_filter_conditions(filters)
         filter_clause = sql.SQL("WHERE " + " AND ".join(filter_conditions)) if filter_conditions else sql.SQL("")
 
@@ -521,6 +553,7 @@ class PGVector(VectorStoreBase):
 
     def reset(self) -> None:
         """Reset the index by deleting and recreating it."""
+        self._ensure_collection()
         logger.warning(f"Resetting index {self.collection_name}...")
         self.delete_col()
         self.create_col()

mem0/vector_stores/redis.py

@@ -158,7 +158,7 @@ class RedisDB(VectorStoreBase):
         return [
             MemoryResult(
                 id=result["memory_id"],
-                score=float(result["vector_distance"]),
+                score=max(0.0, 1.0 - float(result["vector_distance"])),
                 payload={
                     "hash": result["hash"],
                     "data": result["memory"],

mem0/vector_stores/s3_vectors.py

@@ -80,7 +80,9 @@ class S3Vectors(VectorStoreBase):
                 except json.JSONDecodeError:
                     logger.warning(f"Failed to parse metadata for key {v.get('key')}")
                     payload = {}
-            results.append(OutputData(id=v.get("key"), score=v.get("distance"), payload=payload))
+            raw_distance = v.get("distance")
+            score = max(0.0, 1.0 - raw_distance) if raw_distance is not None else None
+            results.append(OutputData(id=v.get("key"), score=score, payload=payload))
         return results
 
     def insert(self, vectors, payloads=None, ids=None):
@@ -180,10 +182,6 @@ class S3Vectors(VectorStoreBase):
         return response.get("index", {})
 
     def list(self, filters=None, top_k=None):
-        # Note: list_vectors does not support metadata filtering.
-        if filters:
-            logger.warning("S3 Vectors `list` does not support metadata filtering. Ignoring filters.")
-
         params = {
             "vectorBucketName": self.vector_bucket_name,
             "indexName": self.collection_name,
@@ -198,7 +196,16 @@ class S3Vectors(VectorStoreBase):
         all_vectors = []
         for page in pages:
             all_vectors.extend(page.get("vectors", []))
-        return [self._parse_output(all_vectors)]
+        results = self._parse_output(all_vectors)
+        if filters:
+            results = [
+                result
+                for result in results
+                if result.payload and all(result.payload.get(k) == v for k, v in filters.items())
+            ]
+        if top_k:
+            results = results[:top_k]
+        return [results]
 
     def reset(self):
         logger.warning(f"Resetting index {self.collection_name}...")

mem0/vector_stores/supabase.py

@@ -135,7 +135,7 @@ class Supabase(VectorStoreBase):
             data=vectors, limit=top_k, filters=filters, include_metadata=True, include_value=True
         )
 
-        return [OutputData(id=str(result[0]), score=float(result[1]), payload=result[2]) for result in results]
+        return [OutputData(id=str(result[0]), score=max(0.0, 1.0 - float(result[1])), payload=result[2]) for result in results]
 
     def delete(self, vector_id: str):
         """

mem0/vector_stores/upstash_vector.py

@@ -132,11 +132,10 @@ class UpstashVector(VectorStoreBase):
                     "top_k": top_k,
                     "filter": filters_str or "",
                     "include_metadata": True,
-                    "namespace": self.collection_name,
                 }
                 for v in vectors
             ]
-            responses = self.client.query_many(queries=queries)
+            responses = self.client.query_many(queries=queries, namespace=self.collection_name)
             # flatten
             response = [res for res_list in responses for res in res_list]
 

mem0/vector_stores/valkey.py

@@ -388,8 +388,8 @@ class ValkeyDB(VectorStoreBase):
         """
         memory_results = []
         for doc in results.docs:
-            # Extract the score
-            score = float(doc.vector_score) if hasattr(doc, "vector_score") else None
+            raw_distance = float(doc.vector_score) if hasattr(doc, "vector_score") else None
+            score = max(0.0, 1.0 - raw_distance) if raw_distance is not None else None
 
             # Create the payload
             payload = {

mem0/vector_stores/vertex_ai_vector_search.py

@@ -114,10 +114,12 @@ class GoogleMatchingEngine(VectorStoreBase):
         results = data.get("nearestNeighbors", {}).get("neighbors", [])
         output_data = []
         for result in results:
+            raw_distance = result.get("distance")
+            score = max(0.0, 1.0 - raw_distance) if raw_distance is not None else None
             output_data.append(
                 OutputData(
                     id=result.get("datapoint").get("datapointId"),
-                    score=result.get("distance"),
+                    score=score,
                     payload=result.get("datapoint").get("metadata"),
                 )
             )
@@ -264,7 +266,8 @@ class GoogleMatchingEngine(VectorStoreBase):
                             logger.debug("Adding %s: %s", restrict.name, restrict.allow_tokens[0])
                             payload[restrict.name] = restrict.allow_tokens[0]
 
-                output_data = OutputData(id=neighbor.id, score=neighbor.distance, payload=payload)
+                score = max(0.0, 1.0 - neighbor.distance) if neighbor.distance is not None else None
+                output_data = OutputData(id=neighbor.id, score=score, payload=payload)
                 results.append(output_data)
 
             logger.debug("Returning %d results", len(results))
@@ -413,7 +416,8 @@ class GoogleMatchingEngine(VectorStoreBase):
                                 if restrict.allow_list:
                                     payload[restrict.namespace] = restrict.allow_list[0]
 
-                        return OutputData(id=neighbor.datapoint.datapoint_id, score=neighbor.distance, payload=payload)
+                        score = max(0.0, 1.0 - neighbor.distance) if neighbor.distance is not None else None
+                        return OutputData(id=neighbor.datapoint.datapoint_id, score=score, payload=payload)
 
                 logger.debug("No results found")
                 return None

openclaw/package.json

@@ -35,7 +35,7 @@
   },
   "dependencies": {
     "@sinclair/typebox": "0.34.47",
-    "mem0ai": "3.0.3"
+    "mem0ai": "3.0.6"
   },
   "openclaw": {
     "extensions": [

openclaw/pnpm-lock.yaml

@@ -19,8 +19,8 @@ importers:
         specifier: 0.34.47
         version: 0.34.47
       mem0ai:
-        specifier: 3.0.3
-        version: 3.0.3(@anthropic-ai/sdk@0.40.1)(@azure/identity@4.13.1)(@azure/search-documents@12.2.0)(@cloudflare/workers-types@4.20260528.1)(@google/genai@1.52.0)(@langchain/core@1.1.48(openai@4.104.0(ws@8.21.0)(zod@3.25.76))(ws@8.21.0))(@mistralai/mistralai@1.15.1)(@qdrant/js-client-rest@1.18.0(typescript@5.9.3))(@supabase/supabase-js@2.106.2)(@types/jest@29.5.14)(@types/pg@8.11.0)(better-sqlite3@12.10.0)(cloudflare@4.5.0)(compromise@14.15.1)(groq-sdk@0.3.0)(natural@8.1.1)(ollama@0.5.18)(pg@8.11.3)(redis@4.7.1)(ws@8.21.0)
+        specifier: 3.0.6
+        version: 3.0.6(@anthropic-ai/sdk@0.40.1)(@azure/identity@4.13.1)(@azure/search-documents@12.2.0)(@cloudflare/workers-types@4.20260528.1)(@google/genai@1.52.0)(@langchain/core@1.1.48(openai@4.104.0(ws@8.21.0)(zod@3.25.76))(ws@8.21.0))(@mistralai/mistralai@1.15.1)(@qdrant/js-client-rest@1.18.0(typescript@5.9.3))(@supabase/supabase-js@2.106.2)(@types/jest@29.5.14)(@types/pg@8.11.0)(better-sqlite3@12.10.0)(cloudflare@4.5.0)(compromise@14.15.1)(groq-sdk@0.3.0)(natural@8.1.1)(ollama@0.5.18)(pg@8.11.3)(redis@5.12.1)(ws@8.21.0)
     devDependencies:
       '@qdrant/js-client-rest':
         specifier: ^1.18.0
@@ -397,21 +397,12 @@ packages:
     resolution: {integrity: sha512-oQG/FejNpItrxRHoyctYvT3rwGZOnK4jr3JdppO/c78ktDvkWiPXPHNsrDf33K9sZdRb6PR7gi4noIapu5q4HA==}
     engines: {node: '>=18.0.0', pnpm: '>=8'}
 
-  '@redis/bloom@1.2.0':
-    resolution: {integrity: sha512-HG2DFjYKbpNmVXsa0keLHp/3leGJz1mjh09f2RLGGLQZzSHpkmZWuwJbAvo3QcRY8p80m5+ZdXZdYOSBLlp7Cg==}
-    peerDependencies:
-      '@redis/client': ^1.0.0
-
   '@redis/bloom@5.12.1':
     resolution: {integrity: sha512-PUUfv+ms7jgPSBVoo/DN4AkPHj4D5TZSd6SbJX7egzBplkYUcKmHRE8RKia7UtZ8bSQbLguLvxVO+asKtQfZWA==}
     engines: {node: '>= 18.19.0'}
     peerDependencies:
       '@redis/client': ^5.12.1
 
-  '@redis/client@1.6.1':
-    resolution: {integrity: sha512-/KCsg3xSlR+nCK8/8ZYSknYxvXHwubJrU82F3Lm1Fp6789VQ0/3RJKfsmRXjqfaTA++23CvC3hqmqe/2GEt6Kw==}
-    engines: {node: '>=14'}
-
   '@redis/client@5.12.1':
     resolution: {integrity: sha512-7aPGWeqA3uFm43o19umzdl16CEjK/JQGtSXVPevplTaOU3VJA/rseBC1QvYUz9lLDIMBimc4SW/zrW4S89BaCA==}
     engines: {node: '>= 18.19.0'}
@@ -424,38 +415,18 @@ packages:
       '@opentelemetry/api':
         optional: true
 
-  '@redis/graph@1.1.1':
-    resolution: {integrity: sha512-FEMTcTHZozZciLRl6GiiIB4zGm5z5F3F6a6FZCyrfxdKOhFlGkiAqlexWMBzCi4DcRoyiOsuLfW+cjlGWyExOw==}
-    peerDependencies:
-      '@redis/client': ^1.0.0
-
-  '@redis/json@1.0.7':
-    resolution: {integrity: sha512-6UyXfjVaTBTJtKNG4/9Z8PSpKE6XgSyEb8iwaqDcy+uKrd/DGYHTWkUdnQDyzm727V7p21WUMhsqz5oy65kPcQ==}
-    peerDependencies:
-      '@redis/client': ^1.0.0
-
   '@redis/json@5.12.1':
     resolution: {integrity: sha512-eOze75esLve4vfqDel7aMX08CNaiLLQS2fV8mpRN9NxPe1rVR4vQyYiW/OgtGUysF6QOr9ANhfxABKNOJfXdKg==}
     engines: {node: '>= 18.19.0'}
     peerDependencies:
       '@redis/client': ^5.12.1
 
-  '@redis/search@1.2.0':
-    resolution: {integrity: sha512-tYoDBbtqOVigEDMAcTGsRlMycIIjwMCgD8eR2t0NANeQmgK/lvxNAvYyb6bZDD4frHRhIHkJu2TBRvB0ERkOmw==}
-    peerDependencies:
-      '@redis/client': ^1.0.0
-
   '@redis/search@5.12.1':
     resolution: {integrity: sha512-ItlxbxC9cKI6IU1TLWoczwJCRb6TdmkEpWv05UrPawqaAnWGRu3rcIqsc5vN483T2fSociuyV1UkWIL5I4//2w==}
     engines: {node: '>= 18.19.0'}
     peerDependencies:
       '@redis/client': ^5.12.1
 
-  '@redis/time-series@1.1.0':
-    resolution: {integrity: sha512-c1Q99M5ljsIuc4YdaCwfUEXsofakb9c8+Zse2qxTadu8TalLXuAESzLvFAvNVbkmSlvlzIQOLpBCmWI9wTOt+g==}
-    peerDependencies:
-      '@redis/client': ^1.0.0
-
   '@redis/time-series@5.12.1':
     resolution: {integrity: sha512-c6JL6E3EcZJuNqKFz+KM+l9l5mpcQiKvTwgA3blt5glWJ8hjDk0yeHN3beE/MpqYIQ8UEX44ItQzgkE/gCBELQ==}
     engines: {node: '>= 18.19.0'}
@@ -497,36 +468,42 @@ packages:
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm64]
     os: [linux]
+    libc: [glibc]
 
   '@rolldown/binding-linux-arm64-musl@1.0.2':
     resolution: {integrity: sha512-QVLO/czFMdoMFSqlX3bcswcJNm/23r+qoa/jgtmFc/qEp6/jXmIkDjF/XIo8dPfGaiwy1xfQn8o77L79GeXFgw==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm64]
     os: [linux]
+    libc: [musl]
 
   '@rolldown/binding-linux-ppc64-gnu@1.0.2':
     resolution: {integrity: sha512-hgO5Abm0w5UL6FEa2iFnZqo2KlK7TQ5QhV5x09hujBf7t5KzHQ1VmfPuTpqRy/rNlSxua3eWH374xxiVrP+lcA==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [ppc64]
     os: [linux]
+    libc: [glibc]
 
   '@rolldown/binding-linux-s390x-gnu@1.0.2':
     resolution: {integrity: sha512-fy8rXxuYEu602abC8MUNaPjYLIFzReOaEIEMKMUa0rFEUxNpVXhs15KSSQ4qlqSaM7B6rcj9rDZgADh/IGDzLQ==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [s390x]
     os: [linux]
+    libc: [glibc]
 
   '@rolldown/binding-linux-x64-gnu@1.0.2':
     resolution: {integrity: sha512-0+bOkiQ779+r1WpoHOWHqncvyySci0vKph+myNDYb+im6meJAzHQXay6oEgnkHuUGouM1LKTZwqKpBow6Kj7CQ==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [x64]
     os: [linux]
+    libc: [glibc]
 
   '@rolldown/binding-linux-x64-musl@1.0.2':
     resolution: {integrity: sha512-mjSkrzZK5Qsl0a9d1JgILOiuZOSDTVdKENcSXBoqbzSrspLR/4/IRVDo5wd2GgZjNss/viBFJdeq+j7qH2nypw==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [x64]
     os: [linux]
+    libc: [musl]
 
   '@rolldown/binding-openharmony-arm64@1.0.2':
     resolution: {integrity: sha512-1v5vHasdfQAZoEHakBV72LIFAC9JjnymsiKxp+GEr/ma3+NJCPSaYK+qavInOovJkgwFrs7GccX2d6IgDA3Z5w==}
@@ -588,66 +565,79 @@ packages:
     resolution: {integrity: sha512-EIPRXTVQpHyF8WOo219AD2yEltPehLTcTMz2fn6JsatLYSzQf00hj3rulF+yauOlF9/FtM2WpkT/hJh/KJFGhA==}
     cpu: [arm]
     os: [linux]
+    libc: [glibc]
 
   '@rollup/rollup-linux-arm-musleabihf@4.60.4':
     resolution: {integrity: sha512-J3Yh9PzzF1Ovah2At+lHiGQdsYgArxBbXv/zHfSyaiFQEqvNv7DcW98pCrmdjCZBrqBiKrKKe2V+aaSGWuBe/w==}
     cpu: [arm]
     os: [linux]
+    libc: [musl]
 
   '@rollup/rollup-linux-arm64-gnu@4.60.4':
     resolution: {integrity: sha512-BFDEZMYfUvLn37ONE1yMBojPxnMlTFsdyNoqncT0qFq1mAfllL+ATMMJd8TeuVMiX84s1KbcxcZbXInmcO2mRg==}
     cpu: [arm64]
     os: [linux]
+    libc: [glibc]
 
   '@rollup/rollup-linux-arm64-musl@4.60.4':
     resolution: {integrity: sha512-pc9EYOSlOgdQ2uPl1o9PF6/kLSgaUosia7gOuS8mB69IxJvlclko1MECXysjs5ryez1/5zjYqx3+xYU0TU6R1A==}
     cpu: [arm64]
     os: [linux]
+    libc: [musl]
 
   '@rollup/rollup-linux-loong64-gnu@4.60.4':
     resolution: {integrity: sha512-NxnomyxYerDh5n4iLrNa+sH+Z+U4BMEE46V2PgQ/hoB909i8gV1M5wPojWg9fk1jWpO3IQnOs20K4wyZuFLEFQ==}
     cpu: [loong64]
     os: [linux]
+    libc: [glibc]
 
   '@rollup/rollup-linux-loong64-musl@4.60.4':
     resolution: {integrity: sha512-nbJnQ8a3z1mtmrwImCYhc6BGpThAyYVRQxw9uKSKG4wR6aAYno9sVjJ0zaZcW9BPJX1GbrDPf+SvdWjgTuDmnw==}
     cpu: [loong64]
     os: [linux]
+    libc: [musl]
 
   '@rollup/rollup-linux-ppc64-gnu@4.60.4':
     resolution: {integrity: sha512-2EU6acNrQLd8tYvo/LXW535wupT3m6fo7HKo6lr7ktQoItxTyOL1ZCR/GfGCuXl2vR+zmfI6eRXkSemafv+iVg==}
     cpu: [ppc64]
     os: [linux]
+    libc: [glibc]
 
   '@rollup/rollup-linux-ppc64-musl@4.60.4':
     resolution: {integrity: sha512-WeBtoMuaMxiiIrO2IYP3xs6GMWkJP2C0EoT8beTLkUPmzV1i/UcOSVw1d5r9KBODtHKilG5yFxsGRnBbK3wJ4A==}
     cpu: [ppc64]
     os: [linux]
+    libc: [musl]
 
   '@rollup/rollup-linux-riscv64-gnu@4.60.4':
     resolution: {integrity: sha512-FJHFfqpKUI3A10WrWKiFbBZ7yVbGT4q4B5o1qKFFojqpaYoh9LrQgqWCmmcxQzVSXYtyB5bzkXrYzlHTs21MYA==}
     cpu: [riscv64]
     os: [linux]
+    libc: [glibc]
 
   '@rollup/rollup-linux-riscv64-musl@4.60.4':
     resolution: {integrity: sha512-mcEl6CUT5IAUmQf1m9FYSmVqCJlpQ8r8eyftFUHG8i9OhY7BkBXSUdnLH5DOf0wCOjcP9v/QO93zpmF1SptCCw==}
     cpu: [riscv64]
     os: [linux]
+    libc: [musl]
 
   '@rollup/rollup-linux-s390x-gnu@4.60.4':
     resolution: {integrity: sha512-ynt3JxVd2w2buzoKDWIyiV1pJW93xlQic1THVLXilz429oijRpSHivZAgp65KBu+cMcgf1eVVjdnTLvPxgCuoQ==}
     cpu: [s390x]
     os: [linux]
+    libc: [glibc]
 
   '@rollup/rollup-linux-x64-gnu@4.60.4':
     resolution: {integrity: sha512-Boiz5+MsaROEWDf+GGEwF8VMHGhlUoQMtIPjOgA5fv4osupqTVnJteQNKJwUcnUog2G55jYXH7KZFFiJe0TEzQ==}
     cpu: [x64]
     os: [linux]
+    libc: [glibc]
 
   '@rollup/rollup-linux-x64-musl@4.60.4':
     resolution: {integrity: sha512-+qfSY27qIrFfI/Hom04KYFw3GKZSGU4lXus51wsb5EuySfFlWRwjkKWoE9emgRw/ukoT4Udsj4W/+xxG8VbPKg==}
     cpu: [x64]
     os: [linux]
+    libc: [musl]
 
   '@rollup/rollup-openbsd-x64@4.60.4':
     resolution: {integrity: sha512-VpTfOPHgVXEBeeR8hZ2O0F3aSso+JDWqTWmTmzcQKted54IAdUVbxE+j/MVxUsKa8L20HJhv3vUezVPoquqWjA==}
@@ -829,6 +819,10 @@ packages:
   afinn-165@2.0.2:
     resolution: {integrity: sha512-mJ/RLUfpXfQA6bzugv+bBsc/QYkVrKaLYeS8fWBpKbTCsonv4iuV9ET0fgReEunm9vKLkaNgnekuSNlTC3WQ1Q==}
 
+  agent-base@6.0.2:
+    resolution: {integrity: sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==}
+    engines: {node: '>= 6.0.0'}
+
   agent-base@7.1.4:
     resolution: {integrity: sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==}
     engines: {node: '>= 14'}
@@ -862,8 +856,8 @@ packages:
   asynckit@0.4.0:
     resolution: {integrity: sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==}
 
-  axios@1.13.6:
-    resolution: {integrity: sha512-ChTCHMouEe2kn713WHbQGcuYrr6fXTBiu460OTwWrWob16g1bXn4vtz07Ope7ewMozJAnEquLk5lWQWtBig9DQ==}
+  axios@1.17.0:
+    resolution: {integrity: sha512-J8SwNxprqqpbfenehxWYXE7CW+wM1BB4w3+N+g+/Wx40xM4rsLrfPmHHxSWIxJLYDgSY/HqlFPIYb2/S3rxafw==}
 
   base-64@0.1.0:
     resolution: {integrity: sha512-Y5gU45svrR5tI2Vt/X9GPd3L0HNIKzGu202EjxrXMpuc2V2CiKgemAbUUsqYmZJvPtCXoUKjNZwBJzsNScUbXA==}
@@ -1170,10 +1164,6 @@ packages:
     resolution: {integrity: sha512-zV/5HKTfCeKWnxG0Dmrw51hEWFGfcF2xiXqcA3+J90WDuP0SvoiSO5ORvcBsifmx/FoIjgQN3oNOGaQ5PhLFkg==}
     engines: {node: '>=18'}
 
-  generic-pool@3.9.0:
-    resolution: {integrity: sha512-hymDOu5B53XvN4QT9dBmZxPX4CWhBPPLguTZ9MMFeFa/Kg0xWVfylOVNlJji/E7yTZWFd/q9GO5TxDLq156D7g==}
-    engines: {node: '>= 4'}
-
   get-intrinsic@1.3.0:
     resolution: {integrity: sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==}
     engines: {node: '>= 0.4'}
@@ -1230,6 +1220,10 @@ packages:
     resolution: {integrity: sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==}
     engines: {node: '>= 14'}
 
+  https-proxy-agent@5.0.1:
+    resolution: {integrity: sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==}
+    engines: {node: '>= 6'}
+
   https-proxy-agent@7.0.6:
     resolution: {integrity: sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==}
     engines: {node: '>= 14'}
@@ -1388,24 +1382,28 @@ packages:
     engines: {node: '>= 12.0.0'}
     cpu: [arm64]
     os: [linux]
+    libc: [glibc]
 
   lightningcss-linux-arm64-musl@1.32.0:
     resolution: {integrity: sha512-UpQkoenr4UJEzgVIYpI80lDFvRmPVg6oqboNHfoH4CQIfNA+HOrZ7Mo7KZP02dC6LjghPQJeBsvXhJod/wnIBg==}
     engines: {node: '>= 12.0.0'}
     cpu: [arm64]
     os: [linux]
+    libc: [musl]
 
   lightningcss-linux-x64-gnu@1.32.0:
     resolution: {integrity: sha512-V7Qr52IhZmdKPVr+Vtw8o+WLsQJYCTd8loIfpDaMRWGUZfBOYEJeyJIkqGIDMZPwPx24pUMfwSxxI8phr/MbOA==}
     engines: {node: '>= 12.0.0'}
     cpu: [x64]
     os: [linux]
+    libc: [glibc]
 
   lightningcss-linux-x64-musl@1.32.0:
     resolution: {integrity: sha512-bYcLp+Vb0awsiXg/80uCRezCYHNg1/l3mt0gzHnWV9XP1W5sKa5/TCdGWaR/zBM2PeF/HbsQv/j2URNOiVuxWg==}
     engines: {node: '>= 12.0.0'}
     cpu: [x64]
     os: [linux]
+    libc: [musl]
 
   lightningcss-win32-arm64-msvc@1.32.0:
     resolution: {integrity: sha512-8SbC8BR40pS6baCM8sbtYDSwEVQd4JlFTOlaD3gWGHfThTcABnNDBda6eTZeqbofalIJhFx0qKzgHJmcPTnGdw==}
@@ -1475,16 +1473,16 @@ packages:
   md5@2.3.0:
     resolution: {integrity: sha512-T1GITYmFaKuO91vxyoQMFETst+O71VUPEU3ze5GNzDm0OWdP8v1ziTaAEPUr/3kLsY3Sftgz242A1SetQiDL7g==}
 
-  mem0ai@3.0.3:
-    resolution: {integrity: sha512-nKwGYNh8DipG9Sw0ik/huFLpKtVtwadSy+T6GjAxkkrHp6hO3tlbR75EWH/bCGDG/HO06nYDsDP5fPSnj3bp5g==}
+  mem0ai@3.0.6:
+    resolution: {integrity: sha512-X1KbCVE5351qpJ6X2KXFhQJiW+dqoHj1otA66DSdXtIEO1uXuIdyeTKeURdAH+wjXtIcFa08ylL2meA1pBk9Iw==}
     engines: {node: '>=18'}
     peerDependencies:
       '@anthropic-ai/sdk': ^0.40.1
       '@azure/identity': ^4.0.0
       '@azure/search-documents': ^12.0.0
       '@cloudflare/workers-types': ^4.20250504.0
-      '@google/genai': ^1.2.0
-      '@langchain/core': ^1.0.0
+      '@google/genai': ^1.40.0
+      '@langchain/core': ^1.1.47
       '@mistralai/mistralai': ^1.5.2
       '@qdrant/js-client-rest': ^1.18.0
       '@supabase/supabase-js': ^2.49.1
@@ -1812,8 +1810,9 @@ packages:
     resolution: {integrity: sha512-4K0myLaWL5EteuSAro91EGFgcfVgxb64Jx+7oDAY6GOkXD4M69yuSEljNcInGVCA5sOPxmZ/EqDLj2x0Q0+Ygg==}
     engines: {node: '>=12.0.0'}
 
-  proxy-from-env@1.1.0:
-    resolution: {integrity: sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==}
+  proxy-from-env@2.1.0:
+    resolution: {integrity: sha512-cJ+oHTW1VAEa8cJslgmUZrc+sjRKgAKl3Zyse6+PV38hZe/V6Z14TbCuXcan9F9ghlz4QrFr2c92TNF82UkYHA==}
+    engines: {node: '>=10'}
 
   pump@3.0.4:
     resolution: {integrity: sha512-VS7sjc6KR7e1ukRFhQSY5LM2uBWAUPiOPa/A3mkKmiMwSmRFUITt0xuj+/lesgnCv+dPIEYlkzrcyXgquIHMcA==}
@@ -1837,9 +1836,6 @@ packages:
     resolution: {integrity: sha512-GDhwkLfywWL2s6vEjyhri+eXmfH6j1L7JE27WhqLeYzoh/A3DBaYGEj2H/HFZCn/kMfim73FXxEJTw06WtxQwg==}
     engines: {node: '>= 14.18.0'}
 
-  redis@4.7.1:
-    resolution: {integrity: sha512-S1bJDnqLftzHXHP8JsT5II/CtHWQrASX5K96REjWjlmWKrviSOLWmM7QnRLstAWsu1VBBV1ffV6DzCvxNP0UJQ==}
-
   redis@5.12.1:
     resolution: {integrity: sha512-LDsoVvb/CpoV9EN3FXvgvSHNJWuCIzl9MiO3ppOevuGLpSGJhwfQjpEwfFJcQvNSddHADDdZaWx0HnmMxRXG7g==}
     engines: {node: '>= 18.19.0'}
@@ -2195,9 +2191,6 @@ packages:
     resolution: {integrity: sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==}
     engines: {node: '>=0.4'}
 
-  yallist@4.0.0:
-    resolution: {integrity: sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==}
-
   zod-to-json-schema@3.25.2:
     resolution: {integrity: sha512-O/PgfnpT1xKSDeQYSCfRI5Gy3hPf91mKVDuYLUHZJMiDFptvP41MSnWofm8dnCm0256ZNfZIM7DSzuSMAFnjHA==}
     peerDependencies:
@@ -2559,48 +2552,22 @@ snapshots:
 
   '@qdrant/openapi-typescript-fetch@1.2.6': {}
 
-  '@redis/bloom@1.2.0(@redis/client@1.6.1)':
-    dependencies:
-      '@redis/client': 1.6.1
-
   '@redis/bloom@5.12.1(@redis/client@5.12.1)':
     dependencies:
       '@redis/client': 5.12.1
 
-  '@redis/client@1.6.1':
-    dependencies:
-      cluster-key-slot: 1.1.2
-      generic-pool: 3.9.0
-      yallist: 4.0.0
-
   '@redis/client@5.12.1':
     dependencies:
       cluster-key-slot: 1.1.2
 
-  '@redis/graph@1.1.1(@redis/client@1.6.1)':
-    dependencies:
-      '@redis/client': 1.6.1
-
-  '@redis/json@1.0.7(@redis/client@1.6.1)':
-    dependencies:
-      '@redis/client': 1.6.1
-
   '@redis/json@5.12.1(@redis/client@5.12.1)':
     dependencies:
       '@redis/client': 5.12.1
 
-  '@redis/search@1.2.0(@redis/client@1.6.1)':
-    dependencies:
-      '@redis/client': 1.6.1
-
   '@redis/search@5.12.1(@redis/client@5.12.1)':
     dependencies:
       '@redis/client': 5.12.1
 
-  '@redis/time-series@1.1.0(@redis/client@1.6.1)':
-    dependencies:
-      '@redis/client': 1.6.1
-
   '@redis/time-series@5.12.1(@redis/client@5.12.1)':
     dependencies:
       '@redis/client': 5.12.1
@@ -2908,6 +2875,12 @@ snapshots:
 
   afinn-165@2.0.2: {}
 
+  agent-base@6.0.2:
+    dependencies:
+      debug: 4.4.3
+    transitivePeerDependencies:
+      - supports-color
+
   agent-base@7.1.4: {}
 
   agentkeepalive@4.6.0:
@@ -2936,13 +2909,15 @@ snapshots:
 
   asynckit@0.4.0: {}
 
-  axios@1.13.6:
+  axios@1.17.0:
     dependencies:
       follow-redirects: 1.16.0
       form-data: 4.0.5
-      proxy-from-env: 1.1.0
+      https-proxy-agent: 5.0.1
+      proxy-from-env: 2.1.0
     transitivePeerDependencies:
       - debug
+      - supports-color
 
   base-64@0.1.0: {}
 
@@ -3240,8 +3215,6 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  generic-pool@3.9.0: {}
-
   get-intrinsic@1.3.0:
     dependencies:
       call-bind-apply-helpers: 1.0.2
@@ -3316,6 +3289,13 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
+  https-proxy-agent@5.0.1:
+    dependencies:
+      agent-base: 6.0.2
+      debug: 4.4.3
+    transitivePeerDependencies:
+      - supports-color
+
   https-proxy-agent@7.0.6:
     dependencies:
       agent-base: 7.1.4
@@ -3539,7 +3519,7 @@ snapshots:
       crypt: 0.0.2
       is-buffer: 1.1.6
 
-  mem0ai@3.0.3(@anthropic-ai/sdk@0.40.1)(@azure/identity@4.13.1)(@azure/search-documents@12.2.0)(@cloudflare/workers-types@4.20260528.1)(@google/genai@1.52.0)(@langchain/core@1.1.48(openai@4.104.0(ws@8.21.0)(zod@3.25.76))(ws@8.21.0))(@mistralai/mistralai@1.15.1)(@qdrant/js-client-rest@1.18.0(typescript@5.9.3))(@supabase/supabase-js@2.106.2)(@types/jest@29.5.14)(@types/pg@8.11.0)(better-sqlite3@12.10.0)(cloudflare@4.5.0)(compromise@14.15.1)(groq-sdk@0.3.0)(natural@8.1.1)(ollama@0.5.18)(pg@8.11.3)(redis@4.7.1)(ws@8.21.0):
+  mem0ai@3.0.6(@anthropic-ai/sdk@0.40.1)(@azure/identity@4.13.1)(@azure/search-documents@12.2.0)(@cloudflare/workers-types@4.20260528.1)(@google/genai@1.52.0)(@langchain/core@1.1.48(openai@4.104.0(ws@8.21.0)(zod@3.25.76))(ws@8.21.0))(@mistralai/mistralai@1.15.1)(@qdrant/js-client-rest@1.18.0(typescript@5.9.3))(@supabase/supabase-js@2.106.2)(@types/jest@29.5.14)(@types/pg@8.11.0)(better-sqlite3@12.10.0)(cloudflare@4.5.0)(compromise@14.15.1)(groq-sdk@0.3.0)(natural@8.1.1)(ollama@0.5.18)(pg@8.11.3)(redis@5.12.1)(ws@8.21.0):
     dependencies:
       '@anthropic-ai/sdk': 0.40.1
       '@azure/identity': 4.13.1
@@ -3552,7 +3532,7 @@ snapshots:
       '@supabase/supabase-js': 2.106.2
       '@types/jest': 29.5.14
       '@types/pg': 8.11.0
-      axios: 1.13.6
+      axios: 1.17.0
       better-sqlite3: 12.10.0
       cloudflare: 4.5.0
       compromise: 14.15.1
@@ -3561,12 +3541,13 @@ snapshots:
       ollama: 0.5.18
       openai: 4.104.0(ws@8.21.0)(zod@3.25.76)
       pg: 8.11.3
-      redis: 4.7.1
+      redis: 5.12.1
       uuid: 9.0.1
       zod: 3.25.76
     transitivePeerDependencies:
       - debug
       - encoding
+      - supports-color
       - ws
 
   memjs@1.3.2: {}
@@ -3890,7 +3871,7 @@ snapshots:
       '@types/node': 22.19.19
       long: 5.3.2
 
-  proxy-from-env@1.1.0: {}
+  proxy-from-env@2.1.0: {}
 
   pump@3.0.4:
     dependencies:
@@ -3916,15 +3897,6 @@ snapshots:
 
   readdirp@4.1.2: {}
 
-  redis@4.7.1:
-    dependencies:
-      '@redis/bloom': 1.2.0(@redis/client@1.6.1)
-      '@redis/client': 1.6.1
-      '@redis/graph': 1.1.1(@redis/client@1.6.1)
-      '@redis/json': 1.0.7(@redis/client@1.6.1)
-      '@redis/search': 1.2.0(@redis/client@1.6.1)
-      '@redis/time-series': 1.1.0(@redis/client@1.6.1)
-
   redis@5.12.1:
     dependencies:
       '@redis/bloom': 5.12.1(@redis/client@5.12.1)
@@ -4237,8 +4209,6 @@ snapshots:
 
   xtend@4.0.2: {}
 
-  yallist@4.0.0: {}
-
   zod-to-json-schema@3.25.2(zod@4.4.3):
     dependencies:
       zod: 4.4.3

openclaw/pnpm-workspace.yaml

@@ -1,6 +1,12 @@
 packages:
   - '.'
 
+allowBuilds:
+  '@google/genai': set this to true or false
+  better-sqlite3: set this to true or false
+  esbuild: set this to true or false
+  protobufjs: set this to true or false
+
 onlyBuiltDependencies:
   - better-sqlite3
   - esbuild

pi-agent-plugin/CHANGELOG.md

@@ -0,0 +1,55 @@
+# Changelog
+
+## 0.1.1 (2026-06-10)
+
+Maintenance release — no functional changes.
+
+### Chores
+
+- Version bump to validate the new release pipeline (`pi-agent-plugin-checks.yml` / `pi-agent-plugin-cd.yml`)
+
+## 0.1.0 (2026-06-09)
+
+Initial release of `@mem0/pi-agent-plugin` — persistent semantic memory for Pi Agent.
+
+### Features
+
+- **Extension entry point** — registers `mem0_memory` tool, 8 slash commands, and auto-capture hooks
+- **Agent tool** (`mem0_memory`) — search, add, get_all, delete, delete_all with scoped filters
+- **Auto-capture** — extracts and stores memories from both user and assistant messages on `agent_end`
+- **Dream consolidation** — automated memory maintenance: merge duplicates, resolve contradictions, prune stale entries. Gated by session count, time elapsed, and memory count thresholds
+- **System prompt injection** — appends `MEMORY_POLICY` to every agent turn via `before_agent_start`
+- **Monorepo-aware project scoping** — uses `git rev-parse --show-toplevel` for consistent app_id across subdirectories
+- **3 memory scopes** — project (default), session, global
+- **10 memory categories** — identity, preferences, goals, projects, decisions, technical, relationships, routines, lessons, work
+- **8 skills** — context-loader, remember, search, forget, dream, tour, pin, status
+- **Confirmation dialogs** — `/mem0-forget` and `/mem0-pin` ask for confirmation before destructive or mutating actions via `ctx.ui.confirm()`
+- **Pin preserves memory ID** — `/mem0-pin` uses `mem0.update()` instead of add+delete, keeping the original UUID
+- **Full memory IDs** — all displayed memory references show the complete UUID, not truncated short IDs
+- **Dream gate optimization** — `dreamChecked` flag prevents repeated `getAll` API calls when the memory gate fails
+- **Output truncation** — tool results capped at 200 lines / 50KB per Pi docs
+- **Signal cancellation** — all tool actions respect `AbortSignal`
+- **Session shutdown cleanup** — releases dream lock on `session_shutdown`
+- **PostHog telemetry** — batched event queue with PII-safe error payloads
+
+### Commands
+
+| Command | Description |
+|---------|-------------|
+| `/mem0-remember` | Store a memory verbatim (no inference) |
+| `/mem0-forget` | Search and delete memories (with confirmation) |
+| `/mem0-search` | Semantic search across memories |
+| `/mem0-tour` | Browse all memories by category |
+| `/mem0-dream` | Trigger memory consolidation |
+| `/mem0-pin` | Pin a memory to protect from pruning (preserves ID) |
+| `/mem0-scope` | Change default scope for this session |
+| `/mem0-status` | Connection health and diagnostics |
+
+### Hooks
+
+| Hook | Purpose |
+|------|---------|
+| `session_start` | Detect project (git root), resolve session ID, increment dream counter |
+| `before_agent_start` | Inject memory policy into system prompt, auto-trigger dream if gates pass |
+| `agent_end` | Auto-capture conversation memories, check dream completion |
+| `session_shutdown` | Release dream lock, flush telemetry |

pi-agent-plugin/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [2026] [Taranjeet Singh]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

pi-agent-plugin/README.md

@@ -0,0 +1,144 @@
+# @mem0/pi-agent-plugin
+
+Persistent semantic memory for [Pi Agent](https://pi.dev), powered by [Mem0](https://mem0.ai).
+
+This extension gives Pi Agent long-term memory that persists across sessions, projects, and devices. Memories are automatically captured from conversations and can be searched, managed, and consolidated through slash commands and an agent-accessible tool.
+
+## Features
+
+- **Automatic memory capture** — learns from every conversation (both user and assistant messages)
+- **Semantic search** — find memories by meaning, not just keywords
+- **Scoped memory** — project, session, or global scope
+- **Monorepo-aware** — uses git root for project detection, consistent app_id across subdirectories
+- **Dream consolidation** — merges duplicates, resolves contradictions, prunes stale entries
+- **Confirmation dialogs** — destructive commands ask before acting
+- **8 slash commands** — essential memory management from the command line
+- **Agent tool** — `mem0_memory` tool lets the agent search and store memories autonomously
+
+## Setup
+
+### 1. Get an API key
+
+Sign up at [app.mem0.ai](https://app.mem0.ai/dashboard/api-keys) and copy your API key.
+
+### 2. Install
+
+```bash
+pi install npm:@mem0/pi-agent-plugin
+```
+
+### 3. Configure
+
+Set the API key as an environment variable:
+
+```bash
+export MEM0_API_KEY="m0-your-key-here"
+```
+
+Or create a config file at `~/.pi/agent/mem0-config.json`:
+
+```json
+{
+  "apiKey": "m0-your-key-here",
+  "userId": "your-username",
+  "autoCapture": true,
+  "defaultScope": "project",
+  "dream": {
+    "enabled": true,
+    "auto": true,
+    "minHours": 24,
+    "minSessions": 5,
+    "minMemories": 20
+  }
+}
+```
+
+Environment variables (`MEM0_API_KEY`, `MEM0_USER_ID`) override the config file.
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `/mem0-remember <text>` | Store a memory verbatim (no inference) |
+| `/mem0-forget <query>` | Search and delete memories (with confirmation) |
+| `/mem0-search <query>` | Semantic search across memories |
+| `/mem0-tour [scope]` | Browse all memories grouped by category |
+| `/mem0-dream` | Consolidate — merge duplicates, prune stale, resolve contradictions |
+| `/mem0-pin <query>` | Pin a memory to protect from dream pruning (preserves ID) |
+| `/mem0-scope <scope>` | Change default scope for this session |
+| `/mem0-status` | Connection health, identity, and memory count |
+
+## Skills
+
+The plugin includes 8 skills that guide the agent on how to use each capability:
+
+| Skill | Purpose |
+|-------|---------|
+| `context-loader` | Pre-fetch relevant memories at session start |
+| `remember` | Store facts with category classification |
+| `search` | Quick semantic search with compact results |
+| `forget` | Delete memories with confirmation |
+| `dream` | Memory consolidation workflow |
+| `tour` | Full memory walkthrough by category |
+| `pin` | Protect critical memories from pruning |
+| `status` | Health check and diagnostics |
+
+## Memory Scopes
+
+| Scope | Filters | Use case |
+|-------|---------|----------|
+| `project` | user + app_id (git root) | Default. Project-specific knowledge |
+| `session` | user + app_id + run_id | Ephemeral, session-only context |
+| `global` | user only | All memories across all your projects |
+
+Project scoping uses `git rev-parse --show-toplevel` to detect the repository root, so all subdirectories within a monorepo share the same memory pool.
+
+## Memory Categories
+
+Memories are automatically classified into 10 general-purpose categories:
+
+| Category | Description |
+|----------|-------------|
+| `identity` | Personal details, background, self-descriptions |
+| `preferences` | Likes, dislikes, habits, preferred approaches |
+| `goals` | Objectives, aspirations, targets |
+| `projects` | Ongoing work, initiatives, areas of focus |
+| `decisions` | Choices made, rationale, trade-offs |
+| `technical` | Technical knowledge, tools, configurations |
+| `relationships` | People, teams, organizations |
+| `routines` | Recurring patterns, workflows, schedules |
+| `lessons` | Insights learned, mistakes to avoid |
+| `work` | Professional context, role, responsibilities |
+
+## Architecture
+
+```
+pi-agent-plugin/
+├── src/
+│   ├── entry.ts          # Extension entry point
+│   ├── index.ts          # Barrel exports
+│   ├── commands.ts       # 8 slash commands
+│   ├── prompt.ts         # System prompt injection (MEMORY_POLICY)
+│   ├── types.ts          # Shared interfaces and categories
+│   ├── telemetry.ts      # PostHog telemetry (batched, PII-safe)
+│   ├── config/           # Config loading (~/.pi/agent/mem0-config.json)
+│   ├── memory/           # Tool registration, scoping (git root), formatting
+│   ├── capture/          # Auto-capture from conversations (user + assistant)
+│   └── dream/            # Consolidation state, gating, locking, prompts
+├── skills/               # 8 SKILL.md files for Pi Agent
+├── tests/                # Vitest unit tests
+└── dist/                 # Built output (ESM + DTS)
+```
+
+## Development
+
+```bash
+pnpm install          # Install dependencies
+pnpm run typecheck    # Type check
+pnpm run test         # Run tests
+pnpm run build        # Build (ESM + declarations)
+```
+
+## License
+
+[Apache-2.0](LICENSE)

pi-agent-plugin/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@mem0/pi-agent-plugin",
+  "version": "0.1.1",
+  "type": "module",
+  "description": "Mem0 memory extension for Pi Agent persistent, scoped, semantic memory across sessions and projects",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mem0ai/mem0",
+    "directory": "pi-agent-plugin"
+  },
+  "keywords": [
+    "pi-package",
+    "pi-extension",
+    "skills",
+    "memory",
+    "mem0",
+    "semantic-memory",
+    "persistent-memory",
+    "agent-memory"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "src",
+    "skills",
+    "CHANGELOG.md",
+    "README.md",
+    "LICENSE"
+  ],
+  "pi": {
+    "extensions": ["./src/entry.ts"],
+    "skills": ["./skills"]
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-ai": "*",
+    "typebox": "*"
+  },
+  "devDependencies": {
+    "@earendil-works/pi-ai": "^0.79.0",
+    "@earendil-works/pi-coding-agent": "^0.79.0",
+    "@types/node": "^25.9.2",
+    "tsup": "^8.5.0",
+    "typebox": "^1.2.3",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.7"
+  },
+  "dependencies": {
+    "mem0ai": "^3.0.6"
+  }
+}

pi-agent-plugin/skills/context-loader/SKILL.md

@@ -0,0 +1,47 @@
+---
+name: context-loader
+description: Searches and injects relevant memories into context before starting work on a task or topic. Use when beginning a new task, switching context, or when past decisions, preferences, or knowledge need to be loaded.
+---
+
+# Context Loader
+
+Pre-fetches relevant memories to prime context before working on a task or topic.
+
+## When to use
+
+- Session start (auto-triggered by the extension's `before_agent_start` event)
+- User starts work on a specific topic or area
+- User says "what do we know about X" or "context for X"
+
+## Steps
+
+1. **Extract topics** from current message/task. Identify: subject areas, people mentioned, project names, goal references.
+
+2. **Run 2-4 parallel searches** using `mem0_memory` tool with `action="search"` and different query angles:
+
+   | Query angle | Purpose |
+   |---|---|
+   | Topic/subject name | Relevant decisions and preferences |
+   | People mentioned | Relationship context |
+   | Project/goal references | Progress and background |
+   | Broad context | Catch-all for anything relevant |
+
+3. **Deduplicate** results by memory ID across all search responses.
+
+4. **Output compact context block** (max 10 memories):
+
+```
+context-loader: loaded <N> memories for "<task summary>"
+  - [decisions] <content> [mem0:<short_id>]
+  - [preferences] <content> [mem0:<short_id>]
+  - [lessons] <content> [mem0:<short_id>]
+```
+
+5. If **zero results**: output nothing. Don't announce empty context.
+
+## Constraints
+
+- **Read-only** — never modify or delete memories
+- **Max 10 memories** returned (most relevant only)
+- **Silent on empty** — only surfaces findings if relevant context exists
+- Skip memories already visible in current session context

pi-agent-plugin/skills/dream/SKILL.md

@@ -0,0 +1,125 @@
+---
+name: dream
+description: Consolidates stored memories by merging duplicates, resolving contradictions, and pruning stale entries. Use when memory count is high, search results feel noisy or repetitive, or periodic cleanup is needed to maintain memory quality.
+---
+
+# Dream — Memory Consolidation
+
+This skill performs a memory consolidation pass: it fetches all memories, identifies near-duplicates, flags contradictions, and prunes stale entries. All proposed changes are shown as a diff for user approval before anything is modified.
+
+**IMPORTANT: Execute steps strictly in order (1 -> 2 -> 3 -> 4 -> 5). Each step depends on the previous one. Do NOT run steps in parallel or skip ahead.**
+
+## Step 1: Fetch ALL Memories
+
+Use `mem0_memory` tool with `action="get_all"` to retrieve every memory.
+
+If zero memories are found, print:
+
+```
+No memories found. Nothing to consolidate.
+```
+
+...and stop.
+
+## Step 2: Analyze — Find Issues
+
+Work entirely in-memory; do not modify anything yet.
+
+Group memories by category. For each group, identify the following:
+
+### 2a. Near-duplicate pairs (merge candidates)
+
+Two memories are near-duplicates when they express the same fact but phrased differently (e.g., "Prefers morning meetings" and "Likes scheduling meetings early").
+
+Heuristics — two memories are near-duplicates if **all** of these hold:
+- If >60% of significant nouns/keywords overlap, treat as near-duplicate.
+- Same category.
+- Neither memory is pinned (content does not start with `[PINNED]`).
+
+For each qualifying pair, draft a merged version that is more complete than either original.
+
+### 2b. Contradictions
+
+Two memories contradict when they assert opposing facts about the same topic (e.g., "Prefers cats" vs. "Allergic to cats, prefers dogs").
+
+Identify the likely winner: the more recent memory wins. Store both IDs and their content for user review.
+
+### 2c. Prune candidates
+
+A memory is a prune candidate when **any** of the following is true:
+
+1. It is older than 180 days AND has not been accessed recently.
+2. Its content is extremely vague (fewer than 5 meaningful words).
+
+**Always skip memories where content starts with `[PINNED]`**, regardless of age.
+
+## Step 3: Print Diff Report
+
+Print a structured diff before making any changes:
+
+```
+## dream — consolidation report
+
+Merges (<N>):
+  [mem0:<id1>] + [mem0:<id2>] -> "<merged content, 100 chars>"
+
+Conflicts (<N>):
+  [mem0:<idA>] vs [mem0:<idB>] — "<topic>" [A/B/skip]
+
+Prune (<N>):
+  [mem0:<id>] — <category>, <age>d old
+
+Proposed: <N> merges, <N> prunes, <N> conflicts. Apply? [Y/n]
+```
+
+If there are zero total proposals, print:
+
+```
+Dream complete. No duplicate, contradictory, or stale memories found.
+```
+
+...and stop.
+
+## Step 4: Wait for User Input and Apply
+
+### 4a. Contradictions
+
+For each conflict pair, wait for the user to choose A, B, or skip.
+
+### 4b. Final confirmation
+
+After all conflict resolutions are collected, prompt: `Apply? [Y/n]`
+
+If the user declines, print `Cancelled. No changes made.` and stop.
+
+If confirmed, apply all changes:
+
+**Merges:** Delete both originals, add the merged version using `mem0_memory` with `action="add"`.
+
+**Contradictions (resolved):** Delete the loser using `mem0_memory` with `action="delete"`.
+
+**Prunes:** Delete each using `mem0_memory` with `action="delete"`.
+
+## Step 5: Print Summary
+
+```
+Dream complete — merged: <N>, pruned: <N>, conflicts resolved: <N>, skipped: <N>
+```
+
+## Auto mode
+
+When invoked with `--auto` (e.g., `/mem0-dream --auto`), run non-interactively:
+
+- **Merges**: applied automatically.
+- **Prunes**: applied automatically.
+- **Contradictions**: skipped — they require human judgment.
+
+Print a compact summary:
+```
+[mem0-dream --auto] merged=<N> pruned=<N> conflicts_skipped=<N>
+```
+
+## See also
+
+- `/mem0-forget` — targeted deletion of specific memories
+- `/mem0-status` — quick health check

pi-agent-plugin/skills/forget/SKILL.md

@@ -0,0 +1,53 @@
+---
+name: forget
+description: Deletes memories by search query or memory ID with confirmation before removal. Use when removing outdated information, incorrect memories, sensitive data, or cleaning up after experiments.
+---
+
+# Forget
+
+Delete specific memories from Mem0.
+
+## Execution
+
+### Step 1: Parse input
+
+The user provides either:
+- A search query: `/mem0-forget travel plans`
+- A memory ID: `/mem0-forget <memory_id>`
+
+If no argument, ask: "What should I forget? Provide a search query or memory ID."
+
+### Step 2: Find memories
+
+**If memory ID provided** (looks like a UUID or hex string):
+- Use `mem0_memory` tool with `action="search"` and the ID as query, or look it up directly.
+- Show: `Found: "<memory content first 120 chars>" (created <date>)`
+
+**If search query provided:**
+- Use `mem0_memory` tool with `action="search"`, `query=<user's query>`.
+- Show numbered list:
+  ```
+  Found <N> memories matching "<query>":
+  1. <content, 120 chars> [<category>] [ID: <short_id>]
+  2. ...
+  ```
+
+### Step 3: Confirm
+
+Ask: "Delete which memories? Enter numbers (e.g., 1,3,5), 'all', or 'cancel'."
+
+For a single memory ID, ask: "Delete this memory? [y/N]"
+
+**Never delete without confirmation.** This is destructive.
+
+### Step 4: Delete
+
+For each confirmed memory, use `mem0_memory` tool with `action="delete"` and the memory ID.
+
+### Step 5: Report
+
+```
+Deleted <N> memories.
+```
+
+If any deletions failed, report which ones and why.

pi-agent-plugin/skills/pin/SKILL.md

@@ -0,0 +1,48 @@
+---
+name: pin
+description: Pins or unpins a memory to protect it from pruning during dream consolidation. Use when a memory is critical and must never be removed, such as core preferences, important decisions, or immutable personal facts.
+---
+
+# Pin
+
+Pin a memory to mark it as high-priority and protect from dream pruning.
+
+## Execution
+
+### Step 1: Find the memory
+
+The user provides either a search query or memory ID.
+
+**If memory ID:** Look it up directly.
+
+**If search query:**
+- Use `mem0_memory` tool with `action="search"`, `query=<query>`.
+- Show numbered list with content previews.
+- Ask: "Which memory to pin? Enter a number."
+
+### Step 2: Pin it
+
+Pinning works by prepending `[PINNED]` to the memory text. This marker tells the dream consolidation to skip it during pruning.
+
+Use `mem0_memory` tool with `action="add"`, `content="[PINNED] <original memory text>"`.
+
+Then delete the original using `mem0_memory` with `action="delete"` and the original memory ID.
+
+**For new memories** (user wants to pin text that isn't stored yet):
+- Use `mem0_memory` tool with `action="add"`, `content="[PINNED] <the user's text>"`.
+
+### Step 3: Confirm
+
+```
+Pinned: "<memory content, first 80 chars>"
+```
+
+Append `...` only if content exceeds 80 characters.
+
+### Unpin
+
+If the user says "unpin":
+1. Find the memory (search or by ID).
+2. Create a new memory without the `[PINNED]` prefix.
+3. Delete the pinned version.
+4. Print: `Unpinned: "<content>..."`

pi-agent-plugin/skills/remember/SKILL.md

@@ -0,0 +1,50 @@
+---
+name: remember
+description: Stores a memory verbatim from user input with appropriate category classification. Use when the user says remember this, save this, store this, note that, or explicitly asks to record a preference, decision, goal, or lesson.
+---
+
+# Remember
+
+Store a fact, preference, or learning directly into Mem0.
+
+## Execution
+
+### Step 1: Extract the content
+
+The user provides the content as an argument: `/mem0-remember <text>`
+
+If no text was provided, ask: "What should I remember?"
+
+### Step 2: Classify the memory
+
+Based on the content, pick the best category:
+
+| Content signal | Category |
+|---|---|
+| "I prefer...", "I like...", "use X instead of Y" | `preferences` |
+| "we decided...", "always use...", "never..." | `decisions` |
+| "I learned...", "figured out...", "don't try..." | `lessons` |
+| "my goal is...", "I want to...", "working toward..." | `goals` |
+| "I work at...", "my role is...", "my team..." | `work` |
+| "every day I...", "my workflow is..." | `routines` |
+| "I'm working on...", "the project involves..." | `projects` |
+| "John is...", "my manager...", "the team..." | `relationships` |
+| "my name is...", "I'm from...", "I studied..." | `identity` |
+| setup, tools, config, environment | `technical` |
+| anything else | `lessons` |
+
+### Step 3: Store
+
+Use the `mem0_memory` tool with:
+- `action="add"`
+- `content="<the user's text>"`
+
+The `/mem0-remember` command stores verbatim — no inference. This is already handled by the command.
+
+### Step 4: Confirm
+
+```
+Remembered as <category>: "<content, first 80 chars>"
+```
+
+Append `...` only if content was truncated (longer than 80 chars).

pi-agent-plugin/skills/search/SKILL.md

@@ -0,0 +1,41 @@
+---
+name: search
+description: Searches memories and displays compact one-liner results, or looks up a specific memory by ID. Use for quick memory lookups, checking if something was recorded, resolving [mem0:id] citations, or browsing memories without full category detail.
+---
+
+# Search / Peek
+
+Quick semantic search with compact output. Lighter than `/mem0-tour`.
+
+## Execution
+
+### Step 1: Parse query
+
+The user provides a search query: `/mem0-search favorite restaurants`
+
+If no query provided, ask: "What should I search for?"
+
+**Memory ID detection:** If the query matches a UUID pattern (`^[a-f0-9-]{20,}$`), treat it as a direct memory lookup instead of a search.
+
+### Step 2: Search
+
+Use `mem0_memory` tool with `action="search"`, `query=<user's query>`.
+
+### Step 3: Display
+
+Show compact results:
+
+```
+## mem0 search: "<query>" (<N> results)
+
+1. [preferences] Prefers window seats on flights (2026-05-15) [mem0:a3f8b2c1]
+2. [goals] Wants to visit Japan in 2027 (2026-05-10) [mem0:7e2d9f4a]
+3. [identity] Lives in San Francisco (2026-05-08) [mem0:c4d5e6f7]
+```
+
+Format: `<number>. [<category>] <content, 80 chars> (<date>) [mem0:<short_id>]`
+
+If no results:
+```
+No memories matching "<query>".
+```

pi-agent-plugin/skills/status/SKILL.md

@@ -0,0 +1,89 @@
+---
+name: status
+description: Diagnoses Mem0 connectivity, API key validity, and memory read/write functionality. Use when memory operations fail, searches return empty, or to verify the plugin is working correctly.
+---
+
+# Health Check / Status
+
+Run a diagnostic check on the Mem0 plugin. Useful for troubleshooting.
+
+## Execution
+
+Run ALL checks, then display a single summary. Do not stop on the first failure.
+
+### Check 1: API key
+
+Verify the API key is configured. The plugin loads it from `MEM0_API_KEY` env var or `~/.pi/agent/mem0-config.json`.
+
+- If not set: FAIL — "No API key configured"
+- If set: PASS — show first 6 chars followed by `...`
+
+### Check 2: Identity resolution
+
+Report the resolved identity:
+- `user_id`: from config, env, or system user
+- `project_id`: auto-detected from current directory
+- `session_id`: current session identifier
+
+PASS if user_id and project_id are non-empty. WARN if any falls back to defaults.
+
+### Check 3: Connectivity
+
+Use `mem0_memory` tool with `action="search"`, `query="health check"`.
+
+- If returns successfully (even empty): PASS
+- If errors: FAIL — show the error message
+
+### Check 4: Memory write capability
+
+Use `mem0_memory` tool with `action="add"`, `content="Health check probe — safe to delete."`.
+
+- If succeeds: PASS — then clean up by deleting the probe memory.
+- If errors: FAIL — show the error.
+
+### Display
+
+```
+## mem0 health
+
+PASS  API Key          m0-dVe...
+PASS  Identity         user=kartik, project=my-app, session=abc123
+PASS  Connectivity     142ms
+PASS  Write/Read       write + delete OK
+
+All checks passed.
+```
+
+If any check fails, add a `## Troubleshooting` section with specific fix steps.
+
+## Extended mode: Memory Quality Analysis
+
+When invoked with `--deep` (e.g., `/mem0-status --deep`), run the standard checks above **plus** a memory quality scan.
+
+### Quality Check 1: Duplicates
+
+Fetch all memories with `mem0_memory` `action="get_all"`. Compare pairs within the same category for high textual overlap (shared nouns > 60%). Report:
+
+```
+Potential duplicates: <N> pairs
+  [mem0:<id1>] ~ [mem0:<id2>] — both about "<shared topic>"
+```
+
+### Quality Check 2: Stale memories
+
+Flag memories older than 180 days that haven't been accessed recently.
+
+### Quality Check 3: Contradictions
+
+Within each category, flag pairs that assert opposing facts.
+
+### Quality summary
+
+```
+## Memory Quality
+
+Duplicates: <N> · Stale: <N> · Contradictions: <N>
+```
+
+If all counts are 0: `Memory quality: clean.`
+If any non-zero: append `Run /mem0-dream to fix.`

pi-agent-plugin/skills/tour/SKILL.md

@@ -0,0 +1,88 @@
+---
+name: tour
+description: Browses all stored memories grouped by category with full content display. Use when reviewing all memories, exploring stored knowledge, onboarding to a new session, or getting an overview of what the agent remembers.
+---
+
+# Memory Tour
+
+Show the user what Mem0 has stored — a full walkthrough of all memories grouped by category.
+
+## Cross-project mode
+
+When invoked with `--all-projects` (e.g., `/mem0-tour --all-projects`), search across ALL projects:
+
+1. Use `mem0_memory` tool with `action="get_all"`, `scope="global"` — no project filter.
+2. Group results by project first, then by category within each project.
+3. Display:
+   ```
+   ## <project_1> (<N> memories) <- current
+   **Goals** — <memory content>
+   ...
+
+   ## <project_2> (<N> memories)
+   ...
+
+   <N> memories across <M> projects
+   ```
+4. Mark the current project with `<- current` in the heading.
+
+If `--all-projects` is NOT present, use the standard single-project flow below.
+
+## Search mode
+
+When `/mem0-tour` receives a search query argument (e.g., `/mem0-tour cooking recipes`), run in **search mode** — compact one-liner results:
+
+1. Use `mem0_memory` tool with `action="search"`, `query=<query>`.
+2. Display compact results (same format as the search skill).
+3. If no results: `No memories matching "<query>".`
+
+If no query argument and no `--all-projects` flag, use the full tour flow below.
+
+## Execution
+
+### Step 1: Fetch ALL memories
+
+Use `mem0_memory` tool with `action="get_all"`.
+
+### Step 2: Group by category
+
+Group memories using their `categories` field. Map to display names:
+
+| Category | Display name |
+|---|---|
+| `identity` | Identity & Background |
+| `preferences` | Preferences |
+| `goals` | Goals & Aspirations |
+| `projects` | Projects & Initiatives |
+| `decisions` | Decisions |
+| `technical` | Technical Knowledge |
+| `relationships` | People & Relationships |
+| `routines` | Routines & Workflows |
+| `lessons` | Lessons Learned |
+| `work` | Work & Professional |
+| anything else | Other |
+
+### Step 3: Display results
+
+Sort groups by descending memory count. For each group:
+
+```
+## <display_name> (<count> memories)
+- <full_memory_content> (<date>)
+- ...
+```
+
+Show the **full memory text** for each entry — do NOT truncate. If a group has more than 10 entries, show top 10 by recency and note `... and <N> more`.
+
+### Step 4: Print totals
+
+```
+<N> memories across <M> categories
+```
+
+### Step 5: Empty state
+
+If zero memories found:
+```
+No memories stored yet. Start a conversation — Mem0 captures learnings automatically, or use /mem0-remember to store something manually.
+```

pi-agent-plugin/src/capture/index.ts

@@ -0,0 +1,70 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type MemoryClient from "mem0ai";
+import type { Mem0Config, ScopeContext } from "../types.ts";
+import { DEFAULT_CUSTOM_CATEGORIES } from "../types.ts";
+import { resolveAddParams } from "../memory/scoping.ts";
+import { captureEvent } from "../telemetry.ts";
+
+interface MessageLike {
+  role: string;
+  content?: unknown;
+}
+
+function extractText(content: unknown): string | null {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    const texts = content
+      .filter((b: any) => b.type === "text" && typeof b.text === "string")
+      .map((b: any) => b.text);
+    return texts.length > 0 ? texts.join("\n") : null;
+  }
+  return null;
+}
+
+export function extractConversation(
+  messages: MessageLike[],
+): Array<{ role: "user" | "assistant"; content: string }> {
+  const result: Array<{ role: "user" | "assistant"; content: string }> = [];
+
+  for (const msg of messages) {
+    if (msg.role !== "user" && msg.role !== "assistant") continue;
+    const text = extractText(msg.content);
+    if (!text) continue;
+    result.push({ role: msg.role as "user" | "assistant", content: text });
+  }
+
+  return result;
+}
+
+export function setupAutoCapture(
+  pi: ExtensionAPI,
+  mem0: MemoryClient,
+  config: Mem0Config,
+  getScopeCtx: () => ScopeContext,
+  telemetryCtx?: { apiKey?: string },
+): void {
+  if (!config.autoCapture) return;
+
+  pi.on("agent_end", async (event) => {
+    const messages = event.messages ?? [];
+    const conversation = extractConversation(messages);
+    if (conversation.length === 0) return;
+
+    const scopeCtx = getScopeCtx();
+    const addParams = resolveAddParams("project", scopeCtx);
+
+    try {
+      await mem0.add(conversation, {
+        ...addParams,
+        customCategories: DEFAULT_CUSTOM_CATEGORIES,
+      });
+      captureEvent("pi.capture.auto", { success: true, message_count: conversation.length }, telemetryCtx);
+    } catch (err: unknown) {
+      captureEvent("pi.capture.auto", {
+        success: false,
+        error_type: err instanceof Error ? err.name : "unknown",
+      }, telemetryCtx);
+      console.error("[mem0] auto-capture failed:", err);
+    }
+  });
+}

pi-agent-plugin/src/commands.test.ts

@@ -0,0 +1,297 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { registerCommands } from "./commands.ts";
+import type { Mem0Config, ScopeContext } from "./types.ts";
+
+vi.mock("./telemetry.ts", () => ({
+  captureCommandEvent: vi.fn(),
+}));
+
+vi.mock("./dream/index.ts", () => ({
+  acquireDreamLock: vi.fn(() => true),
+}));
+
+vi.mock("./dream/prompt.ts", () => ({
+  DREAM_PROTOCOL: "dream protocol text",
+}));
+
+function makeMem0() {
+  return {
+    search: vi.fn(),
+    delete: vi.fn(),
+    add: vi.fn(),
+    get: vi.fn(),
+    getAll: vi.fn(),
+    update: vi.fn(),
+  } as any;
+}
+
+function makePi() {
+  const commands = new Map<string, { handler: (args: string, ctx: any) => Promise<void> }>();
+  return {
+    registerCommand: vi.fn((name: string, opts: any) => {
+      commands.set(name, opts);
+    }),
+    sendMessage: vi.fn(),
+    _commands: commands,
+    _invoke: (name: string, args: string, ctx: any) => commands.get(name)!.handler(args, ctx),
+  };
+}
+
+function makeCtx(confirmResult = true) {
+  return {
+    hasUI: true,
+    ui: {
+      notify: vi.fn(),
+      confirm: vi.fn(async () => confirmResult),
+      select: vi.fn(),
+      input: vi.fn(),
+    },
+  };
+}
+
+const defaultConfig: Mem0Config = {
+  apiKey: "test-key",
+  userId: "test-user",
+  autoCapture: false,
+  defaultScope: "project",
+  contextInjection: false,
+  dream: { enabled: false, auto: false, minHours: 24, minSessions: 5, minMemories: 20 },
+};
+
+const scopeCtx: ScopeContext = { userId: "test-user", appId: "test-app", runId: "test-run" };
+
+describe("registerCommands", () => {
+  let pi: ReturnType<typeof makePi>;
+  let mem0: ReturnType<typeof makeMem0>;
+
+  beforeEach(() => {
+    pi = makePi();
+    mem0 = makeMem0();
+    registerCommands(pi as any, mem0, defaultConfig, () => scopeCtx);
+  });
+
+  it("registers all expected commands", () => {
+    const names = [...pi._commands.keys()];
+    expect(names).toContain("mem0-remember");
+    expect(names).toContain("mem0-forget");
+    expect(names).toContain("mem0-search");
+    expect(names).toContain("mem0-tour");
+    expect(names).toContain("mem0-dream");
+    expect(names).toContain("mem0-pin");
+    expect(names).toContain("mem0-scope");
+    expect(names).toContain("mem0-status");
+  });
+
+  describe("/mem0-forget", () => {
+    it("shows warning when no query provided", async () => {
+      const ctx = makeCtx();
+      await pi._invoke("mem0-forget", "", ctx);
+      expect(ctx.ui.notify).toHaveBeenCalledWith("Usage: /mem0-forget <query>", "warning");
+      expect(mem0.search).not.toHaveBeenCalled();
+    });
+
+    it("notifies when no memories match", async () => {
+      const ctx = makeCtx();
+      mem0.search.mockResolvedValue({ results: [] });
+      await pi._invoke("mem0-forget", "old preference", ctx);
+      expect(ctx.ui.notify).toHaveBeenCalledWith("No matching memories found.", "info");
+    });
+
+    it("asks for confirmation before deleting a single match", async () => {
+      const ctx = makeCtx(true);
+      mem0.search.mockResolvedValue({ results: [{ id: "abc-123", memory: "test mem" }] });
+      mem0.delete.mockResolvedValue({ message: "Deleted" });
+
+      await pi._invoke("mem0-forget", "test", ctx);
+
+      expect(ctx.ui.confirm).toHaveBeenCalledWith(
+        "Delete this memory?",
+        expect.stringContaining("test mem"),
+      );
+      expect(mem0.delete).toHaveBeenCalledWith("abc-123");
+    });
+
+    it("does not delete when user cancels confirmation", async () => {
+      const ctx = makeCtx(false);
+      mem0.search.mockResolvedValue({ results: [{ id: "abc-123", memory: "test mem" }] });
+
+      await pi._invoke("mem0-forget", "test", ctx);
+
+      expect(ctx.ui.confirm).toHaveBeenCalled();
+      expect(mem0.delete).not.toHaveBeenCalled();
+      expect(ctx.ui.notify).toHaveBeenCalledWith("Cancelled.", "info");
+    });
+
+    it("uses select UI for multiple matches and deletes chosen memory", async () => {
+      const ctx = makeCtx();
+      mem0.search.mockResolvedValue({
+        results: [
+          { id: "id-1", memory: "mem one" },
+          { id: "id-2", memory: "mem two" },
+        ],
+      });
+      mem0.delete.mockResolvedValue({ message: "Deleted" });
+      ctx.ui.select = vi.fn(async (_title: string, options: string[]) => options[1]);
+
+      await pi._invoke("mem0-forget", "test", ctx);
+
+      expect(ctx.ui.select).toHaveBeenCalledWith(
+        "Which memory should I delete?",
+        expect.arrayContaining([
+          expect.stringContaining("mem one"),
+          expect.stringContaining("mem two"),
+        ]),
+      );
+      expect(mem0.delete).toHaveBeenCalledWith("id-2");
+    });
+
+    it("does not delete when user cancels select", async () => {
+      const ctx = makeCtx();
+      ctx.ui.select = vi.fn(async () => undefined);
+      mem0.search.mockResolvedValue({
+        results: [
+          { id: "id-1", memory: "mem one" },
+          { id: "id-2", memory: "mem two" },
+        ],
+      });
+
+      await pi._invoke("mem0-forget", "test", ctx);
+
+      expect(mem0.delete).not.toHaveBeenCalled();
+      expect(ctx.ui.notify).toHaveBeenCalledWith("Cancelled.", "info");
+    });
+  });
+
+  describe("/mem0-pin", () => {
+    it("uses update to pin in-place, preserving memory ID", async () => {
+      const ctx = makeCtx(true);
+      mem0.search.mockResolvedValue({ results: [{ id: "abc-123", memory: "important fact" }] });
+      mem0.update.mockResolvedValue([]);
+
+      await pi._invoke("mem0-pin", "important", ctx);
+
+      expect(ctx.ui.confirm).toHaveBeenCalledWith(
+        "Pin this memory?",
+        expect.stringContaining("important fact"),
+      );
+      expect(mem0.update).toHaveBeenCalledWith("abc-123", { text: "[PINNED] important fact" });
+      expect(mem0.add).not.toHaveBeenCalled();
+      expect(mem0.delete).not.toHaveBeenCalled();
+    });
+
+    it("does not pin when user cancels", async () => {
+      const ctx = makeCtx(false);
+      mem0.search.mockResolvedValue({ results: [{ id: "abc-123", memory: "fact" }] });
+
+      await pi._invoke("mem0-pin", "fact", ctx);
+
+      expect(mem0.update).not.toHaveBeenCalled();
+    });
+
+    it("skips already-pinned memories", async () => {
+      const ctx = makeCtx();
+      mem0.search.mockResolvedValue({ results: [{ id: "abc-123", memory: "[PINNED] fact" }] });
+
+      await pi._invoke("mem0-pin", "fact", ctx);
+
+      expect(ctx.ui.confirm).not.toHaveBeenCalled();
+      expect(mem0.add).not.toHaveBeenCalled();
+      expect(ctx.ui.notify).toHaveBeenCalledWith("Already pinned.", "info");
+    });
+
+    it("uses select UI for multiple matches and pins chosen memory", async () => {
+      const ctx = makeCtx();
+      mem0.search.mockResolvedValue({
+        results: [
+          { id: "id-1", memory: "fact one" },
+          { id: "id-2", memory: "fact two" },
+        ],
+      });
+      mem0.update.mockResolvedValue([]);
+      ctx.ui.select = vi.fn(async (_title: string, options: string[]) => options[1]);
+
+      await pi._invoke("mem0-pin", "fact", ctx);
+
+      expect(ctx.ui.select).toHaveBeenCalledWith(
+        "Which memory should I pin?",
+        expect.arrayContaining([
+          expect.stringContaining("fact one"),
+          expect.stringContaining("fact two"),
+        ]),
+      );
+      expect(mem0.update).toHaveBeenCalledWith("id-2", { text: "[PINNED] fact two" });
+    });
+
+    it("does not pin when user cancels select", async () => {
+      const ctx = makeCtx();
+      ctx.ui.select = vi.fn(async () => undefined);
+      mem0.search.mockResolvedValue({
+        results: [
+          { id: "id-1", memory: "fact one" },
+          { id: "id-2", memory: "fact two" },
+        ],
+      });
+
+      await pi._invoke("mem0-pin", "fact", ctx);
+
+      expect(mem0.update).not.toHaveBeenCalled();
+      expect(ctx.ui.notify).toHaveBeenCalledWith("Cancelled.", "info");
+    });
+  });
+
+  describe("/mem0-search", () => {
+    it("always performs semantic search", async () => {
+      const ctx = makeCtx();
+      mem0.search.mockResolvedValue({ results: [{ id: "id-1", memory: "result" }] });
+
+      await pi._invoke("mem0-search", "my preferences", ctx);
+
+      expect(mem0.search).toHaveBeenCalledWith("my preferences", expect.any(Object));
+      expect(pi.sendMessage).toHaveBeenCalledWith(
+        expect.objectContaining({ customType: "mem0-search" }),
+      );
+    });
+
+    it("uses semantic search even for hex-looking strings", async () => {
+      const ctx = makeCtx();
+      mem0.search.mockResolvedValue({ results: [] });
+
+      await pi._invoke("mem0-search", "abcd1234", ctx);
+
+      expect(mem0.search).toHaveBeenCalledWith("abcd1234", expect.any(Object));
+      expect(mem0.getAll).not.toHaveBeenCalled();
+      expect(mem0.get).not.toHaveBeenCalled();
+    });
+
+    it("shows empty results message", async () => {
+      const ctx = makeCtx();
+      mem0.search.mockResolvedValue({ results: [] });
+
+      await pi._invoke("mem0-search", "nonexistent", ctx);
+
+      expect(pi.sendMessage).toHaveBeenCalledWith(
+        expect.objectContaining({ content: "No memories found." }),
+      );
+    });
+  });
+
+  describe("/mem0-remember", () => {
+    it("stores a memory verbatim", async () => {
+      const ctx = makeCtx();
+      mem0.add.mockResolvedValue({ message: "Memory stored." });
+
+      await pi._invoke("mem0-remember", "I prefer dark mode", ctx);
+
+      expect(mem0.add).toHaveBeenCalledWith(
+        [{ role: "user", content: "I prefer dark mode" }],
+        expect.objectContaining({ infer: false }),
+      );
+    });
+
+    it("shows warning when no text provided", async () => {
+      const ctx = makeCtx();
+      await pi._invoke("mem0-remember", "  ", ctx);
+      expect(ctx.ui.notify).toHaveBeenCalledWith("Usage: /mem0-remember <text>", "warning");
+    });
+  });
+});

pi-agent-plugin/src/commands.ts

@@ -0,0 +1,291 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type MemoryClient from "mem0ai";
+import type { Mem0Config, ScopeContext, Scope } from "./types.ts";
+import { DEFAULT_CUSTOM_CATEGORIES } from "./types.ts";
+import { resolveSearchFilters, resolveAddParams } from "./memory/scoping.ts";
+import { formatMemoryList, formatMemoryCompact, groupByCategory } from "./memory/formatting.ts";
+import { DREAM_PROTOCOL } from "./dream/prompt.ts";
+import { acquireDreamLock } from "./dream/index.ts";
+import { CONFIG_DIR } from "./config/index.ts";
+import { captureCommandEvent } from "./telemetry.ts";
+
+export function registerCommands(
+  pi: ExtensionAPI,
+  mem0: MemoryClient,
+  config: Mem0Config,
+  getScopeCtx: () => ScopeContext,
+  telemetryCtx?: { apiKey?: string },
+): void {
+  // ── /mem0-remember ──────────────────────────────────────────────────
+  pi.registerCommand("mem0-remember", {
+    description: "Store a memory verbatim (no inference)",
+    handler: async (args, ctx) => {
+      const text = args?.trim();
+      if (!text) {
+        ctx.ui.notify("Usage: /mem0-remember <text>", "warning");
+        return;
+      }
+
+      const scopeCtx = getScopeCtx();
+      const addParams = resolveAddParams(config.defaultScope, scopeCtx);
+      const result = await mem0.add(
+        [{ role: "user", content: text }],
+        { ...addParams, customCategories: DEFAULT_CUSTOM_CATEGORIES, infer: false },
+      );
+      const msg = (result as { message?: string }).message ?? "Memory stored.";
+      captureCommandEvent("mem0-remember", {}, telemetryCtx);
+      ctx.ui.notify(msg, "info");
+    },
+  });
+
+  // ── /mem0-forget ────────────────────────────────────────────────────
+  pi.registerCommand("mem0-forget", {
+    description: "Delete memories matching a natural language query",
+    handler: async (args, ctx) => {
+      const query = args?.trim();
+      if (!query) {
+        ctx.ui.notify("Usage: /mem0-forget <query>", "warning");
+        return;
+      }
+
+      const scopeCtx = getScopeCtx();
+      const filters = resolveSearchFilters(config.defaultScope, scopeCtx);
+      const result = await mem0.search(query, { filters });
+      const memories = result.results ?? [];
+
+      if (memories.length === 0) {
+        captureCommandEvent("mem0-forget", { result_count: 0 }, telemetryCtx);
+        ctx.ui.notify("No matching memories found.", "info");
+        return;
+      }
+
+      if (memories.length === 1) {
+        const target = memories[0];
+        const confirmed = await ctx.ui.confirm(
+          "Delete this memory?",
+          formatMemoryCompact(target),
+        );
+        if (!confirmed) {
+          ctx.ui.notify("Cancelled.", "info");
+          return;
+        }
+        await mem0.delete(target.id);
+        captureCommandEvent("mem0-forget", { deleted_count: 1 }, telemetryCtx);
+        ctx.ui.notify(`Deleted: ${formatMemoryCompact(target)}`, "info");
+        return;
+      }
+
+      const labels = memories.map((m) => formatMemoryCompact(m));
+      const selected = await ctx.ui.select("Which memory should I delete?", labels);
+      if (!selected) {
+        ctx.ui.notify("Cancelled.", "info");
+        return;
+      }
+      const idx = labels.indexOf(selected);
+      if (idx < 0) return;
+      const target = memories[idx];
+      await mem0.delete(target.id);
+      captureCommandEvent("mem0-forget", { deleted_count: 1 }, telemetryCtx);
+      ctx.ui.notify(`Deleted: ${formatMemoryCompact(target)}`, "info");
+    },
+  });
+
+  // ── /mem0-search ────────────────────────────────────────────────────
+  pi.registerCommand("mem0-search", {
+    description: "Semantic search across memories",
+    handler: async (args, ctx) => {
+      const query = args?.trim();
+      if (!query) {
+        ctx.ui.notify("Usage: /mem0-search <query>", "warning");
+        return;
+      }
+
+      const scopeCtx = getScopeCtx();
+      const filters = resolveSearchFilters(config.defaultScope, scopeCtx);
+      const result = await mem0.search(query, { filters });
+      const memories = result.results ?? [];
+
+      captureCommandEvent("mem0-search", { result_count: memories.length }, telemetryCtx);
+      pi.sendMessage({
+        customType: "mem0-search",
+        content: formatMemoryList(memories),
+        display: true,
+      });
+    },
+  });
+
+  // ── /mem0-tour ──────────────────────────────────────────────────────
+  pi.registerCommand("mem0-tour", {
+    description: "Browse all memories grouped by category",
+    handler: async (args, ctx) => {
+      const raw = args?.trim().toLowerCase();
+      const validScopes: Scope[] = ["project", "session", "global"];
+      if (raw && !validScopes.includes(raw as Scope)) {
+        ctx.ui.notify(`Invalid scope "${raw}". Must be one of: ${validScopes.join(", ")}`, "warning");
+        return;
+      }
+      const scope: Scope = (raw as Scope) || config.defaultScope;
+      const scopeCtx = getScopeCtx();
+      const filters = resolveSearchFilters(scope, scopeCtx);
+      const result = await mem0.getAll({ filters });
+      const memories = result.results ?? [];
+
+      if (memories.length === 0) {
+        captureCommandEvent("mem0-tour", { memory_count: 0, scope }, telemetryCtx);
+        pi.sendMessage({ customType: "mem0-tour", content: "No memories found.", display: true });
+        return;
+      }
+
+      const groups = groupByCategory(memories);
+      const lines: string[] = [`**Memory Tour** (${memories.length} total, scope: ${scope})`, ""];
+
+      for (const [category, items] of groups) {
+        lines.push(`### ${category} (${items.length})`);
+        for (const m of items) {
+          lines.push(`- ${formatMemoryCompact(m)}`);
+        }
+        lines.push("");
+      }
+
+      captureCommandEvent("mem0-tour", { memory_count: memories.length, scope }, telemetryCtx);
+      pi.sendMessage({ customType: "mem0-tour", content: lines.join("\n"), display: true });
+    },
+  });
+
+  // ── /mem0-dream ─────────────────────────────────────────────────────
+  pi.registerCommand("mem0-dream", {
+    description: "Consolidate memories — merge duplicates, prune stale entries, resolve contradictions",
+    handler: async (_args, ctx) => {
+      if (!acquireDreamLock(CONFIG_DIR)) {
+        ctx.ui.notify("A dream consolidation is already in progress.", "warning");
+        return;
+      }
+
+      captureCommandEvent("mem0-dream", {}, telemetryCtx);
+      pi.sendMessage({ customType: "mem0-dream", content: DREAM_PROTOCOL, display: true }, { triggerTurn: true });
+      ctx.ui.notify("Dream consolidation started.", "info");
+    },
+  });
+
+  // ── /mem0-pin ───────────────────────────────────────────────────────
+  pi.registerCommand("mem0-pin", {
+    description: "Pin a memory to protect it from dream pruning",
+    handler: async (args, ctx) => {
+      const query = args?.trim();
+      if (!query) {
+        ctx.ui.notify("Usage: /mem0-pin <query>", "warning");
+        return;
+      }
+
+      const scopeCtx = getScopeCtx();
+      const filters = resolveSearchFilters(config.defaultScope, scopeCtx);
+      const result = await mem0.search(query, { filters });
+      const memories = result.results ?? [];
+
+      if (memories.length === 0) {
+        captureCommandEvent("mem0-pin", { result_count: 0 }, telemetryCtx);
+        ctx.ui.notify("No matching memories found to pin.", "info");
+        return;
+      }
+
+      if (memories.length === 1) {
+        const target = memories[0];
+        const text = target.memory ?? "";
+        if (text.startsWith("[PINNED]")) {
+          ctx.ui.notify("Already pinned.", "info");
+          return;
+        }
+        const confirmed = await ctx.ui.confirm(
+          "Pin this memory?",
+          formatMemoryCompact(target),
+        );
+        if (!confirmed) {
+          ctx.ui.notify("Cancelled.", "info");
+          return;
+        }
+        await mem0.update(target.id, { text: `[PINNED] ${text}` });
+        captureCommandEvent("mem0-pin", { pinned: true }, telemetryCtx);
+        ctx.ui.notify(`Pinned: ${formatMemoryCompact(target)}`, "info");
+        return;
+      }
+
+      const labels = memories.map((m) => formatMemoryCompact(m));
+      const selected = await ctx.ui.select("Which memory should I pin?", labels);
+      if (!selected) {
+        ctx.ui.notify("Cancelled.", "info");
+        return;
+      }
+      const idx = labels.indexOf(selected);
+      if (idx < 0) return;
+      const target = memories[idx];
+      const selectedText = target.memory ?? "";
+      if (selectedText.startsWith("[PINNED]")) {
+        ctx.ui.notify("Already pinned.", "info");
+        return;
+      }
+      await mem0.update(target.id, { text: `[PINNED] ${selectedText}` });
+      captureCommandEvent("mem0-pin", { pinned: true }, telemetryCtx);
+      ctx.ui.notify(`Pinned: ${formatMemoryCompact(target)}`, "info");
+    },
+  });
+
+  // ── /mem0-scope ─────────────────────────────────────────────────────
+  pi.registerCommand("mem0-scope", {
+    description: "Change default memory scope for this session (project, session, global)",
+    handler: async (args, ctx) => {
+      const scope = args?.trim().toLowerCase();
+      const valid: Scope[] = ["project", "session", "global"];
+
+      if (!scope) {
+        ctx.ui.notify(`Current scope: ${config.defaultScope}. Usage: /mem0-scope <${valid.join("|")}>`, "info");
+        return;
+      }
+
+      if (!valid.includes(scope as Scope)) {
+        ctx.ui.notify(`Invalid scope "${scope}". Must be one of: ${valid.join(", ")}`, "warning");
+        return;
+      }
+
+      config.defaultScope = scope as Scope;
+      captureCommandEvent("mem0-scope", { scope }, telemetryCtx);
+      ctx.ui.notify(`Default scope changed to "${scope}" for this session.`, "info");
+    },
+  });
+
+  // ── /mem0-status ────────────────────────────────────────────────────
+  pi.registerCommand("mem0-status", {
+    description: "Show connection health, identity, project, and memory count",
+    handler: async (_args, _ctx) => {
+      const scopeCtx = getScopeCtx();
+      const filters = resolveSearchFilters("project", scopeCtx);
+
+      let count = 0;
+      let connected = false;
+      try {
+        const result = await mem0.getAll({ filters });
+        count = result.count ?? (result.results ?? []).length;
+        connected = true;
+      } catch {
+        connected = false;
+      }
+
+      const lines = [
+        "**Mem0 Status**",
+        "",
+        `- Connection: ${connected ? "connected" : "disconnected"}`,
+        `- User: ${scopeCtx.userId}`,
+        `- Project: ${scopeCtx.appId}`,
+        `- Session: ${scopeCtx.runId}`,
+        `- Default scope: ${config.defaultScope}`,
+        `- Project memories: ${count}`,
+        `- Auto-capture: ${config.autoCapture ? "on" : "off"}`,
+        `- Dream: ${config.dream.enabled ? "enabled" : "disabled"}`,
+      ];
+
+      captureCommandEvent("mem0-status", { connected, memory_count: count }, telemetryCtx);
+      pi.sendMessage({ customType: "mem0-status", content: lines.join("\n"), display: true });
+    },
+  });
+
+
+}

pi-agent-plugin/src/config/index.ts

@@ -0,0 +1,58 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import type { Mem0Config, DreamConfig } from "../types.ts";
+
+const AGENT_ROOT = path.join(os.homedir(), ".pi", "agent");
+export const CONFIG_DIR = AGENT_ROOT;
+const CONFIG_PATH = path.join(AGENT_ROOT, "mem0-config.json");
+
+const DEFAULT_DREAM: DreamConfig = {
+  enabled: true,
+  auto: true,
+  minHours: 24,
+  minSessions: 5,
+  minMemories: 20,
+};
+
+const DEFAULT_CONFIG: Mem0Config = {
+  apiKey: "",
+  userId: "",
+  autoCapture: true,
+  defaultScope: "project",
+  contextInjection: false,
+  dream: DEFAULT_DREAM,
+};
+
+export function loadConfig(): Mem0Config {
+  let fileConfig: Partial<Mem0Config> = {};
+
+  if (fs.existsSync(CONFIG_PATH)) {
+    try {
+      const raw = fs.readFileSync(CONFIG_PATH, "utf-8");
+      fileConfig = JSON.parse(raw);
+    } catch {
+      // Corrupted config — use defaults
+    }
+  }
+
+  const dream: DreamConfig = {
+    ...DEFAULT_DREAM,
+    ...(fileConfig.dream ?? {}),
+  };
+
+  const config: Mem0Config = {
+    ...DEFAULT_CONFIG,
+    ...fileConfig,
+    dream,
+  };
+
+  if (process.env.MEM0_API_KEY) {
+    config.apiKey = process.env.MEM0_API_KEY;
+  }
+  if (process.env.MEM0_USER_ID) {
+    config.userId = process.env.MEM0_USER_ID;
+  }
+
+  return config;
+}

pi-agent-plugin/src/dream/index.ts

@@ -0,0 +1,115 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { DreamState, DreamLock, DreamConfig } from "../types.ts";
+
+const LOCK_STALE_MS = 60 * 60 * 1000;
+
+const DEFAULTS: DreamConfig = {
+  enabled: true,
+  auto: true,
+  minHours: 24,
+  minSessions: 5,
+  minMemories: 20,
+};
+
+function statePath(stateDir: string): string {
+  return path.join(stateDir, "mem0-dream-state.json");
+}
+
+function lockPath(stateDir: string): string {
+  return path.join(stateDir, "mem0-dream.lock");
+}
+
+function ensureDir(dir: string): void {
+  try {
+    fs.mkdirSync(dir, { recursive: true });
+  } catch { /* exists */ }
+}
+
+function readState(stateDir: string): DreamState {
+  try {
+    const raw = fs.readFileSync(statePath(stateDir), "utf-8");
+    return JSON.parse(raw) as DreamState;
+  } catch {
+    return { lastConsolidatedAt: 0, sessionsSince: 0, lastSessionId: null };
+  }
+}
+
+function writeState(stateDir: string, state: DreamState): void {
+  ensureDir(stateDir);
+  fs.writeFileSync(statePath(stateDir), JSON.stringify(state, null, 2));
+}
+
+export function incrementSessionCount(stateDir: string, sessionId: string): void {
+  const state = readState(stateDir);
+  if (state.lastSessionId !== sessionId) {
+    state.sessionsSince++;
+    state.lastSessionId = sessionId;
+    writeState(stateDir, state);
+  }
+}
+
+export function checkCheapGates(
+  stateDir: string,
+  config: Partial<DreamConfig>,
+): { proceed: boolean; reason?: string } {
+  const minHours = config.minHours ?? DEFAULTS.minHours;
+  const minSessions = config.minSessions ?? DEFAULTS.minSessions;
+  const state = readState(stateDir);
+
+  const hoursSince = (Date.now() - state.lastConsolidatedAt) / 3_600_000;
+  if (hoursSince < minHours) {
+    return { proceed: false, reason: `time: ${hoursSince.toFixed(1)}h < ${minHours}h` };
+  }
+
+  if (state.sessionsSince < minSessions) {
+    return { proceed: false, reason: `sessions: ${state.sessionsSince} < ${minSessions}` };
+  }
+
+  return { proceed: true };
+}
+
+export function checkMemoryGate(
+  memoryCount: number,
+  config: Partial<DreamConfig>,
+): { pass: boolean; reason?: string } {
+  const minMemories = config.minMemories ?? DEFAULTS.minMemories;
+  if (memoryCount < minMemories) {
+    return { pass: false, reason: `memories: ${memoryCount} < ${minMemories}` };
+  }
+  return { pass: true };
+}
+
+export function acquireDreamLock(stateDir: string): boolean {
+  ensureDir(stateDir);
+  const lp = lockPath(stateDir);
+
+  try {
+    const raw = fs.readFileSync(lp, "utf-8");
+    const lock = JSON.parse(raw) as DreamLock;
+    if (Date.now() - lock.startedAt < LOCK_STALE_MS) {
+      return false;
+    }
+    try { fs.unlinkSync(lp); } catch { /* race ok */ }
+  } catch { /* no lock file */ }
+
+  const lock: DreamLock = { pid: process.pid, startedAt: Date.now() };
+  try {
+    fs.writeFileSync(lp, JSON.stringify(lock), { flag: "wx" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function releaseDreamLock(stateDir: string): void {
+  try { fs.unlinkSync(lockPath(stateDir)); } catch { /* already gone */ }
+}
+
+export function recordDreamCompletion(stateDir: string): void {
+  const state = readState(stateDir);
+  state.lastConsolidatedAt = Date.now();
+  state.sessionsSince = 0;
+  state.lastSessionId = null;
+  writeState(stateDir, state);
+}

pi-agent-plugin/src/dream/prompt.ts

@@ -0,0 +1,22 @@
+export const DREAM_PROTOCOL = `<mem0-dream>
+You are running memory consolidation. Complete these steps using the mem0_memory tool:
+
+1. ORIENT — Call mem0_memory with action "get_all" to list all memories. Count by category. Note oldest/newest.
+
+2. GATHER TARGETS — Review each memory. Classify as:
+   - DELETE: sensitive information (API keys, passwords, tokens), expired/stale entries, noise, redundant operational details
+   - MERGE: near-duplicates (same fact stated differently). Keep the better-worded one, delete the other.
+   - REWRITE: vague, first-person, or poorly-categorized entries. Use mem0_memory "add" with improved text, then "delete" the old one.
+   - KEEP: everything else.
+   Skip any memory starting with "[PINNED]".
+
+3. CONSOLIDATE — Execute the changes:
+   - Delete stale/duplicate entries
+   - For merges: add the merged text, delete both originals
+   - For rewrites: add improved version, delete original
+
+4. REPORT — Summarize: how many reviewed, deleted, merged, rewritten, final count.
+
+Quality targets: zero sensitive data stored, zero duplicates, all entries are atomic (one fact each), 15-50 words each.
+After consolidation, respond to the user's message normally.
+</mem0-dream>`;