ragbits-document-search 1.4.0.dev202601310254__py3-none-any.whl

ragbits/document_search/retrieval/rerankers/answerai.py

@@ -0,0 +1,82 @@
+from collections.abc import Sequence
+from itertools import chain
+from typing import Any
+
+from rerankers import Reranker as AnswerReranker
+
+from ragbits.core.audit.traces import trace
+from ragbits.document_search.documents.element import Element
+from ragbits.document_search.retrieval.rerankers.base import Reranker, RerankerOptions
+
+
+class AnswerAIReranker(Reranker[RerankerOptions]):
+    """
+    A [rerankers](https://github.com/AnswerDotAI/rerankers) re-ranker covering most popular re-ranking methods.
+    """
+
+    options_cls: type[RerankerOptions] = RerankerOptions
+
+    def __init__(
+        self,
+        model: str,
+        default_options: RerankerOptions | None = None,
+        **rerankers_kwargs: Any,  # noqa: ANN401
+    ) -> None:
+        """
+        Initialize the AnswerAIReranker instance.
+
+        Args:
+            model: The reranker model to use.
+            default_options: The default options for reranking.
+            **rerankers_kwargs: Additional keyword arguments native to rerankers lib.
+        """
+        super().__init__(default_options=default_options)
+        self.model = model
+        self.ranker = AnswerReranker(self.model, **rerankers_kwargs)
+
+    async def rerank(
+        self,
+        elements: Sequence[Sequence[Element]],
+        query: str,
+        options: RerankerOptions | None = None,
+    ) -> Sequence[Element]:
+        """
+        Rerank elements.
+
+        Args:
+            elements: The elements to rerank.
+            query: The query to rerank the elements against.
+            options: The options for reranking.
+
+        Returns:
+            The reranked elements.
+
+        Raises:
+            ValueError: Raised if the input query is empty or if the list of candidate documents is empty.
+            TypeError: Raised if the input types are incorrect, such as if the query is not a string, or List[str].
+            IndexError: Raised if docs is an empty List.
+        """
+        merged_options = (self.default_options | options) if options else self.default_options
+        flat_elements = list(chain.from_iterable(elements))
+        documents = [element.text_representation or "" for element in flat_elements]
+
+        with trace(
+            query=query, documents=documents, elements=elements, model=self.model, options=merged_options
+        ) as outputs:
+            response = self.ranker.rank(
+                query=query,
+                docs=documents,
+            )
+            if merged_options.top_n:
+                response = response.top_k(merged_options.top_n)
+
+            results = []
+            for result in response:
+                if not merged_options.score_threshold or result.score >= merged_options.score_threshold:
+                    if merged_options.override_score:
+                        flat_elements[result.document.doc_id].score = result.score
+                    results.append(flat_elements[result.document.doc_id])
+
+            outputs.results = results
+
+        return outputs.results

ragbits/document_search/retrieval/rerankers/base.py

@@ -0,0 +1,56 @@
+from abc import ABC, abstractmethod
+from collections.abc import Sequence
+from typing import ClassVar, TypeVar
+
+from ragbits.core.options import Options
+from ragbits.core.types import NOT_GIVEN, NotGiven
+from ragbits.core.utils.config_handling import ConfigurableComponent
+from ragbits.document_search.documents.element import Element
+from ragbits.document_search.retrieval import rerankers
+
+
+class RerankerOptions(Options):
+    """
+    Object representing the options for the reranker.
+
+    Attributes:
+        top_n: The number of entries to return.
+        score_threshold: The minimum relevance score for an entry to be returned.
+        override_score: If True reranking will override element score.
+    """
+
+    top_n: int | None | NotGiven = NOT_GIVEN
+    score_threshold: float | None | NotGiven = NOT_GIVEN
+    override_score: bool = True
+
+
+RerankerOptionsT = TypeVar("RerankerOptionsT", bound=RerankerOptions)
+
+
+class Reranker(ConfigurableComponent[RerankerOptionsT], ABC):
+    """
+    Reranks elements retrieved from vector store.
+    """
+
+    options_cls: type[RerankerOptionsT]
+    default_module: ClassVar = rerankers
+    configuration_key: ClassVar = "reranker"
+
+    @abstractmethod
+    async def rerank(
+        self,
+        elements: Sequence[Sequence[Element]],
+        query: str,
+        options: RerankerOptionsT | None = None,
+    ) -> Sequence[Element]:
+        """
+        Rerank elements.
+
+        Args:
+            elements: The elements to rerank.
+            query: The query to rerank the elements against.
+            options: The options for reranking.
+
+        Returns:
+            The reranked elements.
+        """

ragbits/document_search/retrieval/rerankers/litellm.py

@@ -0,0 +1,85 @@
+from collections.abc import Sequence
+from itertools import chain
+
+import litellm
+
+from ragbits.core.audit.traces import traceable
+from ragbits.core.types import NOT_GIVEN, NotGiven
+from ragbits.document_search.documents.element import Element
+from ragbits.document_search.retrieval.rerankers.base import Reranker, RerankerOptions
+
+
+class LiteLLMRerankerOptions(RerankerOptions):
+    """
+    Object representing the options for the litellm reranker.
+
+    Attributes:
+        top_n: The number of entries to return.
+        score_threshold: The minimum relevance score for an entry to be returned.
+        override_score: If True reranking will override element score.
+        max_chunks_per_doc: The maximum amount of tokens a document can have before truncation.
+    """
+
+    max_chunks_per_doc: int | None | NotGiven = NOT_GIVEN
+
+
+class LiteLLMReranker(Reranker[LiteLLMRerankerOptions]):
+    """
+    A [LiteLLM](https://docs.litellm.ai/docs/rerank) reranker for providers such as Cohere, Together AI, Azure AI.
+    """
+
+    options_cls: type[LiteLLMRerankerOptions] = LiteLLMRerankerOptions
+
+    def __init__(
+        self,
+        model: str,
+        default_options: LiteLLMRerankerOptions | None = None,
+    ) -> None:
+        """
+        Initialize the LiteLLMReranker instance.
+
+        Args:
+            model: The reranker model to use.
+            default_options: The default options for reranking.
+        """
+        super().__init__(default_options=default_options)
+        self.model = model
+
+    @traceable
+    async def rerank(
+        self,
+        elements: Sequence[Sequence[Element]],
+        query: str,
+        options: LiteLLMRerankerOptions | None = None,
+    ) -> Sequence[Element]:
+        """
+        Rerank elements with LiteLLM API.
+
+        Args:
+            elements: The elements to rerank.
+            query: The query to rerank the elements against.
+            options: The options for reranking.
+
+        Returns:
+            The reranked elements.
+        """
+        merged_options = (self.default_options | options) if options else self.default_options
+        flat_elements = list(chain.from_iterable(elements))
+        documents = [element.text_representation or "" for element in flat_elements]
+
+        response = await litellm.arerank(
+            model=self.model,
+            query=query,
+            documents=documents,
+            top_n=merged_options.top_n or None,
+            max_chunks_per_doc=merged_options.max_chunks_per_doc or None,
+        )
+
+        results = []
+        for result in response.results:
+            if not merged_options.score_threshold or result["relevance_score"] >= merged_options.score_threshold:
+                if merged_options.override_score:
+                    flat_elements[result["index"]].score = result["relevance_score"]
+                results.append(flat_elements[result["index"]])
+
+        return results

ragbits/document_search/retrieval/rerankers/llm.py

@@ -0,0 +1,177 @@
+import math
+from collections.abc import Sequence
+from itertools import chain
+
+from pydantic import BaseModel
+from typing_extensions import Self
+
+from ragbits.core.audit.traces import traceable
+from ragbits.core.llms.base import LLM
+from ragbits.core.llms.litellm import LiteLLM, LiteLLMOptions
+from ragbits.core.prompt.prompt import Prompt
+from ragbits.core.types import NOT_GIVEN, NotGiven
+from ragbits.core.utils.config_handling import ObjectConstructionConfig, import_by_path
+from ragbits.document_search.documents.element import Element
+from ragbits.document_search.retrieval.rerankers.base import Reranker, RerankerOptions
+
+
+class RerankerInput(BaseModel):
+    """
+    Input data for the document reranker.
+    """
+
+    query: str
+    document: str
+
+
+class RerankerPrompt(Prompt[RerankerInput, str]):
+    """
+    Prompt for reranking documents.
+    """
+
+    system_prompt = """
+        You are an Assistant responsible for helping detect whether the retrieved document is relevant to the query.
+        For a given input, you need to output a single token: "Yes" or "No" indicating the retrieved document is relevant to the query.
+    """  # noqa: E501
+    user_prompt = """
+        Query: {{query}}
+        Document: {{document}}
+        Relevant:
+    """
+
+
+class LLMRerankerOptions(RerankerOptions):
+    """
+    Object representing the options for the llm reranker.
+
+    Attributes:
+        top_n: The number of entries to return.
+        score_threshold: The minimum relevance score for an entry to be returned.
+        override_score: If True reranking will override element score.
+        llm_options: The options for the LLM.
+    """
+
+    llm_options: LiteLLMOptions | None | NotGiven = NOT_GIVEN
+
+
+class LLMReranker(Reranker[LLMRerankerOptions]):
+    """
+    Reranker based on LLM.
+    """
+
+    options_cls: type[LLMRerankerOptions] = LLMRerankerOptions
+
+    def __init__(
+        self,
+        llm: LiteLLM,
+        *,
+        prompt: type[Prompt[RerankerInput, str]] | None = None,
+        default_options: LLMRerankerOptions | None = None,
+    ) -> None:
+        """
+        Initialize the LLMReranker instance.
+
+        Args:
+            llm: The LLM instance to handle reranking.
+            prompt: The prompt to use for reranking elements.
+            default_options: The default options for reranking.
+        """
+        super().__init__(default_options=default_options)
+        self._llm = llm
+        self._prompt = prompt or RerankerPrompt
+        self._llm_options = LiteLLMOptions(
+            temperature=0.0,
+            logprobs=True,
+            max_tokens=1,
+            logit_bias={
+                self._llm.get_token_id(" Yes"): 1,
+                self._llm.get_token_id(" No"): 1,
+            },
+        )
+
+    @classmethod
+    def from_config(cls, config: dict) -> Self:
+        """
+        Initialize the class with the provided configuration.
+
+        Args:
+            config: A dictionary containing configuration details for the class.
+
+        Returns:
+            The initialized instance of LLMReranker.
+
+        Raises:
+            ValidationError: If the configuration doesn't follow the expected format.
+            InvalidConfigError: If llm or prompt can't be found or are not the correct type.
+        """
+        config["llm"] = LLM.subclass_from_config(ObjectConstructionConfig.model_validate(config["llm"]))
+        config["prompt"] = import_by_path(config["prompt"]) if "prompt" in config else None
+        return super().from_config(config)
+
+    @traceable
+    async def rerank(
+        self,
+        elements: Sequence[Sequence[Element]],
+        query: str,
+        options: LLMRerankerOptions | None = None,
+    ) -> Sequence[Element]:
+        """
+        Rerank elements with LLM.
+
+        Args:
+            elements: The elements to rerank.
+            query: The query to rerank the elements against.
+            options: The options for reranking.
+
+        Returns:
+            The reranked elements.
+        """
+        merged_options = (self.default_options | options) if options else self.default_options
+        llm_options = (
+            self._llm_options | merged_options.llm_options if merged_options.llm_options else self._llm_options
+        )
+
+        flat_elements = list(chain.from_iterable(elements))
+        scores = await self._score_elements(flat_elements, query, llm_options)
+
+        scored_elements = list(zip(flat_elements, scores, strict=True))
+        scored_elements.sort(key=lambda x: x[1], reverse=True)
+
+        results = []
+        for element, score in scored_elements[: merged_options.top_n or None]:
+            if not merged_options.score_threshold or score >= merged_options.score_threshold:
+                if merged_options.override_score:
+                    element.score = score
+                results.append(element)
+        return results
+
+    async def _score_elements(
+        self,
+        elements: Sequence[Element],
+        query: str,
+        llm_options: LiteLLMOptions,
+    ) -> Sequence[float]:
+        """
+        Score the elements according to their relevance to the query using LLM.
+
+        Args:
+            elements: The elements to rerank.
+            query: The query to rerank the elements against.
+            llm_options: The LLM options to use for scoring.
+
+        Returns:
+            The elements scores.
+        """
+        scores = []
+        for element in elements:
+            if element.text_representation:
+                prompt = self._prompt(RerankerInput(query=query, document=element.text_representation))
+                response = await self._llm.generate_with_metadata(prompt=prompt, options=llm_options)
+                prob = math.exp(response.metadata["logprobs"][0]["logprob"])
+                score = prob if response.content == "Yes" else 1 - prob
+            else:
+                score = 0.0
+
+            scores.append(score)
+
+        return scores

ragbits/document_search/retrieval/rerankers/noop.py

@@ -0,0 +1,34 @@
+from collections.abc import Sequence
+from itertools import chain
+
+from ragbits.core.audit.traces import traceable
+from ragbits.document_search.documents.element import Element
+from ragbits.document_search.retrieval.rerankers.base import Reranker, RerankerOptions
+
+
+class NoopReranker(Reranker[RerankerOptions]):
+    """
+    A no-op reranker that does not change the order of the elements.
+    """
+
+    options_cls: type[RerankerOptions] = RerankerOptions
+
+    @traceable
+    async def rerank(  # noqa: PLR6301
+        self,
+        elements: Sequence[Sequence[Element]],
+        query: str,
+        options: RerankerOptions | None = None,
+    ) -> Sequence[Element]:
+        """
+        No reranking, returning the elements in the same order.
+
+        Args:
+            elements: The elements to rerank.
+            query: The query to rerank the elements against.
+            options: The options for reranking.
+
+        Returns:
+            The reranked elements.
+        """
+        return [*{element.id: element for element in chain.from_iterable(elements)}.values()]

ragbits/document_search/retrieval/rerankers/rrf.py

@@ -0,0 +1,73 @@
+from collections import defaultdict
+from collections.abc import Sequence
+
+from ragbits.core.audit.traces import traceable
+from ragbits.document_search.documents.element import Element
+from ragbits.document_search.retrieval.rerankers.base import Reranker, RerankerOptions
+
+
+class ReciprocalRankFusionReranker(Reranker[RerankerOptions]):
+    """
+    A reranker that implements the Reciprocal Rank Fusion (RRF) algorithm to
+    combine multiple ranked result sets into a single reranked list.
+
+    RRF is a method that assigns scores to documents based on their positions
+    in multiple ranked lists, allowing for fusion of diverse ranking sources
+    without the need for tuning.
+
+    The score for each document is calculated using the formula:
+
+        score = sum(1.0 / (k + rank(q, d)))
+
+    where:
+        - k is a ranking constant (1 is used here)
+        - q is a query in the set of queries
+        - d is a document in the result set
+        - rank(q, d) is the position of d in the ranking list for q (starting from 1)
+    """
+
+    options_cls: type[RerankerOptions] = RerankerOptions
+
+    @traceable
+    async def rerank(
+        self,
+        elements: Sequence[Sequence[Element]],
+        query: str,
+        options: RerankerOptions | None = None,
+    ) -> Sequence[Element]:
+        """
+        Reranks elements using the Reciprocal Rank Fusion (RRF) algorithm.
+
+        Args:
+            elements: A list of ranked lists of elements to be fused.
+            query: The query string for reranking.
+            options: The options for reranking.
+
+        Returns:
+            The reranked elements.
+        """
+        if len(elements) == 1:
+            return elements[0]
+
+        merged_options = (self.default_options | options) if options else self.default_options
+
+        scores: dict[str, float] = defaultdict(float)
+        elements_map: dict[str, Element] = {}
+
+        for query_elements in elements:
+            for rank, element in enumerate(query_elements):
+                if not element.key:
+                    continue
+                scores[element.key] += 1 / (rank + 1 + 1)
+                elements_map[element.key] = element
+
+        sorted_scores = sorted(scores.items(), key=lambda x: x[1], reverse=True)
+
+        results = []
+        for element_id, score in sorted_scores[: merged_options.top_n or None]:
+            if not merged_options.score_threshold or score >= merged_options.score_threshold:
+                if merged_options.override_score:
+                    elements_map[element_id].score = score
+                results.append(elements_map[element_id])
+
+        return results

ragbits_document_search-1.4.0.dev202601310254.dist-info/METADATA

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: ragbits-document-search
+Version: 1.4.0.dev202601310254
+Summary: Document Search module for Ragbits
+Project-URL: Homepage, https://github.com/deepsense-ai/ragbits
+Project-URL: Bug Reports, https://github.com/deepsense-ai/ragbits/issues
+Project-URL: Documentation, https://ragbits.deepsense.ai/
+Project-URL: Source, https://github.com/deepsense-ai/ragbits
+Author-email: "deepsense.ai" <ragbits@deepsense.ai>
+License-Expression: MIT
+Keywords: Document Search,GenAI,Generative AI,LLMs,Large Language Models,RAG,Retrieval Augmented Generation
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Requires-Dist: docling[easyocr]<3.0.0,>=2.15.1
+Requires-Dist: filetype<2.0.0,>=1.2.0
+Requires-Dist: opencv-python<5.0.0.0,>=4.11.0.86
+Requires-Dist: python-pptx<2.0.0,>=1.0.0
+Requires-Dist: ragbits-core==1.4.0.dev202601310254
+Requires-Dist: rerankers<1.0.0,>=0.6.1
+Provides-Extra: ray
+Requires-Dist: ray[data]<3.0.0,>=2.43.0; extra == 'ray'
+Provides-Extra: unstructured
+Requires-Dist: unstructured-client<1.0.0,>=0.26.0; extra == 'unstructured'
+Requires-Dist: unstructured<1.0.0,>=0.16.9; extra == 'unstructured'
+Description-Content-Type: text/markdown
+
+# Ragbits Document Search
+
+Ragbits Document Search is a Python package that provides tools for building RAG applications. It helps ingest, index, and search documents to retrieve relevant information for your prompts.
+
+## Installation
+
+You can install the latest version of Ragbits Document Search using pip:
+
+```bash
+pip install ragbits-document-search
+```
+
+## Quickstart
+```python
+import asyncio
+
+from ragbits.core.embeddings import LiteLLMEmbedder
+from ragbits.core.vector_stores.in_memory import InMemoryVectorStore
+from ragbits.document_search import DocumentSearch
+
+async def main() -> None:
+    """
+    Run the example.
+    """
+    embedder = LiteLLMEmbedder(
+        model_name="text-embedding-3-small",
+    )
+    vector_store = InMemoryVectorStore(embedder=embedder)
+    document_search = DocumentSearch(
+        vector_store=vector_store,
+    )
+
+    # Ingest all .txt files from the "biographies" directory
+    await document_search.ingest("local://biographies/*.txt")
+
+    # Search the documents for the query
+    results = await document_search.search("When was Marie Curie-Sklodowska born?")
+    print(results)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## Documentation
+* [Quickstart 2: Adding RAG Capabilities](https://ragbits.deepsense.ai/quickstart/quickstart2_rag/)
+* [How-To Guides - Document Search](https://ragbits.deepsense.ai/how-to/document_search/async_processing/)
+* [API Reference - Document Search](https://ragbits.deepsense.ai/api_reference/document_search/)

ragbits_document_search-1.4.0.dev202601310254.dist-info/RECORD

@@ -0,0 +1,46 @@
+ragbits/document_search/__init__.py,sha256=uYbt6kSsfKpL3IY07CCpiRhsG77oZkZjV1pEuwBX1n0,135
+ragbits/document_search/_main.py,sha256=25oeZQ9mWX2tewHi67Wh35wbW3F1LlFthay7HuyL2rI,12331
+ragbits/document_search/cli.py,sha256=GYcm-_tMgW96kBf8Oj88PodjXnWKaXV_OalloK1cU8s,3020
+ragbits/document_search/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ragbits/document_search/documents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ragbits/document_search/documents/document.py,sha256=yxi-07fduOeqM0ay9E_BbDm11nGfqtCxuM13cSAfd74,5158
+ragbits/document_search/documents/element.py,sha256=hQCMyGn4C6bfR7lh1vcKZepQpSySLpaA7Zz3D33GHjA,5898
+ragbits/document_search/ingestion/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ragbits/document_search/ingestion/enrichers/__init__.py,sha256=owoQ-Qw76Yow8cNNfzYtgpjzw3SySrLXvuZ4Wv0Iap0,325
+ragbits/document_search/ingestion/enrichers/base.py,sha256=_vPNgJeZvrV3A8HVAZjCi18MGtDtVMaat8rUN9Vq1Do,2307
+ragbits/document_search/ingestion/enrichers/exceptions.py,sha256=f3dFENXD8rBM6yDdxQWJM4-GzJf-RBrJqArKnTS6GwA,1007
+ragbits/document_search/ingestion/enrichers/image.py,sha256=81lC6gO-6xGrdArDsQ6doDVQgZcsHuqQrw3DQ7G4sXw,3512
+ragbits/document_search/ingestion/enrichers/router.py,sha256=pEFO3sRb3eY8DZhWEGOsPv0iSS0lGAkcXuk1VLtjwiI,2913
+ragbits/document_search/ingestion/parsers/__init__.py,sha256=WMkY-JEi_FxbegnhArrLQC2Dh4Mtn5O7Fu_fsVCEngQ,315
+ragbits/document_search/ingestion/parsers/base.py,sha256=b9zAlDnXi81_WkCJSUpsRl7hVRQkmpxcqBnmQ89GCUc,3174
+ragbits/document_search/ingestion/parsers/docling.py,sha256=nAIQEzoBEyYr9IAlovz6FIRDjUIlnkeKgckIvj2R8C8,6785
+ragbits/document_search/ingestion/parsers/exceptions.py,sha256=ymCw6XhBhtF2gqJ9n-QzLCjzuaaS__J_VKllgwyBFO4,1005
+ragbits/document_search/ingestion/parsers/router.py,sha256=C2dQT4s5I-CDuS6DE6chQyLyLXfhPoRDYlINRVM0ph8,3168
+ragbits/document_search/ingestion/parsers/unstructured.py,sha256=yfze3TQYPzMnV3SwhqUg04bTBURfhOZsK-zJ3JOxl1k,9453
+ragbits/document_search/ingestion/parsers/pptx/__init__.py,sha256=X9vfcWO8Ght3U2vOlNZFhE1_PYM0TZdSoTLS8pj98jo,627
+ragbits/document_search/ingestion/parsers/pptx/callbacks.py,sha256=G6-4fg11c_xCXcEmcnplEcxwJm6mRj3e_NxHz45nTKQ,799
+ragbits/document_search/ingestion/parsers/pptx/exceptions.py,sha256=fIdt9osO2p1QFq0yDPDNLLwhRLq9bW-wJg41lgUz7iY,1868
+ragbits/document_search/ingestion/parsers/pptx/hyperlink_callback.py,sha256=Peg5jYX8ePUS4yDsc1sD-xMHqtPnzGuQ517wtkASccg,3287
+ragbits/document_search/ingestion/parsers/pptx/metadata_callback.py,sha256=raxrMJTFd2S--V6eAosbrhbislAoVZx2LdM8EE-7gww,3038
+ragbits/document_search/ingestion/parsers/pptx/parser.py,sha256=h07vIPFpWLFcKiAY9IxIj-775xHs0QUDb1lTxNpO9u4,3243
+ragbits/document_search/ingestion/parsers/pptx/speaker_notes_callback.py,sha256=xKET2hq_OYnuYS4B8QIln1Pc2iVCr--psfahXtISdA4,2851
+ragbits/document_search/ingestion/strategies/__init__.py,sha256=R7Tx1HKrDE38NqxewCrbvsJ9BTWpvWrjv6RlKUQuJgQ,462
+ragbits/document_search/ingestion/strategies/base.py,sha256=DVrzSZXjiiDqX0ZEy9UO7m96zRu0zOgLpOraFGA6spo,10573
+ragbits/document_search/ingestion/strategies/batched.py,sha256=N1SA4Z5sVOB50CX5i7fpsHlsVX63hf4ApascL3LO4Og,10031
+ragbits/document_search/ingestion/strategies/ray.py,sha256=sNBGBuRDBTfuVSCJXiaPFXjvQkXLfPuD9kOBQnQi8-I,6018
+ragbits/document_search/ingestion/strategies/sequential.py,sha256=H81rULKg4A_di5bxkir4mslbrVWm1TxjdI7dSlaPYE0,880
+ragbits/document_search/retrieval/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ragbits/document_search/retrieval/rephrasers/__init__.py,sha256=RHW1TjSuXwEE6qkUXF2iVnbpcK0iJExOZqihHS_njIQ,578
+ragbits/document_search/retrieval/rephrasers/base.py,sha256=N5egUeRkhz5198LYLZk6zx9KVEvhrj5WjB-7m7etST4,1137
+ragbits/document_search/retrieval/rephrasers/llm.py,sha256=DLAXiFPNExdPGd4Yrg1FxEqVurN99L7qpgrUR_faTjw,5673
+ragbits/document_search/retrieval/rephrasers/noop.py,sha256=4aFtxWCpueVg-uOFc247v3zS_cEB6Bsex37hhSdyxpk,832
+ragbits/document_search/retrieval/rerankers/__init__.py,sha256=QFgBmjkHFjsVS89EpnUoUw36IpjXB45OcLUIcRjCZtE,220
+ragbits/document_search/retrieval/rerankers/answerai.py,sha256=3bx0ao19pXa3vcgptfCbLxmmQL4KimV8AxVtj8kaYqk,2987
+ragbits/document_search/retrieval/rerankers/base.py,sha256=oTHFI4hBNJvPL9s0flZYhwG5xZ9FIflThSuuy5JtgpA,1649
+ragbits/document_search/retrieval/rerankers/litellm.py,sha256=C5pum0YGrQPT3raUD7hYVmAOM5bNHa8MsgWZLoEKTp4,2898
+ragbits/document_search/retrieval/rerankers/llm.py,sha256=YcKu4OqPhChfL1BUygim0xBLtiHOOJqI4oNF6ilYtPc,5902
+ragbits/document_search/retrieval/rerankers/noop.py,sha256=9v381IrfLbNYHQaecTNkQHN6rLZx-WB5QqqA5XKrF20,1072
+ragbits/document_search/retrieval/rerankers/rrf.py,sha256=y281Rucv3fuyMNLjJrikqD5--wLu0KQcwbeI6WxmPao,2628
+ragbits_document_search-1.4.0.dev202601310254.dist-info/METADATA,sha256=joisMG3fGB6M4XETPZyxUeFH8Ts0hMjUg5VzWw85enc,3261
+ragbits_document_search-1.4.0.dev202601310254.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+ragbits_document_search-1.4.0.dev202601310254.dist-info/RECORD,,

ragbits_document_search-1.4.0.dev202601310254.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any