get-claudia 1.55.7 → 1.55.8

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 All notable changes to Claudia will be documented in this file.
 
+## 1.55.8 (2026-03-15)
+
+### The Vector Search Fix
+
+v1.55.7 fixed FTS5 recall but broke vector/semantic search for every user. Three raw `sqlite3.connect()` calls skipped loading the `sqlite_vec` extension, and three KNN queries lacked the required `k = ?` constraint for JOINs. Net effect: 0% embedding coverage and silent fallback to keyword matching.
+
+- **`load_sqlite_vec()` helper** -- Extracted the vec0 extension loading logic from `Database._get_connection()` into a standalone public function. Any raw connection that touches vec0 tables calls this one function. Eliminates the entire class of "forgot to load extension" bugs.
+- **Backfill worker fix** -- `_backfill_worker()` now loads sqlite_vec on its raw connection. Previously it crashed within 60ms of starting because it couldn't query or write to vec0 tables. Degrades gracefully if the extension isn't available.
+- **Index repair fix** -- `_check_and_repair_indexes()` now loads sqlite_vec on its raw connection. Previously it always reported 0 embeddings (triggering unnecessary backfill every startup). Improved exception handling distinguishes "no such table" from "no such module."
+- **KNN `k = ?` constraint** -- Added `AND k = ?` to all three `embedding MATCH` queries in recall.py (`recall()`, `recall_episodes()`, `search_reflections()`). vec0's KNN queries require this constraint when JOINs are present because SQLite's query planner can't push an outer `LIMIT` into the virtual table scan.
+- **Smarter briefing message** -- Embedding health check now reads `_meta['indexes_repaired']` to distinguish "backfill in progress" from "backfill never started." No longer tells users to "Start Ollama" when the real problem was a code bug.
+- **9 new tests** -- Helper extraction, Database integration, backfill/repair patterns, KNN constraint behavior (both success and documented failure without `k`). All 615 tests pass.
+
 ## 1.55.7 (2026-03-15)
 
 ### The Recall Recovery Release

package/memory-daemon/claudia_memory/__main__.py

@@ -20,7 +20,7 @@ from pathlib import Path
 from .config import get_config, set_project_id
 from .daemon.health import start_health_server, stop_health_server
 from .daemon.scheduler import start_scheduler, stop_scheduler
-from .database import get_db
+from .database import get_db, load_sqlite_vec
 from .mcp.server import run_server as run_mcp_server
 
 logger = logging.getLogger(__name__)
@@ -401,6 +401,7 @@ def _check_and_repair_indexes(db_path: Path) -> None:
     try:
         conn = sqlite3.connect(str(db_path), timeout=10)
         conn.row_factory = sqlite3.Row
+        load_sqlite_vec(conn)
 
         # Count memories
         mem_row = conn.execute("SELECT COUNT(*) as c FROM memories WHERE invalidated_at IS NULL").fetchone()
@@ -423,8 +424,13 @@ def _check_and_repair_indexes(db_path: Path) -> None:
         try:
             emb_row = conn.execute("SELECT COUNT(*) as c FROM memory_embeddings").fetchone()
             emb_count = emb_row["c"] if emb_row else 0
-        except Exception:
-            pass  # Vec0 table might not exist
+        except sqlite3.OperationalError as e:
+            if "no such table" in str(e):
+                pass  # Fresh install, vec0 tables not yet created
+            elif "no such module" in str(e):
+                logger.debug("sqlite_vec not loaded, cannot count embeddings")
+            else:
+                logger.warning(f"Unexpected error counting embeddings: {e}")
 
         conn.close()
 
@@ -504,6 +510,13 @@ def _auto_backfill_embeddings(db_path: Path, mem_count: int, emb_count: int) ->
 
             conn = sqlite3.connect(str(db_path), timeout=30)
             conn.row_factory = sqlite3.Row
+            if not load_sqlite_vec(conn):
+                logger.warning(
+                    "sqlite_vec not available in backfill thread. "
+                    "Cannot write to vec0 tables. Skipping embedding backfill."
+                )
+                conn.close()
+                return
 
             # Find memories missing embeddings
             missing = conn.execute(

package/memory-daemon/claudia_memory/database.py

@@ -25,6 +25,73 @@ from .config import get_config
 logger = logging.getLogger(__name__)
 
 
+def load_sqlite_vec(conn: sqlite3.Connection) -> bool:
+    """Load the sqlite-vec extension on a connection.
+
+    Tries two methods:
+    1. sqlite_vec Python package (recommended, works everywhere including Python 3.13+)
+    2. Native extension loading (for systems with pre-installed sqlite-vec)
+
+    Returns True if vec0 is available, False otherwise. Never raises.
+    """
+    # Method 1: Try sqlite_vec Python package
+    try:
+        import sqlite_vec
+        if hasattr(conn, "enable_load_extension"):
+            conn.enable_load_extension(True)
+        sqlite_vec.load(conn)
+        if hasattr(conn, "enable_load_extension"):
+            conn.enable_load_extension(False)
+        logger.debug("Loaded sqlite-vec via Python package")
+        return True
+    except ImportError:
+        logger.debug("sqlite_vec package not installed")
+    except Exception as e:
+        logger.warning(f"sqlite_vec package installed but load() failed: {e}")
+
+    # Method 2: Try native extension loading
+    try:
+        conn.enable_load_extension(True)
+        sqlite_vec_paths = ["vec0"]  # System-wide
+
+        if sys.platform == "win32":
+            try:
+                import sqlite_vec as _sv
+                pkg_dir = Path(_sv.__file__).parent
+                for dll in pkg_dir.rglob("vec0*"):
+                    if dll.suffix in (".dll", ".so"):
+                        sqlite_vec_paths.append(str(dll.with_suffix("")))
+            except ImportError:
+                pass
+            sqlite_vec_paths.extend([
+                str(Path(sys.executable).parent / "DLLs" / "vec0"),
+                str(Path.home() / ".local" / "lib" / "sqlite-vec" / "vec0"),
+            ])
+        else:
+            sqlite_vec_paths.extend([
+                "/usr/local/lib/sqlite-vec/vec0",
+                "/opt/homebrew/lib/sqlite-vec/vec0",
+                str(Path.home() / ".local" / "lib" / "sqlite-vec" / "vec0"),
+            ])
+
+        for path in sqlite_vec_paths:
+            try:
+                conn.load_extension(path)
+                logger.debug(f"Loaded sqlite-vec from {path}")
+                conn.enable_load_extension(False)
+                return True
+            except sqlite3.OperationalError:
+                continue
+
+        conn.enable_load_extension(False)
+    except AttributeError:
+        logger.debug("enable_load_extension not available (Python 3.13+)")
+    except Exception as e:
+        logger.debug(f"Extension loading failed: {e}")
+
+    return False
+
+
 class Database:
     """Thread-safe SQLite database with sqlite-vec support"""
 
@@ -51,72 +118,8 @@ class Database:
             # Recover any uncommitted WAL writes from a previous crashed daemon
             conn.execute("PRAGMA wal_checkpoint(TRUNCATE)")
 
-            # Try to load sqlite-vec for vector search
-            # Priority: sqlite_vec Python package first (works on Python 3.13+),
-            # then fall back to native extension loading
-            loaded = False
-
-            # Method 1: Try sqlite_vec Python package (recommended, works everywhere)
-            # Python 3.14+ requires explicit enable_load_extension() before any
-            # extension loading, even via the sqlite_vec helper package.
-            try:
-                import sqlite_vec
-                if hasattr(conn, "enable_load_extension"):
-                    conn.enable_load_extension(True)
-                sqlite_vec.load(conn)
-                if hasattr(conn, "enable_load_extension"):
-                    conn.enable_load_extension(False)
-                loaded = True
-                logger.debug("Loaded sqlite-vec via Python package")
-            except ImportError:
-                logger.debug("sqlite_vec package not installed")
-            except Exception as e:
-                logger.warning(f"sqlite_vec package installed but load() failed: {e}")
-
-            # Method 2: Try native extension loading (for systems with pre-installed sqlite-vec)
-            if not loaded:
-                try:
-                    conn.enable_load_extension(True)
-                    sqlite_vec_paths = ["vec0"]  # System-wide
-
-                    if sys.platform == "win32":
-                        # Try to find vec0.dll in the sqlite-vec package directory
-                        try:
-                            import sqlite_vec as _sv
-                            pkg_dir = Path(_sv.__file__).parent
-                            for dll in pkg_dir.rglob("vec0*"):
-                                if dll.suffix in (".dll", ".so"):
-                                    sqlite_vec_paths.append(str(dll.with_suffix("")))
-                        except ImportError:
-                            pass
-                        sqlite_vec_paths.extend([
-                            str(Path(sys.executable).parent / "DLLs" / "vec0"),
-                            str(Path.home() / ".local" / "lib" / "sqlite-vec" / "vec0"),
-                        ])
-                    else:
-                        sqlite_vec_paths.extend([
-                            "/usr/local/lib/sqlite-vec/vec0",
-                            "/opt/homebrew/lib/sqlite-vec/vec0",
-                            str(Path.home() / ".local" / "lib" / "sqlite-vec" / "vec0"),
-                        ])
-
-                    for path in sqlite_vec_paths:
-                        try:
-                            conn.load_extension(path)
-                            loaded = True
-                            logger.debug(f"Loaded sqlite-vec from {path}")
-                            break
-                        except sqlite3.OperationalError:
-                            continue
-
-                    conn.enable_load_extension(False)
-                except AttributeError:
-                    # Python 3.13+ may not have enable_load_extension
-                    logger.debug("enable_load_extension not available (Python 3.13+)")
-                except Exception as e:
-                    logger.debug(f"Extension loading failed: {e}")
-
-            if not loaded:
+            # Load sqlite-vec for vector search
+            if not load_sqlite_vec(conn):
                 if sys.platform == "win32":
                     logger.warning(
                         "sqlite-vec not available. Vector search will be disabled. "

package/memory-daemon/claudia_memory/mcp/server.py

@@ -3346,10 +3346,25 @@ def _build_briefing() -> str:
             coverage = (emb_c / mem_c) * 100
             if coverage < 90:
                 gap = mem_c - emb_c
+                # Check _meta for backfill status to give accurate guidance
+                status_hint = "Start Ollama and restart daemon to generate embeddings."
+                try:
+                    repair_row = db.execute(
+                        "SELECT value FROM _meta WHERE key = 'indexes_repaired'",
+                        fetch=True,
+                    )
+                    if repair_row and repair_row[0]["value"]:
+                        repair_info = repair_row[0]["value"]
+                        if "backfill started" in repair_info:
+                            status_hint = "Backfill was started on this run. Check daemon logs for progress."
+                        elif coverage > 0:
+                            status_hint = "Partial embeddings exist. Restart daemon to trigger backfill for the rest."
+                except Exception:
+                    pass
                 lines.append(
                     f"**Embedding coverage:** {emb_c}/{mem_c} ({coverage:.0f}%). "
                     f"{gap} memories lack vector embeddings. "
-                    f"{'Backfill is running in background.' if coverage > 0 else 'Start Ollama and restart daemon to generate embeddings.'} "
+                    f"{status_hint} "
                     f"Recall uses keyword fallback for unembedded memories."
                 )
     except Exception as e:

package/memory-daemon/claudia_memory/services/recall.py

@@ -145,9 +145,11 @@ class RecallService:
                 LEFT JOIN memory_entities me2 ON m.id = me2.memory_id
                 LEFT JOIN entities e ON me2.entity_id = e.id
                 WHERE me.embedding MATCH ?
+                AND k = ?
                 """
             )
             params.append(json.dumps(query_embedding))
+            params.append(limit * 2)
 
             self._apply_filters(sql_parts, params, memory_types, min_importance, date_after, date_before, about_entity, include_archived)
             sql_parts.append("GROUP BY m.id ORDER BY vector_score DESC LIMIT ?")
@@ -1368,11 +1370,12 @@ class RecallService:
                     FROM episode_embeddings ee
                     JOIN episodes e ON e.id = ee.episode_id
                     WHERE ee.embedding MATCH ?
+                    AND k = ?
                     AND e.is_summarized = 1
                     ORDER BY relevance DESC
                     LIMIT ?
                     """,
-                    (json.dumps(query_embedding), limit),
+                    (json.dumps(query_embedding), limit, limit),
                     fetch=True,
                 ) or []
             except Exception as e:
@@ -2286,8 +2289,9 @@ class RecallService:
                     JOIN reflections r ON r.id = re.reflection_id
                     LEFT JOIN entities e ON r.about_entity_id = e.id
                     WHERE re.embedding MATCH ?
+                    AND k = ?
                 """
-                params: list = [json.dumps(query_embedding)]
+                params: list = [json.dumps(query_embedding), limit]
 
                 if reflection_types:
                     placeholders = ", ".join(["?" for _ in reflection_types])

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "get-claudia",
-  "version": "1.55.7",
+  "version": "1.55.8",
   "description": "An AI assistant who learns how you work.",
   "keywords": [
     "claudia",