OutputAdapter
This component helps the output of one component fit smoothly into the input of another. It uses Jinja expressions to define how this adaptation occurs.
Most common position in a pipeline | Flexible |
Mandatory init variables | "template": A Jinja template string that defines how to adapt the data "output_type": Type alias that this instance will return |
Mandatory run variables | “**kwargs”: Input variables to be used in Jinja expression |
Output variables | The output is specified under the “output” key dictionary |
API reference | Converters |
GitHub link | https://github.com/deepset-ai/haystack/blob/main/haystack/components/converters/output_adapter.py |
Overview
To use OutputAdapter
, you need to specify the adaptation rule that includes:
template
: A Jinja template string that defines how to adapt the input data.output_type
: The type of the output data (such asstr
,List[int]
..). This doesn't change the actual output type and is only needed to validate connection with other components.custom_filters
: An optional dictionary of custom Jinja filters to be used in the template.
Unsafe behaviour
The OutputAdapter
internally renders the template
using Jinja, and by default, this is safe behavior. However, it limits the output types to strings, bytes, numbers, tuples, lists, dicts, sets, booleans, None
, and Ellipsis
(...
), as well as any combination of these structures.
If you want to use other types such as ChatMessage
, Document
, or Answer
, you must enable unsafe template rendering by setting the unsafe
init argument to True
.
Be cautious, as enabling this can be unsafe and may lead to remote code execution if the template
is a string customizable by the end user.
Usage
On its own
This component is primarily meant to be used in pipelines.
In this example, OutputAdapter
simply outputs the content field of the first document in the arrays of documents:
from haystack import Document
from haystack.components.converters import OutputAdapter
adapter = OutputAdapter(template="{{ documents[0].content }}", output_type=str)
input_data = {"documents": [Document(content="Test content")]}
expected_output = {"output": "Test content"}
assert adapter.run(**input_data) == expected_output
In a pipeline
The example below demonstrates a straightforward pipeline that uses the OutputAdapter
to capitalize the first document in the list. If needed, you can also utilize the predefined Jinja filters.
from haystack import Pipeline, component, Document
from haystack.components.converters import OutputAdapter
@component
class DocumentProducer:
@component.output_types(documents=dict)
def run(self):
return {"documents": [Document(content="haystack")]}
pipe = Pipeline()
pipe.add_component(
name="output_adapter",
instance=OutputAdapter(template="{{ documents[0].content | capitalize}}", output_type=str),
)
pipe.add_component(name="document_producer", instance=DocumentProducer())
pipe.connect("document_producer", "output_adapter")
result = pipe.run(data={})
assert result["output_adapter"]["output"] == "Haystack"
You can also define your own custom filters, which can then be added to an OutputAdapter
instance through its init method and used in templates. Here’s an example of this approach:
from haystack import Pipeline, component, Document
from haystack.components.converters import OutputAdapter
def reverse_string(s):
return s[::-1]
@component
class DocumentProducer:
@component.output_types(documents=dict)
def run(self):
return {"documents": [Document(content="haystack")]}
pipe = Pipeline()
pipe.add_component(
name="output_adapter",
instance=OutputAdapter(template="{{ documents[0].content | reverse_string}}",
output_type=str,
custom_filters={"reverse_string": reverse_string}))
pipe.add_component(name="document_producer", instance=DocumentProducer())
pipe.connect("document_producer", "output_adapter")
result = pipe.run(data={})
assert result["output_adapter"]["output"] == "kcatsyah"
Updated about 1 month ago