ltcai 11.5.2 → 11.7.0

package/lattice_brain/graph/store.py

@@ -1,268 +0,0 @@
-from __future__ import annotations
-
-# ruff: noqa: F403,F405
-from ._kg_common import *  # noqa: F403,F401
-from .discovery import KnowledgeGraphDiscoveryMixin
-from .discovery_index import KnowledgeGraphLocalIndexMixin
-from .documents import KnowledgeGraphDocumentsMixin
-from .ingest import KnowledgeGraphIngestMixin
-from .projection import KnowledgeGraphProjectionMixin
-from .provenance import KnowledgeGraphProvenanceMixin
-from .retrieval import KnowledgeGraphRetrievalMixin
-from .retrieval_docgen import KnowledgeGraphDocGenMixin
-from .retrieval_reads import KnowledgeGraphReadsMixin
-from .retrieval_vector import KnowledgeGraphVectorMixin
-from .write_master import KnowledgeGraphWriteMixin
-
-
-class KnowledgeGraphStore(
-    KnowledgeGraphProjectionMixin,
-    KnowledgeGraphWriteMixin,
-    KnowledgeGraphDiscoveryMixin,
-    KnowledgeGraphLocalIndexMixin,
-    KnowledgeGraphIngestMixin,
-    KnowledgeGraphProvenanceMixin,
-    KnowledgeGraphDocumentsMixin,
-    KnowledgeGraphRetrievalMixin,
-    KnowledgeGraphReadsMixin,
-    KnowledgeGraphVectorMixin,
-    KnowledgeGraphDocGenMixin,
-):
-    def __init__(
-        self,
-        db_path: Path,
-        blob_dir: Path,
-        embedder: Any = None,
-        storage_engine: Any = None,
-    ):
-        self.db_path = Path(db_path)
-        self.blob_dir = Path(blob_dir)
-        self.db_path.parent.mkdir(parents=True, exist_ok=True)
-        self.blob_dir.mkdir(parents=True, exist_ok=True)
-        if storage_engine is None:
-            from ..storage import SQLiteEngine
-
-            storage_engine = SQLiteEngine(self.db_path)
-        storage_caps = storage_engine.capabilities()
-        if not storage_caps.available:
-            raise RuntimeError(storage_caps.reason or "Brain storage is unavailable.")
-        if storage_caps.engine != "sqlite":
-            raise RuntimeError(
-                "KnowledgeGraphStore currently requires SQLiteEngine. "
-                "Explicit non-SQLite storage must use the migration/scale tooling; "
-                "no SQLite fallback is attempted."
-            )
-        self.storage_engine = storage_engine
-        # The embedder is swappable behind a fixed interface
-        # (model_id/dim/embed/encode/decode/similarity). Defaults to the
-        # deterministic, offline hash model so the store works with no config;
-        # server_app injects a provider-backed embedder from Config.
-        self._embedding_model = (
-            embedder if embedder is not None else LocalEmbeddingModel()
-        )
-        self._v2_projection_available = False
-        self._init_db()
-        # Read graph queries from the v2 projection (kgv2_* views) when available.
-        # Toggle off (e.g. in tests) to compare against the legacy tables.
-        self._read_from_v2 = (
-            KGStoreV2 is not None
-            and _READ_FROM_V2_DEFAULT
-            and self._v2_projection_available
-        )
-
-    def _read_tables(self) -> tuple:
-        """Return (nodes_table, edges_table) for read queries.
-
-        Same read code runs against the legacy tables or the v2 reconstruction
-        views, so the two paths are equivalent by construction.
-        """
-        if self._read_from_v2:
-            return ("kgv2_nodes", "kgv2_edges")
-        return ("nodes", "edges")
-
-    @contextmanager
-    def _connect(self) -> Iterator[sqlite3.Connection]:
-        """Transactional connection that is closed when the block exits.
-
-        This used to return the raw connection, so ``with self._connect() as
-        conn`` inherited sqlite3's context-manager semantics: commit on success,
-        rollback on error, **never close**. Each of the ~58 call sites therefore
-        held a descriptor open until garbage collection reclaimed it. That is
-        invisible while CPython refcounting frees the local immediately, and
-        fatal as soon as anything keeps the frame alive — a coverage tracer, a
-        profiler, or a traceback captured by ``logger.exception``.
-
-        Use ``storage_engine.connect()`` directly only for statements that
-        cannot run inside a transaction, and close it yourself.
-        """
-        with self.storage_engine.session() as conn:
-            yield conn
-
-    def _init_db(self) -> None:
-        with self._connect() as conn:
-            db_format = int(conn.execute("PRAGMA user_version").fetchone()[0] or 0)
-            if db_format > _KG_DB_FORMAT_VERSION:
-                raise RuntimeError(
-                    f"Knowledge Graph DB format {db_format} is newer than this build "
-                    f"({_KG_DB_FORMAT_VERSION}); restore a pre-upgrade backup or upgrade Lattice AI."
-                )
-            conn.executescript(
-                """
-                    CREATE TABLE IF NOT EXISTS graph_meta (
-                      key TEXT PRIMARY KEY,
-                      value TEXT NOT NULL
-                    );
-                    CREATE TABLE IF NOT EXISTS nodes (
-                      id TEXT PRIMARY KEY,
-                      type TEXT NOT NULL,
-                      title TEXT NOT NULL,
-                      summary TEXT,
-                      metadata_json TEXT NOT NULL CHECK (json_valid(metadata_json)),
-                      raw_json TEXT NOT NULL CHECK (json_valid(raw_json)),
-                      created_at TEXT NOT NULL,
-                      updated_at TEXT NOT NULL
-                    );
-                    CREATE TABLE IF NOT EXISTS edges (
-                      id TEXT PRIMARY KEY,
-                      from_node TEXT NOT NULL,
-                      to_node TEXT NOT NULL,
-                      type TEXT NOT NULL,
-                      weight REAL NOT NULL DEFAULT 1.0,
-                      metadata_json TEXT NOT NULL CHECK (json_valid(metadata_json)),
-                      created_at TEXT NOT NULL,
-                      UNIQUE(from_node, to_node, type),
-                      FOREIGN KEY(from_node) REFERENCES nodes(id) ON DELETE CASCADE,
-                      FOREIGN KEY(to_node) REFERENCES nodes(id) ON DELETE CASCADE
-                    );
-                    CREATE TABLE IF NOT EXISTS chunks (
-                      id TEXT PRIMARY KEY,
-                      source_node TEXT NOT NULL,
-                      text TEXT NOT NULL,
-                      metadata_json TEXT NOT NULL CHECK (json_valid(metadata_json)),
-                      created_at TEXT NOT NULL,
-                      FOREIGN KEY(source_node) REFERENCES nodes(id) ON DELETE CASCADE
-                    );
-                    CREATE TABLE IF NOT EXISTS knowledge_sources (
-                      id TEXT PRIMARY KEY,
-                      root_path TEXT NOT NULL UNIQUE,
-                      os_type TEXT NOT NULL,
-                      drive_id TEXT,
-                      label TEXT,
-                      status TEXT NOT NULL,
-                      include_ocr INTEGER NOT NULL DEFAULT 0,
-                      watch_enabled INTEGER NOT NULL DEFAULT 0,
-                      consent_json TEXT NOT NULL CHECK (json_valid(consent_json)),
-                      created_at TEXT NOT NULL,
-                      updated_at TEXT NOT NULL,
-                      last_scanned_at TEXT
-                    );
-                    CREATE TABLE IF NOT EXISTS local_file_index (
-                      id TEXT PRIMARY KEY,
-                      source_id TEXT NOT NULL,
-                      os_type TEXT NOT NULL,
-                      drive_id TEXT,
-                      root_path TEXT NOT NULL,
-                      file_path TEXT NOT NULL,
-                      relative_path TEXT NOT NULL,
-                      file_name TEXT NOT NULL,
-                      extension TEXT NOT NULL,
-                      size_bytes INTEGER,
-                      modified_at TEXT,
-                      sha256 TEXT,
-                      last_scanned_at TEXT,
-                      last_indexed_at TEXT,
-                      parser_type TEXT,
-                      status TEXT NOT NULL,
-                      error_message TEXT,
-                      graph_node_id TEXT,
-                      deleted INTEGER NOT NULL DEFAULT 0,
-                      metadata_json TEXT NOT NULL CHECK (json_valid(metadata_json)),
-                      UNIQUE(source_id, relative_path),
-                      FOREIGN KEY(source_id) REFERENCES knowledge_sources(id) ON DELETE CASCADE
-                    );
-                    CREATE TABLE IF NOT EXISTS vector_embeddings (
-                      item_id TEXT PRIMARY KEY,
-                      item_type TEXT NOT NULL,
-                      source_node TEXT NOT NULL,
-                      text_hash TEXT NOT NULL,
-                      embedding BLOB NOT NULL,
-                      embedding_dim INTEGER NOT NULL,
-                      embedding_model TEXT NOT NULL,
-                      metadata_json TEXT NOT NULL CHECK (json_valid(metadata_json)),
-                      indexed_at TEXT NOT NULL,
-                      FOREIGN KEY(source_node) REFERENCES nodes(id) ON DELETE CASCADE
-                    );
-                    CREATE TABLE IF NOT EXISTS vector_index_operations (
-                      id TEXT PRIMARY KEY,
-                      operation TEXT NOT NULL,
-                      status TEXT NOT NULL,
-                      requested_at TEXT NOT NULL,
-                      started_at TEXT,
-                      completed_at TEXT,
-                      items_total INTEGER NOT NULL DEFAULT 0,
-                      items_indexed INTEGER NOT NULL DEFAULT 0,
-                      items_skipped INTEGER NOT NULL DEFAULT 0,
-                      error_message TEXT,
-                      metadata_json TEXT NOT NULL CHECK (json_valid(metadata_json))
-                    );
-                    -- v3.6.0 Knowledge Graph First: per-ingestion provenance trail.
-                    -- Append-only audit of where every graph node came from, when it
-                    -- was captured, how it was processed, and whether it was embedded /
-                    -- linked / used by an agent. get_provenance() returns the latest row.
-                    CREATE TABLE IF NOT EXISTS ingestion_provenance (
-                      id TEXT PRIMARY KEY,
-                      node_id TEXT NOT NULL,
-                      source_type TEXT NOT NULL,
-                      source_uri TEXT,
-                      content_hash TEXT,
-                      title TEXT,
-                      pipeline TEXT NOT NULL,
-                      owner TEXT,
-                      workspace_id TEXT,
-                      captured_at TEXT,
-                      modified_at TEXT,
-                      embedded INTEGER NOT NULL DEFAULT 0,
-                      linked INTEGER NOT NULL DEFAULT 0,
-                      duplicate INTEGER NOT NULL DEFAULT 0,
-                      agent_used TEXT,
-                      chunk_count INTEGER NOT NULL DEFAULT 0,
-                      permissions_json TEXT NOT NULL DEFAULT '{}' CHECK (json_valid(permissions_json)),
-                      metadata_json TEXT NOT NULL DEFAULT '{}' CHECK (json_valid(metadata_json)),
-                      created_at TEXT NOT NULL
-                    );
-                    CREATE INDEX IF NOT EXISTS idx_nodes_type ON nodes(type);
-                    CREATE INDEX IF NOT EXISTS idx_edges_from ON edges(from_node);
-                    CREATE INDEX IF NOT EXISTS idx_edges_to ON edges(to_node);
-                    CREATE INDEX IF NOT EXISTS idx_chunks_source ON chunks(source_node);
-                    CREATE INDEX IF NOT EXISTS idx_knowledge_sources_root ON knowledge_sources(root_path);
-                    CREATE INDEX IF NOT EXISTS idx_local_file_index_source ON local_file_index(source_id);
-                    CREATE INDEX IF NOT EXISTS idx_local_file_index_status ON local_file_index(status);
-                    CREATE INDEX IF NOT EXISTS idx_local_file_index_graph_node ON local_file_index(graph_node_id);
-                    CREATE INDEX IF NOT EXISTS idx_vector_embeddings_type ON vector_embeddings(item_type);
-                    CREATE INDEX IF NOT EXISTS idx_vector_embeddings_source ON vector_embeddings(source_node);
-                    CREATE INDEX IF NOT EXISTS idx_vector_embeddings_model ON vector_embeddings(embedding_model);
-                    -- v11.2.0: the ANN sidecar's freshness fingerprint is
-                    -- COUNT(*) + MAX(indexed_at) filtered by (embedding_model,
-                    -- embedding_dim), and it runs on *every* approximate
-                    -- search. Against the single-column model index that was a
-                    -- table scan of every row for the current model; this
-                    -- covering index answers both aggregates from the index
-                    -- alone. Additive and idempotent — no data is rewritten.
-                    CREATE INDEX IF NOT EXISTS idx_vector_embeddings_model_dim_indexed
-                      ON vector_embeddings(embedding_model, embedding_dim, indexed_at);
-                    CREATE INDEX IF NOT EXISTS idx_vector_index_operations_requested ON vector_index_operations(requested_at);
-                    CREATE INDEX IF NOT EXISTS idx_provenance_node ON ingestion_provenance(node_id);
-                    CREATE INDEX IF NOT EXISTS idx_provenance_source_type ON ingestion_provenance(source_type);
-                    CREATE INDEX IF NOT EXISTS idx_provenance_hash ON ingestion_provenance(content_hash);
-                    CREATE INDEX IF NOT EXISTS idx_provenance_created ON ingestion_provenance(created_at);
-                    """
-            )
-            conn.execute(
-                "INSERT OR REPLACE INTO graph_meta(key, value) VALUES (?, ?)",
-                ("schema_version", str(GRAPH_SCHEMA_VERSION)),
-            )
-        self._init_v2_schema()
-        self._init_fts()
-
-
-__all__ = ["KnowledgeGraphStore"]

package/lattice_brain/graph/vector_index/__init__.py

@@ -1,85 +0,0 @@
-"""Pluggable vector-index backends + the durable pending-embed queue.
-
-Public surface (v11.1.0, Track 1):
-
-* :class:`VectorIndex` — the Protocol every backend satisfies.
-* :class:`BruteForceIndex` — exact, exhaustive, the default.
-* :class:`QuantizedIndex` — int8 storage, exhaustive, approximate scores.
-* :class:`HnswIndex` — approximate nearest neighbour, optional ``hnswlib``.
-* :func:`resolve_vector_index` / :func:`build_index` — ``LATTICEAI_VECTOR_INDEX``
-  resolution with an honest fallback reason.
-* :class:`VectorEmbedQueue` — SQLite-backed background embedding backlog.
-"""
-
-from __future__ import annotations
-
-from .base import (
-    IndexItem,
-    IndexStats,
-    ScoredId,
-    Similarity,
-    VectorIndex,
-    dot_similarity,
-    score_floor,
-    take_top,
-)
-from .brute_force import BRUTE_FORCE_BACKEND, BruteForceIndex
-from .hnsw import (
-    HNSW_BACKEND,
-    HNSW_META_SUFFIX,
-    HNSW_SUFFIX,
-    HnswIndex,
-    hnswlib_available,
-    load_hnswlib,
-    sidecar_paths,
-)
-from .jobs import (
-    DEFAULT_MAX_ATTEMPTS,
-    DEFAULT_TICK_LIMIT,
-    VECTOR_JOB_STATUSES,
-    VectorEmbedQueue,
-    VectorJobStore,
-)
-from .quantized import QUANTIZED_BACKEND, QuantizedIndex, quantize
-from .selector import (
-    DEFAULT_VECTOR_INDEX,
-    VECTOR_INDEX_CHOICES,
-    VECTOR_INDEX_ENV,
-    BackendSelection,
-    build_index,
-    resolve_vector_index,
-)
-
-__all__ = [
-    "BRUTE_FORCE_BACKEND",
-    "DEFAULT_MAX_ATTEMPTS",
-    "DEFAULT_TICK_LIMIT",
-    "DEFAULT_VECTOR_INDEX",
-    "HNSW_BACKEND",
-    "HNSW_META_SUFFIX",
-    "HNSW_SUFFIX",
-    "QUANTIZED_BACKEND",
-    "VECTOR_INDEX_CHOICES",
-    "VECTOR_INDEX_ENV",
-    "VECTOR_JOB_STATUSES",
-    "BackendSelection",
-    "BruteForceIndex",
-    "HnswIndex",
-    "IndexItem",
-    "IndexStats",
-    "QuantizedIndex",
-    "ScoredId",
-    "Similarity",
-    "VectorEmbedQueue",
-    "VectorIndex",
-    "VectorJobStore",
-    "build_index",
-    "dot_similarity",
-    "hnswlib_available",
-    "load_hnswlib",
-    "quantize",
-    "resolve_vector_index",
-    "score_floor",
-    "sidecar_paths",
-    "take_top",
-]

package/lattice_brain/graph/vector_index/base.py

@@ -1,167 +0,0 @@
-"""The vector-index contract: what it means to score embeddings (v11.1.0).
-
-Before this package the only vector "index" was the scan loop inside
-``retrieval_vector.vector_search``: fetch every embedding row, decode it,
-score it, sort. That is a perfectly good *exact* index and it stays the
-default — but it was welded to SQL row handling, so there was nowhere to put
-a second strategy without forking the search.
-
-This module defines the seam. A backend owns exactly one question — *given a
-query vector, which stored ids score highest* — and nothing about SQLite,
-chunk metadata, workspaces, or citations. The vectors are ``Sequence[float]``
-(the repo's embedders return ``list[float]``; numpy is not a dependency).
-
-Honesty contract: every backend reports whether it is ``approx`` (scores are
-estimates) and whether it is ``exhaustive`` (every stored vector was
-compared). Those two bits travel with the search result so a caller never has
-to guess whether "no match" means "not in your brain" or "the index did not
-look".
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import (
-    Any,
-    Callable,
-    Dict,
-    Iterable,
-    List,
-    Mapping,
-    Optional,
-    Protocol,
-    Sequence,
-    Tuple,
-)
-
-#: ``(item_id, score)`` — the one shape every backend returns.
-ScoredId = Tuple[str, float]
-#: ``(item_id, vector, metadata)`` — one item as handed to :meth:`rebuild`.
-IndexItem = Tuple[str, Sequence[float], Mapping[str, Any]]
-#: Pluggable similarity so a backend can borrow the embedder's own function.
-Similarity = Callable[[Sequence[float], Sequence[float]], float]
-
-#: "no score floor" — ``0.0`` is a meaningful floor, so it cannot be the
-#: sentinel (the score-0-is-falsy trap this codebase keeps re-learning).
-NO_FLOOR = float("-inf")
-
-
-def dot_similarity(left: Sequence[float], right: Sequence[float]) -> float:
-    """Dot product, which is cosine similarity for unit-length vectors.
-
-    Mirrors :meth:`lattice_brain.embeddings.LocalEmbeddingModel.similarity`,
-    including its refusal to compare different dimensions: truncating to the
-    shorter vector produces a plausible-looking number that means nothing.
-    """
-    left_v, right_v = list(left), list(right)
-    if len(left_v) != len(right_v):
-        raise ValueError(
-            f"embedding dimension mismatch: {len(left_v)} vs {len(right_v)}; "
-            "the vector index was built with a different model"
-        )
-    return float(sum(a * b for a, b in zip(left_v, right_v, strict=True)))
-
-
-def score_floor(filter: Optional[Mapping[str, Any]]) -> float:
-    """Resolve ``filter["min_score"]`` (absent/unparseable → no floor)."""
-    if not filter:
-        return NO_FLOOR
-    raw = filter.get("min_score")
-    if raw is None:
-        return NO_FLOOR
-    try:
-        return float(raw)
-    except (TypeError, ValueError):
-        return NO_FLOOR
-
-
-def take_top(scored: List[ScoredId], top_k: int) -> List[ScoredId]:
-    """Sort by score descending (stable → insertion order breaks ties), cut."""
-    scored.sort(key=lambda pair: -pair[1])
-    return scored[: max(0, int(top_k))]
-
-
-@dataclass(frozen=True)
-class IndexStats:
-    """What a backend is willing to claim about itself."""
-
-    backend: str
-    size: int
-    dim: int
-    approx: bool
-    exhaustive: bool
-    available: bool = True
-    detail: Optional[str] = None
-
-    def as_dict(self) -> Dict[str, Any]:
-        return {
-            "backend": self.backend,
-            "size": self.size,
-            "dim": self.dim,
-            "approx": self.approx,
-            "exhaustive": self.exhaustive,
-            "available": self.available,
-            "detail": self.detail,
-        }
-
-
-class VectorIndex(Protocol):
-    """Structural contract implemented by every backend in this package.
-
-    Declared, never implemented — same convention as
-    :mod:`lattice_brain.graph._kg_contract`: the bodies raise so a stub can
-    never be mistaken for a working index.
-    """
-
-    @property
-    def backend(self) -> str:
-        """Stable id of the scoring strategy (goes into ``recall.backend``)."""
-        raise NotImplementedError
-
-    @property
-    def approx(self) -> bool:
-        """True when scores are estimates rather than exact similarities."""
-        raise NotImplementedError
-
-    @property
-    def exhaustive(self) -> bool:
-        """True when every stored vector is compared on every search."""
-        raise NotImplementedError
-
-    def add(
-        self,
-        id: str,
-        vector: Sequence[float],
-        metadata: Optional[Mapping[str, Any]] = None,
-    ) -> None:
-        raise NotImplementedError
-
-    def remove(self, id: str) -> None:
-        raise NotImplementedError
-
-    def rebuild(self, items: Iterable[IndexItem]) -> None:
-        raise NotImplementedError
-
-    def search(
-        self,
-        query: Sequence[float],
-        top_k: int,
-        filter: Optional[Mapping[str, Any]] = None,
-    ) -> List[ScoredId]:
-        raise NotImplementedError
-
-    def stats(self) -> IndexStats:
-        raise NotImplementedError
-
-
-__all__ = [
-    "NO_FLOOR",
-    "IndexItem",
-    "IndexStats",
-    "ScoredId",
-    "Similarity",
-    "VectorIndex",
-    "dot_similarity",
-    "score_floor",
-    "take_top",
-]

package/lattice_brain/graph/vector_index/brute_force.py

@@ -1,110 +0,0 @@
-"""Exact cosine scan — the historical ``vector_search`` scoring loop, moved.
-
-This backend is deliberately boring and deliberately the default. It compares
-the query against every vector it holds, so its answer is the ground truth the
-other backends are measured against (``scripts/bench_vector_index.py`` reports
-recall@k relative to this one).
-
-Behaviour parity with the pre-11.1.0 inline loop is the whole point of the
-move: same similarity function (injected, so it is the embedder's own), same
-``score < min_score`` drop, same stable ordering. ``retrieval_vector`` feeds
-it in bounded batches so a scan never holds every decoded vector at once.
-"""
-
-from __future__ import annotations
-
-from typing import Any, Dict, Iterable, List, Mapping, Optional, Sequence
-
-from .base import (
-    IndexItem,
-    IndexStats,
-    ScoredId,
-    Similarity,
-    dot_similarity,
-    score_floor,
-    take_top,
-)
-
-BRUTE_FORCE_BACKEND = "bruteforce-cosine"
-
-
-class BruteForceIndex:
-    """Exhaustive, exact, in-memory cosine index."""
-
-    def __init__(
-        self,
-        *,
-        dim: int = 0,
-        similarity: Optional[Similarity] = None,
-    ) -> None:
-        self._dim = int(dim)
-        self._similarity: Similarity = (
-            dot_similarity if similarity is None else similarity
-        )
-        self._vectors: Dict[str, List[float]] = {}
-        self._metadata: Dict[str, Dict[str, Any]] = {}
-
-    @property
-    def backend(self) -> str:
-        return BRUTE_FORCE_BACKEND
-
-    @property
-    def approx(self) -> bool:
-        return False
-
-    @property
-    def exhaustive(self) -> bool:
-        return True
-
-    def add(
-        self,
-        id: str,
-        vector: Sequence[float],
-        metadata: Optional[Mapping[str, Any]] = None,
-    ) -> None:
-        values = [float(value) for value in vector]
-        if not self._dim:
-            self._dim = len(values)
-        key = str(id)
-        self._vectors[key] = values
-        self._metadata[key] = dict(metadata or {})
-
-    def remove(self, id: str) -> None:
-        key = str(id)
-        self._vectors.pop(key, None)
-        self._metadata.pop(key, None)
-
-    def rebuild(self, items: Iterable[IndexItem]) -> None:
-        self._vectors.clear()
-        self._metadata.clear()
-        for item_id, vector, metadata in items:
-            self.add(item_id, vector, metadata)
-
-    def search(
-        self,
-        query: Sequence[float],
-        top_k: int,
-        filter: Optional[Mapping[str, Any]] = None,
-    ) -> List[ScoredId]:
-        floor = score_floor(filter)
-        query_vector = list(query)
-        scored: List[ScoredId] = []
-        for item_id, vector in self._vectors.items():
-            score = float(self._similarity(query_vector, vector))
-            if score < floor:
-                continue
-            scored.append((item_id, score))
-        return take_top(scored, top_k)
-
-    def stats(self) -> IndexStats:
-        return IndexStats(
-            backend=self.backend,
-            size=len(self._vectors),
-            dim=self._dim,
-            approx=False,
-            exhaustive=True,
-            detail=None,
-        )
-
-
-__all__ = ["BRUTE_FORCE_BACKEND", "BruteForceIndex"]