| | |
| | |
| | |
| |
|
| | from typing import Any, Dict, Type |
| |
|
| | from haystack import component, default_from_dict, default_to_dict, logging |
| | from haystack.core.component.types import GreedyVariadic |
| | from haystack.utils import deserialize_type, serialize_type |
| |
|
| | logger = logging.getLogger(__name__) |
| |
|
| |
|
| | @component() |
| | class BranchJoiner: |
| | """ |
| | A component to join different branches of a pipeline into one single output. |
| | |
| | `BranchJoiner` receives multiple data connections of the same type from other components and passes the first |
| | value coming to its single output, possibly distributing it to various other components. |
| | |
| | `BranchJoiner` is fundamental to close loops in a pipeline, where the two branches it joins are the ones |
| | coming from the previous component and one coming back from a loop. For example, `BranchJoiner` could be used |
| | to send data to a component evaluating errors. `BranchJoiner` would receive two connections, one to get the |
| | original data and another one to get modified data in case there was an error. In both cases, `BranchJoiner` |
| | would send (or re-send in case of a loop) data to the component evaluating errors. See "Usage example" below. |
| | |
| | Another use case with a need for `BranchJoiner` is to reconcile multiple branches coming out of a decision |
| | or Classifier component. For example, in a RAG pipeline, there might be a "query language classifier" component |
| | sending the query to different retrievers, selecting one specifically according to the detected language. After the |
| | retrieval step the pipeline would ideally continue with a `PromptBuilder`, and since we don't know in advance the |
| | language of the query, all the retrievers should be ideally connected to the single `PromptBuilder`. Since the |
| | `PromptBuilder` won't accept more than one connection in input, we would connect all the retrievers to a |
| | `BranchJoiner` component and reconcile them in a single output that can be connected to the `PromptBuilder` |
| | downstream. |
| | |
| | Usage example: |
| | |
| | ```python |
| | import json |
| | from typing import List |
| | |
| | from haystack import Pipeline |
| | from haystack.components.converters import OutputAdapter |
| | from haystack.components.generators.chat import OpenAIChatGenerator |
| | from haystack.components.joiners import BranchJoiner |
| | from haystack.components.validators import JsonSchemaValidator |
| | from haystack.dataclasses import ChatMessage |
| | |
| | person_schema = { |
| | "type": "object", |
| | "properties": { |
| | "first_name": {"type": "string", "pattern": "^[A-Z][a-z]+$"}, |
| | "last_name": {"type": "string", "pattern": "^[A-Z][a-z]+$"}, |
| | "nationality": {"type": "string", "enum": ["Italian", "Portuguese", "American"]}, |
| | }, |
| | "required": ["first_name", "last_name", "nationality"] |
| | } |
| | |
| | # Initialize a pipeline |
| | pipe = Pipeline() |
| | |
| | # Add components to the pipeline |
| | pipe.add_component('joiner', BranchJoiner(List[ChatMessage])) |
| | pipe.add_component('fc_llm', OpenAIChatGenerator(model="gpt-4o-mini")) |
| | pipe.add_component('validator', JsonSchemaValidator(json_schema=person_schema)) |
| | pipe.add_component('adapter', OutputAdapter("{{chat_message}}", List[ChatMessage])), |
| | # And connect them |
| | pipe.connect("adapter", "joiner") |
| | pipe.connect("joiner", "fc_llm") |
| | pipe.connect("fc_llm.replies", "validator.messages") |
| | pipe.connect("validator.validation_error", "joiner") |
| | |
| | result = pipe.run(data={"fc_llm": {"generation_kwargs": {"response_format": {"type": "json_object"}}}, |
| | "adapter": {"chat_message": [ChatMessage.from_user("Create json from Peter Parker")]}}) |
| | |
| | print(json.loads(result["validator"]["validated"][0].content)) |
| | |
| | |
| | >> {'first_name': 'Peter', 'last_name': 'Parker', 'nationality': 'American', 'name': 'Spider-Man', 'occupation': |
| | >> 'Superhero', 'age': 23, 'location': 'New York City'} |
| | ``` |
| | |
| | Note that `BranchJoiner` can manage only one data type at a time. In this case, `BranchJoiner` is created for |
| | passing `List[ChatMessage]`. This determines the type of data that `BranchJoiner` will receive from the upstream |
| | connected components and also the type of data that `BranchJoiner` will send through its output. |
| | |
| | In the code example, `BranchJoiner` receives a looped back `List[ChatMessage]` from the `JsonSchemaValidator` and |
| | sends it down to the `OpenAIChatGenerator` for re-generation. We can have multiple loopback connections in the |
| | pipeline. In this instance, the downstream component is only one (the `OpenAIChatGenerator`), but the pipeline might |
| | have more than one downstream component. |
| | """ |
| |
|
| | def __init__(self, type_: Type): |
| | """ |
| | Create a `BranchJoiner` component. |
| | |
| | :param type_: The type of data that the `BranchJoiner` will receive from the upstream connected components and |
| | distribute to the downstream connected components. |
| | """ |
| | self.type_ = type_ |
| | |
| | component.set_input_types(self, value=GreedyVariadic[type_]) |
| | component.set_output_types(self, value=type_) |
| |
|
| | def to_dict(self): |
| | """ |
| | Serializes the component to a dictionary. |
| | |
| | :returns: |
| | Dictionary with serialized data. |
| | """ |
| | return default_to_dict(self, type_=serialize_type(self.type_)) |
| |
|
| | @classmethod |
| | def from_dict(cls, data: Dict[str, Any]) -> "BranchJoiner": |
| | """ |
| | Deserializes the component from a dictionary. |
| | |
| | :param data: |
| | Dictionary to deserialize from. |
| | :returns: |
| | Deserialized component. |
| | """ |
| | data["init_parameters"]["type_"] = deserialize_type(data["init_parameters"]["type_"]) |
| | return default_from_dict(cls, data) |
| |
|
| | def run(self, **kwargs): |
| | """ |
| | The run method of the `BranchJoiner` component. |
| | |
| | Multiplexes the input data from the upstream connected components and distributes it to the downstream connected |
| | components. |
| | |
| | :param **kwargs: The input data. Must be of the type declared in `__init__`. |
| | :return: A dictionary with the following keys: |
| | - `value`: The input data. |
| | """ |
| | if (inputs_count := len(kwargs["value"])) != 1: |
| | raise ValueError(f"BranchJoiner expects only one input, but {inputs_count} were received.") |
| | return {"value": kwargs["value"][0]} |
| |
|
