haystack-experimental 0.14.3__py3-none-any.whl → 0.15.1__py3-none-any.whl

{haystack_experimental-0.14.3.dist-info → haystack_experimental-0.15.1.dist-info}/RECORD

@@ -1,55 +1,48 @@
 haystack_experimental/__init__.py,sha256=eHD7xrty2PCky_gG3ty19rpM4WfV32TyytM7gJODwl4,110
-haystack_experimental/chat_message_stores/__init__.py,sha256=sQhjMoaVfC0XsL257egtZageGg_NgzntRF71rPS0lvc,238
-haystack_experimental/chat_message_stores/in_memory.py,sha256=nc_B_70KOvtgsul4QJb7HihHZrO220HRFsm-aXjYFJk,2305
-haystack_experimental/chat_message_stores/types.py,sha256=QzjA5-A08PlMAy7MMLNNUpob8S60Ypec74gSbz_l49E,2101
+haystack_experimental/chat_message_stores/__init__.py,sha256=zu1bbMQDv9xUbGadIKWrC8v-87w_Xxg6KQnTb6K0k-Q,240
+haystack_experimental/chat_message_stores/in_memory.py,sha256=i4ZK5W0Q0rDpgoRCYdIjPoJV8UJBr1PlUBH4ul5Adxk,8688
+haystack_experimental/chat_message_stores/types.py,sha256=mXz6QTCyNomSBzr1eU76oHVrxQEwPDuiTIGTWvKwYJM,2739
 haystack_experimental/components/__init__.py,sha256=eHD7xrty2PCky_gG3ty19rpM4WfV32TyytM7gJODwl4,110
 haystack_experimental/components/agents/__init__.py,sha256=Sxu9LxPpQ5cljgoTgUeNC0GY8CwUdiSy1JWkd_-RRJ4,414
-haystack_experimental/components/agents/agent.py,sha256=861fVcgFXePbxJZ0EYTkR_EhqUXBWoEwajrcjo81nvE,35589
+haystack_experimental/components/agents/agent.py,sha256=ZIrzAQygva8zFhEl1Tu7WRJCz0W_MersPjtesqx8HQE,42128
 haystack_experimental/components/agents/human_in_the_loop/__init__.py,sha256=xLr1G9pNWMmCpKN9mbv6yqeFfwMcbZyaVfCkzlwMxhY,1674
 haystack_experimental/components/agents/human_in_the_loop/breakpoint.py,sha256=GhNdGdFNDnwSiTukD4WVp6-1YgGjq5oqCEcGMC2dcog,2902
 haystack_experimental/components/agents/human_in_the_loop/dataclasses.py,sha256=OakB0PXBSG0LbQixcuo-d7IC-A3_k6qi80pB8hwY23o,2563
 haystack_experimental/components/agents/human_in_the_loop/errors.py,sha256=HAjD_MCOTBirqnJdxpc2MhqIm-XnU3Soev29wRBWoMw,1066
 haystack_experimental/components/agents/human_in_the_loop/policies.py,sha256=nzblePptT4Fg2GFHa4_SDIK_d7hZ_70qPhkteZBRXWk,3172
-haystack_experimental/components/agents/human_in_the_loop/strategies.py,sha256=KXfMLky27EuxOUhqbHO7oQ3KkL_3lzkwvk1Gk1EMXYY,19643
-haystack_experimental/components/agents/human_in_the_loop/types.py,sha256=aY93Wsd-5BgOiJaaSEGB_bGC-BTx_V_UT1faXtbNNdo,3072
+haystack_experimental/components/agents/human_in_the_loop/strategies.py,sha256=kX_3T6DWh4l3_-baOtJPwR0rZi4ZYWUibRA1Myeikp8,28645
+haystack_experimental/components/agents/human_in_the_loop/types.py,sha256=zdKGZ0vgaq-e0akYV_aGvCBpXplRiorpWcBmEbOQvT8,4604
 haystack_experimental/components/agents/human_in_the_loop/user_interfaces.py,sha256=HlJ3-CYNrQGsHOtpvrQE4ayQls8Q3EkLFUkOoRnLVC4,8707
 haystack_experimental/components/embedders/__init__.py,sha256=eHD7xrty2PCky_gG3ty19rpM4WfV32TyytM7gJODwl4,110
 haystack_experimental/components/embedders/types/__init__.py,sha256=HGR8aavwIEx7v-8nm5JxFIw47EWn7vAUmywhakTNDCo,182
-haystack_experimental/components/embedders/types/protocol.py,sha256=EEVtggoYWZL6zF-vbasJollCxLbheMYIISAh7hJ8LkA,1038
+haystack_experimental/components/embedders/types/protocol.py,sha256=nVMo2x_sFP9T_DN-q-_HKGrLRd3rj27m7ZLxtigY4UQ,1026
 haystack_experimental/components/generators/__init__.py,sha256=eHD7xrty2PCky_gG3ty19rpM4WfV32TyytM7gJODwl4,110
 haystack_experimental/components/generators/chat/__init__.py,sha256=LEKI1mMtltVbSiU40QgBfnWC-z3_660TWuV-cVHhdTw,465
 haystack_experimental/components/generators/chat/openai.py,sha256=gX6UI4yfY0pzKhWErquvPF_gV-3Ut0y6wSJytAD07Jk,9855
 haystack_experimental/components/preprocessors/__init__.py,sha256=qZPFKpRxdw_VZ8fZ4T3GIKOObsbeOf_pKnZbLHR9AFU,653
-haystack_experimental/components/preprocessors/embedding_based_document_splitter.py,sha256=VyQ--gaMsWid-IRBVXi5YPJpwbFlaK-2mRFvRF8MSBQ,17616
+haystack_experimental/components/preprocessors/embedding_based_document_splitter.py,sha256=NLi9e-aVJkZEvwQVzeWduyvR74wlYRHe6ZviDBx2rTk,17604
 haystack_experimental/components/preprocessors/md_header_level_inferrer.py,sha256=vyJWAFN-uhBkb5nCuJm0p29H75gGeaomOlHolD-fj5Q,5604
-haystack_experimental/components/query/__init__.py,sha256=quaqe16cbtgIdJx7d56CMdk1zZQ6f_3_TICsU0HF_U8,446
-haystack_experimental/components/query/query_expander.py,sha256=yyBrtYey9EhaWVNgtUDhYVBIylBt7JTWF7QmSKGDXbM,11961
-haystack_experimental/components/retrievers/__init__.py,sha256=CqPvqyvGp5L3Y1gTVQC8DD_xHzbIfTzGlj3oCsZM3J8,528
-haystack_experimental/components/retrievers/chat_message_retriever.py,sha256=CaAgW1qzzhMYyKNOyk-eIBgSsO7Bg7uDqAtgcorCE60,4030
-haystack_experimental/components/retrievers/multi_query_embedding_retriever.py,sha256=CQAWAGSBeMrLg1PxEPQNCHplYnOgvpXA0f-zbJtugKw,8101
-haystack_experimental/components/retrievers/multi_query_text_retriever.py,sha256=CfaqzBHHgnh79eSGU4Iada_gcnYwavj8_Ou6Bc4ndiA,6511
+haystack_experimental/components/retrievers/__init__.py,sha256=7NLOg-A7LmwxskDYebB_bDzawByCb7cXn67hVN_3e6I,245
+haystack_experimental/components/retrievers/chat_message_retriever.py,sha256=O94cNAbiTQ1Jkwsk6qjt9ty4JJwd_3uBh1odJjcvG2I,6046
 haystack_experimental/components/retrievers/types/__init__.py,sha256=iOngs3gs5enY8y6AWGeyQANTB_9qpXQ0QHSFFDDeEGc,218
 haystack_experimental/components/retrievers/types/protocol.py,sha256=oUdX_P_pTszzamrkUz3YZsXL3bb4mAYIXsPCtKDH1tw,2375
 haystack_experimental/components/summarizers/__init__.py,sha256=BqnfB0ZMb9ufYUjJ4qmmmRLPXa9FT8XKhMWW8G9Zg9Y,221
 haystack_experimental/components/summarizers/llm_summarizer.py,sha256=Rzl3DKWENBKoAiHvgYPsc4ev0WHZGJZj4PBF-FDHiXI,14392
-haystack_experimental/components/writers/__init__.py,sha256=iMdeAaZozza8E6dQ4Lc2uOYIFaR95K7bR9mSeuDqSAA,233
-haystack_experimental/components/writers/chat_message_writer.py,sha256=iu8gmvmRXlqd9S2-9B8p-7C0Y5GTuOI1AqcVKAkrzDc,3502
+haystack_experimental/components/writers/__init__.py,sha256=DNVIwIEUi6HKsGM5UcIUPjVH7P3I8Hzc8e4PO7tjoPM,235
+haystack_experimental/components/writers/chat_message_writer.py,sha256=Mkv9nShsPFAw1PPC6cK-tyYmXjWydCOl62boPNr7KkU,4042
 haystack_experimental/core/__init__.py,sha256=eHD7xrty2PCky_gG3ty19rpM4WfV32TyytM7gJODwl4,110
 haystack_experimental/core/pipeline/__init__.py,sha256=eHD7xrty2PCky_gG3ty19rpM4WfV32TyytM7gJODwl4,110
 haystack_experimental/core/pipeline/breakpoint.py,sha256=x6EW1lAv4em1z90Ezr0oKNOZGiR8jorzZBI4MOU6qKg,5239
 haystack_experimental/dataclasses/__init__.py,sha256=eHD7xrty2PCky_gG3ty19rpM4WfV32TyytM7gJODwl4,110
 haystack_experimental/dataclasses/breakpoints.py,sha256=f0kxYXJRHzk6jAW5Na51MZfUuRIlulhN4oTrGWTpSFE,2095
-haystack_experimental/super_components/__init__.py,sha256=eHD7xrty2PCky_gG3ty19rpM4WfV32TyytM7gJODwl4,110
-haystack_experimental/super_components/indexers/__init__.py,sha256=4VPKnuzVb89Zb4PT6ejYT4s0zJ4I3rwFtcLwsCdQKJA,313
-haystack_experimental/super_components/indexers/sentence_transformers_document_indexer.py,sha256=hfXznLVTgO39xO4GRYgi2Xy-pl4EFKtt13JrGncjvXQ,8519
 haystack_experimental/utils/__init__.py,sha256=eHD7xrty2PCky_gG3ty19rpM4WfV32TyytM7gJODwl4,110
 haystack_experimental/utils/hallucination_risk_calculator/__init__.py,sha256=kCd-qceud_T8P1XJHgRMaOnljyDjfFQ5UIdxEb5t6V0,219
 haystack_experimental/utils/hallucination_risk_calculator/core_math.py,sha256=8XIa2gX1B7U400KutPgxfIUHrOggkBPAm9gIkwhF7UM,4079
 haystack_experimental/utils/hallucination_risk_calculator/dataclasses.py,sha256=3vk9jsbW-7C9n408Qe730qgdXxIOzsTigf4TMLpryvI,2318
 haystack_experimental/utils/hallucination_risk_calculator/openai_planner.py,sha256=-yVQsGzM5rXsAVwolE6sp5W6q1yDw66SiIUuUbPk1ng,11413
 haystack_experimental/utils/hallucination_risk_calculator/skeletonization.py,sha256=qNdBUoFiBjQsI3ovrhd4RyTFmIbv51Goai1Z_l9lG28,5488
-haystack_experimental-0.14.3.dist-info/METADATA,sha256=9qsaqiWgCWrmALaybmA37OSLZjYXS8H95YlqIoP6DMA,18566
-haystack_experimental-0.14.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-haystack_experimental-0.14.3.dist-info/licenses/LICENSE,sha256=93_5nS97uHxptHvK9E8BZgKxLGeIS-rBWT2swIv-X5Y,11368
-haystack_experimental-0.14.3.dist-info/licenses/LICENSE-MIT.txt,sha256=knmLkIKj_6tTrTSVRg9Tq88Kww4UCPLt2I1RGXJv9sQ,1037
-haystack_experimental-0.14.3.dist-info/RECORD,,
+haystack_experimental-0.15.1.dist-info/METADATA,sha256=bjMAG3cFa5-gq7l8sVKD58gITsPKgvv0wJjb_Mq_TUM,17581
+haystack_experimental-0.15.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+haystack_experimental-0.15.1.dist-info/licenses/LICENSE,sha256=93_5nS97uHxptHvK9E8BZgKxLGeIS-rBWT2swIv-X5Y,11368
+haystack_experimental-0.15.1.dist-info/licenses/LICENSE-MIT.txt,sha256=knmLkIKj_6tTrTSVRg9Tq88Kww4UCPLt2I1RGXJv9sQ,1037
+haystack_experimental-0.15.1.dist-info/RECORD,,

{haystack_experimental-0.14.3.dist-info → haystack_experimental-0.15.1.dist-info}/WHEEL

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

haystack_experimental/components/query/__init__.py

@@ -1,18 +0,0 @@
-# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-import sys
-from typing import TYPE_CHECKING
-
-from lazy_imports import LazyImporter
-
-_import_structure = {
-    "query_expander": ["QueryExpander"],
-}
-
-if TYPE_CHECKING:
-    from .query_expander import QueryExpander
-
-else:
-    sys.modules[__name__] = LazyImporter(name=__name__, module_file=__file__, import_structure=_import_structure)

haystack_experimental/components/query/query_expander.py

@@ -1,294 +0,0 @@
-# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-import json
-from typing import Any, Optional
-
-from haystack import default_from_dict, default_to_dict, logging
-from haystack.components.builders.prompt_builder import PromptBuilder
-from haystack.components.generators.chat.openai import OpenAIChatGenerator
-from haystack.components.generators.chat.types import ChatGenerator
-from haystack.core.component import component
-from haystack.core.serialization import component_to_dict
-from haystack.dataclasses.chat_message import ChatMessage
-from haystack.utils.deserialization import deserialize_chatgenerator_inplace
-
-logger = logging.getLogger(__name__)
-
-
-DEFAULT_PROMPT_TEMPLATE = """
-You are part of an information system that processes user queries for retrieval.
-You have to expand a given query into {{ n_expansions }} queries that are
-semantically similar to improve retrieval recall.
-
-Structure:
-Follow the structure shown below in examples to generate expanded queries.
-
-Examples:
-1.  Query: "climate change effects"
-    {"queries": ["impact of climate change", "consequences of global warming", "effects of environmental changes"]}
-
-2.  Query: "machine learning algorithms"
-    {"queries": ["neural networks", "clustering techniques", "supervised learning methods", "deep learning models"]}
-
-3.  Query: "open source NLP frameworks"
-    {"queries": ["natural language processing tools", "free nlp libraries", "open-source NLP platforms"]}
-
-Guidelines:
-- Generate queries that use different words and phrasings
-- Include synonyms and related terms
-- Maintain the same core meaning and intent
-- Make queries that are likely to retrieve relevant information the original might miss
-- Focus on variations that would work well with keyword-based search
-- Respond in the same language as the input query
-
-Your Task:
-Query: "{{ query }}"
-
-You *must* respond with a JSON object containing a "queries" array with the expanded queries.
-Example: {"queries": ["query1", "query2", "query3"]}"""
-
-
-@component
-class QueryExpander:
-    """
-    A component that returns a list of semantically similar queries to improve retrieval recall in RAG systems.
-
-    The component uses a chat generator to expand queries. The chat generator is expected to return a JSON response
-    with the following structure:
-    ```json
-    {"queries": ["expanded query 1", "expanded query 2", "expanded query 3"]}
-    ```
-
-    ### Usage example
-
-    ```python
-    from haystack.components.generators.chat.openai import OpenAIChatGenerator
-    from haystack_experimental.components.query import QueryExpander
-
-    expander = QueryExpander(
-        chat_generator=OpenAIChatGenerator(model="gpt-4.1-mini"),
-        n_expansions=3
-    )
-
-    result = expander.run(query="green energy sources")
-    print(result["queries"])
-    # Output: ['alternative query 1', 'alternative query 2', 'alternative query 3', 'green energy sources']
-    # Note: Up to 3 additional queries + 1 original query (if include_original_query=True)
-
-    # To control total number of queries:
-    expander = QueryExpander(n_expansions=2, include_original_query=True)  # Up to 3 total
-    # or
-    expander = QueryExpander(n_expansions=3, include_original_query=False)  # Exactly 3 total
-    ```
-    """
-
-    def __init__(
-        self,
-        *,
-        chat_generator: Optional[ChatGenerator] = None,
-        prompt_template: Optional[str] = None,
-        n_expansions: int = 4,
-        include_original_query: bool = True,
-    ) -> None:
-        """
-        Initialize the QueryExpander component.
-
-        :param chat_generator: The chat generator component to use for query expansion.
-            If None, a default OpenAIChatGenerator with gpt-4.1-mini model is used.
-        :param prompt_template: Custom [PromptBuilder](https://docs.haystack.deepset.ai/docs/promptbuilder)
-            template for query expansion. The template should instruct the LLM to return a JSON response with the
-            structure: `{"queries": ["query1", "query2", "query3"]}`. The template should include 'query' and
-            'n_expansions' variables.
-        :param n_expansions: Number of alternative queries to generate (default: 4).
-        :param include_original_query: Whether to include the original query in the output.
-        """
-        if n_expansions <= 0:
-            raise ValueError("n_expansions must be positive")
-
-        self.n_expansions = n_expansions
-        self.include_original_query = include_original_query
-
-        if chat_generator is None:
-            self.chat_generator: ChatGenerator = OpenAIChatGenerator(
-                model="gpt-4.1-mini",
-                generation_kwargs={
-                    "temperature": 0.7,
-                    "response_format": {
-                        "type": "json_schema",
-                        "json_schema": {
-                            "name": "query_expansion",
-                            "schema": {
-                                "type": "object",
-                                "properties": {"queries": {"type": "array", "items": {"type": "string"}}},
-                                "required": ["queries"],
-                                "additionalProperties": False,
-                            },
-                        },
-                    },
-                    "seed": 42,
-                },
-            )
-        else:
-            self.chat_generator = chat_generator
-
-        self._is_warmed_up = False
-        self.prompt_template = prompt_template or DEFAULT_PROMPT_TEMPLATE
-
-        # Check if required variables are present in the template
-        if "query" not in self.prompt_template:
-            logger.warning(
-                "The prompt template does not contain the 'query' variable. This may cause issues during execution."
-            )
-        if "n_expansions" not in self.prompt_template:
-            logger.warning(
-                "The prompt template does not contain the 'n_expansions' variable. "
-                "This may cause issues during execution."
-            )
-
-        self._prompt_builder = PromptBuilder(
-            template=self.prompt_template,
-            required_variables=["n_expansions", "query"],
-        )
-
-    def to_dict(self) -> dict[str, Any]:
-        """
-        Serializes the component to a dictionary.
-
-        :return: Dictionary with serialized data.
-        """
-        return default_to_dict(
-            self,
-            chat_generator=component_to_dict(self.chat_generator, name="chat_generator"),
-            prompt_template=self.prompt_template,
-            n_expansions=self.n_expansions,
-            include_original_query=self.include_original_query,
-        )
-
-    @classmethod
-    def from_dict(cls, data: dict[str, Any]) -> "QueryExpander":
-        """
-        Deserializes the component from a dictionary.
-
-        :param data: Dictionary with serialized data.
-        :return: Deserialized component.
-        """
-        init_params = data.get("init_parameters", {})
-
-        deserialize_chatgenerator_inplace(init_params, key="chat_generator")
-
-        return default_from_dict(cls, data)
-
-    @component.output_types(queries=list[str])
-    def run(self, query: str, n_expansions: Optional[int] = None) -> dict[str, list[str]]:
-        """
-        Expand the input query into multiple semantically similar queries.
-
-        The language of the original query is preserved in the expanded queries.
-
-        :param query: The original query to expand.
-        :param n_expansions: Number of additional queries to generate (not including the original).
-            If None, uses the value from initialization. Can be 0 to generate no additional queries.
-        :return: Dictionary with "queries" key containing the list of expanded queries.
-            If include_original_query=True, the original query will be included in addition
-            to the n_expansions alternative queries.
-        :raises ValueError: If n_expansions is not positive (less than or equal to 0).
-        """
-
-        if not self._is_warmed_up:
-            self.warm_up()
-
-        response = {"queries": [query] if self.include_original_query else []}
-
-        if not query.strip():
-            logger.warning("Empty query provided to QueryExpander")
-            return response
-
-        expansion_count = n_expansions if n_expansions is not None else self.n_expansions
-        if expansion_count <= 0:
-            raise ValueError("n_expansions must be positive")
-
-        try:
-            prompt_result = self._prompt_builder.run(query=query.strip(), n_expansions=expansion_count)
-            generator_result = self.chat_generator.run(messages=[ChatMessage.from_user(prompt_result["prompt"])])
-
-            if not generator_result.get("replies") or len(generator_result["replies"]) == 0:
-                logger.warning("ChatGenerator returned no replies for query: {query}", query=query)
-                return response
-
-            expanded_text = generator_result["replies"][0].text.strip()
-            expanded_queries = self._parse_expanded_queries(expanded_text)
-
-            # Limit the number of expanded queries to the requested amount
-            if len(expanded_queries) > expansion_count:
-                logger.warning(
-                    "Generated {generated_count} queries but only {requested_count} were requested. "
-                    "Truncating to the first {requested_count} queries. ",
-                    generated_count=len(expanded_queries),
-                    requested_count=expansion_count,
-                )
-                expanded_queries = expanded_queries[:expansion_count]
-
-            # Add original query if requested and remove duplicates
-            if self.include_original_query:
-                expanded_queries_lower = [q.lower() for q in expanded_queries]
-                if query.lower() not in expanded_queries_lower:
-                    expanded_queries.append(query)
-
-            response["queries"] = expanded_queries
-            return response
-
-        except Exception as e:
-            # Fallback: return original query to maintain pipeline functionality
-            logger.error("Failed to expand query {query}: {error}", query=query, error=str(e))
-            return response
-
-    def warm_up(self):
-        """
-        Warm up the LLM provider component.
-        """
-        if not self._is_warmed_up:
-            if hasattr(self.chat_generator, "warm_up"):
-                self.chat_generator.warm_up()
-            self._is_warmed_up = True
-
-    @staticmethod
-    def _parse_expanded_queries(generator_response: str) -> list[str]:
-        """
-        Parse the generator response to extract individual expanded queries.
-
-        :param generator_response: The raw text response from the generator.
-        :return: List of parsed expanded queries.
-        """
-        if not generator_response.strip():
-            return []
-
-        try:
-            parsed = json.loads(generator_response)
-            if not isinstance(parsed, dict) or "queries" not in parsed:
-                logger.warning(
-                    "Generator response is not a JSON object containing a 'queries' array: {response}",
-                    response=generator_response[:100],
-                )
-                return []
-
-            queries = []
-            for item in parsed["queries"]:
-                if isinstance(item, str) and item.strip():
-                    queries.append(item.strip())
-                else:
-                    logger.warning(
-                        "Skipping non-string or empty query in response: {item}",
-                        item=item,
-                    )
-
-            return queries
-
-        except json.JSONDecodeError as e:
-            logger.warning(
-                "Failed to parse JSON response: {error}. Response: {response}",
-                error=str(e),
-                response=generator_response[:100],
-            )
-            return []

haystack_experimental/components/retrievers/multi_query_embedding_retriever.py

@@ -1,173 +0,0 @@
-# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from concurrent.futures import ThreadPoolExecutor
-from typing import Any, Optional
-
-from haystack import Document, component, default_from_dict, default_to_dict
-from haystack.components.embedders.types.protocol import TextEmbedder
-from haystack.core.serialization import component_to_dict
-from haystack.utils.deserialization import deserialize_component_inplace
-
-from haystack_experimental.components.retrievers.types import EmbeddingRetriever
-
-
-@component
-class MultiQueryEmbeddingRetriever:
-    """
-    A component that retrieves documents using multiple queries in parallel with an embedding-based retriever.
-
-    This component takes a list of text queries, converts them to embeddings using a query embedder,
-    and then uses an embedding-based retriever to find relevant documents for each query in parallel.
-    The results are combined and sorted by relevance score.
-
-    ### Usage example
-
-    ```python
-    from haystack import Document
-    from haystack.document_stores.in_memory import InMemoryDocumentStore
-    from haystack.document_stores.types import DuplicatePolicy
-    from haystack.components.embedders import SentenceTransformersTextEmbedder
-    from haystack.components.embedders import SentenceTransformersDocumentEmbedder
-    from haystack.components.retrievers import InMemoryEmbeddingRetriever
-    from haystack.components.writers import DocumentWriter
-    from haystack_experimental.components.retrievers import MultiQueryEmbeddingRetriever
-
-    documents = [
-        Document(content="Renewable energy is energy that is collected from renewable resources."),
-        Document(content="Solar energy is a type of green energy that is harnessed from the sun."),
-        Document(content="Wind energy is another type of green energy that is generated by wind turbines."),
-        Document(content="Geothermal energy is heat that comes from the sub-surface of the earth."),
-        Document(content="Biomass energy is produced from organic materials, such as plant and animal waste."),
-        Document(content="Fossil fuels, such as coal, oil, and natural gas, are non-renewable energy sources."),
-    ]
-
-    # Populate the document store
-    doc_store = InMemoryDocumentStore()
-    doc_embedder = SentenceTransformersDocumentEmbedder(model="sentence-transformers/all-MiniLM-L6-v2")
-    doc_embedder.warm_up()
-    doc_writer = DocumentWriter(document_store=doc_store, policy=DuplicatePolicy.SKIP)
-    documents = doc_embedder.run(documents)["documents"]
-    doc_writer.run(documents=documents)
-
-    # Run the multi-query retriever
-    in_memory_retriever = InMemoryEmbeddingRetriever(document_store=doc_store, top_k=1)
-    query_embedder = SentenceTransformersTextEmbedder(model="sentence-transformers/all-MiniLM-L6-v2")
-
-    multi_query_retriever = MultiQueryEmbeddingRetriever(
-        retriever=in_memory_retriever,
-        query_embedder=query_embedder,
-        max_workers=3
-    )
-
-    queries = ["Geothermal energy", "natural gas", "turbines"]
-    result = multi_query_retriever.run(queries=queries)
-    for doc in result["documents"]:
-        print(f"Content: {doc.content}, Score: {doc.score}")
-    >> Content: Geothermal energy is heat that comes from the sub-surface of the earth., Score: 0.8509603046266574
-    >> Content: Renewable energy is energy that is collected from renewable resources., Score: 0.42763211298893034
-    >> Content: Solar energy is a type of green energy that is harnessed from the sun., Score: 0.40077417016494354
-    >> Content: Fossil fuels, such as coal, oil, and natural gas, are non-renewable energy sources., Score: 0.3774863680995796
-    >> Content: Wind energy is another type of green energy that is generated by wind turbines., Score: 0.3091423972562246
-    >> Content: Biomass energy is produced from organic materials, such as plant and animal waste., Score: 0.25173074243668087
-    ```
-    """  # noqa E501
-
-    def __init__(self, *, retriever: EmbeddingRetriever, query_embedder: TextEmbedder, max_workers: int = 3) -> None:
-        """
-        Initialize MultiQueryEmbeddingRetriever.
-
-        :param retriever: The embedding-based retriever to use for document retrieval.
-        :param query_embedder: The query embedder to convert text queries to embeddings.
-        :param max_workers: Maximum number of worker threads for parallel processing.
-        """
-        self.retriever = retriever
-        self.query_embedder = query_embedder
-        self.max_workers = max_workers
-        self._is_warmed_up = False
-
-    def warm_up(self) -> None:
-        """
-        Warm up the query embedder and the retriever if any has a warm_up method.
-        """
-        if not self._is_warmed_up:
-            if hasattr(self.query_embedder, "warm_up") and callable(getattr(self.query_embedder, "warm_up")):
-                self.query_embedder.warm_up()
-            if hasattr(self.retriever, "warm_up") and callable(getattr(self.retriever, "warm_up")):
-                self.retriever.warm_up()
-            self._is_warmed_up = True
-
-    @component.output_types(documents=list[Document])
-    def run(self, queries: list[str], retriever_kwargs: Optional[dict[str, Any]] = None) -> dict[str, list[Document]]:
-        """
-        Retrieve documents using multiple queries in parallel.
-
-        :param queries: List of text queries to process.
-        :param retriever_kwargs: Optional dictionary of arguments to pass to the retriever's run method.
-        :returns:
-            A dictionary containing:
-                - `documents`: List of retrieved documents sorted by relevance score.
-        """
-        docs: list[Document] = []
-        seen_contents = set()
-        retriever_kwargs = retriever_kwargs or {}
-
-        if not self._is_warmed_up:
-            self.warm_up()
-
-        with ThreadPoolExecutor(max_workers=self.max_workers) as executor:
-            queries_results = executor.map(lambda query: self._run_on_thread(query, retriever_kwargs), queries)
-            for result in queries_results:
-                if not result:
-                    continue
-                for doc in result:
-                    # deduplicate based on content
-                    if doc.content not in seen_contents:
-                        docs.append(doc)
-                        seen_contents.add(doc.content)
-
-        docs.sort(key=lambda x: x.score or 0.0, reverse=True)
-        return {"documents": docs}
-
-    def _run_on_thread(self, query: str, retriever_kwargs: Optional[dict[str, Any]] = None) -> Optional[list[Document]]:
-        """
-        Process a single query on a separate thread.
-
-        :param query: The text query to process.
-        :returns:
-            List of retrieved documents or None if no results.
-        """
-        embedding_result = self.query_embedder.run(text=query)
-        query_embedding = embedding_result["embedding"]
-        result = self.retriever.run(query_embedding=query_embedding, **(retriever_kwargs or {}))
-        if result and "documents" in result:
-            return result["documents"]
-        return None
-
-    def to_dict(self) -> dict[str, Any]:
-        """
-        Serializes the component to a dictionary.
-
-        :returns:
-            A dictionary representing the serialized component.
-        """
-        return default_to_dict(
-            self,
-            retriever=component_to_dict(obj=self.retriever, name="retriever"),
-            query_embedder=component_to_dict(obj=self.query_embedder, name="query_embedder"),
-            max_workers=self.max_workers,
-        )
-
-    @classmethod
-    def from_dict(cls, data: dict[str, Any]) -> "MultiQueryEmbeddingRetriever":
-        """
-        Deserializes the component from a dictionary.
-
-        :param data: The dictionary to deserialize from.
-        :returns:
-            The deserialized component.
-        """
-        deserialize_component_inplace(data["init_parameters"], key="retriever")
-        deserialize_component_inplace(data["init_parameters"], key="query_embedder")
-        return default_from_dict(cls, data)