kodit 0.1.14__tar.gz → 0.1.16__tar.gz

kodit-0.1.16/.github/dependabot.yml

@@ -0,0 +1,10 @@
+version: 2
+updates:
+  - package-ecosystem: "uv"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+  - package-ecosystem: "docker"
+    directory: "/"
+    schedule:
+      interval: "weekly"

kodit-0.1.16/.github/workflows/pull_request.yaml

@@ -0,0 +1,35 @@
+# This workflow will install dependencies, create coverage tests and run Pytest Coverage Comment
+# For more information see: https://github.com/MishaKav/pytest-coverage-comment/
+name: pytest-coverage-comment
+on:
+  pull_request:
+    branches:
+      - "*"
+
+# https://docs.github.com/en/actions/using-jobs/assigning-permissions-to-jobs
+# `contents` is for permission to the contents of the repository.
+# `pull-requests` is for permission to pull request
+permissions:
+  contents: write
+  checks: write
+  pull-requests: write
+
+jobs:
+  coverage-comment:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version-file: ".python-version"
+      - uses: astral-sh/setup-uv@v5
+      - run: uv sync --locked --all-extras --dev
+
+      - name: Run tests
+        run: uv run pytest --junitxml=pytest.xml --cov-report=term-missing:skip-covered --cov=src tests/kodit | tee pytest-coverage.txt
+
+      - name: Pytest coverage comment
+        uses: MishaKav/pytest-coverage-comment@main
+        with:
+          pytest-coverage-path: ./pytest-coverage.txt
+          junitxml-path: ./pytest.xml

{kodit-0.1.14 → kodit-0.1.16}/.github/workflows/pypi.yaml

@@ -42,10 +42,10 @@ jobs:
               if curl -sfL https://pypi.org/packages/source/${REPO_NAME_FIRST_LETTER}/${REPO_NAME}/${REPO_NAME}-${REPO_TAG}.tar.gz > /dev/null; then
                   break
               fi
-              sleep 1
+              sleep 5
               count=$((count+1))
               if [ $count -ge 60 ]; then
-                  echo "Timeout reached after 60 seconds"
+                  echo "Timeout reached after 300 seconds"
                   exit 1
               fi
           done

{kodit-0.1.14 → kodit-0.1.16}/.github/workflows/test.yaml

@@ -9,7 +9,6 @@ on:
 permissions:
   contents: read # Needed to check out code
   checks: write # Needed to report test results
-  pull-requests: write # Needed to add comments/annotations to PRs
 
 jobs:
   test:
@@ -37,12 +36,6 @@ jobs:
       - name: Run tests
         run: uv run pytest -s --cov=src --cov-report=xml tests/kodit
 
-      - name: Pytest coverage comment
-        if: github.event_name == 'pull_request'
-        uses: MishaKav/pytest-coverage-comment@v1.1.54
-        with:
-          pytest-xml-coverage-path: ./coverage.xml
-
   build-package:
     runs-on: ubuntu-latest
     timeout-minutes: 10
@@ -58,23 +51,29 @@ jobs:
       - name: Install uv
         uses: astral-sh/setup-uv@v5
 
-      - run: uv build --sdist --out-dir test-build
+      - run: uv build --wheel --out-dir test-build
 
       - name: Upload built package
         uses: actions/upload-artifact@v4
         with:
           name: built-package
-          path: test-build/*.tar.gz
+          path: test-build/*.whl
 
   test-package:
     needs: build-package
     runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version:
+          - 3.12
+          - 3.13
     timeout-minutes: 10
     steps:
       - uses: actions/checkout@v4
         with:
           sparse-checkout: |
             tests/smoke.sh
+            uv.lock
           sparse-checkout-cone-mode: false
 
       - name: Download built package
@@ -86,16 +85,18 @@ jobs:
       - name: "Set up Python"
         uses: actions/setup-python@v5
         with:
-          python-version: 3.12
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
 
-      - name: Extract path to sdist
-        id: sdist_path
-        run: echo "sdist_path=$(ls test-build/*.tar.gz)" >> $GITHUB_OUTPUT
+      - name: Extract path to wheel
+        id: wheel_path
+        run: echo "wheel_path=$(ls test-build/*.whl)" >> $GITHUB_OUTPUT
 
-      - name: Install sdist
-        uses: threeal/pipx-install-action@v1.0.0
-        with:
-          packages: "${{ steps.sdist_path.outputs.sdist_path }}"
+      # This is equivalent to `pipx install --include-deps, but faster
+      - name: Install wheel
+        run: uv tool install "${{ steps.wheel_path.outputs.wheel_path }}"
 
       - name: Run simple version command test
         run: kodit version

kodit-0.1.16/.python-version

@@ -0,0 +1 @@
+3.13

{kodit-0.1.14 → kodit-0.1.16}/Dockerfile

@@ -1,5 +1,5 @@
 # syntax=docker/dockerfile:1.9
-FROM python:3.12.10-slim-bookworm AS build
+FROM python:3.13.3-slim-bookworm AS build
 
 # The following does not work in Podman unless you build in Docker
 # compatibility mode: <https://github.com/containers/podman/issues/8477>
@@ -23,12 +23,12 @@ COPY --from=ghcr.io/astral-sh/uv:0.7.2 /uv /usr/local/bin/uv
 # - Silence uv complaining about not being able to use hard links,
 # - tell uv to byte-compile packages for faster application startups,
 # - prevent uv from accidentally downloading isolated Python builds,
-# - pick a Python (use `/usr/bin/python3.12` on uv 0.5.0 and later),
+# - pick a Python (use `/usr/bin/python3.13` on uv 0.5.0 and later),
 # - and finally declare `/app` as the target for `uv sync`.
 ENV UV_LINK_MODE=copy \
     UV_COMPILE_BYTECODE=1 \
     UV_PYTHON_DOWNLOADS=never \
-    UV_PYTHON=python3.12 \
+    UV_PYTHON=python3.13 \
     UV_PROJECT_ENVIRONMENT=/app
 
 # Synchronize DEPENDENCIES without the application itself.
@@ -60,7 +60,7 @@ RUN --mount=type=cache,target=/root/.cache \
 
 ##########################################################################
 
-FROM python:3.12.10-slim-bookworm
+FROM python:3.13.3-slim-bookworm
 SHELL ["sh", "-exc"]
 
 ENV PATH=/app/bin:$PATH

{kodit-0.1.14 → kodit-0.1.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kodit
-Version: 0.1.14
+Version: 0.1.16
 Summary: Code indexing for better AI code generation
 Project-URL: Homepage, https://docs.helixml.tech/kodit/
 Project-URL: Documentation, https://docs.helixml.tech/kodit/
@@ -15,12 +15,14 @@ Keywords: ai,indexing,mcp,rag
 Classifier: Development Status :: 2 - Pre-Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Code Generators
 Requires-Python: >=3.12
 Requires-Dist: aiofiles>=24.1.0
 Requires-Dist: aiosqlite>=0.20.0
 Requires-Dist: alembic>=1.15.2
 Requires-Dist: asgi-correlation-id>=4.3.4
+Requires-Dist: asyncpg>=0.30.0
 Requires-Dist: better-exceptions>=0.3.3
 Requires-Dist: bm25s[core]>=0.2.12
 Requires-Dist: click>=8.1.8
@@ -41,6 +43,7 @@ Requires-Dist: sqlalchemy[asyncio]>=2.0.40
 Requires-Dist: structlog>=25.3.0
 Requires-Dist: tdqm>=0.0.1
 Requires-Dist: tiktoken>=0.9.0
+Requires-Dist: transformers>=4.51.3
 Requires-Dist: tree-sitter-language-pack>=0.7.3
 Requires-Dist: tree-sitter>=0.24.0
 Requires-Dist: uritools>=5.0.0

{kodit-0.1.14 → kodit-0.1.16}/docs/_index.md

@@ -169,7 +169,7 @@ recreate all indexes.
 
 ### Indexing
 
-#### Default Provider
+#### Default Indexing Provider
 
 By default, Kodit will use small local models for semantic search and enrichment. If you
 are using Kodit in a professional capacity, it is likely that the local model latency is
@@ -188,6 +188,71 @@ DEFAULT_ENDPOINT_BASE_URL=https://api.openai.com/v1
 DEFAULT_ENDPOINT_API_KEY=sk-xxxxxx
 ```
 
+### Database
+
+Out of the box Kodit uses a local sqlite file to make it easier for users to get
+started. But for production use, it's likely you will want to use a database that has
+dedicated semantic and keyword search capabilities for reduced latency.
+
+#### VectorChord Database
+
+[VectorChord](https://github.com/tensorchord/VectorChord) is an optimized PostgreSQL
+extension that provides both vector and BM25 search. (See [Search](#search))
+
+Start a container with:
+
+```sh
+docker run \
+  --name kodit-vectorchord \
+  -e POSTGRES_DB=kodit \
+  -e POSTGRES_PASSWORD=mysecretpassword \
+  -p 5432:5432 \
+  -d tensorchord/vchord-suite:pg17-20250601
+```
+
+{{< warn >}}
+Kodit assumes the database exists. In the above example I'm abusing the POSTGRES_DB
+environmental variable from the [Postgres Docker
+container](https://hub.docker.com/_/postgres/) to create the database for me. In
+production setups, please create a database yourself.
+{{< /warn >}}
+
+Then update your `.env` file to include:
+
+```env
+DB_URL=postgresql+asyncpg://postgres:mysecretpassword@localhost:5432/kodit
+```
+
+### Search
+
+#### Default Search Provider
+
+By default, Kodit will use built-in implementations of BM25 and similarity search to
+improve the out of the box experience. If you are using Kodit in a professional
+capacity, it is likely that the search latency is too high to provide a good developer
+experience.
+
+Instead, you should use the features included in your database. The settings provided
+here will cause all search functionality to use this database by default. You can
+override the database used for each search type if you wish. (Coming soon!)
+
+##### VectorChord Search
+
+Configure Kodit to use a [VectorChord database](#vectorchord-database).
+
+Then update your `.env` file to include:
+
+```env
+DB_URL=postgresql+asyncpg://postgres:mysecretpassword@localhost:5432/kodit
+DEFAULT_SEARCH_PROVIDER=vectorchord
+```
+
+### Enrichment
+
+#### Default Enrichment Provider
+
+The default enrichment provider is the same as [the default indexing provider](#default-indexing-provider).
+
 ## Managing Kodit
 
 There is limited management functionality at this time. To delete indexes you must

{kodit-0.1.14 → kodit-0.1.16}/pyproject.toml

@@ -18,6 +18,7 @@ classifiers = [
 
   # Specify the Python versions you support here.
   "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
 ]
 requires-python = ">=3.12"
 dependencies = [
@@ -48,6 +49,8 @@ dependencies = [
     "hf-xet>=1.1.2",
     "openai>=1.82.0",
     "tiktoken>=0.9.0",
+    "asyncpg>=0.30.0",
+    "transformers>=4.51.3",
 ]
 
 [dependency-groups]

{kodit-0.1.14 → kodit-0.1.16}/src/kodit/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.1.14'
-__version_tuple__ = version_tuple = (0, 1, 14)
+__version__ = version = '0.1.16'
+__version_tuple__ = version_tuple = (0, 1, 16)

kodit-0.1.16/src/kodit/bm25/keyword_search_factory.py

@@ -0,0 +1,17 @@
+"""Factory for creating keyword search providers."""
+
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from kodit.bm25.keyword_search_service import KeywordSearchProvider
+from kodit.bm25.local_bm25 import BM25Service
+from kodit.bm25.vectorchord_bm25 import VectorChordBM25
+from kodit.config import AppContext
+
+
+def keyword_search_factory(
+    app_context: AppContext, session: AsyncSession
+) -> KeywordSearchProvider:
+    """Create a keyword search provider."""
+    if app_context.default_search.provider == "vectorchord":
+        return VectorChordBM25(session=session)
+    return BM25Service(data_dir=app_context.get_data_dir())

kodit-0.1.16/src/kodit/bm25/keyword_search_service.py

@@ -0,0 +1,34 @@
+"""Keyword search service."""
+
+from abc import ABC, abstractmethod
+from typing import NamedTuple
+
+
+class BM25Document(NamedTuple):
+    """BM25 document."""
+
+    snippet_id: int
+    text: str
+
+
+class BM25Result(NamedTuple):
+    """BM25 result."""
+
+    snippet_id: int
+    score: float
+
+
+class KeywordSearchProvider(ABC):
+    """Interface for keyword search providers."""
+
+    @abstractmethod
+    async def index(self, corpus: list[BM25Document]) -> None:
+        """Index a new corpus."""
+
+    @abstractmethod
+    async def retrieve(self, query: str, top_k: int = 2) -> list[BM25Result]:
+        """Retrieve from the index."""
+
+    @abstractmethod
+    async def delete(self, snippet_ids: list[int]) -> None:
+        """Delete documents from the index."""

kodit-0.1.14/src/kodit/bm25/bm25.py → kodit-0.1.16/src/kodit/bm25/local_bm25.py

@@ -1,23 +1,36 @@
-"""BM25 service."""
+"""Locally hosted BM25 service primarily for use with SQLite."""
 
+import json
 from pathlib import Path
 
+import aiofiles
 import bm25s
 import Stemmer
 import structlog
 from bm25s.tokenization import Tokenized
 
+from kodit.bm25.keyword_search_service import (
+    BM25Document,
+    BM25Result,
+    KeywordSearchProvider,
+)
 
-class BM25Service:
-    """Service for BM25."""
+SNIPPET_IDS_FILE = "snippet_ids.jsonl"
+
+
+class BM25Service(KeywordSearchProvider):
+    """LocalBM25 service."""
 
     def __init__(self, data_dir: Path) -> None:
         """Initialize the BM25 service."""
         self.log = structlog.get_logger(__name__)
         self.index_path = data_dir / "bm25s_index"
+        self.snippet_ids: list[int] = []
         try:
             self.log.debug("Loading BM25 index")
             self.retriever = bm25s.BM25.load(self.index_path, mmap=True)
+            with Path(self.index_path / SNIPPET_IDS_FILE).open() as f:
+                self.snippet_ids = json.load(f)
         except FileNotFoundError:
             self.log.debug("BM25 index not found, creating new index")
             self.retriever = bm25s.BM25()
@@ -33,28 +46,34 @@ class BM25Service:
             show_progress=True,
         )
 
-    def index(self, corpus: list[str]) -> None:
+    async def index(self, corpus: list[BM25Document]) -> None:
         """Index a new corpus."""
         self.log.debug("Indexing corpus")
-        vocab = self._tokenize(corpus)
+        vocab = self._tokenize([doc.text for doc in corpus])
         self.retriever = bm25s.BM25()
         self.retriever.index(vocab, show_progress=False)
         self.retriever.save(self.index_path)
+        self.snippet_ids = self.snippet_ids + [doc.snippet_id for doc in corpus]
+        async with aiofiles.open(self.index_path / SNIPPET_IDS_FILE, "w") as f:
+            await f.write(json.dumps(self.snippet_ids))
 
-    def retrieve(
-        self, doc_ids: list[int], query: str, top_k: int = 2
-    ) -> list[tuple[int, float]]:
+    async def retrieve(self, query: str, top_k: int = 2) -> list[BM25Result]:
         """Retrieve from the index."""
         if top_k == 0:
             self.log.warning("Top k is 0, returning empty list")
             return []
-        if len(doc_ids) == 0:
-            self.log.warning("No documents to retrieve from, returning empty list")
+
+        # Get the number of documents in the index
+        num_docs = self.retriever.scores["num_docs"]
+        if num_docs == 0:
             return []
 
-        top_k = min(top_k, len(self.retriever.scores))
+        # Adjust top_k to not exceed corpus size
+        top_k = min(top_k, num_docs)
         self.log.debug(
-            "Retrieving from index", query=query, top_k=top_k, num_docs=len(doc_ids)
+            "Retrieving from index",
+            query=query,
+            top_k=top_k,
         )
 
         query_tokens = self._tokenize([query])
@@ -62,10 +81,17 @@ class BM25Service:
         self.log.debug("Query tokens", query_tokens=query_tokens)
 
         results, scores = self.retriever.retrieve(
-            query_tokens=query_tokens, corpus=doc_ids, k=top_k
+            query_tokens=query_tokens,
+            corpus=self.snippet_ids,
+            k=top_k,
         )
         self.log.debug("Raw results", results=results, scores=scores)
         return [
-            (int(result), float(score))
+            BM25Result(snippet_id=int(result), score=float(score))
             for result, score in zip(results[0], scores[0], strict=False)
+            if score > 0.0
         ]
+
+    async def delete(self, snippet_ids: list[int]) -> None:  # noqa: ARG002
+        """Delete documents from the index."""
+        self.log.warning("Deletion not supported for local BM25 index")

kodit-0.1.16/src/kodit/bm25/vectorchord_bm25.py

@@ -0,0 +1,193 @@
+"""VectorChord repository for document operations."""
+
+from typing import Any
+
+from sqlalchemy import Result, TextClause, bindparam, text
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from kodit.bm25.keyword_search_service import (
+    BM25Document,
+    BM25Result,
+    KeywordSearchProvider,
+)
+
+TABLE_NAME = "vectorchord_bm25_documents"
+INDEX_NAME = f"{TABLE_NAME}_idx"
+TOKENIZER_NAME = "bert"
+
+# SQL statements
+CREATE_VCHORD_EXTENSION = "CREATE EXTENSION IF NOT EXISTS vchord CASCADE;"
+CREATE_PG_TOKENIZER = "CREATE EXTENSION IF NOT EXISTS pg_tokenizer CASCADE;"
+CREATE_VCHORD_BM25 = "CREATE EXTENSION IF NOT EXISTS vchord_bm25 CASCADE;"
+SET_SEARCH_PATH = """
+SET search_path TO
+    "$user", public, bm25_catalog, pg_catalog, information_schema, tokenizer_catalog;
+"""
+CREATE_BM25_TABLE = f"""
+CREATE TABLE IF NOT EXISTS {TABLE_NAME} (
+    id SERIAL PRIMARY KEY,
+    snippet_id BIGINT NOT NULL,
+    passage TEXT NOT NULL,
+    embedding bm25vector,
+    UNIQUE(snippet_id)
+)
+"""
+
+CREATE_BM25_INDEX = f"""
+CREATE INDEX IF NOT EXISTS {INDEX_NAME}
+ON {TABLE_NAME}
+USING bm25 (embedding bm25_ops)
+"""
+TOKENIZER_NAME_CHECK_QUERY = (
+    f"SELECT 1 FROM tokenizer_catalog.tokenizer WHERE name = '{TOKENIZER_NAME}'"  # noqa: S608
+)
+LOAD_TOKENIZER = """
+SELECT create_tokenizer('bert', $$
+model = "llmlingua2"
+pre_tokenizer = "unicode_segmentation"  # Unicode Standard Annex #29
+[[character_filters]]
+to_lowercase = {}                       # convert all characters to lowercase
+[[character_filters]]
+unicode_normalization = "nfkd"          # Unicode Normalization Form KD
+[[token_filters]]
+skip_non_alphanumeric = {}              # remove non-alphanumeric tokens
+[[token_filters]]
+stopwords = "nltk_english"              # remove stopwords using the nltk dictionary
+[[token_filters]]
+stemmer = "english_porter2"             # stem tokens using the English Porter2 stemmer
+$$)
+"""
+INSERT_QUERY = f"""
+INSERT INTO {TABLE_NAME} (snippet_id, passage)
+VALUES (:snippet_id, :passage)
+ON CONFLICT (snippet_id) DO UPDATE
+SET passage = EXCLUDED.passage
+"""  # noqa: S608
+UPDATE_QUERY = f"""
+UPDATE {TABLE_NAME}
+SET embedding = tokenize(passage, '{TOKENIZER_NAME}')
+"""  # noqa: S608
+SEARCH_QUERY = f"""
+    SELECT
+        snippet_id,
+        embedding <&>
+            to_bm25query('{INDEX_NAME}', tokenize(:query_text, '{TOKENIZER_NAME}'))
+    AS bm25_score
+    FROM {TABLE_NAME}
+    ORDER BY bm25_score
+    LIMIT :limit
+"""  # noqa: S608
+DELETE_QUERY = f"""
+DELETE FROM {TABLE_NAME}
+WHERE snippet_id IN :snippet_ids
+"""  # noqa: S608
+
+
+class VectorChordBM25(KeywordSearchProvider):
+    """BM25 using VectorChord."""
+
+    def __init__(
+        self,
+        session: AsyncSession,
+    ) -> None:
+        """Initialize the VectorChord BM25."""
+        self.__session = session
+        self._initialized = False
+
+    async def _initialize(self) -> None:
+        """Initialize the VectorChord environment."""
+        try:
+            await self._create_extensions()
+            await self._create_tokenizer_if_not_exists()
+            await self._create_tables()
+            self._initialized = True
+        except Exception as e:
+            msg = f"Failed to initialize VectorChord repository: {e}"
+            raise RuntimeError(msg) from e
+
+    async def _create_extensions(self) -> None:
+        """Create the necessary extensions."""
+        await self.__session.execute(text(CREATE_VCHORD_EXTENSION))
+        await self.__session.execute(text(CREATE_PG_TOKENIZER))
+        await self.__session.execute(text(CREATE_VCHORD_BM25))
+        await self.__session.execute(text(SET_SEARCH_PATH))
+        await self._commit()
+
+    async def _create_tokenizer_if_not_exists(self) -> None:
+        """Create the tokenizer if it doesn't exist."""
+        # Check if tokenizer exists in the catalog
+        result = await self.__session.execute(text(TOKENIZER_NAME_CHECK_QUERY))
+        if result.scalar_one_or_none() is None:
+            # Tokenizer doesn't exist, create it
+            await self.__session.execute(text(LOAD_TOKENIZER))
+            await self._commit()
+
+    async def _create_tables(self) -> None:
+        """Create the necessary tables in the correct order."""
+        await self.__session.execute(text(CREATE_BM25_TABLE))
+        await self.__session.execute(text(CREATE_BM25_INDEX))
+        await self._commit()
+
+    async def _execute(
+        self, query: TextClause, param_list: list[Any] | dict[str, Any] | None = None
+    ) -> Result:
+        """Execute a query."""
+        if not self._initialized:
+            await self._initialize()
+        return await self.__session.execute(query, param_list)
+
+    async def _commit(self) -> None:
+        """Commit the session."""
+        await self.__session.commit()
+
+    async def index(self, corpus: list[BM25Document]) -> None:
+        """Index a new corpus."""
+        # Filter out any documents that don't have a snippet_id or text
+        corpus = [
+            doc
+            for doc in corpus
+            if doc.snippet_id is not None and doc.text is not None and doc.text != ""
+        ]
+
+        if not corpus:
+            return
+
+        # Execute inserts
+        await self._execute(
+            text(INSERT_QUERY),
+            [{"snippet_id": doc.snippet_id, "passage": doc.text} for doc in corpus],
+        )
+
+        # Tokenize the new documents with schema qualification
+        await self._execute(text(UPDATE_QUERY))
+        await self._commit()
+
+    async def delete(self, snippet_ids: list[int]) -> None:
+        """Delete documents from the index."""
+        await self._execute(
+            text(DELETE_QUERY).bindparams(bindparam("snippet_ids", expanding=True)),
+            {"snippet_ids": snippet_ids},
+        )
+        await self._commit()
+
+    async def retrieve(
+        self,
+        query: str,
+        top_k: int = 10,
+    ) -> list[BM25Result]:
+        """Search documents using BM25 similarity."""
+        if not query or query == "":
+            return []
+
+        sql = text(SEARCH_QUERY).bindparams(query_text=query, limit=top_k)
+        try:
+            result = await self._execute(sql)
+            rows = result.mappings().all()
+
+            return [
+                BM25Result(snippet_id=row["snippet_id"], score=row["bm25_score"])
+                for row in rows
+            ]
+        except Exception as e:
+            msg = f"Error during BM25 search: {e}"
+            raise RuntimeError(msg) from e