superlocalmemory 3.4.49__tar.gz → 3.4.52__tar.gz

{superlocalmemory-3.4.49/src/superlocalmemory.egg-info → superlocalmemory-3.4.52}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superlocalmemory
-Version: 3.4.49
+Version: 3.4.52
 Summary: Information-geometric agent memory with mathematical guarantees
 Author-email: Varun Pratap Bhardwaj <admin@superlocalmemory.com>
 License: AGPL-3.0-or-later
@@ -93,7 +93,7 @@ Dynamic: license-file
 
 <h1 align="center">SuperLocalMemory V3.4</h1>
 <p align="center"><strong>Every other AI forgets. Yours won't.</strong><br/><em>Infinite memory for Claude Code, Cursor, Windsurf, and any MCP-compatible AI client.</em></p>
-<p align="center"><code>v3.4.48</code> — Install once. Every session remembers the last. Automatically.<br><strong>Now with multi-machine agent mesh — M4 and M5 coordinate as one.</strong></p>
+<p align="center"><code>v3.4.51 "Recency Intelligence"</code> — <strong>Session context is now time-aware.</strong><br>Stale memories from old projects no longer surface. Ebbinghaus decay + FSRS stability. One command: <code>pip install -U superlocalmemory && slm restart</code></p>
 <p align="center"><strong>Backed by 3 published research papers</strong> (arXiv preprints + Zenodo-archived) · <a href="https://arxiv.org/abs/2603.02240">arXiv:2603.02240</a> · <a href="https://arxiv.org/abs/2603.14588">arXiv:2603.14588</a> · <a href="https://arxiv.org/abs/2604.04514">arXiv:2604.04514</a></p>
 
 <p align="center">
@@ -272,6 +272,30 @@ slm warmup    # Pre-download embedding model (~500MB, optional)
 pip install superlocalmemory
 ```
 
+### Upgrading to v3.4.5 "Scale-Ready"
+
+**Migration is automatic.** Upgrade your package, restart the daemon, and your database migrates silently.
+
+```bash
+# pip users
+pip install -U superlocalmemory
+slm restart
+
+# npm users  
+npm update -g superlocalmemory
+slm restart
+
+# Verify migration
+slm doctor
+```
+
+No manual commands. No data loss. Your database upgrades in-place with zero downtime. The daemon auto-detects the old version and applies the migration on first start.
+
+**New capabilities after upgrade:**
+- Tiered storage: memories auto-classified as active/warm/cold/archived
+- Graph pruning: redundant edges removed, queries stay fast at 1M+ connections
+- Optional: `pip install superlocalmemory[cozo,lancedb]` for graph + vector acceleration
+
 ### First Use
 
 ```bash
@@ -499,6 +523,23 @@ Every recall generates learning signals. Over time, the system adapts to your pa
 
 Auto-capture hooks: `slm hooks install` + `slm observe` + `slm session-context`. MCP tools: `session_init`, `observe`, `report_feedback`.
 
+**`session_init` MCP parameters:**
+| Parameter | Type | Default | Description |
+|---|---|---|---|
+| `project_path` | string | `""` | Working directory — used to derive search query |
+| `query` | string | `""` | Override search query |
+| `max_results` | int | `10` | Max memories to return |
+| `max_age_days` | int | `30` | Suppress memories older than N days (0 = disabled). Memories with score ≥ 0.70 always surface regardless of age. |
+
+**`slm session-context` CLI flags** (consistent with MCP):
+```bash
+slm session-context                          # fast path, 30-day window (default)
+slm session-context --max-age-days 7         # only last 7 days
+slm session-context --max-age-days 0         # no age filter
+slm session-context "my query" --full        # full engine path (slow, requires Ollama)
+slm session-context --json                   # agent-native JSON output
+```
+
 **No competitor learns at zero token cost.**
 
 </details>
@@ -637,6 +678,7 @@ All 8 mesh tools work seamlessly across machines:
 | `slm hooks install` | Wire auto-memory into Claude Code hooks |
 | `slm profile list/create/switch` | Profile management |
 | `slm decay` | Run memory lifecycle review |
+| `slm session-context [query]` | Print session context (for hooks). Flags: `--max-age-days N` (default 30), `--full`, `--json` |
 | `slm quantize` | Run smart compression cycle |
 | `slm consolidate --cognitive` | Extract patterns from memory clusters |
 | `slm soft-prompts` | View auto-learned patterns |

{superlocalmemory-3.4.49 → superlocalmemory-3.4.52}/README.md

@@ -4,7 +4,7 @@
 
 <h1 align="center">SuperLocalMemory V3.4</h1>
 <p align="center"><strong>Every other AI forgets. Yours won't.</strong><br/><em>Infinite memory for Claude Code, Cursor, Windsurf, and any MCP-compatible AI client.</em></p>
-<p align="center"><code>v3.4.48</code> — Install once. Every session remembers the last. Automatically.<br><strong>Now with multi-machine agent mesh — M4 and M5 coordinate as one.</strong></p>
+<p align="center"><code>v3.4.51 "Recency Intelligence"</code> — <strong>Session context is now time-aware.</strong><br>Stale memories from old projects no longer surface. Ebbinghaus decay + FSRS stability. One command: <code>pip install -U superlocalmemory && slm restart</code></p>
 <p align="center"><strong>Backed by 3 published research papers</strong> (arXiv preprints + Zenodo-archived) · <a href="https://arxiv.org/abs/2603.02240">arXiv:2603.02240</a> · <a href="https://arxiv.org/abs/2603.14588">arXiv:2603.14588</a> · <a href="https://arxiv.org/abs/2604.04514">arXiv:2604.04514</a></p>
 
 <p align="center">
@@ -183,6 +183,30 @@ slm warmup    # Pre-download embedding model (~500MB, optional)
 pip install superlocalmemory
 ```
 
+### Upgrading to v3.4.5 "Scale-Ready"
+
+**Migration is automatic.** Upgrade your package, restart the daemon, and your database migrates silently.
+
+```bash
+# pip users
+pip install -U superlocalmemory
+slm restart
+
+# npm users  
+npm update -g superlocalmemory
+slm restart
+
+# Verify migration
+slm doctor
+```
+
+No manual commands. No data loss. Your database upgrades in-place with zero downtime. The daemon auto-detects the old version and applies the migration on first start.
+
+**New capabilities after upgrade:**
+- Tiered storage: memories auto-classified as active/warm/cold/archived
+- Graph pruning: redundant edges removed, queries stay fast at 1M+ connections
+- Optional: `pip install superlocalmemory[cozo,lancedb]` for graph + vector acceleration
+
 ### First Use
 
 ```bash
@@ -410,6 +434,23 @@ Every recall generates learning signals. Over time, the system adapts to your pa
 
 Auto-capture hooks: `slm hooks install` + `slm observe` + `slm session-context`. MCP tools: `session_init`, `observe`, `report_feedback`.
 
+**`session_init` MCP parameters:**
+| Parameter | Type | Default | Description |
+|---|---|---|---|
+| `project_path` | string | `""` | Working directory — used to derive search query |
+| `query` | string | `""` | Override search query |
+| `max_results` | int | `10` | Max memories to return |
+| `max_age_days` | int | `30` | Suppress memories older than N days (0 = disabled). Memories with score ≥ 0.70 always surface regardless of age. |
+
+**`slm session-context` CLI flags** (consistent with MCP):
+```bash
+slm session-context                          # fast path, 30-day window (default)
+slm session-context --max-age-days 7         # only last 7 days
+slm session-context --max-age-days 0         # no age filter
+slm session-context "my query" --full        # full engine path (slow, requires Ollama)
+slm session-context --json                   # agent-native JSON output
+```
+
 **No competitor learns at zero token cost.**
 
 </details>
@@ -548,6 +589,7 @@ All 8 mesh tools work seamlessly across machines:
 | `slm hooks install` | Wire auto-memory into Claude Code hooks |
 | `slm profile list/create/switch` | Profile management |
 | `slm decay` | Run memory lifecycle review |
+| `slm session-context [query]` | Print session context (for hooks). Flags: `--max-age-days N` (default 30), `--full`, `--json` |
 | `slm quantize` | Run smart compression cycle |
 | `slm consolidate --cognitive` | Extract patterns from memory clusters |
 | `slm soft-prompts` | View auto-learned patterns |

{superlocalmemory-3.4.49 → superlocalmemory-3.4.52}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "superlocalmemory"
-version = "3.4.49"
+version = "3.4.52"
 description = "Information-geometric agent memory with mathematical guarantees"
 readme = "README.md"
 license = {text = "AGPL-3.0-or-later"}

{superlocalmemory-3.4.49 → superlocalmemory-3.4.52}/src/superlocalmemory/__init__.py

@@ -3,7 +3,7 @@
 import os
 os.environ.setdefault("KMP_DUPLICATE_LIB_OK", "TRUE")
 
-__version__ = "3.4.46"
+__version__ = "3.4.52"
 
 _REQUIRED_VERSIONS = {
     "sentence_transformers": "5.3.0",

{superlocalmemory-3.4.49 → superlocalmemory-3.4.52}/src/superlocalmemory/cli/commands.py

@@ -2147,12 +2147,17 @@ def cmd_session_context(args: Namespace) -> None:
         except sqlite3.OperationalError:
             pass
 
-        # 2. Recent important memories (last 7 days, top 10 by importance)
+        # 2. Recent important memories — age gate from --max-age-days (default 30)
+        max_age = getattr(args, "max_age_days", 30)
+        age_clause = (
+            f"AND created_at >= datetime('now', '-{int(max_age)} days') "
+            if max_age > 0 else ""
+        )
         try:
             rows = conn.execute(
                 "SELECT content, fact_type, created_at FROM atomic_facts "
                 "WHERE profile_id = ? "
-                "AND created_at >= datetime('now', '-7 days') "
+                f"{age_clause}"
                 "AND lifecycle = 'active' "
                 "ORDER BY importance DESC, created_at DESC LIMIT 10",
                 (pid,),

{superlocalmemory-3.4.49 → superlocalmemory-3.4.52}/src/superlocalmemory/cli/main.py

@@ -289,6 +289,16 @@ def main() -> None:
 
     ctx_p = sub.add_parser("session-context", help="Print session context (for hooks)")
     ctx_p.add_argument("query", nargs="?", default="", help="Optional context query")
+    ctx_p.add_argument(
+        "--max-age-days", type=int, default=30,
+        help="Suppress memories older than N days unless score ≥ 0.7 (default: 30). "
+             "Set 0 to disable age filter.",
+    )
+    ctx_p.add_argument(
+        "--full", action="store_true",
+        help="Use full engine path (slower, requires Ollama). Default is fast SQLite path.",
+    )
+    ctx_p.add_argument("--json", action="store_true", help="Output structured JSON (agent-native)")
 
     obs_p = sub.add_parser("observe", help="Auto-capture content (pipe or argument)")
     obs_p.add_argument("content", nargs="?", default="", help="Content to evaluate")

superlocalmemory-3.4.52/src/superlocalmemory/core/backend_orchestrator.py

@@ -0,0 +1,365 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under AGPL-3.0-or-later - see LICENSE file
+# Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
+
+"""SuperLocalMemory v3.4.5 — Backend Orchestrator.
+
+Central coordinator for multi-backend architecture.
+Manages CozoDB, LanceDB, and TierManager lifecycle.
+Handles auto-migration, fallback, and incremental sync.
+
+This is the ONLY module that imports all three backends.
+Other modules call BackendOrchestrator methods.
+
+Part of Qualixar | Author: Varun Pratap Bhardwaj
+"""
+
+from __future__ import annotations
+
+import logging
+import sqlite3
+import threading
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from superlocalmemory.core.config import SLMConfig
+    from superlocalmemory.storage.database import DatabaseManager
+
+logger = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# Global singleton (set by daemon, read by store_pipeline)
+# ---------------------------------------------------------------------------
+
+_orchestrator: BackendOrchestrator | None = None
+
+
+def get_orchestrator() -> BackendOrchestrator | None:
+    """Return the global BackendOrchestrator singleton."""
+    return _orchestrator
+
+
+def set_orchestrator(orch: BackendOrchestrator) -> None:
+    """Set the global BackendOrchestrator singleton."""
+    global _orchestrator
+    _orchestrator = orch
+
+
+# ---------------------------------------------------------------------------
+# BackendOrchestrator
+# ---------------------------------------------------------------------------
+
+class BackendOrchestrator:
+    """Central coordinator for multi-backend architecture.
+
+    Lifecycle:
+      on_daemon_start() → migrate backends → ready
+      sync_new_fact() → called from store_pipeline after SQLite write
+      health_check() → returns status of all backends
+    """
+
+    def __init__(self, config: SLMConfig, db: DatabaseManager) -> None:
+        self._config = config
+        self._db = db
+        self._data_dir = Path(config.data_dir)
+        self._cozo: Any = None
+        self._lancedb: Any = None
+        self._tiers: Any = None
+        self._backend_cache: dict[str, str] = {}
+
+    # ------------------------------------------------------------------
+    # Daemon Startup
+    # ------------------------------------------------------------------
+
+    def on_daemon_start(self) -> None:
+        """Called once on daemon startup. Order matters (F-11: rebalance before migration)."""
+        logger.info("BackendOrchestrator: daemon starting")
+
+        # 1. Apply schema (if not already applied)
+        self._apply_schema_v345()
+
+        # 2. Initialize TierManager (always)
+        try:
+            from superlocalmemory.core.tier_manager import evaluate_tiers, set_backends
+            self._tiers = evaluate_tiers
+            set_backends(cozo=self._cozo, lancedb=self._lancedb)
+            logger.info("BackendOrchestrator: TierManager initialized")
+        except Exception as exc:
+            logger.warning("TierManager init failed (non-fatal): %s", exc)
+
+        # 3. Run initial tier rebalance FIRST (F-11: before migration)
+        try:
+            from superlocalmemory.core.tier_manager import evaluate_tiers as rebalance
+            result = rebalance(self._db)
+            logger.info("BackendOrchestrator: initial rebalance — %s",
+                         result.get("total_evaluated", "?"))
+        except Exception as exc:
+            logger.warning("Initial rebalance failed (non-fatal): %s", exc)
+
+        # 4. Initialize CozoDB if available
+        cozo_available = self._detect_cozo()
+        if cozo_available:
+            self._init_cozo()
+
+        # 5. Initialize LanceDB if available
+        lancedb_available = self._detect_lancedb()
+        if lancedb_available:
+            self._init_lancedb()
+
+        # 6. Auto-migrate
+        if self._cozo:
+            status = self._cozo_status()
+            if status in ("not_initialized", "migrating"):
+                if status == "migrating":
+                    logger.warning("CozoDB migration interrupted — rebuilding")
+                self._migrate_cozo()
+
+        if self._lancedb:
+            status = self._lancedb_status()
+            if status in ("not_initialized", "migrating"):
+                if status == "migrating":
+                    logger.warning("LanceDB migration interrupted — rebuilding")
+                self._migrate_lancedb()
+
+        logger.info("BackendOrchestrator: daemon ready (cozo=%s, lancedb=%s)",
+                     "active" if self._cozo and self._cozo_status() == "active" else "off",
+                     "active" if self._lancedb and self._lancedb_status() == "active" else "off")
+
+    # ------------------------------------------------------------------
+    # Incremental Sync (F-04: called from store_pipeline)
+    # ------------------------------------------------------------------
+
+    def sync_new_fact(self, fact: Any) -> None:
+        """Sync a newly stored fact to CozoDB and LanceDB.
+
+        Called AFTER SQLite write in store_pipeline.
+        Non-blocking, best-effort. Failures are logged, not raised.
+        """
+        try:
+            tier = getattr(fact, "lifecycle", "active")
+        except Exception:
+            tier = "active"
+
+        if tier in ("active", "warm"):
+            if self._cozo and self._cozo_status() == "active":
+                self._sync_fact_entities(fact)
+
+            if self._lancedb and self._lancedb_status() == "active":
+                self._sync_fact_embedding(fact)
+
+    def _sync_fact_entities(self, fact: Any) -> None:
+        """Sync fact's entities and edges to CozoDB."""
+        try:
+            entities = getattr(fact, "canonical_entities", []) or []
+            for eid in entities:
+                self._cozo.add_entity(eid, eid, "concept", {})
+                # Add edges from this entity to existing ones
+                for other in entities:
+                    if other != eid:
+                        self._cozo.add_edge(eid, other, "co_occurs", 1.0)
+        except Exception as exc:
+            logger.debug("CozoDB incremental sync skipped: %s", exc)
+
+    def _sync_fact_embedding(self, fact: Any) -> None:
+        """Sync fact's embedding to LanceDB."""
+        try:
+            embedding = getattr(fact, "embedding", None)
+            if embedding:
+                tier = getattr(fact, "lifecycle", "active")
+                self._lancedb.add_vectors(
+                    [fact.fact_id], [embedding], [tier],
+                )
+        except Exception as exc:
+            logger.debug("LanceDB incremental sync skipped: %s", exc)
+
+    # ------------------------------------------------------------------
+    # Backend Access
+    # ------------------------------------------------------------------
+
+    def get_graph_backend(self) -> Any:
+        """Return active graph backend or None (caller falls back to NetworkX)."""
+        if self._cozo and self._cozo_status() == "active":
+            return self._cozo
+        return None
+
+    def get_vector_backend(self) -> Any:
+        """Return active vector backend or None."""
+        if self._lancedb and self._lancedb_status() == "active":
+            return self._lancedb
+        return None
+
+    # ------------------------------------------------------------------
+    # Health Check
+    # ------------------------------------------------------------------
+
+    def health_check(self) -> dict[str, Any]:
+        """Comprehensive health status for dashboard + CLI."""
+        result: dict[str, Any] = {
+            "sqlite": {"status": "active"},
+            "cozo": {"status": "not_available"},
+            "lancedb": {"status": "not_available"},
+            "tiers": {},
+            "warnings": [],
+        }
+
+        try:
+            from superlocalmemory.core.tier_manager import get_tier_stats
+            result["tiers"] = get_tier_stats(self._db)
+        except Exception:
+            pass
+
+        if self._cozo:
+            try:
+                result["cozo"] = self._cozo.health_check()
+            except Exception as exc:
+                result["cozo"] = {"status": "error", "error": str(exc)}
+        else:
+            result["warnings"].append(
+                "CozoDB not active. Install: pip install superlocalmemory[cozo]"
+            )
+
+        if self._lancedb:
+            try:
+                result["lancedb"] = self._lancedb.health_check()
+            except Exception as exc:
+                result["lancedb"] = {"status": "error", "error": str(exc)}
+        else:
+            result["warnings"].append(
+                "LanceDB not active. Install: pip install superlocalmemory[lancedb]"
+            )
+
+        return result
+
+    # ------------------------------------------------------------------
+    # Internal: Detection
+    # ------------------------------------------------------------------
+
+    def _detect_cozo(self) -> bool:
+        if self._config.get("graph_backend") == "sqlite":
+            return False
+        try:
+            import pycozo  # noqa: F401
+            return True
+        except ImportError:
+            return False
+
+    def _detect_lancedb(self) -> bool:
+        if self._config.get("vector_backend") == "sqlite-vec":
+            return False
+        try:
+            import lancedb  # noqa: F401
+            return True
+        except ImportError:
+            return False
+
+    # ------------------------------------------------------------------
+    # Internal: Init
+    # ------------------------------------------------------------------
+
+    def _init_cozo(self) -> None:
+        try:
+            from superlocalmemory.graph.cozo_backend import CozoDBGraphBackend
+            cozo_path = self._data_dir / "cozo"
+            cozo_path.mkdir(parents=True, exist_ok=True)
+            self._cozo = CozoDBGraphBackend(str(cozo_path / "graph"))
+            self._update_status("cozo", "not_initialized")
+            logger.info("CozoDB initialized at %s", cozo_path)
+        except Exception as exc:
+            logger.warning("CozoDB init failed: %s", exc)
+            self._cozo = None
+
+    def _init_lancedb(self) -> None:
+        try:
+            from superlocalmemory.vector.lancedb_backend import LanceDBVectorBackend
+            lance_path = self._data_dir / "lance"
+            self._lancedb = LanceDBVectorBackend(str(lance_path))
+            self._update_status("lancedb", "not_initialized")
+            logger.info("LanceDB initialized at %s", lance_path)
+        except Exception as exc:
+            logger.warning("LanceDB init failed: %s", exc)
+            self._lancedb = None
+
+    # ------------------------------------------------------------------
+    # Internal: Migration
+    # ------------------------------------------------------------------
+
+    def _migrate_cozo(self) -> None:
+        self._update_status("cozo", "migrating")
+
+        def _run():
+            conn = sqlite3.connect(str(self._data_dir / "memory.db"))
+            conn.execute("PRAGMA journal_mode=WAL")
+            conn.execute("PRAGMA query_only=ON")  # F-07: read-only in migration thread
+            try:
+                count = self._cozo.bulk_import_from_sqlite(conn)
+                self._update_status("cozo", "active", count)
+                logger.info("CozoDB migration complete: %d edges", count)
+            except Exception as exc:
+                logger.error("CozoDB migration failed: %s", exc)
+                self._update_status("cozo", "failed", error=str(exc))
+            finally:
+                conn.close()
+
+        threading.Thread(target=_run, daemon=True).start()
+
+    def _migrate_lancedb(self) -> None:
+        self._update_status("lancedb", "migrating")
+
+        def _run():
+            conn = sqlite3.connect(str(self._data_dir / "memory.db"))
+            conn.execute("PRAGMA journal_mode=WAL")
+            conn.execute("PRAGMA query_only=ON")
+            try:
+                count = self._lancedb.bulk_import_from_sqlite(conn)
+                self._update_status("lancedb", "active", count)
+                logger.info("LanceDB migration complete: %d vectors", count)
+            except Exception as exc:
+                logger.error("LanceDB migration failed: %s", exc)
+                self._update_status("lancedb", "failed", error=str(exc))
+            finally:
+                conn.close()
+
+        threading.Thread(target=_run, daemon=True).start()
+
+    # ------------------------------------------------------------------
+    # Internal: Status
+    # ------------------------------------------------------------------
+
+    def _cozo_status(self) -> str:
+        return self._backend_cache.get("cozo", "not_initialized")
+
+    def _lancedb_status(self) -> str:
+        return self._backend_cache.get("lancedb", "not_initialized")
+
+    def _update_status(self, name: str, status: str,
+                        count: int = 0, error: str = "") -> None:
+        self._backend_cache[name] = status
+        try:
+            self._db.conn.execute(
+                "INSERT OR REPLACE INTO backend_status "
+                "(backend_name, status, record_count, error_message, last_sync_at) "
+                "VALUES (?, ?, ?, ?, datetime('now'))",
+                (name, status, count, error),
+            )
+            self._db.conn.commit()
+        except Exception:
+            pass
+
+    # ------------------------------------------------------------------
+    # Internal: Schema
+    # ------------------------------------------------------------------
+
+    def _apply_schema_v345(self) -> None:
+        try:
+            from superlocalmemory.storage.schema_v345 import (
+                apply_migration, schema_version_applied,
+            )
+            if not schema_version_applied(self._db.conn):
+                result = apply_migration(self._db.conn)
+                if result.get("errors"):
+                    logger.warning("Schema v3.4.5 had errors: %s", result["errors"])
+        except ImportError:
+            logger.debug("schema_v345 not found — skipping")
+        except Exception as exc:
+            logger.warning("Schema v3.4.5 apply failed (non-fatal): %s", exc)

{superlocalmemory-3.4.49 → superlocalmemory-3.4.52}/src/superlocalmemory/core/ollama_embedder.py

@@ -204,12 +204,18 @@ class OllamaEmbedder:
             return False
 
     def _call_ollama_embed(self, text: str) -> list[float]:
-        """Call Ollama embed endpoint for a single text."""
+        """Call Ollama embed endpoint for a single text.
+
+        v3.4.52: ``keep_alive: -1`` pins the embedding model in VRAM
+        forever so subsequent calls have no cold-start latency. Industry
+        pattern (Hindsight, Zep, Supermemory) — without this, Ollama
+        unloads after 5min idle and the next call takes 20-30s.
+        """
         import httpx
 
         resp = httpx.post(
             f"{self._base_url}/api/embed",
-            json={"model": self._model, "input": [text]},
+            json={"model": self._model, "input": [text], "keep_alive": -1},
             timeout=httpx.Timeout(_RESPONSE_TIMEOUT, connect=_CONNECT_TIMEOUT),
         )
         resp.raise_for_status()
@@ -219,12 +225,16 @@ class OllamaEmbedder:
         return self._normalize(vec)
 
     def _call_ollama_embed_batch(self, texts: list[str]) -> list[list[float] | None]:
-        """Call Ollama embed endpoint with batch input."""
+        """Call Ollama embed endpoint with batch input.
+
+        v3.4.52: ``keep_alive: -1`` pins the embedding model — see
+        ``_call_ollama_embed`` docstring for rationale.
+        """
         import httpx
 
         resp = httpx.post(
             f"{self._base_url}/api/embed",
-            json={"model": self._model, "input": texts},
+            json={"model": self._model, "input": texts, "keep_alive": -1},
             timeout=httpx.Timeout(_RESPONSE_TIMEOUT, connect=_CONNECT_TIMEOUT),
         )
         resp.raise_for_status()