Add files using upload-large-folder tool

testbed/deepset-ai__haystack/haystack/components/generators/hugging_face_api.py

@@ -0,0 +1,243 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from dataclasses import asdict
+from typing import Any, Callable, Dict, Iterable, List, Optional, Union
+
+from haystack import component, default_from_dict, default_to_dict, logging
+from haystack.dataclasses import StreamingChunk
+from haystack.lazy_imports import LazyImport
+from haystack.utils import Secret, deserialize_callable, deserialize_secrets_inplace, serialize_callable
+from haystack.utils.hf import HFGenerationAPIType, HFModelType, check_valid_model
+from haystack.utils.url_validation import is_valid_http_url
+
+with LazyImport(message="Run 'pip install \"huggingface_hub>=0.23.0\"'") as huggingface_hub_import:
+    from huggingface_hub import (
+        InferenceClient,
+        TextGenerationOutput,
+        TextGenerationOutputToken,
+        TextGenerationStreamOutput,
+    )
+
+
+logger = logging.getLogger(__name__)
+
+
+@component
+class HuggingFaceAPIGenerator:
+    """
+    Generates text using Hugging Face APIs.
+
+    Use it with the following Hugging Face APIs:
+    - [Free Serverless Inference API]((https://huggingface.co/inference-api)
+    - [Paid Inference Endpoints](https://huggingface.co/inference-endpoints)
+    - [Self-hosted Text Generation Inference](https://github.com/huggingface/text-generation-inference)
+
+    ### Usage examples
+
+    #### With the free serverless inference API
+
+    ```python
+    from haystack.components.generators import HuggingFaceAPIGenerator
+    from haystack.utils import Secret
+
+    generator = HuggingFaceAPIGenerator(api_type="serverless_inference_api",
+                                        api_params={"model": "HuggingFaceH4/zephyr-7b-beta"},
+                                        token=Secret.from_token("<your-api-key>"))
+
+    result = generator.run(prompt="What's Natural Language Processing?")
+    print(result)
+    ```
+
+    #### With paid inference endpoints
+
+    ```python
+    from haystack.components.generators import HuggingFaceAPIGenerator
+    from haystack.utils import Secret
+
+    generator = HuggingFaceAPIGenerator(api_type="inference_endpoints",
+                                        api_params={"url": "<your-inference-endpoint-url>"},
+                                        token=Secret.from_token("<your-api-key>"))
+
+    result = generator.run(prompt="What's Natural Language Processing?")
+    print(result)
+
+    #### With self-hosted text generation inference
+    ```python
+    from haystack.components.generators import HuggingFaceAPIGenerator
+
+    generator = HuggingFaceAPIGenerator(api_type="text_generation_inference",
+                                        api_params={"url": "http://localhost:8080"})
+
+    result = generator.run(prompt="What's Natural Language Processing?")
+    print(result)
+    ```
+    """
+
+    def __init__(  # pylint: disable=too-many-positional-arguments
+        self,
+        api_type: Union[HFGenerationAPIType, str],
+        api_params: Dict[str, str],
+        token: Optional[Secret] = Secret.from_env_var(["HF_API_TOKEN", "HF_TOKEN"], strict=False),
+        generation_kwargs: Optional[Dict[str, Any]] = None,
+        stop_words: Optional[List[str]] = None,
+        streaming_callback: Optional[Callable[[StreamingChunk], None]] = None,
+    ):
+        """
+        Initialize the HuggingFaceAPIGenerator instance.
+
+        :param api_type:
+            The type of Hugging Face API to use. Available types:
+            - `text_generation_inference`: See [TGI](https://github.com/huggingface/text-generation-inference).
+            - `inference_endpoints`: See [Inference Endpoints](https://huggingface.co/inference-endpoints).
+            - `serverless_inference_api`: See [Serverless Inference API](https://huggingface.co/inference-api).
+        :param api_params:
+            A dictionary with the following keys:
+            - `model`: Hugging Face model ID. Required when `api_type` is `SERVERLESS_INFERENCE_API`.
+            - `url`: URL of the inference endpoint. Required when `api_type` is `INFERENCE_ENDPOINTS` or
+            `TEXT_GENERATION_INFERENCE`.
+        :param token: The Hugging Face token to use as HTTP bearer authorization.
+            Check your HF token in your [account settings](https://huggingface.co/settings/tokens).
+        :param generation_kwargs:
+            A dictionary with keyword arguments to customize text generation. Some examples: `max_new_tokens`,
+            `temperature`, `top_k`, `top_p`.
+            For details, see [Hugging Face documentation](https://huggingface.co/docs/huggingface_hub/en/package_reference/inference_client#huggingface_hub.InferenceClient.text_generation)
+            for more information.
+        :param stop_words: An optional list of strings representing the stop words.
+        :param streaming_callback: An optional callable for handling streaming responses.
+        """
+
+        huggingface_hub_import.check()
+
+        if isinstance(api_type, str):
+            api_type = HFGenerationAPIType.from_str(api_type)
+
+        if api_type == HFGenerationAPIType.SERVERLESS_INFERENCE_API:
+            model = api_params.get("model")
+            if model is None:
+                raise ValueError(
+                    "To use the Serverless Inference API, you need to specify the `model` parameter in `api_params`."
+                )
+            check_valid_model(model, HFModelType.GENERATION, token)
+            model_or_url = model
+        elif api_type in [HFGenerationAPIType.INFERENCE_ENDPOINTS, HFGenerationAPIType.TEXT_GENERATION_INFERENCE]:
+            url = api_params.get("url")
+            if url is None:
+                msg = (
+                    "To use Text Generation Inference or Inference Endpoints, you need to specify the `url` "
+                    "parameter in `api_params`."
+                )
+                raise ValueError(msg)
+            if not is_valid_http_url(url):
+                raise ValueError(f"Invalid URL: {url}")
+            model_or_url = url
+        else:
+            msg = f"Unknown api_type {api_type}"
+            raise ValueError(msg)
+
+        # handle generation kwargs setup
+        generation_kwargs = generation_kwargs.copy() if generation_kwargs else {}
+        generation_kwargs["stop_sequences"] = generation_kwargs.get("stop_sequences", [])
+        generation_kwargs["stop_sequences"].extend(stop_words or [])
+        generation_kwargs.setdefault("max_new_tokens", 512)
+
+        self.api_type = api_type
+        self.api_params = api_params
+        self.token = token
+        self.generation_kwargs = generation_kwargs
+        self.streaming_callback = streaming_callback
+        self._client = InferenceClient(model_or_url, token=token.resolve_value() if token else None)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Serialize this component to a dictionary.
+
+        :returns:
+            A dictionary containing the serialized component.
+        """
+        callback_name = serialize_callable(self.streaming_callback) if self.streaming_callback else None
+        return default_to_dict(
+            self,
+            api_type=str(self.api_type),
+            api_params=self.api_params,
+            token=self.token.to_dict() if self.token else None,
+            generation_kwargs=self.generation_kwargs,
+            streaming_callback=callback_name,
+        )
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "HuggingFaceAPIGenerator":
+        """
+        Deserialize this component from a dictionary.
+        """
+        deserialize_secrets_inplace(data["init_parameters"], keys=["token"])
+        init_params = data["init_parameters"]
+        serialized_callback_handler = init_params.get("streaming_callback")
+        if serialized_callback_handler:
+            init_params["streaming_callback"] = deserialize_callable(serialized_callback_handler)
+        return default_from_dict(cls, data)
+
+    @component.output_types(replies=List[str], meta=List[Dict[str, Any]])
+    def run(
+        self,
+        prompt: str,
+        streaming_callback: Optional[Callable[[StreamingChunk], None]] = None,
+        generation_kwargs: Optional[Dict[str, Any]] = None,
+    ):
+        """
+        Invoke the text generation inference for the given prompt and generation parameters.
+
+        :param prompt:
+            A string representing the prompt.
+        :param streaming_callback:
+            A callback function that is called when a new token is received from the stream.
+        :param generation_kwargs:
+            Additional keyword arguments for text generation.
+        :returns:
+            A dictionary with the generated replies and metadata. Both are lists of length n.
+            - replies: A list of strings representing the generated replies.
+        """
+        # update generation kwargs by merging with the default ones
+        generation_kwargs = {**self.generation_kwargs, **(generation_kwargs or {})}
+
+        # check if streaming_callback is passed
+        streaming_callback = streaming_callback or self.streaming_callback
+
+        hf_output = self._client.text_generation(
+            prompt, details=True, stream=streaming_callback is not None, **generation_kwargs
+        )
+
+        if streaming_callback is not None:
+            return self._stream_and_build_response(hf_output, streaming_callback)
+
+        return self._build_non_streaming_response(hf_output)
+
+    def _stream_and_build_response(
+        self, hf_output: Iterable["TextGenerationStreamOutput"], streaming_callback: Callable[[StreamingChunk], None]
+    ):
+        chunks: List[StreamingChunk] = []
+        for chunk in hf_output:
+            token: TextGenerationOutputToken = chunk.token
+            if token.special:
+                continue
+            chunk_metadata = {**asdict(token), **(asdict(chunk.details) if chunk.details else {})}
+            stream_chunk = StreamingChunk(token.text, chunk_metadata)
+            chunks.append(stream_chunk)
+            streaming_callback(stream_chunk)
+        metadata = {
+            "finish_reason": chunks[-1].meta.get("finish_reason", None),
+            "model": self._client.model,
+            "usage": {"completion_tokens": chunks[-1].meta.get("generated_tokens", 0)},
+        }
+        return {"replies": ["".join([chunk.content for chunk in chunks])], "meta": [metadata]}
+
+    def _build_non_streaming_response(self, hf_output: "TextGenerationOutput"):
+        meta = [
+            {
+                "model": self._client.model,
+                "finish_reason": hf_output.details.finish_reason if hf_output.details else None,
+                "usage": {"completion_tokens": len(hf_output.details.tokens) if hf_output.details else 0},
+            }
+        ]
+        return {"replies": [hf_output.generated_text], "meta": meta}

testbed/deepset-ai__haystack/haystack/components/generators/utils.py

@@ -0,0 +1,14 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from haystack.dataclasses import StreamingChunk
+
+
+def print_streaming_chunk(chunk: StreamingChunk) -> None:
+    """
+    Default callback function for streaming responses.
+
+    Prints the tokens of the first completion to stdout as soon as they are received
+    """
+    print(chunk.content, flush=True, end="")

testbed/deepset-ai__haystack/haystack/components/joiners/__init__.py

@@ -0,0 +1,10 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from .answer_joiner import AnswerJoiner
+from .branch import BranchJoiner
+from .document_joiner import DocumentJoiner
+from .string_joiner import StringJoiner
+
+__all__ = ["DocumentJoiner", "BranchJoiner", "AnswerJoiner", "StringJoiner"]

testbed/deepset-ai__haystack/haystack/components/preprocessors/document_splitter.py

@@ -0,0 +1,281 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from copy import deepcopy
+from typing import Any, Callable, Dict, List, Literal, Optional, Tuple
+
+from more_itertools import windowed
+
+from haystack import Document, component, logging
+from haystack.core.serialization import default_from_dict, default_to_dict
+from haystack.utils import deserialize_callable, serialize_callable
+
+logger = logging.getLogger(__name__)
+
+
+@component
+class DocumentSplitter:
+    """
+    Splits long documents into smaller chunks.
+
+    This is a common preprocessing step during indexing.
+    It helps Embedders create meaningful semantic representations
+    and prevents exceeding language model context limits.
+
+    The DocumentSplitter is compatible with the following DocumentStores:
+    - [Astra](https://docs.haystack.deepset.ai/docs/astradocumentstore)
+    - [Chroma](https://docs.haystack.deepset.ai/docs/chromadocumentstore) limited support, overlapping information is
+      not stored
+    - [Elasticsearch](https://docs.haystack.deepset.ai/docs/elasticsearch-document-store)
+    - [OpenSearch](https://docs.haystack.deepset.ai/docs/opensearch-document-store)
+    - [Pgvector](https://docs.haystack.deepset.ai/docs/pgvectordocumentstore)
+    - [Pinecone](https://docs.haystack.deepset.ai/docs/pinecone-document-store) limited support, overlapping
+       information is not stored
+    - [Qdrant](https://docs.haystack.deepset.ai/docs/qdrant-document-store)
+    - [Weaviate](https://docs.haystack.deepset.ai/docs/weaviatedocumentstore)
+
+    ### Usage example
+
+    ```python
+    from haystack import Document
+    from haystack.components.preprocessors import DocumentSplitter
+
+    doc = Document(content="Moonlight shimmered softly, wolves howled nearby, night enveloped everything.")
+
+    splitter = DocumentSplitter(split_by="word", split_length=3, split_overlap=0)
+    result = splitter.run(documents=[doc])
+    ```
+    """
+
+    def __init__(  # pylint: disable=too-many-positional-arguments
+        self,
+        split_by: Literal["function", "page", "passage", "sentence", "word"] = "word",
+        split_length: int = 200,
+        split_overlap: int = 0,
+        split_threshold: int = 0,
+        splitting_function: Optional[Callable[[str], List[str]]] = None,
+    ):
+        """
+        Initialize DocumentSplitter.
+
+        :param split_by: The unit for splitting your documents. Choose from `word` for splitting by spaces (" "),
+            `sentence` for splitting by periods ("."), `page` for splitting by form feed ("\\f"),
+            or `passage` for splitting by double line breaks ("\\n\\n").
+        :param split_length: The maximum number of units in each split.
+        :param split_overlap: The number of overlapping units for each split.
+        :param split_threshold: The minimum number of units per split. If a split has fewer units
+            than the threshold, it's attached to the previous split.
+        :param splitting_function: Necessary when `split_by` is set to "function".
+            This is a function which must accept a single `str` as input and return a `list` of `str` as output,
+            representing the chunks after splitting.
+        """
+
+        self.split_by = split_by
+        if split_by not in ["function", "page", "passage", "sentence", "word"]:
+            raise ValueError("split_by must be one of 'word', 'sentence', 'page' or 'passage'.")
+        if split_by == "function" and splitting_function is None:
+            raise ValueError("When 'split_by' is set to 'function', a valid 'splitting_function' must be provided.")
+        if split_length <= 0:
+            raise ValueError("split_length must be greater than 0.")
+        self.split_length = split_length
+        if split_overlap < 0:
+            raise ValueError("split_overlap must be greater than or equal to 0.")
+        self.split_overlap = split_overlap
+        self.split_threshold = split_threshold
+        self.splitting_function = splitting_function
+
+    @component.output_types(documents=List[Document])
+    def run(self, documents: List[Document]):
+        """
+        Split documents into smaller parts.
+
+        Splits documents by the unit expressed in `split_by`, with a length of `split_length`
+        and an overlap of `split_overlap`.
+
+        :param documents: The documents to split.
+
+        :returns: A dictionary with the following key:
+            - `documents`: List of documents with the split texts. Each document includes:
+                - A metadata field `source_id` to track the original document.
+                - A metadata field `page_number` to track the original page number.
+                - All other metadata copied from the original document.
+
+        :raises TypeError: if the input is not a list of Documents.
+        :raises ValueError: if the content of a document is None.
+        """
+
+        if not isinstance(documents, list) or (documents and not isinstance(documents[0], Document)):
+            raise TypeError("DocumentSplitter expects a List of Documents as input.")
+
+        split_docs = []
+        for doc in documents:
+            if doc.content is None:
+                raise ValueError(
+                    f"DocumentSplitter only works with text documents but content for document ID {doc.id} is None."
+                )
+            if doc.content == "":
+                logger.warning("Document ID {doc_id} has an empty content. Skipping this document.", doc_id=doc.id)
+                continue
+            units = self._split_into_units(doc.content, self.split_by)
+            text_splits, splits_pages, splits_start_idxs = self._concatenate_units(
+                units, self.split_length, self.split_overlap, self.split_threshold
+            )
+            metadata = deepcopy(doc.meta)
+            metadata["source_id"] = doc.id
+            split_docs += self._create_docs_from_splits(
+                text_splits=text_splits, splits_pages=splits_pages, splits_start_idxs=splits_start_idxs, meta=metadata
+            )
+        return {"documents": split_docs}
+
+    def _split_into_units(
+        self, text: str, split_by: Literal["function", "page", "passage", "sentence", "word"]
+    ) -> List[str]:
+        if split_by == "page":
+            self.split_at = "\f"
+        elif split_by == "passage":
+            self.split_at = "\n\n"
+        elif split_by == "sentence":
+            self.split_at = "."
+        elif split_by == "word":
+            self.split_at = " "
+        elif split_by == "function" and self.splitting_function is not None:
+            return self.splitting_function(text)
+        else:
+            raise NotImplementedError(
+                "DocumentSplitter only supports 'function', 'page', 'passage', 'sentence' or 'word' split_by options."
+            )
+        units = text.split(self.split_at)
+        # Add the delimiter back to all units except the last one
+        for i in range(len(units) - 1):
+            units[i] += self.split_at
+        return units
+
+    def _concatenate_units(
+        self, elements: List[str], split_length: int, split_overlap: int, split_threshold: int
+    ) -> Tuple[List[str], List[int], List[int]]:
+        """
+        Concatenates the elements into parts of split_length units.
+
+        Keeps track of the original page number that each element belongs. If the length of the current units is less
+        than the pre-defined `split_threshold`, it does not create a new split. Instead, it concatenates the current
+        units with the last split, preventing the creation of excessively small splits.
+        """
+
+        text_splits: List[str] = []
+        splits_pages = []
+        splits_start_idxs = []
+        cur_start_idx = 0
+        cur_page = 1
+        segments = windowed(elements, n=split_length, step=split_length - split_overlap)
+
+        for seg in segments:
+            current_units = [unit for unit in seg if unit is not None]
+            txt = "".join(current_units)
+
+            # check if length of current units is below split_threshold
+            if len(current_units) < split_threshold and len(text_splits) > 0:
+                # concatenate the last split with the current one
+                text_splits[-1] += txt
+
+            # NOTE: This line skips documents that have content=""
+            elif len(txt) > 0:
+                text_splits.append(txt)
+                splits_pages.append(cur_page)
+                splits_start_idxs.append(cur_start_idx)
+
+            processed_units = current_units[: split_length - split_overlap]
+            cur_start_idx += len("".join(processed_units))
+
+            if self.split_by == "page":
+                num_page_breaks = len(processed_units)
+            else:
+                num_page_breaks = sum(processed_unit.count("\f") for processed_unit in processed_units)
+
+            cur_page += num_page_breaks
+
+        return text_splits, splits_pages, splits_start_idxs
+
+    def _create_docs_from_splits(
+        self, text_splits: List[str], splits_pages: List[int], splits_start_idxs: List[int], meta: Dict
+    ) -> List[Document]:
+        """
+        Creates Document objects from splits enriching them with page number and the metadata of the original document.
+        """
+        documents: List[Document] = []
+
+        for i, (txt, split_idx) in enumerate(zip(text_splits, splits_start_idxs)):
+            meta = deepcopy(meta)
+            doc = Document(content=txt, meta=meta)
+            doc.meta["page_number"] = splits_pages[i]
+            doc.meta["split_id"] = i
+            doc.meta["split_idx_start"] = split_idx
+            documents.append(doc)
+
+            if self.split_overlap <= 0:
+                continue
+
+            doc.meta["_split_overlap"] = []
+
+            if i == 0:
+                continue
+
+            doc_start_idx = splits_start_idxs[i]
+            previous_doc = documents[i - 1]
+            previous_doc_start_idx = splits_start_idxs[i - 1]
+            self._add_split_overlap_information(doc, doc_start_idx, previous_doc, previous_doc_start_idx)
+
+        return documents
+
+    @staticmethod
+    def _add_split_overlap_information(
+        current_doc: Document, current_doc_start_idx: int, previous_doc: Document, previous_doc_start_idx: int
+    ):
+        """
+        Adds split overlap information to the current and previous Document's meta.
+
+        :param current_doc: The Document that is being split.
+        :param current_doc_start_idx: The starting index of the current Document.
+        :param previous_doc: The Document that was split before the current Document.
+        :param previous_doc_start_idx: The starting index of the previous Document.
+        """
+        overlapping_range = (current_doc_start_idx - previous_doc_start_idx, len(previous_doc.content))  # type: ignore
+
+        if overlapping_range[0] < overlapping_range[1]:
+            overlapping_str = previous_doc.content[overlapping_range[0] : overlapping_range[1]]  # type: ignore
+
+            if current_doc.content.startswith(overlapping_str):  # type: ignore
+                # add split overlap information to this Document regarding the previous Document
+                current_doc.meta["_split_overlap"].append({"doc_id": previous_doc.id, "range": overlapping_range})
+
+                # add split overlap information to previous Document regarding this Document
+                overlapping_range = (0, overlapping_range[1] - overlapping_range[0])
+                previous_doc.meta["_split_overlap"].append({"doc_id": current_doc.id, "range": overlapping_range})
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Serializes the component to a dictionary.
+        """
+        serialized = default_to_dict(
+            self,
+            split_by=self.split_by,
+            split_length=self.split_length,
+            split_overlap=self.split_overlap,
+            split_threshold=self.split_threshold,
+        )
+        if self.splitting_function:
+            serialized["init_parameters"]["splitting_function"] = serialize_callable(self.splitting_function)
+        return serialized
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "DocumentSplitter":
+        """
+        Deserializes the component from a dictionary.
+        """
+        init_params = data.get("init_parameters", {})
+
+        splitting_function = init_params.get("splitting_function", None)
+        if splitting_function:
+            init_params["splitting_function"] = deserialize_callable(splitting_function)
+
+        return default_from_dict(cls, data)

testbed/deepset-ai__haystack/haystack/components/rankers/__init__.py

@@ -0,0 +1,15 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from haystack.components.rankers.lost_in_the_middle import LostInTheMiddleRanker
+from haystack.components.rankers.meta_field import MetaFieldRanker
+from haystack.components.rankers.sentence_transformers_diversity import SentenceTransformersDiversityRanker
+from haystack.components.rankers.transformers_similarity import TransformersSimilarityRanker
+
+__all__ = [
+    "LostInTheMiddleRanker",
+    "MetaFieldRanker",
+    "SentenceTransformersDiversityRanker",
+    "TransformersSimilarityRanker",
+]

testbed/deepset-ai__haystack/haystack/components/rankers/meta_field.py

@@ -0,0 +1,423 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from collections import defaultdict
+from typing import Any, Callable, Dict, List, Literal, Optional
+
+from dateutil.parser import parse as date_parse
+
+from haystack import Document, component, logging
+
+logger = logging.getLogger(__name__)
+
+
+@component
+class MetaFieldRanker:
+    """
+    Ranks Documents based on the value of their specific meta field.
+
+    The ranking can be performed in descending order or ascending order.
+
+    Usage example:
+
+    ```python
+    from haystack import Document
+    from haystack.components.rankers import MetaFieldRanker
+
+    ranker = MetaFieldRanker(meta_field="rating")
+    docs = [
+        Document(content="Paris", meta={"rating": 1.3}),
+        Document(content="Berlin", meta={"rating": 0.7}),
+        Document(content="Barcelona", meta={"rating": 2.1}),
+    ]
+
+    output = ranker.run(documents=docs)
+    docs = output["documents"]
+    assert docs[0].content == "Barcelona"
+    ```
+    """
+
+    def __init__(
+        self,
+        meta_field: str,
+        weight: float = 1.0,
+        top_k: Optional[int] = None,
+        ranking_mode: Literal["reciprocal_rank_fusion", "linear_score"] = "reciprocal_rank_fusion",
+        sort_order: Literal["ascending", "descending"] = "descending",
+        missing_meta: Literal["drop", "top", "bottom"] = "bottom",
+        meta_value_type: Optional[Literal["float", "int", "date"]] = None,
+    ):
+        """
+        Creates an instance of MetaFieldRanker.
+
+        :param meta_field:
+            The name of the meta field to rank by.
+        :param weight:
+            In range [0,1].
+            0 disables ranking by a meta field.
+            0.5 ranking from previous component and based on meta field have the same weight.
+            1 ranking by a meta field only.
+        :param top_k:
+            The maximum number of Documents to return per query.
+            If not provided, the Ranker returns all documents it receives in the new ranking order.
+        :param ranking_mode:
+            The mode used to combine the Retriever's and Ranker's scores.
+            Possible values are 'reciprocal_rank_fusion' (default) and 'linear_score'.
+            Use the 'linear_score' mode only with Retrievers or Rankers that return a score in range [0,1].
+        :param sort_order:
+            Whether to sort the meta field by ascending or descending order.
+            Possible values are `descending` (default) and `ascending`.
+        :param missing_meta:
+            What to do with documents that are missing the sorting metadata field.
+            Possible values are:
+                - 'drop' will drop the documents entirely.
+                - 'top' will place the documents at the top of the metadata-sorted list
+                    (regardless of 'ascending' or 'descending').
+                - 'bottom' will place the documents at the bottom of metadata-sorted list
+                    (regardless of 'ascending' or 'descending').
+        :param meta_value_type:
+            Parse the meta value into the data type specified before sorting.
+            This will only work if all meta values stored under `meta_field` in the provided documents are strings.
+            For example, if we specified `meta_value_type="date"` then for the meta value `"date": "2015-02-01"`
+            we would parse the string into a datetime object and then sort the documents by date.
+            The available options are:
+            - 'float' will parse the meta values into floats.
+            - 'int' will parse the meta values into integers.
+            - 'date' will parse the meta values into datetime objects.
+            - 'None' (default) will do no parsing.
+        """
+
+        self.meta_field = meta_field
+        self.weight = weight
+        self.top_k = top_k
+        self.ranking_mode = ranking_mode
+        self.sort_order = sort_order
+        self.missing_meta = missing_meta
+        self._validate_params(
+            weight=self.weight,
+            top_k=self.top_k,
+            ranking_mode=self.ranking_mode,
+            sort_order=self.sort_order,
+            missing_meta=self.missing_meta,
+            meta_value_type=meta_value_type,
+        )
+        self.meta_value_type = meta_value_type
+
+    def _validate_params(
+        self,
+        weight: float,
+        top_k: Optional[int],
+        ranking_mode: Literal["reciprocal_rank_fusion", "linear_score"],
+        sort_order: Literal["ascending", "descending"],
+        missing_meta: Literal["drop", "top", "bottom"],
+        meta_value_type: Optional[Literal["float", "int", "date"]],
+    ):
+        if top_k is not None and top_k <= 0:
+            raise ValueError("top_k must be > 0, but got %s" % top_k)
+
+        if weight < 0 or weight > 1:
+            raise ValueError(
+                "Parameter <weight> must be in range [0,1] but is currently set to '%s'.\n'0' disables sorting by a "
+                "meta field, '0.5' assigns equal weight to the previous relevance scores and the meta field, and "
+                "'1' ranks by the meta field only.\nChange the <weight> parameter to a value in range 0 to 1 when "
+                "initializing the MetaFieldRanker." % weight
+            )
+
+        if ranking_mode not in ["reciprocal_rank_fusion", "linear_score"]:
+            raise ValueError(
+                "The value of parameter <ranking_mode> must be 'reciprocal_rank_fusion' or 'linear_score', but is "
+                "currently set to '%s'.\nChange the <ranking_mode> value to 'reciprocal_rank_fusion' or "
+                "'linear_score' when initializing the MetaFieldRanker." % ranking_mode
+            )
+
+        if sort_order not in ["ascending", "descending"]:
+            raise ValueError(
+                "The value of parameter <sort_order> must be 'ascending' or 'descending', "
+                "but is currently set to '%s'.\n"
+                "Change the <sort_order> value to 'ascending' or 'descending' when initializing the "
+                "MetaFieldRanker." % sort_order
+            )
+
+        if missing_meta not in ["drop", "top", "bottom"]:
+            raise ValueError(
+                "The value of parameter <missing_meta> must be 'drop', 'top', or 'bottom', "
+                "but is currently set to '%s'.\n"
+                "Change the <missing_meta> value to 'drop', 'top', or 'bottom' when initializing the "
+                "MetaFieldRanker." % missing_meta
+            )
+
+        if meta_value_type not in ["float", "int", "date", None]:
+            raise ValueError(
+                "The value of parameter <meta_value_type> must be 'float', 'int', 'date' or None but is "
+                "currently set to '%s'.\n"
+                "Change the <meta_value_type> value to 'float', 'int', 'date' or None when initializing the "
+                "MetaFieldRanker." % meta_value_type
+            )
+
+    @component.output_types(documents=List[Document])
+    def run(
+        self,
+        documents: List[Document],
+        top_k: Optional[int] = None,
+        weight: Optional[float] = None,
+        ranking_mode: Optional[Literal["reciprocal_rank_fusion", "linear_score"]] = None,
+        sort_order: Optional[Literal["ascending", "descending"]] = None,
+        missing_meta: Optional[Literal["drop", "top", "bottom"]] = None,
+        meta_value_type: Optional[Literal["float", "int", "date"]] = None,
+    ):
+        """
+        Ranks a list of Documents based on the selected meta field by:
+
+        1. Sorting the Documents by the meta field in descending or ascending order.
+        2. Merging the rankings from the previous component and based on the meta field according to ranking mode and
+        weight.
+        3. Returning the top-k documents.
+
+        :param documents:
+            Documents to be ranked.
+        :param top_k:
+            The maximum number of Documents to return per query.
+            If not provided, the top_k provided at initialization time is used.
+        :param weight:
+            In range [0,1].
+            0 disables ranking by a meta field.
+            0.5 ranking from previous component and based on meta field have the same weight.
+            1 ranking by a meta field only.
+            If not provided, the weight provided at initialization time is used.
+        :param ranking_mode:
+            (optional) The mode used to combine the Retriever's and Ranker's scores.
+            Possible values are 'reciprocal_rank_fusion' (default) and 'linear_score'.
+            Use the 'score' mode only with Retrievers or Rankers that return a score in range [0,1].
+            If not provided, the ranking_mode provided at initialization time is used.
+        :param sort_order:
+            Whether to sort the meta field by ascending or descending order.
+            Possible values are `descending` (default) and `ascending`.
+            If not provided, the sort_order provided at initialization time is used.
+        :param missing_meta:
+            What to do with documents that are missing the sorting metadata field.
+            Possible values are:
+            - 'drop' will drop the documents entirely.
+            - 'top' will place the documents at the top of the metadata-sorted list
+                (regardless of 'ascending' or 'descending').
+            - 'bottom' will place the documents at the bottom of metadata-sorted list
+                (regardless of 'ascending' or 'descending').
+            If not provided, the missing_meta provided at initialization time is used.
+        :param meta_value_type:
+            Parse the meta value into the data type specified before sorting.
+            This will only work if all meta values stored under `meta_field` in the provided documents are strings.
+            For example, if we specified `meta_value_type="date"` then for the meta value `"date": "2015-02-01"`
+            we would parse the string into a datetime object and then sort the documents by date.
+            The available options are:
+            -'float' will parse the meta values into floats.
+            -'int' will parse the meta values into integers.
+            -'date' will parse the meta values into datetime objects.
+            -'None' (default) will do no parsing.
+        :returns:
+            A dictionary with the following keys:
+            - `documents`: List of Documents sorted by the specified meta field.
+
+        :raises ValueError:
+            If `top_k` is not > 0.
+            If `weight` is not in range [0,1].
+            If `ranking_mode` is not 'reciprocal_rank_fusion' or 'linear_score'.
+            If `sort_order` is not 'ascending' or 'descending'.
+            If `meta_value_type` is not 'float', 'int', 'date' or `None`.
+        """
+        if not documents:
+            return {"documents": []}
+
+        top_k = top_k or self.top_k
+        weight = weight if weight is not None else self.weight
+        ranking_mode = ranking_mode or self.ranking_mode
+        sort_order = sort_order or self.sort_order
+        missing_meta = missing_meta or self.missing_meta
+        meta_value_type = meta_value_type or self.meta_value_type
+        self._validate_params(
+            weight=weight,
+            top_k=top_k,
+            ranking_mode=ranking_mode,
+            sort_order=sort_order,
+            missing_meta=missing_meta,
+            meta_value_type=meta_value_type,
+        )
+
+        # If the weight is 0 then ranking by meta field is disabled and the original documents should be returned
+        if weight == 0:
+            return {"documents": documents[:top_k]}
+
+        docs_with_meta_field = [doc for doc in documents if self.meta_field in doc.meta]
+        docs_missing_meta_field = [doc for doc in documents if self.meta_field not in doc.meta]
+
+        # If all docs are missing self.meta_field return original documents
+        if len(docs_with_meta_field) == 0:
+            logger.warning(
+                "The parameter <meta_field> is currently set to '{meta_field}', but none of the provided "
+                "Documents with IDs {document_ids} have this meta key.\n"
+                "Set <meta_field> to the name of a field that is present within the provided Documents.\n"
+                "Returning the <top_k> of the original Documents since there are no values to rank.",
+                meta_field=self.meta_field,
+                document_ids=",".join([doc.id for doc in documents]),
+            )
+            return {"documents": documents[:top_k]}
+
+        if len(docs_missing_meta_field) > 0:
+            warning_start = (
+                f"The parameter <meta_field> is currently set to '{self.meta_field}' but the Documents "
+                f"with IDs {','.join([doc.id for doc in docs_missing_meta_field])} don't have this meta key.\n"
+            )
+
+            if missing_meta == "bottom":
+                logger.warning(
+                    "{warning_start}Because the parameter <missing_meta> is set to 'bottom', these Documents will be "
+                    "placed at the end of the sorting order.",
+                    warning_start=warning_start,
+                )
+            elif missing_meta == "top":
+                logger.warning(
+                    "{warning_start}Because the parameter <missing_meta> is set to 'top', these Documents will be "
+                    "placed at the top of the sorting order.",
+                    warning_start=warning_start,
+                )
+            else:
+                logger.warning(
+                    "{warning_start}Because the parameter <missing_meta> is set to 'drop', these Documents will be "
+                    "removed from the list of retrieved Documents.",
+                    warning_start=warning_start,
+                )
+
+        # If meta_value_type is provided try to parse the meta values
+        parsed_meta = self._parse_meta(docs_with_meta_field=docs_with_meta_field, meta_value_type=meta_value_type)
+        tuple_parsed_meta_and_docs = list(zip(parsed_meta, docs_with_meta_field))
+
+        # Sort the documents by self.meta_field
+        reverse = sort_order == "descending"
+        try:
+            tuple_sorted_by_meta = sorted(tuple_parsed_meta_and_docs, key=lambda x: x[0], reverse=reverse)
+        except TypeError as error:
+            # Return original documents if mixed types that are not comparable are returned (e.g. int and list)
+            logger.warning(
+                "Tried to sort Documents with IDs {document_ids}, but got TypeError with the message: {error}\n"
+                "Returning the <top_k> of the original Documents since meta field ranking is not possible.",
+                document_ids=",".join([doc.id for doc in docs_with_meta_field]),
+                error=error,
+            )
+            return {"documents": documents[:top_k]}
+
+        # Merge rankings and handle missing meta fields as specified in the missing_meta parameter
+        sorted_by_meta = [doc for meta, doc in tuple_sorted_by_meta]
+        if missing_meta == "bottom":
+            sorted_documents = sorted_by_meta + docs_missing_meta_field
+            sorted_documents = self._merge_rankings(documents, sorted_documents, weight, ranking_mode)
+        elif missing_meta == "top":
+            sorted_documents = docs_missing_meta_field + sorted_by_meta
+            sorted_documents = self._merge_rankings(documents, sorted_documents, weight, ranking_mode)
+        else:
+            sorted_documents = sorted_by_meta
+            sorted_documents = self._merge_rankings(docs_with_meta_field, sorted_documents, weight, ranking_mode)
+
+        return {"documents": sorted_documents[:top_k]}
+
+    def _parse_meta(
+        self, docs_with_meta_field: List[Document], meta_value_type: Optional[Literal["float", "int", "date"]]
+    ) -> List[Any]:
+        """
+        Parse the meta values stored under `self.meta_field` for the Documents provided in `docs_with_meta_field`.
+        """
+        if meta_value_type is None:
+            return [d.meta[self.meta_field] for d in docs_with_meta_field]
+
+        unique_meta_values = {doc.meta[self.meta_field] for doc in docs_with_meta_field}
+        if not all(isinstance(meta_value, str) for meta_value in unique_meta_values):
+            logger.warning(
+                "The parameter <meta_value_type> is currently set to '{meta_field}', but not all of meta values in the "
+                "provided Documents with IDs {document_ids} are strings.\n"
+                "Skipping parsing of the meta values.\n"
+                "Set all meta values found under the <meta_field> parameter to strings to use <meta_value_type>.",
+                meta_field=meta_value_type,
+                document_ids=",".join([doc.id for doc in docs_with_meta_field]),
+            )
+            return [d.meta[self.meta_field] for d in docs_with_meta_field]
+
+        parse_fn: Callable
+        if meta_value_type == "float":
+            parse_fn = float
+        elif meta_value_type == "int":
+            parse_fn = int
+        else:
+            parse_fn = date_parse
+
+        try:
+            meta_values = [parse_fn(d.meta[self.meta_field]) for d in docs_with_meta_field]
+        except ValueError as error:
+            logger.warning(
+                "Tried to parse the meta values of Documents with IDs {document_ids}, but got ValueError with the "
+                "message: {error}\n"
+                "Skipping parsing of the meta values.",
+                document_ids=",".join([doc.id for doc in docs_with_meta_field]),
+                error=error,
+            )
+            meta_values = [d.meta[self.meta_field] for d in docs_with_meta_field]
+
+        return meta_values
+
+    def _merge_rankings(
+        self,
+        documents: List[Document],
+        sorted_documents: List[Document],
+        weight: float,
+        ranking_mode: Literal["reciprocal_rank_fusion", "linear_score"],
+    ) -> List[Document]:
+        """
+        Merge the two different rankings for Documents sorted both by their content and by their meta field.
+        """
+        scores_map: Dict = defaultdict(int)
+
+        if ranking_mode == "reciprocal_rank_fusion":
+            for i, (document, sorted_doc) in enumerate(zip(documents, sorted_documents)):
+                scores_map[document.id] += self._calculate_rrf(rank=i) * (1 - weight)
+                scores_map[sorted_doc.id] += self._calculate_rrf(rank=i) * weight
+        elif ranking_mode == "linear_score":
+            for i, (document, sorted_doc) in enumerate(zip(documents, sorted_documents)):
+                score = float(0)
+                if document.score is None:
+                    logger.warning("The score wasn't provided; defaulting to 0.")
+                elif document.score < 0 or document.score > 1:
+                    logger.warning(
+                        "The score {score} for Document {document_id} is outside the [0,1] range; defaulting to 0",
+                        score=document.score,
+                        document_id=document.id,
+                    )
+                else:
+                    score = document.score
+
+                scores_map[document.id] += score * (1 - weight)
+                scores_map[sorted_doc.id] += self._calc_linear_score(rank=i, amount=len(sorted_documents)) * weight
+
+        for document in documents:
+            document.score = scores_map[document.id]
+
+        new_sorted_documents = sorted(documents, key=lambda doc: doc.score if doc.score else -1, reverse=True)
+        return new_sorted_documents
+
+    @staticmethod
+    def _calculate_rrf(rank: int, k: int = 61) -> float:
+        """
+        Calculates the reciprocal rank fusion.
+
+        The constant K is set to 61 (60 was suggested by the original paper, plus 1 as python lists are 0-based and
+        the [paper](https://plg.uwaterloo.ca/~gvcormac/cormacksigir09-rrf.pdf) used 1-based ranking).
+        """
+        return 1 / (k + rank)
+
+    @staticmethod
+    def _calc_linear_score(rank: int, amount: int) -> float:
+        """
+        Calculate the meta field score as a linear score between the greatest and the lowest score in the list.
+
+        This linear scaling is useful for:
+        - Reducing the effect of outliers
+        - Creating scores that are meaningfully distributed in the range [0,1],
+        similar to scores coming from a Retriever or Ranker.
+        """
+        return (amount - rank) / amount

testbed/deepset-ai__haystack/haystack/components/rankers/sentence_transformers_diversity.py

@@ -0,0 +1,253 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Any, Dict, List, Literal, Optional
+
+from haystack import Document, component, default_from_dict, default_to_dict, logging
+from haystack.lazy_imports import LazyImport
+from haystack.utils import ComponentDevice, Secret, deserialize_secrets_inplace
+
+logger = logging.getLogger(__name__)
+
+
+with LazyImport(message="Run 'pip install \"sentence-transformers>=3.0.0\"'") as torch_and_sentence_transformers_import:
+    import torch
+    from sentence_transformers import SentenceTransformer
+
+
+@component
+class SentenceTransformersDiversityRanker:
+    """
+    A Diversity Ranker based on Sentence Transformers.
+
+    Implements a document ranking algorithm that orders documents in such a way as to maximize the overall diversity
+    of the documents.
+
+    This component provides functionality to rank a list of documents based on their similarity with respect to the
+    query to maximize the overall diversity. It uses a pre-trained Sentence Transformers model to embed the query and
+    the Documents.
+
+    Usage example:
+    ```python
+    from haystack import Document
+    from haystack.components.rankers import SentenceTransformersDiversityRanker
+
+    ranker = SentenceTransformersDiversityRanker(model="sentence-transformers/all-MiniLM-L6-v2", similarity="cosine")
+    ranker.warm_up()
+
+    docs = [Document(content="Paris"), Document(content="Berlin")]
+    query = "What is the capital of germany?"
+    output = ranker.run(query=query, documents=docs)
+    docs = output["documents"]
+    ```
+    """
+
+    def __init__(
+        self,
+        model: str = "sentence-transformers/all-MiniLM-L6-v2",
+        top_k: int = 10,
+        device: Optional[ComponentDevice] = None,
+        token: Optional[Secret] = Secret.from_env_var(["HF_API_TOKEN", "HF_TOKEN"], strict=False),
+        similarity: Literal["dot_product", "cosine"] = "cosine",
+        query_prefix: str = "",
+        query_suffix: str = "",
+        document_prefix: str = "",
+        document_suffix: str = "",
+        meta_fields_to_embed: Optional[List[str]] = None,
+        embedding_separator: str = "\n",
+    ):
+        """
+        Initialize a SentenceTransformersDiversityRanker.
+
+        :param model: Local path or name of the model in Hugging Face's model hub,
+            such as `'sentence-transformers/all-MiniLM-L6-v2'`.
+        :param top_k: The maximum number of Documents to return per query.
+        :param device: The device on which the model is loaded. If `None`, the default device is automatically
+            selected.
+        :param token: The API token used to download private models from Hugging Face.
+        :param similarity: Similarity metric for comparing embeddings. Can be set to "dot_product" (default) or
+            "cosine".
+        :param query_prefix: A string to add to the beginning of the query text before ranking.
+            Can be used to prepend the text with an instruction, as required by some embedding models,
+            such as E5 and BGE.
+        :param query_suffix: A string to add to the end of the query text before ranking.
+        :param document_prefix: A string to add to the beginning of each Document text before ranking.
+            Can be used to prepend the text with an instruction, as required by some embedding models,
+            such as E5 and BGE.
+        :param document_suffix: A string to add to the end of each Document text before ranking.
+        :param meta_fields_to_embed: List of meta fields that should be embedded along with the Document content.
+        :param embedding_separator: Separator used to concatenate the meta fields to the Document content.
+        """
+        torch_and_sentence_transformers_import.check()
+
+        self.model_name_or_path = model
+        if top_k is None or top_k <= 0:
+            raise ValueError(f"top_k must be > 0, but got {top_k}")
+        self.top_k = top_k
+        self.device = ComponentDevice.resolve_device(device)
+        self.token = token
+        self.model = None
+        if similarity not in ["dot_product", "cosine"]:
+            raise ValueError(f"Similarity must be one of 'dot_product' or 'cosine', but got {similarity}.")
+        self.similarity = similarity
+        self.query_prefix = query_prefix
+        self.document_prefix = document_prefix
+        self.query_suffix = query_suffix
+        self.document_suffix = document_suffix
+        self.meta_fields_to_embed = meta_fields_to_embed or []
+        self.embedding_separator = embedding_separator
+
+    def warm_up(self):
+        """
+        Initializes the component.
+        """
+        if self.model is None:
+            self.model = SentenceTransformer(
+                model_name_or_path=self.model_name_or_path,
+                device=self.device.to_torch_str(),
+                use_auth_token=self.token.resolve_value() if self.token else None,
+            )
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Serializes the component to a dictionary.
+
+        :returns:
+            Dictionary with serialized data.
+        """
+        return default_to_dict(
+            self,
+            model=self.model_name_or_path,
+            device=self.device.to_dict(),
+            token=self.token.to_dict() if self.token else None,
+            top_k=self.top_k,
+            similarity=self.similarity,
+            query_prefix=self.query_prefix,
+            document_prefix=self.document_prefix,
+            query_suffix=self.query_suffix,
+            document_suffix=self.document_suffix,
+            meta_fields_to_embed=self.meta_fields_to_embed,
+            embedding_separator=self.embedding_separator,
+        )
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "SentenceTransformersDiversityRanker":
+        """
+        Deserializes the component from a dictionary.
+
+        :param data:
+            The dictionary to deserialize from.
+        :returns:
+            The deserialized component.
+        """
+        init_params = data["init_parameters"]
+        if init_params.get("device") is not None:
+            init_params["device"] = ComponentDevice.from_dict(init_params["device"])
+        deserialize_secrets_inplace(init_params, keys=["token"])
+        return default_from_dict(cls, data)
+
+    def _prepare_texts_to_embed(self, documents: List[Document]) -> List[str]:
+        """
+        Prepare the texts to embed by concatenating the Document text with the metadata fields to embed.
+        """
+        texts_to_embed = []
+        for doc in documents:
+            meta_values_to_embed = [
+                str(doc.meta[key]) for key in self.meta_fields_to_embed if key in doc.meta and doc.meta[key]
+            ]
+            text_to_embed = (
+                self.document_prefix
+                + self.embedding_separator.join(meta_values_to_embed + [doc.content or ""])
+                + self.document_suffix
+            )
+            texts_to_embed.append(text_to_embed)
+
+        return texts_to_embed
+
+    def _greedy_diversity_order(self, query: str, documents: List[Document]) -> List[Document]:
+        """
+        Orders the given list of documents to maximize diversity.
+
+        The algorithm first calculates embeddings for each document and the query. It starts by selecting the document
+        that is semantically closest to the query. Then, for each remaining document, it selects the one that, on
+        average, is least similar to the already selected documents. This process continues until all documents are
+        selected, resulting in a list where each subsequent document contributes the most to the overall diversity of
+        the selected set.
+
+        :param query: The search query.
+        :param documents: The list of Document objects to be ranked.
+
+        :return: A list of documents ordered to maximize diversity.
+        """
+        texts_to_embed = self._prepare_texts_to_embed(documents)
+
+        # Calculate embeddings
+        doc_embeddings = self.model.encode(texts_to_embed, convert_to_tensor=True)  # type: ignore[attr-defined]
+        query_embedding = self.model.encode([self.query_prefix + query + self.query_suffix], convert_to_tensor=True)  # type: ignore[attr-defined]
+
+        # Normalize embeddings to unit length for computing cosine similarity
+        if self.similarity == "cosine":
+            doc_embeddings /= torch.norm(doc_embeddings, p=2, dim=-1).unsqueeze(-1)
+            query_embedding /= torch.norm(query_embedding, p=2, dim=-1).unsqueeze(-1)
+
+        n = len(documents)
+        selected: List[int] = []
+
+        # Compute the similarity vector between the query and documents
+        query_doc_sim = query_embedding @ doc_embeddings.T
+
+        # Start with the document with the highest similarity to the query
+        selected.append(int(torch.argmax(query_doc_sim).item()))
+
+        selected_sum = doc_embeddings[selected[0]] / n
+
+        while len(selected) < n:
+            # Compute mean of dot products of all selected documents and all other documents
+            similarities = selected_sum @ doc_embeddings.T
+            # Mask documents that are already selected
+            similarities[selected] = torch.inf
+            # Select the document with the lowest total similarity score
+            index_unselected = int(torch.argmin(similarities).item())
+            selected.append(index_unselected)
+            # It's enough just to add to the selected vectors because dot product is distributive
+            # It's divided by n for numerical stability
+            selected_sum += doc_embeddings[index_unselected] / n
+
+        ranked_docs: List[Document] = [documents[i] for i in selected]
+
+        return ranked_docs
+
+    @component.output_types(documents=List[Document])
+    def run(self, query: str, documents: List[Document], top_k: Optional[int] = None):
+        """
+        Rank the documents based on their diversity.
+
+        :param query: The search query.
+        :param documents: List of Document objects to be ranker.
+        :param top_k: Optional. An integer to override the top_k set during initialization.
+
+        :returns: A dictionary with the following key:
+            - `documents`: List of Document objects that have been selected based on the diversity ranking.
+
+        :raises ValueError: If the top_k value is less than or equal to 0.
+        :raises RuntimeError: If the component has not been warmed up.
+        """
+        if self.model is None:
+            error_msg = (
+                "The component SentenceTransformersDiversityRanker wasn't warmed up. "
+                "Run 'warm_up()' before calling 'run()'."
+            )
+            raise RuntimeError(error_msg)
+
+        if not documents:
+            return {"documents": []}
+
+        if top_k is None:
+            top_k = self.top_k
+        elif top_k <= 0:
+            raise ValueError(f"top_k must be > 0, but got {top_k}")
+
+        diversity_sorted = self._greedy_diversity_order(query=query, documents=documents)
+
+        return {"documents": diversity_sorted[:top_k]}

testbed/deepset-ai__haystack/haystack/components/rankers/transformers_similarity.py

@@ -0,0 +1,309 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+
+from haystack import Document, component, default_from_dict, default_to_dict, logging
+from haystack.lazy_imports import LazyImport
+from haystack.utils import ComponentDevice, DeviceMap, Secret, deserialize_secrets_inplace
+from haystack.utils.hf import deserialize_hf_model_kwargs, resolve_hf_device_map, serialize_hf_model_kwargs
+
+logger = logging.getLogger(__name__)
+
+
+with LazyImport(message="Run 'pip install transformers[torch,sentencepiece]'") as torch_and_transformers_import:
+    import accelerate  # pylint: disable=unused-import # the library is used but not directly referenced
+    import torch
+    from torch.utils.data import DataLoader, Dataset
+    from transformers import AutoModelForSequenceClassification, AutoTokenizer
+
+
+@component
+class TransformersSimilarityRanker:
+    """
+    Ranks documents based on their semantic similarity to the query.
+
+    It uses a pre-trained cross-encoder model from Hugging Face to embed the query and the documents.
+
+    ### Usage example
+
+    ```python
+    from haystack import Document
+    from haystack.components.rankers import TransformersSimilarityRanker
+
+    ranker = TransformersSimilarityRanker()
+    docs = [Document(content="Paris"), Document(content="Berlin")]
+    query = "City in Germany"
+    ranker.warm_up()
+    result = ranker.run(query=query, documents=docs)
+    docs = result["documents"]
+    print(docs[0].content)
+    ```
+    """
+
+    def __init__(  # noqa: PLR0913
+        self,
+        model: Union[str, Path] = "cross-encoder/ms-marco-MiniLM-L-6-v2",
+        device: Optional[ComponentDevice] = None,
+        token: Optional[Secret] = Secret.from_env_var(["HF_API_TOKEN", "HF_TOKEN"], strict=False),
+        top_k: int = 10,
+        query_prefix: str = "",
+        document_prefix: str = "",
+        meta_fields_to_embed: Optional[List[str]] = None,
+        embedding_separator: str = "\n",
+        scale_score: bool = True,
+        calibration_factor: Optional[float] = 1.0,
+        score_threshold: Optional[float] = None,
+        model_kwargs: Optional[Dict[str, Any]] = None,
+        tokenizer_kwargs: Optional[Dict[str, Any]] = None,
+        batch_size: int = 16,
+    ):
+        """
+        Creates an instance of TransformersSimilarityRanker.
+
+        :param model:
+            The ranking model. Pass a local path or the Hugging Face model name of a cross-encoder model.
+        :param device:
+            The device on which the model is loaded. If `None`, overrides the default device.
+        :param token:
+            The API token to download private models from Hugging Face.
+        :param top_k:
+            The maximum number of documents to return per query.
+        :param query_prefix:
+            A string to add at the beginning of the query text before ranking.
+            Use it to prepend the text with an instruction, as required by reranking models like `bge`.
+        :param document_prefix:
+            A string to add at the beginning of each document before ranking. You can use it to prepend the document
+            with an instruction, as required by embedding models like `bge`.
+        :param meta_fields_to_embed:
+            List of metadata fields to embed with the document.
+        :param embedding_separator:
+            Separator to concatenate metadata fields to the document.
+        :param scale_score:
+            If `True`, scales the raw logit predictions using a Sigmoid activation function.
+            If `False`, disables scaling of the raw logit predictions.
+        :param calibration_factor:
+            Use this factor to calibrate probabilities with `sigmoid(logits * calibration_factor)`.
+            Used only if `scale_score` is `True`.
+        :param score_threshold:
+            Use it to return documents with a score above this threshold only.
+        :param model_kwargs:
+            Additional keyword arguments for `AutoModelForSequenceClassification.from_pretrained`
+            when loading the model. Refer to specific model documentation for available kwargs.
+        :param tokenizer_kwargs:
+            Additional keyword arguments for `AutoTokenizer.from_pretrained` when loading the tokenizer.
+            Refer to specific model documentation for available kwargs.
+        :param batch_size:
+            The batch size to use for inference. The higher the batch size, the more memory is required.
+            If you run into memory issues, reduce the batch size.
+
+        :raises ValueError:
+            If `top_k` is not > 0.
+            If `scale_score` is True and `calibration_factor` is not provided.
+        """
+        torch_and_transformers_import.check()
+
+        self.model_name_or_path = str(model)
+        self.model = None
+        self.query_prefix = query_prefix
+        self.document_prefix = document_prefix
+        self.tokenizer = None
+        self.device = None
+        self.top_k = top_k
+        self.token = token
+        self.meta_fields_to_embed = meta_fields_to_embed or []
+        self.embedding_separator = embedding_separator
+        self.scale_score = scale_score
+        self.calibration_factor = calibration_factor
+        self.score_threshold = score_threshold
+
+        model_kwargs = resolve_hf_device_map(device=device, model_kwargs=model_kwargs)
+        self.model_kwargs = model_kwargs
+        self.tokenizer_kwargs = tokenizer_kwargs or {}
+        self.batch_size = batch_size
+
+        # Parameter validation
+        if self.scale_score and self.calibration_factor is None:
+            raise ValueError(
+                f"scale_score is True so calibration_factor must be provided, but got {calibration_factor}"
+            )
+
+        if self.top_k <= 0:
+            raise ValueError(f"top_k must be > 0, but got {top_k}")
+
+    def _get_telemetry_data(self) -> Dict[str, Any]:
+        """
+        Data that is sent to Posthog for usage analytics.
+        """
+        return {"model": self.model_name_or_path}
+
+    def warm_up(self):
+        """
+        Initializes the component.
+        """
+        if self.model is None:
+            self.model = AutoModelForSequenceClassification.from_pretrained(
+                self.model_name_or_path, token=self.token.resolve_value() if self.token else None, **self.model_kwargs
+            )
+            self.tokenizer = AutoTokenizer.from_pretrained(
+                self.model_name_or_path,
+                token=self.token.resolve_value() if self.token else None,
+                **self.tokenizer_kwargs,
+            )
+            self.device = ComponentDevice.from_multiple(device_map=DeviceMap.from_hf(self.model.hf_device_map))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Serializes the component to a dictionary.
+
+        :returns:
+            Dictionary with serialized data.
+        """
+        serialization_dict = default_to_dict(
+            self,
+            device=None,
+            model=self.model_name_or_path,
+            token=self.token.to_dict() if self.token else None,
+            top_k=self.top_k,
+            query_prefix=self.query_prefix,
+            document_prefix=self.document_prefix,
+            meta_fields_to_embed=self.meta_fields_to_embed,
+            embedding_separator=self.embedding_separator,
+            scale_score=self.scale_score,
+            calibration_factor=self.calibration_factor,
+            score_threshold=self.score_threshold,
+            model_kwargs=self.model_kwargs,
+            tokenizer_kwargs=self.tokenizer_kwargs,
+        )
+
+        serialize_hf_model_kwargs(serialization_dict["init_parameters"]["model_kwargs"])
+        return serialization_dict
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "TransformersSimilarityRanker":
+        """
+        Deserializes the component from a dictionary.
+
+        :param data:
+            Dictionary to deserialize from.
+        :returns:
+            Deserialized component.
+        """
+        init_params = data["init_parameters"]
+        if init_params.get("device") is not None:
+            init_params["device"] = ComponentDevice.from_dict(init_params["device"])
+        if init_params.get("model_kwargs") is not None:
+            deserialize_hf_model_kwargs(init_params["model_kwargs"])
+        deserialize_secrets_inplace(init_params, keys=["token"])
+
+        return default_from_dict(cls, data)
+
+    @component.output_types(documents=List[Document])
+    def run(
+        self,
+        query: str,
+        documents: List[Document],
+        top_k: Optional[int] = None,
+        scale_score: Optional[bool] = None,
+        calibration_factor: Optional[float] = None,
+        score_threshold: Optional[float] = None,
+    ):
+        """
+        Returns a list of documents ranked by their similarity to the given query.
+
+        :param query:
+            The input query to compare the documents to.
+        :param documents:
+            A list of documents to be ranked.
+        :param top_k:
+            The maximum number of documents to return.
+        :param scale_score:
+            If `True`, scales the raw logit predictions using a Sigmoid activation function.
+            If `False`, disables scaling of the raw logit predictions.
+        :param calibration_factor:
+            Use this factor to calibrate probabilities with `sigmoid(logits * calibration_factor)`.
+            Used only if `scale_score` is `True`.
+        :param score_threshold:
+            Use it to return documents only with a score above this threshold.
+        :returns:
+            A dictionary with the following keys:
+            - `documents`: A list of documents closest to the query, sorted from most similar to least similar.
+
+        :raises ValueError:
+            If `top_k` is not > 0.
+            If `scale_score` is True and `calibration_factor` is not provided.
+        :raises RuntimeError:
+            If the model is not loaded because `warm_up()` was not called before.
+        """
+        # If a model path is provided but the model isn't loaded
+        if self.model is None:
+            raise RuntimeError(
+                "The component TransformersSimilarityRanker wasn't warmed up. Run 'warm_up()' before calling 'run()'."
+            )
+
+        if not documents:
+            return {"documents": []}
+
+        top_k = top_k or self.top_k
+        scale_score = scale_score or self.scale_score
+        calibration_factor = calibration_factor or self.calibration_factor
+        score_threshold = score_threshold or self.score_threshold
+
+        if top_k <= 0:
+            raise ValueError(f"top_k must be > 0, but got {top_k}")
+
+        if scale_score and calibration_factor is None:
+            raise ValueError(
+                f"scale_score is True so calibration_factor must be provided, but got {calibration_factor}"
+            )
+
+        query_doc_pairs = []
+        for doc in documents:
+            meta_values_to_embed = [
+                str(doc.meta[key]) for key in self.meta_fields_to_embed if key in doc.meta and doc.meta[key]
+            ]
+            text_to_embed = self.embedding_separator.join(meta_values_to_embed + [doc.content or ""])
+            query_doc_pairs.append([self.query_prefix + query, self.document_prefix + text_to_embed])
+
+        class _Dataset(Dataset):
+            def __init__(self, batch_encoding):
+                self.batch_encoding = batch_encoding
+
+            def __len__(self):
+                return len(self.batch_encoding["input_ids"])
+
+            def __getitem__(self, item):
+                return {key: self.batch_encoding.data[key][item] for key in self.batch_encoding.data.keys()}
+
+        batch_enc = self.tokenizer(query_doc_pairs, padding=True, truncation=True, return_tensors="pt").to(  # type: ignore
+            self.device.first_device.to_torch()
+        )
+        dataset = _Dataset(batch_enc)
+        inp_dataloader = DataLoader(dataset, batch_size=self.batch_size, shuffle=False)
+
+        similarity_scores = []
+        with torch.inference_mode():
+            for features in inp_dataloader:
+                model_preds = self.model(**features).logits.squeeze(dim=1)  # type: ignore
+                similarity_scores.extend(model_preds)
+        similarity_scores = torch.stack(similarity_scores)
+
+        if scale_score:
+            similarity_scores = torch.sigmoid(similarity_scores * calibration_factor)
+
+        _, sorted_indices = torch.sort(similarity_scores, descending=True)
+
+        sorted_indices = sorted_indices.cpu().tolist()  # type: ignore
+        similarity_scores = similarity_scores.cpu().tolist()
+        ranked_docs = []
+        for sorted_index in sorted_indices:
+            i = sorted_index
+            documents[i].score = similarity_scores[i]
+            ranked_docs.append(documents[i])
+
+        if score_threshold is not None:
+            ranked_docs = [doc for doc in ranked_docs if doc.score >= score_threshold]
+
+        return {"documents": ranked_docs[:top_k]}

testbed/deepset-ai__haystack/haystack/components/readers/__init__.py

@@ -0,0 +1,7 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from haystack.components.readers.extractive import ExtractiveReader
+
+__all__ = ["ExtractiveReader"]

testbed/deepset-ai__haystack/haystack/components/retrievers/filter_retriever.py

@@ -0,0 +1,96 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Any, Dict, List, Optional
+
+from haystack import Document, component, default_from_dict, default_to_dict, logging
+from haystack.document_stores.types import DocumentStore
+from haystack.utils import deserialize_document_store_in_init_params_inplace
+
+logger = logging.getLogger(__name__)
+
+
+@component
+class FilterRetriever:
+    """
+    Retrieves documents that match the provided filters.
+
+    ### Usage example
+
+    ```python
+    from haystack import Document
+    from haystack.components.retrievers import FilterRetriever
+    from haystack.document_stores.in_memory import InMemoryDocumentStore
+
+    docs = [
+        Document(content="Python is a popular programming language", meta={"lang": "en"}),
+        Document(content="python ist eine beliebte Programmiersprache", meta={"lang": "de"}),
+    ]
+
+    doc_store = InMemoryDocumentStore()
+    doc_store.write_documents(docs)
+    retriever = FilterRetriever(doc_store, filters={"field": "lang", "operator": "==", "value": "en"})
+
+    # if passed in the run method, filters override those provided at initialization
+    result = retriever.run(filters={"field": "lang", "operator": "==", "value": "de"})
+
+    print(result["documents"])
+    ```
+    """
+
+    def __init__(self, document_store: DocumentStore, filters: Optional[Dict[str, Any]] = None):
+        """
+        Create the FilterRetriever component.
+
+        :param document_store:
+            An instance of a Document Store to use with the Retriever.
+        :param filters:
+            A dictionary with filters to narrow down the search space.
+        """
+        self.document_store = document_store
+        self.filters = filters
+
+    def _get_telemetry_data(self) -> Dict[str, Any]:
+        """
+        Data that is sent to Posthog for usage analytics.
+        """
+        return {"document_store": type(self.document_store).__name__}
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Serializes the component to a dictionary.
+
+        :returns:
+            Dictionary with serialized data.
+        """
+        docstore = self.document_store.to_dict()
+        return default_to_dict(self, document_store=docstore, filters=self.filters)
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "FilterRetriever":
+        """
+        Deserializes the component from a dictionary.
+
+        :param data:
+            The dictionary to deserialize from.
+        :returns:
+            The deserialized component.
+        """
+        # deserialize the document store
+        deserialize_document_store_in_init_params_inplace(data)
+
+        return default_from_dict(cls, data)
+
+    @component.output_types(documents=List[Document])
+    def run(self, filters: Optional[Dict[str, Any]] = None):
+        """
+        Run the FilterRetriever on the given input data.
+
+        :param filters:
+            A dictionary with filters to narrow down the search space.
+            If not specified, the FilterRetriever uses the values provided at initialization.
+        :returns:
+            A list of retrieved documents.
+        """
+        return {"documents": self.document_store.filter_documents(filters=filters or self.filters)}

testbed/deepset-ai__haystack/haystack/components/retrievers/in_memory/__init__.py

@@ -0,0 +1,8 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from haystack.components.retrievers.in_memory.bm25_retriever import InMemoryBM25Retriever
+from haystack.components.retrievers.in_memory.embedding_retriever import InMemoryEmbeddingRetriever
+
+__all__ = ["InMemoryBM25Retriever", "InMemoryEmbeddingRetriever"]

testbed/deepset-ai__haystack/haystack/components/routers/__init__.py

@@ -0,0 +1,19 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from haystack.components.routers.conditional_router import ConditionalRouter
+from haystack.components.routers.file_type_router import FileTypeRouter
+from haystack.components.routers.metadata_router import MetadataRouter
+from haystack.components.routers.text_language_router import TextLanguageRouter
+from haystack.components.routers.transformers_text_router import TransformersTextRouter
+from haystack.components.routers.zero_shot_text_router import TransformersZeroShotTextRouter
+
+__all__ = [
+    "FileTypeRouter",
+    "MetadataRouter",
+    "TextLanguageRouter",
+    "ConditionalRouter",
+    "TransformersZeroShotTextRouter",
+    "TransformersTextRouter",
+]

testbed/deepset-ai__haystack/haystack/components/routers/conditional_router.py

@@ -0,0 +1,366 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import ast
+import contextlib
+from typing import Any, Callable, Dict, List, Mapping, Optional, Sequence, Set, Union, get_args, get_origin
+from warnings import warn
+
+from jinja2 import Environment, TemplateSyntaxError, meta
+from jinja2.nativetypes import NativeEnvironment
+from jinja2.sandbox import SandboxedEnvironment
+
+from haystack import component, default_from_dict, default_to_dict, logging
+from haystack.utils import deserialize_callable, deserialize_type, serialize_callable, serialize_type
+
+logger = logging.getLogger(__name__)
+
+
+class NoRouteSelectedException(Exception):
+    """Exception raised when no route is selected in ConditionalRouter."""
+
+
+class RouteConditionException(Exception):
+    """Exception raised when there is an error parsing or evaluating the condition expression in ConditionalRouter."""
+
+
+@component
+class ConditionalRouter:
+    """
+    Routes data based on specific conditions.
+
+    You define these conditions in a list of dictionaries called `routes`.
+    Each dictionary in this list represents a single route. Each route has these four elements:
+    - `condition`: A Jinja2 string expression that determines if the route is selected.
+    - `output`: A Jinja2 expression defining the route's output value.
+    - `output_type`: The type of the output data (for example, `str`, `List[int]`).
+    - `output_name`: The name you want to use to publish `output`. This name is used to connect
+    the router to other components in the pipeline.
+
+    ### Usage example
+
+    ```python
+    from typing import List
+    from haystack.components.routers import ConditionalRouter
+
+    routes = [
+        {
+            "condition": "{{streams|length > 2}}",
+            "output": "{{streams}}",
+            "output_name": "enough_streams",
+            "output_type": List[int],
+        },
+        {
+            "condition": "{{streams|length <= 2}}",
+            "output": "{{streams}}",
+            "output_name": "insufficient_streams",
+            "output_type": List[int],
+        },
+    ]
+    router = ConditionalRouter(routes)
+    # When 'streams' has more than 2 items, 'enough_streams' output will activate, emitting the list [1, 2, 3]
+    kwargs = {"streams": [1, 2, 3], "query": "Haystack"}
+    result = router.run(**kwargs)
+    assert result == {"enough_streams": [1, 2, 3]}
+    ```
+
+    In this example, we configure two routes. The first route sends the 'streams' value to 'enough_streams' if the
+    stream count exceeds two. The second route directs 'streams' to 'insufficient_streams' if there
+    are two or fewer streams.
+
+    In the pipeline setup, the Router connects to other components using the output names. For example,
+    'enough_streams' might connect to a component that processes streams, while
+    'insufficient_streams' might connect to a component that fetches more streams.
+
+
+    Here is a pipeline that uses `ConditionalRouter` and routes the fetched `ByteStreams` to
+    different components depending on the number of streams fetched:
+
+    ```python
+    from typing import List
+    from haystack import Pipeline
+    from haystack.dataclasses import ByteStream
+    from haystack.components.routers import ConditionalRouter
+
+    routes = [
+        {
+            "condition": "{{streams|length > 2}}",
+            "output": "{{streams}}",
+            "output_name": "enough_streams",
+            "output_type": List[ByteStream],
+        },
+        {
+            "condition": "{{streams|length <= 2}}",
+            "output": "{{streams}}",
+            "output_name": "insufficient_streams",
+            "output_type": List[ByteStream],
+        },
+    ]
+
+    pipe = Pipeline()
+    pipe.add_component("router", router)
+    ...
+    pipe.connect("router.enough_streams", "some_component_a.streams")
+    pipe.connect("router.insufficient_streams", "some_component_b.streams_or_some_other_input")
+    ...
+    ```
+    """
+
+    def __init__(
+        self,
+        routes: List[Dict],
+        custom_filters: Optional[Dict[str, Callable]] = None,
+        unsafe: bool = False,
+        validate_output_type: bool = False,
+    ):
+        """
+        Initializes the `ConditionalRouter` with a list of routes detailing the conditions for routing.
+
+        :param routes: A list of dictionaries, each defining a route.
+            Each route has these four elements:
+            - `condition`: A Jinja2 string expression that determines if the route is selected.
+            - `output`: A Jinja2 expression defining the route's output value.
+            - `output_type`: The type of the output data (for example, `str`, `List[int]`).
+            - `output_name`: The name you want to use to publish `output`. This name is used to connect
+            the router to other components in the pipeline.
+        :param custom_filters: A dictionary of custom Jinja2 filters used in the condition expressions.
+            For example, passing `{"my_filter": my_filter_fcn}` where:
+            - `my_filter` is the name of the custom filter.
+            - `my_filter_fcn` is a callable that takes `my_var:str` and returns `my_var[:3]`.
+              `{{ my_var|my_filter }}` can then be used inside a route condition expression:
+                `"condition": "{{ my_var|my_filter == 'foo' }}"`.
+        :param unsafe:
+            Enable execution of arbitrary code in the Jinja template.
+            This should only be used if you trust the source of the template as it can be lead to remote code execution.
+        :param validate_output_type:
+            Enable validation of routes' output.
+            If a route output doesn't match the declared type a ValueError is raised running.
+        """
+        self.routes: List[dict] = routes
+        self.custom_filters = custom_filters or {}
+        self._unsafe = unsafe
+        self._validate_output_type = validate_output_type
+
+        # Create a Jinja environment to inspect variables in the condition templates
+        if self._unsafe:
+            msg = (
+                "Unsafe mode is enabled. This allows execution of arbitrary code in the Jinja template. "
+                "Use this only if you trust the source of the template."
+            )
+            warn(msg)
+
+        self._env = NativeEnvironment() if self._unsafe else SandboxedEnvironment()
+        self._env.filters.update(self.custom_filters)
+
+        self._validate_routes(routes)
+        # Inspect the routes to determine input and output types.
+        input_types: Set[str] = set()  # let's just store the name, type will always be Any
+        output_types: Dict[str, str] = {}
+
+        for route in routes:
+            # extract inputs
+            route_input_names = self._extract_variables(self._env, [route["output"], route["condition"]])
+            input_types.update(route_input_names)
+
+            # extract outputs
+            output_types.update({route["output_name"]: route["output_type"]})
+
+        component.set_input_types(self, **{var: Any for var in input_types})
+        component.set_output_types(self, **output_types)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Serializes the component to a dictionary.
+
+        :returns:
+            Dictionary with serialized data.
+        """
+        for route in self.routes:
+            # output_type needs to be serialized to a string
+            route["output_type"] = serialize_type(route["output_type"])
+        se_filters = {name: serialize_callable(filter_func) for name, filter_func in self.custom_filters.items()}
+        return default_to_dict(
+            self,
+            routes=self.routes,
+            custom_filters=se_filters,
+            unsafe=self._unsafe,
+            validate_output_type=self._validate_output_type,
+        )
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "ConditionalRouter":
+        """
+        Deserializes the component from a dictionary.
+
+        :param data:
+            The dictionary to deserialize from.
+        :returns:
+            The deserialized component.
+        """
+        init_params = data.get("init_parameters", {})
+        routes = init_params.get("routes")
+        for route in routes:
+            # output_type needs to be deserialized from a string to a type
+            route["output_type"] = deserialize_type(route["output_type"])
+
+        # Since the custom_filters are typed as optional in the init signature, we catch the
+        # case where they are not present in the serialized data and set them to an empty dict.
+        custom_filters = init_params.get("custom_filters", {})
+        if custom_filters is not None:
+            for name, filter_func in custom_filters.items():
+                init_params["custom_filters"][name] = deserialize_callable(filter_func) if filter_func else None
+        return default_from_dict(cls, data)
+
+    def run(self, **kwargs):
+        """
+        Executes the routing logic.
+
+        Executes the routing logic by evaluating the specified boolean condition expressions for each route in the
+        order they are listed. The method directs the flow of data to the output specified in the first route whose
+        `condition` is True.
+
+        :param kwargs: All variables used in the `condition` expressed in the routes. When the component is used in a
+            pipeline, these variables are passed from the previous component's output.
+
+        :returns: A dictionary where the key is the `output_name` of the selected route and the value is the `output`
+            of the selected route.
+
+        :raises NoRouteSelectedException:
+            If no `condition' in the routes is `True`.
+        :raises RouteConditionException:
+            If there is an error parsing or evaluating the `condition` expression in the routes.
+        :raises ValueError:
+            If type validation is enabled and route type doesn't match actual value type.
+        """
+        # Create a Jinja native environment to evaluate the condition templates as Python expressions
+        for route in self.routes:
+            try:
+                t = self._env.from_string(route["condition"])
+                rendered = t.render(**kwargs)
+                if not self._unsafe:
+                    rendered = ast.literal_eval(rendered)
+                if not rendered:
+                    continue
+                # We now evaluate the `output` expression to determine the route output
+                t_output = self._env.from_string(route["output"])
+                output = t_output.render(**kwargs)
+                # We suppress the exception in case the output is already a string, otherwise
+                # we try to evaluate it and would fail.
+                # This must be done cause the output could be different literal structures.
+                # This doesn't support any user types.
+                with contextlib.suppress(Exception):
+                    if not self._unsafe:
+                        output = ast.literal_eval(output)
+            except Exception as e:
+                msg = f"Error evaluating condition for route '{route}': {e}"
+                raise RouteConditionException(msg) from e
+
+            if self._validate_output_type and not self._output_matches_type(output, route["output_type"]):
+                msg = f"""Route '{route["output_name"]}' type doesn't match expected type"""
+                raise ValueError(msg)
+
+            # and return the output as a dictionary under the output_name key
+            return {route["output_name"]: output}
+
+        raise NoRouteSelectedException(f"No route fired. Routes: {self.routes}")
+
+    def _validate_routes(self, routes: List[Dict]):
+        """
+        Validates a list of routes.
+
+        :param routes: A list of routes.
+        """
+        for route in routes:
+            try:
+                keys = set(route.keys())
+            except AttributeError:
+                raise ValueError(f"Route must be a dictionary, got: {route}")
+
+            mandatory_fields = {"condition", "output", "output_type", "output_name"}
+            has_all_mandatory_fields = mandatory_fields.issubset(keys)
+            if not has_all_mandatory_fields:
+                raise ValueError(
+                    f"Route must contain 'condition', 'output', 'output_type' and 'output_name' fields: {route}"
+                )
+            for field in ["condition", "output"]:
+                if not self._validate_template(self._env, route[field]):
+                    raise ValueError(f"Invalid template for field '{field}': {route[field]}")
+
+    def _extract_variables(self, env: Environment, templates: List[str]) -> Set[str]:
+        """
+        Extracts all variables from a list of Jinja template strings.
+
+        :param env: A Jinja environment.
+        :param templates: A list of Jinja template strings.
+        :returns: A set of variable names.
+        """
+        variables = set()
+        for template in templates:
+            ast = env.parse(template)
+            variables.update(meta.find_undeclared_variables(ast))
+        return variables
+
+    def _validate_template(self, env: Environment, template_text: str):
+        """
+        Validates a template string by parsing it with Jinja.
+
+        :param env: A Jinja environment.
+        :param template_text: A Jinja template string.
+        :returns: `True` if the template is valid, `False` otherwise.
+        """
+        try:
+            env.parse(template_text)
+            return True
+        except TemplateSyntaxError:
+            return False
+
+    def _output_matches_type(self, value: Any, expected_type: type):  # noqa: PLR0911 # pylint: disable=too-many-return-statements
+        """
+        Checks whether `value` type matches the `expected_type`.
+        """
+        # Handle Any type
+        if expected_type is Any:
+            return True
+
+        # Get the origin type (List, Dict, etc) and type arguments
+        origin = get_origin(expected_type)
+        args = get_args(expected_type)
+
+        # Handle basic types (int, str, etc)
+        if origin is None:
+            return isinstance(value, expected_type)
+
+        # Handle Sequence types (List, Tuple, etc)
+        if isinstance(origin, type) and issubclass(origin, Sequence):
+            if not isinstance(value, Sequence):
+                return False
+            # Empty sequence is valid
+            if not value:
+                return True
+            # Check each element against the sequence's type parameter
+            return all(self._output_matches_type(item, args[0]) for item in value)
+
+        # Handle basic types (int, str, etc)
+        if origin is None:
+            return isinstance(value, expected_type)
+
+        # Handle Mapping types (Dict, etc)
+        if isinstance(origin, type) and issubclass(origin, Mapping):
+            if not isinstance(value, Mapping):
+                return False
+            # Empty mapping is valid
+            if not value:
+                return True
+            key_type, value_type = args
+            # Check all keys and values match their respective types
+            return all(
+                self._output_matches_type(k, key_type) and self._output_matches_type(v, value_type)
+                for k, v in value.items()
+            )
+
+        # Handle Union types (including Optional)
+        if origin is Union:
+            return any(self._output_matches_type(value, arg) for arg in args)
+
+        return False

testbed/deepset-ai__haystack/haystack/components/routers/transformers_text_router.py

@@ -0,0 +1,205 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Any, Dict, List, Optional
+
+from haystack import component, default_from_dict, default_to_dict, logging
+from haystack.lazy_imports import LazyImport
+from haystack.utils import ComponentDevice, Secret, deserialize_secrets_inplace
+
+logger = logging.getLogger(__name__)
+
+
+with LazyImport(message="Run 'pip install transformers[torch,sentencepiece]'") as torch_and_transformers_import:
+    from transformers import AutoConfig, pipeline
+
+    from haystack.utils.hf import (  # pylint: disable=ungrouped-imports
+        deserialize_hf_model_kwargs,
+        resolve_hf_pipeline_kwargs,
+        serialize_hf_model_kwargs,
+    )
+
+
+@component
+class TransformersTextRouter:
+    """
+    Routes the text strings to different connections based on a category label.
+
+    The labels are specific to each model and can be found it its description on Hugging Face.
+
+    ### Usage example
+
+    ```python
+    from haystack.core.pipeline import Pipeline
+    from haystack.components.routers import TransformersTextRouter
+    from haystack.components.builders import PromptBuilder
+    from haystack.components.generators import HuggingFaceLocalGenerator
+
+    p = Pipeline()
+    p.add_component(
+        instance=TransformersTextRouter(model="papluca/xlm-roberta-base-language-detection"),
+        name="text_router"
+    )
+    p.add_component(
+        instance=PromptBuilder(template="Answer the question: {{query}}\\nAnswer:"),
+        name="english_prompt_builder"
+    )
+    p.add_component(
+        instance=PromptBuilder(template="Beantworte die Frage: {{query}}\\nAntwort:"),
+        name="german_prompt_builder"
+    )
+
+    p.add_component(
+        instance=HuggingFaceLocalGenerator(model="DiscoResearch/Llama3-DiscoLeo-Instruct-8B-v0.1"),
+        name="german_llm"
+    )
+    p.add_component(
+        instance=HuggingFaceLocalGenerator(model="microsoft/Phi-3-mini-4k-instruct"),
+        name="english_llm"
+    )
+
+    p.connect("text_router.en", "english_prompt_builder.query")
+    p.connect("text_router.de", "german_prompt_builder.query")
+    p.connect("english_prompt_builder.prompt", "english_llm.prompt")
+    p.connect("german_prompt_builder.prompt", "german_llm.prompt")
+
+    # English Example
+    print(p.run({"text_router": {"text": "What is the capital of Germany?"}}))
+
+    # German Example
+    print(p.run({"text_router": {"text": "Was ist die Hauptstadt von Deutschland?"}}))
+    ```
+    """
+
+    def __init__(
+        self,
+        model: str,
+        labels: Optional[List[str]] = None,
+        device: Optional[ComponentDevice] = None,
+        token: Optional[Secret] = Secret.from_env_var(["HF_API_TOKEN", "HF_TOKEN"], strict=False),
+        huggingface_pipeline_kwargs: Optional[Dict[str, Any]] = None,
+    ):
+        """
+        Initializes the TransformersTextRouter component.
+
+        :param model: The name or path of a Hugging Face model for text classification.
+        :param labels: The list of labels. If not provided, the component fetches the labels
+            from the model configuration file hosted on the Hugging Face Hub using
+            `transformers.AutoConfig.from_pretrained`.
+        :param device: The device for loading the model. If `None`, automatically selects the default device.
+            If a device or device map is specified in `huggingface_pipeline_kwargs`, it overrides this parameter.
+        :param token: The API token used to download private models from Hugging Face.
+            If `True`, uses either `HF_API_TOKEN` or `HF_TOKEN` environment variables.
+            To generate these tokens, run `transformers-cli login`.
+        :param huggingface_pipeline_kwargs: A dictionary of keyword arguments for initializing the Hugging Face
+            text classification pipeline.
+        """
+        torch_and_transformers_import.check()
+
+        self.token = token
+
+        huggingface_pipeline_kwargs = resolve_hf_pipeline_kwargs(
+            huggingface_pipeline_kwargs=huggingface_pipeline_kwargs or {},
+            model=model,
+            task="text-classification",
+            supported_tasks=["text-classification"],
+            device=device,
+            token=token,
+        )
+        self.huggingface_pipeline_kwargs = huggingface_pipeline_kwargs
+
+        if labels is None:
+            config = AutoConfig.from_pretrained(
+                huggingface_pipeline_kwargs["model"], token=huggingface_pipeline_kwargs["token"]
+            )
+            self.labels = list(config.label2id.keys())
+        else:
+            self.labels = labels
+        component.set_output_types(self, **{label: str for label in self.labels})
+
+        self.pipeline = None
+
+    def _get_telemetry_data(self) -> Dict[str, Any]:
+        """
+        Data that is sent to Posthog for usage analytics.
+        """
+        if isinstance(self.huggingface_pipeline_kwargs["model"], str):
+            return {"model": self.huggingface_pipeline_kwargs["model"]}
+        return {"model": f"[object of type {type(self.huggingface_pipeline_kwargs['model'])}]"}
+
+    def warm_up(self):
+        """
+        Initializes the component.
+        """
+        if self.pipeline is None:
+            self.pipeline = pipeline(**self.huggingface_pipeline_kwargs)
+
+        # Verify labels from the model configuration file match provided labels
+        labels = set(self.pipeline.model.config.label2id.keys())
+        if set(self.labels) != labels:
+            raise ValueError(
+                f"The provided labels do not match the labels in the model configuration file. "
+                f"Provided labels: {self.labels}. Model labels: {labels}"
+            )
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Serializes the component to a dictionary.
+
+        :returns:
+            Dictionary with serialized data.
+        """
+        serialization_dict = default_to_dict(
+            self,
+            labels=self.labels,
+            model=self.huggingface_pipeline_kwargs["model"],
+            huggingface_pipeline_kwargs=self.huggingface_pipeline_kwargs,
+            token=self.token.to_dict() if self.token else None,
+        )
+
+        huggingface_pipeline_kwargs = serialization_dict["init_parameters"]["huggingface_pipeline_kwargs"]
+        huggingface_pipeline_kwargs.pop("token", None)
+
+        serialize_hf_model_kwargs(huggingface_pipeline_kwargs)
+        return serialization_dict
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "TransformersTextRouter":
+        """
+        Deserializes the component from a dictionary.
+
+        :param data:
+            Dictionary to deserialize from.
+        :returns:
+            Deserialized component.
+        """
+        deserialize_secrets_inplace(data["init_parameters"], keys=["token"])
+        if data["init_parameters"].get("huggingface_pipeline_kwargs") is not None:
+            deserialize_hf_model_kwargs(data["init_parameters"]["huggingface_pipeline_kwargs"])
+        return default_from_dict(cls, data)
+
+    def run(self, text: str) -> Dict[str, str]:
+        """
+        Routes the text strings to different connections based on a category label.
+
+        :param text: A string of text to route.
+        :returns:
+            A dictionary with the label as key and the text as value.
+
+        :raises TypeError:
+            If the input is not a str.
+        :raises RuntimeError:
+            If the pipeline has not been loaded because warm_up() was not called before.
+        """
+        if self.pipeline is None:
+            raise RuntimeError(
+                "The component TextTransformersRouter wasn't warmed up. Run 'warm_up()' before calling 'run()'."
+            )
+
+        if not isinstance(text, str):
+            raise TypeError("TransformersTextRouter expects a str as input.")
+
+        prediction = self.pipeline([text], return_all_scores=False, function_to_apply="none")
+        label = prediction[0]["label"]
+        return {label: text}

testbed/deepset-ai__haystack/haystack/components/routers/zero_shot_text_router.py

@@ -0,0 +1,219 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Any, Dict, List, Optional
+
+from haystack import component, default_from_dict, default_to_dict, logging
+from haystack.lazy_imports import LazyImport
+from haystack.utils import ComponentDevice, Secret, deserialize_secrets_inplace
+
+logger = logging.getLogger(__name__)
+
+
+with LazyImport(message="Run 'pip install transformers[torch,sentencepiece]'") as torch_and_transformers_import:
+    from transformers import pipeline
+
+    from haystack.utils.hf import (  # pylint: disable=ungrouped-imports
+        deserialize_hf_model_kwargs,
+        resolve_hf_pipeline_kwargs,
+        serialize_hf_model_kwargs,
+    )
+
+
+@component
+class TransformersZeroShotTextRouter:
+    """
+    Routes the text strings to different connections based on a category label.
+
+    Specify the set of labels for categorization when initializing the component.
+
+    ### Usage example
+
+    ```python
+    from haystack import Document
+    from haystack.document_stores.in_memory import InMemoryDocumentStore
+    from haystack.core.pipeline import Pipeline
+    from haystack.components.routers import TransformersZeroShotTextRouter
+    from haystack.components.embedders import SentenceTransformersTextEmbedder, SentenceTransformersDocumentEmbedder
+    from haystack.components.retrievers import InMemoryEmbeddingRetriever
+
+    document_store = InMemoryDocumentStore()
+    doc_embedder = SentenceTransformersDocumentEmbedder(model="intfloat/e5-base-v2")
+    doc_embedder.warm_up()
+    docs = [
+        Document(
+            content="Germany, officially the Federal Republic of Germany, is a country in the western region of "
+            "Central Europe. The nation's capital and most populous city is Berlin and its main financial centre "
+            "is Frankfurt; the largest urban area is the Ruhr."
+        ),
+        Document(
+            content="France, officially the French Republic, is a country located primarily in Western Europe. "
+            "France is a unitary semi-presidential republic with its capital in Paris, the country's largest city "
+            "and main cultural and commercial centre; other major urban areas include Marseille, Lyon, Toulouse, "
+            "Lille, Bordeaux, Strasbourg, Nantes and Nice."
+        )
+    ]
+    docs_with_embeddings = doc_embedder.run(docs)
+    document_store.write_documents(docs_with_embeddings["documents"])
+
+    p = Pipeline()
+    p.add_component(instance=TransformersZeroShotTextRouter(labels=["passage", "query"]), name="text_router")
+    p.add_component(
+        instance=SentenceTransformersTextEmbedder(model="intfloat/e5-base-v2", prefix="passage: "),
+        name="passage_embedder"
+    )
+    p.add_component(
+        instance=SentenceTransformersTextEmbedder(model="intfloat/e5-base-v2", prefix="query: "),
+        name="query_embedder"
+    )
+    p.add_component(
+        instance=InMemoryEmbeddingRetriever(document_store=document_store),
+        name="query_retriever"
+    )
+    p.add_component(
+        instance=InMemoryEmbeddingRetriever(document_store=document_store),
+        name="passage_retriever"
+    )
+
+    p.connect("text_router.passage", "passage_embedder.text")
+    p.connect("passage_embedder.embedding", "passage_retriever.query_embedding")
+    p.connect("text_router.query", "query_embedder.text")
+    p.connect("query_embedder.embedding", "query_retriever.query_embedding")
+
+    # Query Example
+    p.run({"text_router": {"text": "What is the capital of Germany?"}})
+
+    # Passage Example
+    p.run({
+        "text_router":{
+            "text": "The United Kingdom of Great Britain and Northern Ireland, commonly known as the "\
+            "United Kingdom (UK) or Britain, is a country in Northwestern Europe, off the north-western coast of "\
+            "the continental mainland."
+        }
+    })
+    ```
+    """
+
+    def __init__(
+        self,
+        labels: List[str],
+        multi_label: bool = False,
+        model: str = "MoritzLaurer/deberta-v3-base-zeroshot-v1.1-all-33",
+        device: Optional[ComponentDevice] = None,
+        token: Optional[Secret] = Secret.from_env_var(["HF_API_TOKEN", "HF_TOKEN"], strict=False),
+        huggingface_pipeline_kwargs: Optional[Dict[str, Any]] = None,
+    ):
+        """
+        Initializes the TransformersZeroShotTextRouter component.
+
+        :param labels: The set of labels to use for classification. Can be a single label,
+            a string of comma-separated labels, or a list of labels.
+        :param multi_label:
+            Indicates if multiple labels can be true.
+            If `False`, label scores are normalized so their sum equals 1 for each sequence.
+            If `True`, the labels are considered independent and probabilities are normalized for each candidate by
+            doing a softmax of the entailment score vs. the contradiction score.
+        :param model: The name or path of a Hugging Face model for zero-shot text classification.
+        :param device: The device for loading the model. If `None`, automatically selects the default device.
+            If a device or device map is specified in `huggingface_pipeline_kwargs`, it overrides this parameter.
+        :param token: The API token used to download private models from Hugging Face.
+            If `True`, uses either `HF_API_TOKEN` or `HF_TOKEN` environment variables.
+            To generate these tokens, run `transformers-cli login`.
+        :param huggingface_pipeline_kwargs: A dictionary of keyword arguments for initializing the Hugging Face
+            zero shot text classification.
+        """
+        torch_and_transformers_import.check()
+
+        self.token = token
+        self.labels = labels
+        self.multi_label = multi_label
+        component.set_output_types(self, **{label: str for label in labels})
+
+        huggingface_pipeline_kwargs = resolve_hf_pipeline_kwargs(
+            huggingface_pipeline_kwargs=huggingface_pipeline_kwargs or {},
+            model=model,
+            task="zero-shot-classification",
+            supported_tasks=["zero-shot-classification"],
+            device=device,
+            token=token,
+        )
+        self.huggingface_pipeline_kwargs = huggingface_pipeline_kwargs
+        self.pipeline = None
+
+    def _get_telemetry_data(self) -> Dict[str, Any]:
+        """
+        Data that is sent to Posthog for usage analytics.
+        """
+        if isinstance(self.huggingface_pipeline_kwargs["model"], str):
+            return {"model": self.huggingface_pipeline_kwargs["model"]}
+        return {"model": f"[object of type {type(self.huggingface_pipeline_kwargs['model'])}]"}
+
+    def warm_up(self):
+        """
+        Initializes the component.
+        """
+        if self.pipeline is None:
+            self.pipeline = pipeline(**self.huggingface_pipeline_kwargs)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Serializes the component to a dictionary.
+
+        :returns:
+            Dictionary with serialized data.
+        """
+        serialization_dict = default_to_dict(
+            self,
+            labels=self.labels,
+            huggingface_pipeline_kwargs=self.huggingface_pipeline_kwargs,
+            token=self.token.to_dict() if self.token else None,
+        )
+
+        huggingface_pipeline_kwargs = serialization_dict["init_parameters"]["huggingface_pipeline_kwargs"]
+        huggingface_pipeline_kwargs.pop("token", None)
+
+        serialize_hf_model_kwargs(huggingface_pipeline_kwargs)
+        return serialization_dict
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "TransformersZeroShotTextRouter":
+        """
+        Deserializes the component from a dictionary.
+
+        :param data:
+            Dictionary to deserialize from.
+        :returns:
+            Deserialized component.
+        """
+        deserialize_secrets_inplace(data["init_parameters"], keys=["token"])
+        if data["init_parameters"].get("huggingface_pipeline_kwargs") is not None:
+            deserialize_hf_model_kwargs(data["init_parameters"]["huggingface_pipeline_kwargs"])
+        return default_from_dict(cls, data)
+
+    def run(self, text: str) -> Dict[str, str]:
+        """
+        Routes the text strings to different connections based on a category label.
+
+        :param text: A string of text to route.
+        :returns:
+            A dictionary with the label as key and the text as value.
+
+        :raises TypeError:
+            If the input is not a str.
+        :raises RuntimeError:
+            If the pipeline has not been loaded because warm_up() was not called before.
+        """
+        if self.pipeline is None:
+            raise RuntimeError(
+                "The component TransformersZeroShotTextRouter wasn't warmed up. Run 'warm_up()' before calling 'run()'."
+            )
+
+        if not isinstance(text, str):
+            raise TypeError("TransformersZeroShotTextRouter expects a str as input.")
+
+        prediction = self.pipeline(sequences=[text], candidate_labels=self.labels, multi_label=self.multi_label)
+        predicted_scores = prediction[0]["scores"]
+        max_score_index = max(range(len(predicted_scores)), key=predicted_scores.__getitem__)
+        label = prediction[0]["labels"][max_score_index]
+        return {label: text}

testbed/deepset-ai__haystack/haystack/components/samplers/__init__.py

@@ -0,0 +1,7 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from haystack.components.samplers.top_p import TopPSampler
+
+__all__ = ["TopPSampler"]

testbed/deepset-ai__haystack/haystack/components/websearch/serper_dev.py

@@ -0,0 +1,175 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import json
+from typing import Any, Dict, List, Optional, Union
+
+import requests
+
+from haystack import ComponentError, Document, component, default_from_dict, default_to_dict, logging
+from haystack.utils import Secret, deserialize_secrets_inplace
+
+logger = logging.getLogger(__name__)
+
+
+SERPERDEV_BASE_URL = "https://google.serper.dev/search"
+
+
+class SerperDevError(ComponentError): ...
+
+
+@component
+class SerperDevWebSearch:
+    """
+    Uses [Serper](https://serper.dev/) to search the web for relevant documents.
+
+    See the [Serper Dev website](https://serper.dev/) for more details.
+
+    Usage example:
+    ```python
+    from haystack.components.websearch import SerperDevWebSearch
+    from haystack.utils import Secret
+
+    websearch = SerperDevWebSearch(top_k=10, api_key=Secret.from_token("test-api-key"))
+    results = websearch.run(query="Who is the boyfriend of Olivia Wilde?")
+
+    assert results["documents"]
+    assert results["links"]
+    ```
+    """
+
+    def __init__(
+        self,
+        api_key: Secret = Secret.from_env_var("SERPERDEV_API_KEY"),
+        top_k: Optional[int] = 10,
+        allowed_domains: Optional[List[str]] = None,
+        search_params: Optional[Dict[str, Any]] = None,
+    ):
+        """
+        Initialize the SerperDevWebSearch component.
+
+        :param api_key: API key for the Serper API.
+        :param top_k: Number of documents to return.
+        :param allowed_domains: List of domains to limit the search to.
+        :param search_params: Additional parameters passed to the Serper API.
+            For example, you can set 'num' to 20 to increase the number of search results.
+            See the [Serper website](https://serper.dev/) for more details.
+        """
+        self.api_key = api_key
+        self.top_k = top_k
+        self.allowed_domains = allowed_domains
+        self.search_params = search_params or {}
+
+        # Ensure that the API key is resolved.
+        _ = self.api_key.resolve_value()
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Serializes the component to a dictionary.
+
+        :returns:
+                Dictionary with serialized data.
+        """
+        return default_to_dict(
+            self,
+            top_k=self.top_k,
+            allowed_domains=self.allowed_domains,
+            search_params=self.search_params,
+            api_key=self.api_key.to_dict(),
+        )
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "SerperDevWebSearch":
+        """
+        Serializes the component to a dictionary.
+
+        :returns:
+                Dictionary with serialized data.
+        """
+        deserialize_secrets_inplace(data["init_parameters"], keys=["api_key"])
+        return default_from_dict(cls, data)
+
+    @component.output_types(documents=List[Document], links=List[str])
+    def run(self, query: str) -> Dict[str, Union[List[Document], List[str]]]:
+        """
+        Use [Serper](https://serper.dev/) to search the web.
+
+        :param query: Search query.
+        :returns: A dictionary with the following keys:
+            - "documents": List of documents returned by the search engine.
+            - "links": List of links returned by the search engine.
+        :raises SerperDevError: If an error occurs while querying the SerperDev API.
+        :raises TimeoutError: If the request to the SerperDev API times out.
+        """
+        query_prepend = "OR ".join(f"site:{domain} " for domain in self.allowed_domains) if self.allowed_domains else ""
+
+        payload = json.dumps(
+            {"q": query_prepend + query, "gl": "us", "hl": "en", "autocorrect": True, **self.search_params}
+        )
+        headers = {"X-API-KEY": self.api_key.resolve_value(), "Content-Type": "application/json"}
+
+        try:
+            response = requests.post(SERPERDEV_BASE_URL, headers=headers, data=payload, timeout=30)  # type: ignore
+            response.raise_for_status()  # Will raise an HTTPError for bad responses
+        except requests.Timeout as error:
+            raise TimeoutError(f"Request to {self.__class__.__name__} timed out.") from error
+
+        except requests.RequestException as e:
+            raise SerperDevError(f"An error occurred while querying {self.__class__.__name__}. Error: {e}") from e
+
+        # If we reached this point, it means the request was successful and we can proceed
+        json_result = response.json()
+
+        # we get the snippet from the json result and put it in the content field of the document
+        organic = [
+            Document(meta={k: v for k, v in d.items() if k != "snippet"}, content=d.get("snippet"))
+            for d in json_result["organic"]
+        ]
+
+        # answer box is what search engine shows as a direct answer to the query
+        answer_box = []
+        if "answerBox" in json_result:
+            answer_dict = json_result["answerBox"]
+            highlighted_answers = answer_dict.get("snippetHighlighted")
+            answer_box_content = None
+            # Check if highlighted_answers is a list and has at least one element
+            if isinstance(highlighted_answers, list) and len(highlighted_answers) > 0:
+                answer_box_content = highlighted_answers[0]
+            elif isinstance(highlighted_answers, str):
+                answer_box_content = highlighted_answers
+            if not answer_box_content:
+                for key in ["snippet", "answer", "title"]:
+                    if key in answer_dict:
+                        answer_box_content = answer_dict[key]
+                        break
+            if answer_box_content:
+                answer_box = [
+                    Document(
+                        content=answer_box_content,
+                        meta={"title": answer_dict.get("title", ""), "link": answer_dict.get("link", "")},
+                    )
+                ]
+
+        # these are related questions that search engine shows
+        people_also_ask = []
+        if "peopleAlsoAsk" in json_result:
+            for result in json_result["peopleAlsoAsk"]:
+                title = result.get("title", "")
+                people_also_ask.append(
+                    Document(
+                        content=result["snippet"] if result.get("snippet") else title,
+                        meta={"title": title, "link": result.get("link", None)},
+                    )
+                )
+
+        documents = answer_box + organic + people_also_ask
+
+        links = [result["link"] for result in json_result["organic"]]
+
+        logger.debug(
+            "Serper Dev returned {number_documents} documents for the query '{query}'",
+            number_documents=len(documents),
+            query=query,
+        )
+        return {"documents": documents[: self.top_k], "links": links[: self.top_k]}