haiku.rag 0.5.5__py3-none-any.whl → 0.7.0__py3-none-any.whl

haiku/rag/utils.py

@@ -1,4 +1,7 @@
+import asyncio
 import sys
+from collections.abc import Callable
+from functools import wraps
 from importlib import metadata
 from io import BytesIO
 from pathlib import Path
@@ -10,6 +13,42 @@ from docling_core.types.io import DocumentStream
 from packaging.version import Version, parse
 
 
+def debounce(wait: float) -> Callable:
+    """
+    A decorator to debounce a function, ensuring it is called only after a specified delay
+    and always executes after the last call.
+
+    Args:
+        wait (float): The debounce delay in seconds.
+
+    Returns:
+        Callable: The decorated function.
+    """
+
+    def decorator(func: Callable) -> Callable:
+        last_call = None
+        task = None
+
+        @wraps(func)
+        async def debounced(*args, **kwargs):
+            nonlocal last_call, task
+            last_call = asyncio.get_event_loop().time()
+
+            if task:
+                task.cancel()
+
+            async def call_func():
+                await asyncio.sleep(wait)
+                if asyncio.get_event_loop().time() - last_call >= wait:  # type: ignore
+                    await func(*args, **kwargs)
+
+            task = asyncio.create_task(call_func())
+
+        return debounced
+
+    return decorator
+
+
 def get_default_data_dir() -> Path:
     """Get the user data directory for the current system platform.
 
@@ -32,37 +71,6 @@ def get_default_data_dir() -> Path:
     return data_path
 
 
-def semantic_version_to_int(version: str) -> int:
-    """Convert a semantic version string to an integer.
-
-    Args:
-        version: Semantic version string.
-
-    Returns:
-        Integer representation of semantic version.
-    """
-    major, minor, patch = version.split(".")
-    major = int(major) << 16
-    minor = int(minor) << 8
-    patch = int(patch)
-    return major + minor + patch
-
-
-def int_to_semantic_version(version: int) -> str:
-    """Convert an integer to a semantic version string.
-
-    Args:
-        version: Integer representation of semantic version.
-
-    Returns:
-        Semantic version string.
-    """
-    major = version >> 16
-    minor = (version >> 8) & 255
-    patch = version & 255
-    return f"{major}.{minor}.{patch}"
-
-
 async def is_up_to_date() -> tuple[bool, Version, Version]:
     """Check whether haiku.rag is current.
 

{haiku_rag-0.5.5.dist-info → haiku_rag-0.7.0.dist-info}/METADATA

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: haiku.rag
-Version: 0.5.5
-Summary: Retrieval Augmented Generation (RAG) with SQLite
+Version: 0.7.0
+Summary: Retrieval Augmented Generation (RAG) with LanceDB
 Author-email: Yiorgis Gozadinos <ggozadinos@gmail.com>
 License: MIT
 License-File: LICENSE
-Keywords: RAG,mcp,ml,sqlite,sqlite-vec
+Keywords: RAG,lancedb,mcp,ml,vector-database
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
@@ -17,42 +17,39 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Typing :: Typed
-Requires-Python: >=3.11
-Requires-Dist: docling>=2.15.0
+Requires-Python: >=3.12
+Requires-Dist: docling>=2.49.0
 Requires-Dist: fastmcp>=2.8.1
 Requires-Dist: httpx>=0.28.1
+Requires-Dist: lancedb>=0.24.3
 Requires-Dist: ollama>=0.5.3
+Requires-Dist: pydantic-ai>=0.8.1
 Requires-Dist: pydantic>=2.11.7
 Requires-Dist: python-dotenv>=1.1.0
-Requires-Dist: rich>=14.0.0
-Requires-Dist: sqlite-vec>=0.1.6
-Requires-Dist: tiktoken>=0.9.0
-Requires-Dist: typer>=0.16.0
+Requires-Dist: rich>=14.1.0
+Requires-Dist: tiktoken>=0.11.0
+Requires-Dist: typer>=0.16.1
 Requires-Dist: watchfiles>=1.1.0
-Provides-Extra: anthropic
-Requires-Dist: anthropic>=0.56.0; extra == 'anthropic'
-Provides-Extra: cohere
-Requires-Dist: cohere>=5.16.1; extra == 'cohere'
 Provides-Extra: mxbai
 Requires-Dist: mxbai-rerank>=0.1.6; extra == 'mxbai'
-Provides-Extra: openai
-Requires-Dist: openai>=1.0.0; extra == 'openai'
 Provides-Extra: voyageai
 Requires-Dist: voyageai>=0.3.2; extra == 'voyageai'
 Description-Content-Type: text/markdown
 
-# Haiku SQLite RAG
+# Haiku RAG
 
-Retrieval-Augmented Generation (RAG) library on SQLite.
+Retrieval-Augmented Generation (RAG) library built on LanceDB.
 
-`haiku.rag` is a Retrieval-Augmented Generation (RAG) library built to work on SQLite alone without the need for external vector databases. It uses [sqlite-vec](https://github.com/asg017/sqlite-vec) for storing the embeddings and performs semantic (vector) search as well as full-text search combined through Reciprocal Rank Fusion. Both open-source (Ollama) as well as commercial (OpenAI, VoyageAI) embedding providers are supported.
+`haiku.rag` is a Retrieval-Augmented Generation (RAG) library built to work with LanceDB as a local vector database. It uses LanceDB for storing embeddings and performs semantic (vector) search as well as full-text search combined through native hybrid search with Reciprocal Rank Fusion. Both open-source (Ollama) as well as commercial (OpenAI, VoyageAI) embedding providers are supported.
+
+> **Note**: Starting with version 0.7.0, haiku.rag uses LanceDB instead of SQLite. If you have an existing SQLite database, use `haiku-rag migrate old_database.sqlite` to migrate your data safely.
 
 ## Features
 
-- **Local SQLite**: No external servers required
+- **Local LanceDB**: No external servers required, supports also LanceDB cloud storage, S3, Google Cloud & Azure
 - **Multiple embedding providers**: Ollama, VoyageAI, OpenAI
-- **Multiple QA providers**: Ollama, OpenAI, Anthropic
-- **Hybrid search**: Vector + full-text search with Reciprocal Rank Fusion
+- **Multiple QA providers**: Any provider/model supported by Pydantic AI
+- **Native hybrid search**: Vector + full-text search with native LanceDB RRF reranking
 - **Reranking**: Default search result reranking with MixedBread AI or Cohere
 - **Question answering**: Built-in QA agents on your documents
 - **File monitoring**: Auto-index files when run as server
@@ -82,6 +79,9 @@ haiku-rag ask "Who is the author of haiku.rag?" --cite
 # Rebuild database (re-chunk and re-embed all documents)
 haiku-rag rebuild
 
+# Migrate from SQLite to LanceDB
+haiku-rag migrate old_database.sqlite
+
 # Start server with file monitoring
 export MONITOR_DIRECTORIES="/path/to/docs"
 haiku-rag serve
@@ -92,7 +92,7 @@ haiku-rag serve
 ```python
 from haiku.rag.client import HaikuRAG
 
-async with HaikuRAG("database.db") as client:
+async with HaikuRAG("database.lancedb") as client:
     # Add document
     doc = await client.create_document("Your content")
 

haiku_rag-0.7.0.dist-info/RECORD

@@ -0,0 +1,39 @@
+haiku/rag/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+haiku/rag/app.py,sha256=GmuZxH7BMutWt8Mdu0RSateRBaKiqXh7Z9tV7cZX6n0,7655
+haiku/rag/chunker.py,sha256=PVe6ysv8UlacUd4Zb3_8RFWIaWDXnzBAy2VDJ4TaUsE,1555
+haiku/rag/cli.py,sha256=UY9Vh5RsIxSCV14eQbNOiwToKmbFAvqTOAnxjieaYBs,6399
+haiku/rag/client.py,sha256=N4zkWjE9Rsw9YgPvNo83xptHUQR2ognfOnjkoV_w6hc,20999
+haiku/rag/config.py,sha256=9Mv0QJ3c6VF1oVRSXJlSsG234dCd_sKnJO-ybMaTpDQ,1690
+haiku/rag/logging.py,sha256=9RjS931Dkp0nSdJaCSCydi33jq4gXmLmIidONvD9qD4,731
+haiku/rag/mcp.py,sha256=bR9Y-Nz-hvjiql20Y0KE0hwNGwyjmPGX8K9d-qmXptY,4683
+haiku/rag/migration.py,sha256=gWxQwiKo0YulRhogYz4K8N98kHN9LQXIx9FeTmT24v4,10915
+haiku/rag/monitor.py,sha256=r386nkhdlsU8UECwIuVwnrSlgMk3vNIuUZGNIzkZuec,2770
+haiku/rag/reader.py,sha256=qkPTMJuQ_o4sK-8zpDl9WFYe_MJ7aL_gUw6rczIpW-g,3274
+haiku/rag/utils.py,sha256=c8F0ECsFSqvQxzxINAOAnvShoOnJPLsOaNE3JEY2JSc,3230
+haiku/rag/embeddings/__init__.py,sha256=n7aHW3BxHlpGxU4ze4YYDOsljzFpEep8dwVE2n45JoE,1218
+haiku/rag/embeddings/base.py,sha256=NTQvuzbZPu0LBo5wAu3qGyJ4xXUaRAt1fjBO0ygWn_Y,465
+haiku/rag/embeddings/ollama.py,sha256=y6-lp0XpbnyIjoOEdtSzMdEVkU5glOwnWQ1FkpUZnpI,370
+haiku/rag/embeddings/openai.py,sha256=iA-DewCOSip8PLU_RhEJHFHBle4DtmCCIGNfGs58Wvk,357
+haiku/rag/embeddings/voyageai.py,sha256=0hiRTIqu-bpl-4OaCtMHvWfPdgbrzhnfZJowSV8pLRA,415
+haiku/rag/qa/__init__.py,sha256=Sl7Kzrg9CuBOcMF01wc1NtQhUNWjJI0MhIHfCWrb8V4,434
+haiku/rag/qa/agent.py,sha256=r6tYKvOW4W1HxBRHH1kmzlzb1bIJcQSuHd6cG9ANqXY,2594
+haiku/rag/qa/prompts.py,sha256=xdT4cyrOrAK9UDgVqyev1wHF49jD57Bh40gx2sH4NPI,3341
+haiku/rag/reranking/__init__.py,sha256=IRXHs4qPu6VbGJQpzSwhgtVWWumURH_vEoVFE-extlo,894
+haiku/rag/reranking/base.py,sha256=LM9yUSSJ414UgBZhFTgxGprlRqzfTe4I1vgjricz2JY,405
+haiku/rag/reranking/cohere.py,sha256=1iTdiaa8vvb6oHVB2qpWzUOVkyfUcimVSZp6Qr4aq4c,1049
+haiku/rag/reranking/mxbai.py,sha256=46sVTsTIkzIX9THgM3u8HaEmgY7evvEyB-N54JTHvK8,867
+haiku/rag/store/__init__.py,sha256=hq0W0DAC7ysqhWSP2M2uHX8cbG6kbr-sWHxhq6qQcY0,103
+haiku/rag/store/engine.py,sha256=XHGo5Xl-dCFdQHrOdMo64xVK5n0k8-LoUl5V-tlA0HI,7131
+haiku/rag/store/models/__init__.py,sha256=s0E72zneGlowvZrFWaNxHYjOAUjgWdLxzdYsnvNRVlY,88
+haiku/rag/store/models/chunk.py,sha256=ZNyTfO6lh3rXWLVYO3TZcitbL4LSUGr42fR6jQQ5iQc,364
+haiku/rag/store/models/document.py,sha256=zSSpt6pyrMJAIXGQvIcqojcqUzwZnhp3WxVokaWxNRc,396
+haiku/rag/store/repositories/__init__.py,sha256=Olv5dLfBQINRV3HrsfUpjzkZ7Qm7goEYyMNykgo_DaY,291
+haiku/rag/store/repositories/chunk.py,sha256=5S77mGh6pWxPHjaXriJGmvbSOhoNM8tLwygE2GXPlbU,13586
+haiku/rag/store/repositories/document.py,sha256=lP8Lo82KTP-qwXFRpYZ46WjeAdAsHwZ5pJcrXdz4g0U,6988
+haiku/rag/store/repositories/settings.py,sha256=dqnAvm-98nQrWpLBbf9QghJw673QD80-iqQhRMP5t0c,5025
+haiku/rag/store/upgrades/__init__.py,sha256=wUiEoSiHTahvuagx93E4FB07v123AhdbOjwUkPusiIg,14
+haiku_rag-0.7.0.dist-info/METADATA,sha256=FGx5ufhc35VUXqXLdbhmUEa-3hi7aaBuDeyZYf8xaaQ,4597
+haiku_rag-0.7.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+haiku_rag-0.7.0.dist-info/entry_points.txt,sha256=G1U3nAkNd5YDYd4v0tuYFbriz0i-JheCsFuT9kIoGCI,48
+haiku_rag-0.7.0.dist-info/licenses/LICENSE,sha256=eXZrWjSk9PwYFNK9yUczl3oPl95Z4V9UXH7bPN46iPo,1065
+haiku_rag-0.7.0.dist-info/RECORD,,

haiku/rag/qa/anthropic.py

@@ -1,108 +0,0 @@
-from collections.abc import Sequence
-
-try:
-    from anthropic import AsyncAnthropic  # type: ignore
-    from anthropic.types import (  # type: ignore
-        MessageParam,
-        TextBlock,
-        ToolParam,
-        ToolUseBlock,
-    )
-
-    from haiku.rag.client import HaikuRAG
-    from haiku.rag.qa.base import QuestionAnswerAgentBase
-
-    class QuestionAnswerAnthropicAgent(QuestionAnswerAgentBase):
-        def __init__(
-            self,
-            client: HaikuRAG,
-            model: str = "claude-3-5-haiku-20241022",
-            use_citations: bool = False,
-        ):
-            super().__init__(client, model or self._model, use_citations)
-            self.tools: Sequence[ToolParam] = [
-                ToolParam(
-                    name="search_documents",
-                    description="Search the knowledge base for relevant documents. Returns a JSON array with content, score, and document_uri for each result.",
-                    input_schema={
-                        "type": "object",
-                        "properties": {
-                            "query": {
-                                "type": "string",
-                                "description": "The search query to find relevant documents",
-                            },
-                            "limit": {
-                                "type": "integer",
-                                "description": "Maximum number of results to return",
-                                "default": 3,
-                            },
-                        },
-                        "required": ["query"],
-                    },
-                )
-            ]
-
-        async def answer(self, question: str) -> str:
-            anthropic_client = AsyncAnthropic()
-
-            messages: list[MessageParam] = [{"role": "user", "content": question}]
-
-            max_rounds = 5  # Prevent infinite loops
-
-            for _ in range(max_rounds):
-                response = await anthropic_client.messages.create(
-                    model=self._model,
-                    max_tokens=4096,
-                    system=self._system_prompt,
-                    messages=messages,
-                    tools=self.tools,
-                    temperature=0.0,
-                )
-
-                if response.stop_reason == "tool_use":
-                    messages.append({"role": "assistant", "content": response.content})
-
-                    # Process tool calls
-                    tool_results = []
-                    for content_block in response.content:
-                        if isinstance(content_block, ToolUseBlock):
-                            if content_block.name == "search_documents":
-                                args = content_block.input
-                                query = (
-                                    args.get("query", question)
-                                    if isinstance(args, dict)
-                                    else question
-                                )
-                                limit = (
-                                    int(args.get("limit", 3))
-                                    if isinstance(args, dict)
-                                    else 3
-                                )
-
-                                context = await self._search_and_expand(
-                                    query, limit=limit
-                                )
-
-                                tool_results.append(
-                                    {
-                                        "type": "tool_result",
-                                        "tool_use_id": content_block.id,
-                                        "content": context,
-                                    }
-                                )
-
-                    if tool_results:
-                        messages.append({"role": "user", "content": tool_results})
-                else:
-                    # No tool use, return the response
-                    if response.content:
-                        first_content = response.content[0]
-                        if isinstance(first_content, TextBlock):
-                            return first_content.text
-                    return ""
-
-            # If we've exhausted max rounds, return empty string
-            return ""
-
-except ImportError:
-    pass

haiku/rag/qa/base.py

@@ -1,89 +0,0 @@
-import json
-
-from haiku.rag.client import HaikuRAG
-from haiku.rag.qa.prompts import SYSTEM_PROMPT, SYSTEM_PROMPT_WITH_CITATIONS
-
-
-class QuestionAnswerAgentBase:
-    _model: str = ""
-    _system_prompt: str = SYSTEM_PROMPT
-
-    def __init__(self, client: HaikuRAG, model: str = "", use_citations: bool = False):
-        self._model = model
-        self._client = client
-        self._system_prompt = (
-            SYSTEM_PROMPT_WITH_CITATIONS if use_citations else SYSTEM_PROMPT
-        )
-
-    async def answer(self, question: str) -> str:
-        raise NotImplementedError(
-            "QABase is an abstract class. Please implement the answer method in a subclass."
-        )
-
-    async def _search_and_expand(self, query: str, limit: int = 3) -> str:
-        """Search for documents and expand context, then format as JSON"""
-        search_results = await self._client.search(query, limit=limit)
-        expanded_results = await self._client.expand_context(search_results)
-        return self._format_search_results(expanded_results)
-
-    def _format_search_results(self, search_results) -> str:
-        """Format search results as JSON list of {content, score, document_uri}"""
-        formatted_results = []
-        for chunk, score in search_results:
-            formatted_results.append(
-                {
-                    "content": chunk.content,
-                    "score": score,
-                    "document_uri": chunk.document_uri,
-                }
-            )
-        return json.dumps(formatted_results, indent=2)
-
-    tools = [
-        {
-            "type": "function",
-            "function": {
-                "name": "search_documents",
-                "description": "Search the knowledge base for relevant documents. Returns a JSON array of search results.",
-                "parameters": {
-                    "type": "object",
-                    "properties": {
-                        "query": {
-                            "type": "string",
-                            "description": "The search query to find relevant documents",
-                        },
-                        "limit": {
-                            "type": "integer",
-                            "description": "Maximum number of results to return",
-                            "default": 3,
-                        },
-                    },
-                    "required": ["query"],
-                },
-                "returns": {
-                    "type": "string",
-                    "description": "JSON array of search results",
-                    "schema": {
-                        "type": "array",
-                        "items": {
-                            "type": "object",
-                            "properties": {
-                                "content": {
-                                    "type": "string",
-                                    "description": "The document text content",
-                                },
-                                "score": {
-                                    "type": "number",
-                                    "description": "Relevance score (higher is more relevant)",
-                                },
-                                "document_uri": {
-                                    "type": "string",
-                                    "description": "Source URI/path of the document",
-                                },
-                            },
-                        },
-                    },
-                },
-            },
-        }
-    ]

haiku/rag/qa/ollama.py

@@ -1,60 +0,0 @@
-from ollama import AsyncClient
-
-from haiku.rag.client import HaikuRAG
-from haiku.rag.config import Config
-from haiku.rag.qa.base import QuestionAnswerAgentBase
-
-OLLAMA_OPTIONS = {"temperature": 0.0, "seed": 42, "num_ctx": 16384}
-
-
-class QuestionAnswerOllamaAgent(QuestionAnswerAgentBase):
-    def __init__(
-        self,
-        client: HaikuRAG,
-        model: str = Config.QA_MODEL,
-        use_citations: bool = False,
-    ):
-        super().__init__(client, model or self._model, use_citations)
-
-    async def answer(self, question: str) -> str:
-        ollama_client = AsyncClient(host=Config.OLLAMA_BASE_URL)
-
-        messages = [
-            {"role": "system", "content": self._system_prompt},
-            {"role": "user", "content": question},
-        ]
-
-        max_rounds = 5  # Prevent infinite loops
-
-        for _ in range(max_rounds):
-            response = await ollama_client.chat(
-                model=self._model,
-                messages=messages,
-                tools=self.tools,
-                options=OLLAMA_OPTIONS,
-                think=False,
-            )
-
-            if response.get("message", {}).get("tool_calls"):
-                messages.append(response["message"])
-
-                for tool_call in response["message"]["tool_calls"]:
-                    if tool_call["function"]["name"] == "search_documents":
-                        args = tool_call["function"]["arguments"]
-                        query = args.get("query", question)
-                        limit = int(args.get("limit", 3))
-
-                        context = await self._search_and_expand(query, limit=limit)
-                        messages.append(
-                            {
-                                "role": "tool",
-                                "content": context,
-                                "tool_call_id": tool_call.get("id", "search_tool"),
-                            }
-                        )
-            else:
-                # No tool calls, return the response
-                return response["message"]["content"]
-
-        # If we've exhausted max rounds, return empty string
-        return ""

haiku/rag/qa/openai.py

@@ -1,97 +0,0 @@
-from collections.abc import Sequence
-
-try:
-    from openai import AsyncOpenAI  # type: ignore
-    from openai.types.chat import (  # type: ignore
-        ChatCompletionAssistantMessageParam,
-        ChatCompletionMessageParam,
-        ChatCompletionSystemMessageParam,
-        ChatCompletionToolMessageParam,
-        ChatCompletionUserMessageParam,
-    )
-    from openai.types.chat.chat_completion_tool_param import (  # type: ignore
-        ChatCompletionToolParam,
-    )
-
-    from haiku.rag.client import HaikuRAG
-    from haiku.rag.qa.base import QuestionAnswerAgentBase
-
-    class QuestionAnswerOpenAIAgent(QuestionAnswerAgentBase):
-        def __init__(
-            self,
-            client: HaikuRAG,
-            model: str = "gpt-4o-mini",
-            use_citations: bool = False,
-        ):
-            super().__init__(client, model or self._model, use_citations)
-            self.tools: Sequence[ChatCompletionToolParam] = [
-                ChatCompletionToolParam(tool) for tool in self.tools
-            ]
-
-        async def answer(self, question: str) -> str:
-            openai_client = AsyncOpenAI()
-
-            messages: list[ChatCompletionMessageParam] = [
-                ChatCompletionSystemMessageParam(
-                    role="system", content=self._system_prompt
-                ),
-                ChatCompletionUserMessageParam(role="user", content=question),
-            ]
-
-            max_rounds = 5  # Prevent infinite loops
-
-            for _ in range(max_rounds):
-                response = await openai_client.chat.completions.create(
-                    model=self._model,
-                    messages=messages,
-                    tools=self.tools,
-                    temperature=0.0,
-                )
-
-                response_message = response.choices[0].message
-
-                if response_message.tool_calls:
-                    messages.append(
-                        ChatCompletionAssistantMessageParam(
-                            role="assistant",
-                            content=response_message.content,
-                            tool_calls=[
-                                {
-                                    "id": tc.id,
-                                    "type": "function",
-                                    "function": {
-                                        "name": tc.function.name,
-                                        "arguments": tc.function.arguments,
-                                    },
-                                }
-                                for tc in response_message.tool_calls
-                            ],
-                        )
-                    )
-
-                    for tool_call in response_message.tool_calls:
-                        if tool_call.function.name == "search_documents":
-                            import json
-
-                            args = json.loads(tool_call.function.arguments)
-                            query = args.get("query", question)
-                            limit = int(args.get("limit", 3))
-
-                            context = await self._search_and_expand(query, limit=limit)
-
-                            messages.append(
-                                ChatCompletionToolMessageParam(
-                                    role="tool",
-                                    content=context,
-                                    tool_call_id=tool_call.id,
-                                )
-                            )
-                else:
-                    # No tool calls, return the response
-                    return response_message.content or ""
-
-            # If we've exhausted max rounds, return empty string
-            return ""
-
-except ImportError:
-    pass

haiku/rag/reranking/ollama.py

@@ -1,84 +0,0 @@
-import json
-
-from ollama import AsyncClient
-from pydantic import BaseModel
-
-from haiku.rag.config import Config
-from haiku.rag.reranking.base import RerankerBase
-from haiku.rag.store.models.chunk import Chunk
-
-OLLAMA_OPTIONS = {"temperature": 0.0, "seed": 42, "num_ctx": 16384}
-
-
-class RerankResult(BaseModel):
-    """Individual rerank result with index and relevance score."""
-
-    index: int
-    relevance_score: float
-
-
-class RerankResponse(BaseModel):
-    """Response from the reranking model containing ranked results."""
-
-    results: list[RerankResult]
-
-
-class OllamaReranker(RerankerBase):
-    def __init__(self, model: str = Config.RERANK_MODEL):
-        self._model = model
-        self._client = AsyncClient(host=Config.OLLAMA_BASE_URL)
-
-    async def rerank(
-        self, query: str, chunks: list[Chunk], top_n: int = 10
-    ) -> list[tuple[Chunk, float]]:
-        if not chunks:
-            return []
-
-        documents = []
-        for i, chunk in enumerate(chunks):
-            documents.append({"index": i, "content": chunk.content})
-
-        # Create the prompt for reranking
-        system_prompt = """You are a document reranking assistant. Given a query and a list of document chunks, you must rank them by relevance to the query.
-
-Return your response as a JSON object with a "results" array. Each result should have:
-- "index": the original index of the document (integer)
-- "relevance_score": a score between 0.0 and 1.0 indicating relevance (float, where 1.0 is most relevant)
-
-Only return the top documents up to the requested limit, ordered by decreasing relevance score."""
-
-        documents_text = ""
-        for doc in documents:
-            documents_text += f"Index {doc['index']}: {doc['content']}\n\n"
-
-        user_prompt = f"""Query: {query}
-
-Documents to rerank:
-{documents_text.strip()}
-
-Please rank these documents by relevance to the query and return the top {top_n} results as JSON."""
-
-        messages = [
-            {"role": "system", "content": system_prompt},
-            {"role": "user", "content": user_prompt},
-        ]
-
-        try:
-            response = await self._client.chat(
-                model=self._model,
-                messages=messages,
-                format=RerankResponse.model_json_schema(),
-                options=OLLAMA_OPTIONS,
-            )
-
-            content = response["message"]["content"]
-
-            parsed_response = RerankResponse.model_validate(json.loads(content))
-            return [
-                (chunks[result.index], result.relevance_score)
-                for result in parsed_response.results[:top_n]
-            ]
-
-        except Exception:
-            # Fallback: return chunks in original order with same score
-            return [(chunks[i], 1.0) for i in range(min(top_n, len(chunks)))]