diff --git a/burr/integrations/haystack.py b/burr/integrations/haystack.py
new file mode 100644
index 00000000..508862f5
--- /dev/null
+++ b/burr/integrations/haystack.py
@@ -0,0 +1,303 @@
+import inspect
+from collections.abc import Mapping
+from typing import Any, Optional, Sequence, Union
+
+from haystack import Pipeline
+from haystack.core.component import Component
+from haystack.core.component.types import _empty as haystack_empty
+
+from burr.core.action import Action
+from burr.core.graph import Graph, GraphBuilder
+from burr.core.state import State
+
+
+# TODO show OpenTelemetry integration
+class HaystackAction(Action):
+    """Burr ``Action`` wrapping a Haystack ``Component``.
+
+    Haystack ``Component`` is the basic block of a Haystack ``Pipeline``.
+    A ``Component`` is instantiated, then it receives inputs for its ``.run()`` method
+    and returns output values.
+
+    Learn more about components here: https://docs.haystack.deepset.ai/docs/custom-components
+    """
+
+    def __init__(
+        self,
+        component: Component,
+        reads: Union[list[str], dict[str, str]],
+        writes: Union[list[str], dict[str, str]],
+        name: Optional[str] = None,
+        bound_params: Optional[dict] = None,
+    ):
+        """Create a Burr ``Action`` from a Haystack ``Component``.
+
+        :param component: Haystack ``Component`` to wrap
+        :param reads: State fields read and passed to ``Component.run()``
+        :param writes: State fields where results of ``Component.run()`` are written
+        :param name: Name of the action. Can be set later via ``.with_name()`` or in the
+            ``ApplicationBuilder``.
+        :param bound_params: Parameters to bind to the `Component.run()` method.
+
+        Basic example:
+
+        .. code-block:: python
+
+            from haystack.components.retrievers.in_memory import InMemoryEmbeddingRetriever
+            from haystack.document_stores.in_memory import InMemoryDocumentStore
+            from burr.core import ApplicationBuilder
+            from burr.integrations.haystack import HaystackAction
+
+            retrieve_documents = HaystackAction(
+                component=InMemoryEmbeddingRetriever(InMemoryDocumentStore()),
+                name="retrieve_documents",
+                reads=["query_embedding"],
+                writes=["documents"],
+            )
+
+            app = (
+              ApplicationBuilder()
+              .with_actions(retrieve_documents)
+              .with_transitions("retrieve_documents", "retrieve_documents")
+              .with_entrypoint("retrieve_documents")
+              .build()
+            )
+        """
+        self._component = component
+        self._name = name
+        self._bound_params = bound_params if bound_params is not None else {}
+
+        # NOTE input and output socket mappings are kept separately to avoid naming conflicts.
+        if isinstance(reads, Mapping):
+            self._input_socket_mapping = reads
+            self._reads = list(set(reads.values()))
+        elif isinstance(reads, Sequence):
+            self._input_socket_mapping = {socket_name: socket_name for socket_name in reads}
+            self._reads = reads
+        else:
+            raise TypeError(f"`reads` must be a sequence or mapping. Received: {type(reads)}")
+
+        self._validate_input_sockets()
+
+        if isinstance(writes, Mapping):
+            self._output_socket_mapping = writes
+            self._writes = list(writes.keys())
+        elif isinstance(writes, Sequence):
+            self._output_socket_mapping = {socket_name: socket_name for socket_name in writes}
+            self._writes = writes
+        else:
+            raise TypeError(f"`writes` must be a sequence or mapping. Received: {type(writes)}")
+
+        self._validate_output_sockets()
+
+    def _validate_input_sockets(self) -> None:
+        component_inputs = self._component.__haystack_input__._sockets_dict.keys()
+        for socket_name in self._input_socket_mapping.keys():
+            if socket_name not in component_inputs:
+                raise ValueError(
+                    f"Socket `{socket_name}` not found in `Component` inputs: {component_inputs}"
+                )
+
+    def _validate_output_sockets(self) -> None:
+        component_outputs = self._component.__haystack_output__._sockets_dict.keys()
+        for socket_name in self._output_socket_mapping.values():
+            if socket_name not in component_outputs:
+                raise ValueError(
+                    f"Socket `{socket_name}` not found in `Component` outputs: {component_outputs}"
+                )
+
+    @property
+    def component(self) -> Component:
+        """Haystack `Component` used by this action."""
+        return self._component
+
+    @property
+    def reads(self) -> list[str]:
+        """State fields read and passed to `Component.run()`"""
+        return self._reads
+
+    @property
+    def writes(self) -> list[str]:
+        """State fields where results of `Component.run()` are written."""
+        return self._writes
+
+    @property
+    def inputs(self) -> tuple[dict[str, str], dict[str, str]]:
+        """Return dictionaries of required and optional inputs for `Component.run()`"""
+        required_inputs, optional_inputs = {}, {}
+        for socket_name, input_socket in self._component.__haystack_input__._sockets_dict.items():
+            state_field_name = self._input_socket_mapping.get(socket_name, socket_name)
+
+            # if we expect the value to come from state (previous actions) or it's a
+            # bound parameter, then this socket isn't a user-provided input
+            if state_field_name in self.reads or state_field_name in self._bound_params:
+                continue
+
+            # determine if input is required or optional based on the socket's default value
+            if input_socket.default_value == haystack_empty:
+                required_inputs[state_field_name] = input_socket.type
+            else:
+                optional_inputs[state_field_name] = input_socket.type
+
+        return required_inputs, optional_inputs
+
+    def run(self, state: State, **run_kwargs) -> dict[str, Any]:
+        """Call the Haystack `Component.run()` method.
+
+        :param state: State object of the application. It contains some input values
+           for ``Component.run()``.
+        :param run_kwargs: User-provided inputs for ``Component.run()``.
+        :return: Dictionary of results with mapping ``{socket_name: value}``.
+
+        Note, values come from 3 sources:
+        - state (from previous actions)
+        - run_kwargs (inputs from ``Application.run()``)
+        - bound parameters (from ``HaystackAction`` instantiation)
+        """
+        values = {}
+
+        # here, precedence matters. Alternatively, we could unpack all dictionaries at once
+        # which would throw an error for key collisions
+        for input_socket_name, value in self._bound_params.items():
+            values[input_socket_name] = value
+
+        for input_socket_name, state_field_name in self._input_socket_mapping.items():
+            try:
+                values[input_socket_name] = state[state_field_name]
+            except KeyError as e:
+                raise ValueError(f"No value found in state for field: {state_field_name}") from e
+
+        for input_socket_name, value in run_kwargs.items():
+            values[input_socket_name] = value
+
+        return self._component.run(**values)
+
+    def update(self, result: dict, state: State) -> State:
+        """Update the state using the results of ``Component.run()``.
+        The output socket name is mapped to the Burr state field name.
+
+        Values returned by ``Component.run()`` that aren't in ``writes`` are ignored.
+        """
+        # TODO we could want to handle ``.update()`` and ``.append()`` differently
+        state_update = {}
+
+        for state_field_name, output_socket_name in self._output_socket_mapping.items():
+            if state_field_name in self.writes:
+                try:
+                    state_update[state_field_name] = result[output_socket_name]
+                except KeyError as e:
+                    raise ValueError(
+                        f"Socket `{output_socket_name}` missing from output of `Component.run()`"
+                    ) from e
+        return state.update(**state_update)
+
+    def get_source(self) -> str:
+        """Return the source code of the Haystack ``Component``.
+
+        NOTE. This doesn't include the initialization parameters of the ``Component``.
+        This can be obtained using``HaystackAction().component.to_dict()``, but this
+        method might is not implemented for all components.
+        """
+        return inspect.getsource(self._component.__class__)
+
+
+def _socket_name_mapping(sockets_connections: list[tuple[str, str]]) -> dict[str, str]:
+    """Map socket names to a single socket name.
+
+    In Haystack, components communicate via sockets. A socket called
+    "embedding" in one component can be renamed to "query_embedding" when
+    passed to another component.
+
+    In Burr, there is a single state object so we need a mapping to resolve
+    that `embedding` and `query_embedding` point to the same value. This function
+    creates a mapping {socket_name: state_field} to rename sockets when creating
+    the Burr `Graph`.
+    """
+    all_connections: dict[str, set[str]] = {}
+    for from_, to in sockets_connections:
+        if from_ not in all_connections:
+            all_connections[from_] = {from_}
+        all_connections[from_].add(to)
+
+        if to not in all_connections:
+            all_connections[to] = {to}
+        all_connections[to].add(from_)
+
+    reduced_mapping: dict[str, str] = {}
+    for key, values in all_connections.items():
+        unique_name = min(values)
+        reduced_mapping[key] = unique_name
+
+    return reduced_mapping
+
+
+def _connected_inputs(pipeline) -> dict[str, list[str]]:
+    """Get all input sockets that are connected to other components."""
+    return {
+        name: [
+            socket.name
+            for socket in data.get("input_sockets", {}).values()
+            if socket.is_variadic or socket.senders
+        ]
+        for name, data in pipeline.graph.nodes(data=True)
+    }
+
+
+def _connected_outputs(pipeline) -> dict[str, list[str]]:
+    """Get all output sockets that are connected to other components."""
+    return {
+        name: [
+            socket.name for socket in data.get("output_sockets", {}).values() if socket.receivers
+        ]
+        for name, data in pipeline.graph.nodes(data=True)
+    }
+
+
+def haystack_pipeline_to_burr_graph(pipeline: Pipeline) -> Graph:
+    """Convert a Haystack `Pipeline` to a Burr `Graph`.
+
+    NOTE. This currently doesn't support Haystack pipelines with
+    parallel branches. Learn more https://docs.haystack.deepset.ai/docs/pipelines#branching
+
+    From the Haystack `Pipeline`, we can easily retrieve transitions.
+    For actions, we need to create `HaystackAction` from components
+    and map their sockets to Burr state fields
+
+    EXPERIMENTAL: This feature is experimental and may change in the future.
+    Changes to Haystack or Burr could impact this function. Please let us know if
+    you encounter any issues.
+    """
+
+    # get all socket connections in the pipeline
+    sockets_connections = [
+        (edge_data["from_socket"].name, edge_data["to_socket"].name)
+        for _, _, edge_data in pipeline.graph.edges.data()
+    ]
+    socket_mapping = _socket_name_mapping(sockets_connections)
+
+    transitions = [(from_, to) for from_, to, _ in pipeline.graph.edges]
+
+    # get all input and output sockets that are connected to other components
+    connected_inputs = _connected_inputs(pipeline)
+    connected_outputs = _connected_outputs(pipeline)
+
+    actions = []
+    for component_name, component in pipeline.walk():
+        inputs_mapping = {
+            socket_name: socket_mapping[socket_name]
+            for socket_name in connected_inputs[component_name]
+        }
+        outputs_mapping = {
+            socket_mapping[socket_name]: socket_name
+            for socket_name in connected_outputs[component_name]
+        }
+
+        haystack_action = HaystackAction(
+            name=component_name,
+            component=component,
+            reads=inputs_mapping,
+            writes=outputs_mapping,
+        )
+        actions.append(haystack_action)
+
+    return GraphBuilder().with_actions(*actions).with_transitions(*transitions).build()
diff --git a/docs/reference/integrations/haystack.rst b/docs/reference/integrations/haystack.rst
new file mode 100644
index 00000000..045a099b
--- /dev/null
+++ b/docs/reference/integrations/haystack.rst
@@ -0,0 +1,9 @@
+========
+Haystack
+========
+
+The Haystack integration allows you to use ``Component`` as Burr ``Action`` using the ``HaystackAction`` construct. You can visit the examples in ``burr/examples/haystack-integration`` for a notebook tutorial.
+
+.. autoclass:: burr.integrations.haystack.HaystackAction
+
+.. autofunction:: burr.integrations.haystack.haystack_pipeline_to_burr_graph
diff --git a/examples/haystack-integration/README.md b/examples/haystack-integration/README.md
new file mode 100644
index 00000000..b99d7e17
--- /dev/null
+++ b/examples/haystack-integration/README.md
@@ -0,0 +1,5 @@
+# Haystack + Burr integration
+
+Haystack is a Python library to build AI pipelines. It assembles `Component` objects into a `Pipeline`, which is a graph of operations. One benefit of Haystack is that it provides many pre-built components to manage documents and interact with LLMs.
+
+This notebook shows how to convert a Haystack `Component` into a Burr `Action` and a `Pipeline` into a `Graph`. This allows you to integrate Haystack with Burr and leverage other Burr and Burr UI features!
diff --git a/examples/haystack-integration/__init__.py b/examples/haystack-integration/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/examples/haystack-integration/application.py b/examples/haystack-integration/application.py
new file mode 100644
index 00000000..584ad93f
--- /dev/null
+++ b/examples/haystack-integration/application.py
@@ -0,0 +1,77 @@
+import os
+
+from haystack.components.builders import PromptBuilder
+from haystack.components.embedders import SentenceTransformersTextEmbedder
+from haystack.components.generators import OpenAIGenerator
+from haystack.components.retrievers.in_memory import InMemoryEmbeddingRetriever
+from haystack.document_stores.in_memory import InMemoryDocumentStore
+
+from burr.core import ApplicationBuilder, State, action
+from burr.integrations.haystack import HaystackAction
+
+# dummy OpenAI key to avoid raising an error
+os.environ["OPENAI_API_KEY"] = "sk-..."
+
+
+embed_text = HaystackAction(
+    component=SentenceTransformersTextEmbedder(model="sentence-transformers/all-MiniLM-L6-v2"),
+    name="embed_text",
+    reads=[],
+    writes={"embedding": "query_embedding"},
+)
+
+
+retrieve_documents = HaystackAction(
+    component=InMemoryEmbeddingRetriever(InMemoryDocumentStore()),
+    name="retrieve_documents",
+    reads=["query_embedding"],
+    writes=["documents"],
+)
+
+
+build_prompt = HaystackAction(
+    component=PromptBuilder(template="Document: {{documents}} Question: {{question}}"),
+    name="build_prompt",
+    reads=["documents"],
+    writes={"prompt": "question_prompt"},
+)
+
+
+generate_answer = HaystackAction(
+    component=OpenAIGenerator(model="gpt-4o-mini"),
+    name="generate_answer",
+    reads={"question_prompt": "prompt"},
+    writes={"text": "answer"},
+)
+
+
+@action(reads=["answer"], writes=[])
+def display_answer(state: State) -> State:
+    print(state["answer"])
+    return state
+
+
+def build_application():
+    return (
+        ApplicationBuilder()
+        .with_actions(
+            embed_text,
+            retrieve_documents,
+            build_prompt,
+            generate_answer,
+            display_answer,
+        )
+        .with_transitions(
+            ("embed_text", "retrieve_documents"),
+            ("retrieve_documents", "build_prompt"),
+            ("build_prompt", "generate_answer"),
+            ("generate_answer", "display_answer"),
+        )
+        .with_entrypoint("embed_text")
+        .build()
+    )
+
+
+if __name__ == "__main__":
+    app = build_application()
+    app.visualize(include_state=True)
diff --git a/examples/haystack-integration/notebook.ipynb b/examples/haystack-integration/notebook.ipynb
new file mode 100644
index 00000000..2bbed2a4
--- /dev/null
+++ b/examples/haystack-integration/notebook.ipynb
@@ -0,0 +1,812 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Haystack + Burr integration\n",
+    "\n",
+    "Haystack is a Python library to build AI pipelines. It assembles `Component` objects into a `Pipeline`, which is a graph of operations. One benefit of Haystack is that it provides many pre-built components to manage documents and interact with LLMs.\n",
+    "\n",
+    "This notebook shows how to convert a Haystack `Component` into a Burr `Action` and a `Pipeline` into a `Graph`. This allows you to integrate Haystack with Burr and leverage other Burr and Burr UI features!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Native Haystack\n",
+    "The next cells show how to build a simple RAG pipeline using Haystack. You create the components and add them to the pipeline using `.add_component()`. Then, you need to specify connections between components using `.connect()`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tjean/projects/dagworks/burr/.venv/lib/python3.11/site-packages/haystack/core/errors.py:34: DeprecationWarning: PipelineMaxLoops is deprecated and will be remove in version '2.7.0'; use PipelineMaxComponentRuns instead.\n",
+      "  warnings.warn(\n",
+      "/home/tjean/projects/dagworks/burr/.venv/lib/python3.11/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<IPython.core.display.Image object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import os\n",
+    "\n",
+    "from haystack.components.embedders import SentenceTransformersTextEmbedder\n",
+    "from haystack.components.builders import PromptBuilder\n",
+    "from haystack.components.generators import OpenAIGenerator\n",
+    "from haystack.components.retrievers.in_memory import InMemoryEmbeddingRetriever\n",
+    "from haystack.document_stores.in_memory import InMemoryDocumentStore\n",
+    "from haystack import Pipeline\n",
+    "\n",
+    "# dummy OpenAI key to avoid raising an error\n",
+    "os.environ[\"OPENAI_API_KEY\"] = \"sk-...\"\n",
+    "\n",
+    "# 1. create components\n",
+    "document_store = InMemoryDocumentStore()\n",
+    "text_embedder = SentenceTransformersTextEmbedder(model=\"sentence-transformers/all-MiniLM-L6-v2\")\n",
+    "prompt_builder = PromptBuilder(template=\"Document: {{documents}} Question: {{question}}\")\n",
+    "retriever = InMemoryEmbeddingRetriever(document_store)\n",
+    "generator = OpenAIGenerator(model=\"gpt-4o-mini\")\n",
+    "\n",
+    "# 2. create pipeline\n",
+    "basic_rag_pipeline = Pipeline()\n",
+    "\n",
+    "# 3. add components to the pipeline\n",
+    "basic_rag_pipeline.add_component(\"text_embedder\", text_embedder)\n",
+    "basic_rag_pipeline.add_component(\"retriever\", retriever)\n",
+    "basic_rag_pipeline.add_component(\"prompt_builder\", prompt_builder)\n",
+    "basic_rag_pipeline.add_component(\"llm\", generator)\n",
+    "\n",
+    "# 4. connect components\n",
+    "basic_rag_pipeline.connect(\"text_embedder.embedding\", \"retriever.query_embedding\")\n",
+    "basic_rag_pipeline.connect(\"retriever\", \"prompt_builder.documents\")\n",
+    "basic_rag_pipeline.connect(\"prompt_builder\", \"llm\")\n",
+    "\n",
+    "basic_rag_pipeline.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Without using any integration, you could use Haystack within Burr's `actions`. The next is illustrative of how it can work."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/svg+xml": [
+       "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n",
+       "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n",
+       " \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n",
+       "<!-- Generated by graphviz version 2.43.0 (0)\n",
+       " -->\n",
+       "<!-- Title: %3 Pages: 1 -->\n",
+       "<svg width=\"473pt\" height=\"309pt\"\n",
+       " viewBox=\"0.00 0.00 473.00 309.00\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n",
+       "<g id=\"graph0\" class=\"graph\" transform=\"scale(1 1) rotate(0) translate(4 305)\">\n",
+       "<title>%3</title>\n",
+       "<polygon fill=\"white\" stroke=\"transparent\" points=\"-4,4 -4,-305 469,-305 469,4 -4,4\"/>\n",
+       "<!-- embed_text -->\n",
+       "<g id=\"node1\" class=\"node\">\n",
+       "<title>embed_text</title>\n",
+       "<path fill=\"#b4d8e4\" stroke=\"black\" d=\"M337.5,-235C337.5,-235 111.5,-235 111.5,-235 105.5,-235 99.5,-229 99.5,-223 99.5,-223 99.5,-210 99.5,-210 99.5,-204 105.5,-198 111.5,-198 111.5,-198 337.5,-198 337.5,-198 343.5,-198 349.5,-204 349.5,-210 349.5,-210 349.5,-223 349.5,-223 349.5,-229 343.5,-235 337.5,-235\"/>\n",
+       "<text text-anchor=\"middle\" x=\"224.5\" y=\"-212.8\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">embed_text(): query_embedding</text>\n",
+       "</g>\n",
+       "<!-- retrieve_documents -->\n",
+       "<g id=\"node3\" class=\"node\">\n",
+       "<title>retrieve_documents</title>\n",
+       "<path fill=\"#b4d8e4\" stroke=\"black\" d=\"M371,-169C371,-169 12,-169 12,-169 6,-169 0,-163 0,-157 0,-157 0,-144 0,-144 0,-138 6,-132 12,-132 12,-132 371,-132 371,-132 377,-132 383,-138 383,-144 383,-144 383,-157 383,-157 383,-163 377,-169 371,-169\"/>\n",
+       "<text text-anchor=\"middle\" x=\"191.5\" y=\"-146.8\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">retrieve_documents(query_embedding): documents</text>\n",
+       "</g>\n",
+       "<!-- embed_text&#45;&gt;retrieve_documents -->\n",
+       "<g id=\"edge3\" class=\"edge\">\n",
+       "<title>embed_text&#45;&gt;retrieve_documents</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M215.31,-197.67C212.23,-191.71 208.73,-184.92 205.38,-178.42\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"208.34,-176.52 200.64,-169.23 202.12,-179.72 208.34,-176.52\"/>\n",
+       "</g>\n",
+       "<!-- input__user_question -->\n",
+       "<g id=\"node2\" class=\"node\">\n",
+       "<title>input__user_question</title>\n",
+       "<polygon fill=\"none\" stroke=\"black\" stroke-dasharray=\"5,2\" points=\"383,-301 218,-301 218,-264 383,-264 383,-301\"/>\n",
+       "<text text-anchor=\"middle\" x=\"300.5\" y=\"-278.8\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">input: user_question</text>\n",
+       "</g>\n",
+       "<!-- input__user_question&#45;&gt;embed_text -->\n",
+       "<g id=\"edge1\" class=\"edge\">\n",
+       "<title>input__user_question&#45;&gt;embed_text</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M279.33,-263.67C271.19,-256.82 261.76,-248.88 253.04,-241.54\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"255.2,-238.77 245.29,-235.01 250.69,-244.13 255.2,-238.77\"/>\n",
+       "</g>\n",
+       "<!-- build_prompt -->\n",
+       "<g id=\"node4\" class=\"node\">\n",
+       "<title>build_prompt</title>\n",
+       "<path fill=\"#b4d8e4\" stroke=\"black\" d=\"M452.5,-103C452.5,-103 148.5,-103 148.5,-103 142.5,-103 136.5,-97 136.5,-91 136.5,-91 136.5,-78 136.5,-78 136.5,-72 142.5,-66 148.5,-66 148.5,-66 452.5,-66 452.5,-66 458.5,-66 464.5,-72 464.5,-78 464.5,-78 464.5,-91 464.5,-91 464.5,-97 458.5,-103 452.5,-103\"/>\n",
+       "<text text-anchor=\"middle\" x=\"300.5\" y=\"-80.8\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">build_prompt(documents): question_prompt</text>\n",
+       "</g>\n",
+       "<!-- input__user_question&#45;&gt;build_prompt -->\n",
+       "<g id=\"edge2\" class=\"edge\">\n",
+       "<title>input__user_question&#45;&gt;build_prompt</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M327.17,-263.94C337.84,-256 349.66,-245.94 358.5,-235 388.7,-197.6 416.59,-173 391.5,-132 385.48,-122.17 376.66,-114.33 366.84,-108.11\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"368.42,-104.98 358,-103.05 364.94,-111.06 368.42,-104.98\"/>\n",
+       "</g>\n",
+       "<!-- retrieve_documents&#45;&gt;build_prompt -->\n",
+       "<g id=\"edge4\" class=\"edge\">\n",
+       "<title>retrieve_documents&#45;&gt;build_prompt</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M221.57,-131.84C233.96,-124.57 248.48,-116.05 261.66,-108.31\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"263.67,-111.18 270.52,-103.1 260.13,-105.15 263.67,-111.18\"/>\n",
+       "</g>\n",
+       "<!-- generate_answer -->\n",
+       "<g id=\"node5\" class=\"node\">\n",
+       "<title>generate_answer</title>\n",
+       "<path fill=\"#b4d8e4\" stroke=\"black\" d=\"M453,-37C453,-37 148,-37 148,-37 142,-37 136,-31 136,-25 136,-25 136,-12 136,-12 136,-6 142,0 148,0 148,0 453,0 453,0 459,0 465,-6 465,-12 465,-12 465,-25 465,-25 465,-31 459,-37 453,-37\"/>\n",
+       "<text text-anchor=\"middle\" x=\"300.5\" y=\"-14.8\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">generate_answer(question_prompt): answer</text>\n",
+       "</g>\n",
+       "<!-- build_prompt&#45;&gt;generate_answer -->\n",
+       "<g id=\"edge5\" class=\"edge\">\n",
+       "<title>build_prompt&#45;&gt;generate_answer</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M300.5,-65.67C300.5,-59.99 300.5,-53.55 300.5,-47.33\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"304,-47.23 300.5,-37.23 297,-47.23 304,-47.23\"/>\n",
+       "</g>\n",
+       "</g>\n",
+       "</svg>\n"
+      ],
+      "text/plain": [
+       "<graphviz.graphs.Digraph at 0x7f49360dea10>"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from burr.core import action, State, ApplicationBuilder\n",
+    "\n",
+    "\n",
+    "@action(reads=[], writes=[\"query_embedding\"])\n",
+    "def embed_text(state: State, user_question: str) -> State:\n",
+    "    text_embedder = SentenceTransformersTextEmbedder(model=\"sentence-transformers/all-MiniLM-L6-v2\")\n",
+    "\n",
+    "    results = text_embedder.run(text=user_question)\n",
+    "    return state.update(query_embedding=results[\"embedding\"])\n",
+    "\n",
+    "\n",
+    "@action(reads=[\"query_embedding\"], writes=[\"documents\"])\n",
+    "def retrieve_documents(state: State) -> State:\n",
+    "    query_embedding = state[\"query_embedding\"]\n",
+    "\n",
+    "    document_store = InMemoryDocumentStore()\n",
+    "    retriever = InMemoryEmbeddingRetriever(document_store)\n",
+    "\n",
+    "    results = retriever.run(query_embedding=query_embedding)\n",
+    "    return state.update(documents=results[\"documents\"])\n",
+    "\n",
+    "\n",
+    "@action(reads=[\"documents\"], writes=[\"question_prompt\"])\n",
+    "def build_prompt(state: State, user_question: str) -> State:\n",
+    "    documents = state[\"documents\"]\n",
+    "\n",
+    "    prompt_builder = PromptBuilder(template=\"Document: {{documents}} Question: {{question}}\")\n",
+    "\n",
+    "    results = prompt_builder.run(documents=documents, question=user_question)   \n",
+    "    return state.update(question_prompt=results[\"prompt\"])\n",
+    "\n",
+    "\n",
+    "@action(reads=[\"question_prompt\"], writes=[\"answer\"])\n",
+    "def generate_answer(state: State) -> State:\n",
+    "    question_prompt = state[\"question_prompt\"]\n",
+    "\n",
+    "    generator = OpenAIGenerator(model=\"gpt-4o-mini\")\n",
+    "\n",
+    "    results = generator.run(prompt=question_prompt)\n",
+    "    return state.update(answer=results[\"text\"])\n",
+    "\n",
+    "\n",
+    "app = (\n",
+    "    ApplicationBuilder()\n",
+    "    .with_actions(\n",
+    "        embed_text,\n",
+    "        retrieve_documents,\n",
+    "        build_prompt,\n",
+    "        generate_answer\n",
+    "    )\n",
+    "    .with_transitions(\n",
+    "        (\"embed_text\", \"retrieve_documents\"),\n",
+    "        (\"retrieve_documents\", \"build_prompt\"),\n",
+    "        (\"build_prompt\", \"generate_answer\"))\n",
+    "    .with_entrypoint(\"embed_text\")\n",
+    "    .build()\n",
+    ")\n",
+    "app.visualize(include_state=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Notes:\n",
+    "- Instead of using `Component` objects, we wrap them into `@action` decorated functions.\n",
+    "- While Haystack pipelines allow components to communicate via sockets, Burr relies on a centralized state.\n",
+    "- Burr requires building the `Graph` \"all at once\" via the `ApplicationBuilder` or `GraphBuilder` while Haystack allows to incrementally add `.add_component()` and `.connect()` statements to the pipeline.\n",
+    "- Haystack allows the parameters of `Component.run()` to be provided by other components via sockets or from the user inputs. Burr separates the two via the `State` object or the function arguments given through `.run(inputs=...)`.\n",
+    "- Haystack `Component` are objects, meaning they need to be instantiated and are stateful. Burr `Action` are stateless, which allows to resume runs from any `State` and enable \"time-travel debugging\".\n",
+    "- Haystack uses a `Router` component to [expression conditional edges](https://docs.haystack.deepset.ai/reference/routers-api#conditionalrouter). Burr allows to add condition directly via the `.with_transitions()` method by specifying in the tuple `(from_action, to_action, condition)`."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Burr's `HaystackAction`\n",
+    "\n",
+    "To avoid having to wrap each component into an `@action` function, the `HaystackAction` was added to Burr. It takes an instantiated `Component`, a `name`, and the `reads/writes` of the action.\n",
+    "\n",
+    "The next cell shows two identical actions, one without the integration (taken from the previous section) and one using `HaystackAction`.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from burr.integrations.haystack import HaystackAction\n",
+    "\n",
+    "@action(reads=[\"query_embedding\"], writes=[\"documents\"])\n",
+    "def retrieve_documents(state: State) -> State:\n",
+    "    query_embedding = state[\"query_embedding\"]\n",
+    "\n",
+    "    document_store = InMemoryDocumentStore()\n",
+    "    retriever = InMemoryEmbeddingRetriever(document_store)\n",
+    "    \n",
+    "    results = retriever.run(query_embedding=query_embedding)\n",
+    "    return state.update(documents=results[\"documents\"])\n",
+    "\n",
+    "\n",
+    "haystack_retrieve_documents = HaystackAction(\n",
+    "    component=InMemoryEmbeddingRetriever(InMemoryDocumentStore()),\n",
+    "    name=\"retrieve_documents\",\n",
+    "    reads=[\"query_embedding\"],\n",
+    "    writes=[\"documents\"],\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The next cell shows the entire application using the `HaystackAction` integration. The action `display_answer` defined using `@action` was added to show you can can combine both approaches.\n",
+    "\n",
+    "Note that some for some `HaystackAction`, `reads` and `writes` are dictionaries instead of the usual lists. This helps map the values from the Burr `State` to the Haystack `Component.run()` parameters and outputs. \n",
+    "\n",
+    "For example, in `generate_answer`:\n",
+    " - `reads={\"prompt\": \"question_prompt\"}` takes the value `State[\"question_prompt\"]` and assigns it to `Component.run(prompt=...)`\n",
+    " - `writes={\"answer\": \"replies\"}` takes the value `Component.run(...)[\"replies\"]` and assigns it to `state.update(answer=...)`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/svg+xml": [
+       "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n",
+       "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n",
+       " \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n",
+       "<!-- Generated by graphviz version 2.43.0 (0)\n",
+       " -->\n",
+       "<!-- Title: %3 Pages: 1 -->\n",
+       "<svg width=\"1400pt\" height=\"375pt\"\n",
+       " viewBox=\"0.00 0.00 1400.00 375.00\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n",
+       "<g id=\"graph0\" class=\"graph\" transform=\"scale(1 1) rotate(0) translate(4 371)\">\n",
+       "<title>%3</title>\n",
+       "<polygon fill=\"white\" stroke=\"transparent\" points=\"-4,4 -4,-371 1396,-371 1396,4 -4,4\"/>\n",
+       "<!-- embed_text -->\n",
+       "<g id=\"node1\" class=\"node\">\n",
+       "<title>embed_text</title>\n",
+       "<path fill=\"#b4d8e4\" stroke=\"black\" d=\"M1380,-301C1380,-301 1154,-301 1154,-301 1148,-301 1142,-295 1142,-289 1142,-289 1142,-276 1142,-276 1142,-270 1148,-264 1154,-264 1154,-264 1380,-264 1380,-264 1386,-264 1392,-270 1392,-276 1392,-276 1392,-289 1392,-289 1392,-295 1386,-301 1380,-301\"/>\n",
+       "<text text-anchor=\"middle\" x=\"1267\" y=\"-278.8\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">embed_text(): query_embedding</text>\n",
+       "</g>\n",
+       "<!-- retrieve_documents -->\n",
+       "<g id=\"node3\" class=\"node\">\n",
+       "<title>retrieve_documents</title>\n",
+       "<path fill=\"#b4d8e4\" stroke=\"black\" d=\"M1126.5,-235C1126.5,-235 767.5,-235 767.5,-235 761.5,-235 755.5,-229 755.5,-223 755.5,-223 755.5,-210 755.5,-210 755.5,-204 761.5,-198 767.5,-198 767.5,-198 1126.5,-198 1126.5,-198 1132.5,-198 1138.5,-204 1138.5,-210 1138.5,-210 1138.5,-223 1138.5,-223 1138.5,-229 1132.5,-235 1126.5,-235\"/>\n",
+       "<text text-anchor=\"middle\" x=\"947\" y=\"-212.8\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">retrieve_documents(query_embedding): documents</text>\n",
+       "</g>\n",
+       "<!-- embed_text&#45;&gt;retrieve_documents -->\n",
+       "<g id=\"edge11\" class=\"edge\">\n",
+       "<title>embed_text&#45;&gt;retrieve_documents</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M1179.14,-263.93C1137.42,-255.58 1087.44,-245.59 1044.55,-237.01\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"1045.16,-233.56 1034.67,-235.03 1043.79,-240.43 1045.16,-233.56\"/>\n",
+       "</g>\n",
+       "<!-- input__text -->\n",
+       "<g id=\"node2\" class=\"node\">\n",
+       "<title>input__text</title>\n",
+       "<polygon fill=\"none\" stroke=\"black\" stroke-dasharray=\"5,2\" points=\"1314.5,-367 1219.5,-367 1219.5,-330 1314.5,-330 1314.5,-367\"/>\n",
+       "<text text-anchor=\"middle\" x=\"1267\" y=\"-344.8\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">input: text</text>\n",
+       "</g>\n",
+       "<!-- input__text&#45;&gt;embed_text -->\n",
+       "<g id=\"edge1\" class=\"edge\">\n",
+       "<title>input__text&#45;&gt;embed_text</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M1267,-329.67C1267,-323.99 1267,-317.55 1267,-311.33\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"1270.5,-311.23 1267,-301.23 1263.5,-311.23 1270.5,-311.23\"/>\n",
+       "</g>\n",
+       "<!-- build_prompt -->\n",
+       "<g id=\"node8\" class=\"node\">\n",
+       "<title>build_prompt</title>\n",
+       "<path fill=\"#b4d8e4\" stroke=\"black\" d=\"M752,-169C752,-169 448,-169 448,-169 442,-169 436,-163 436,-157 436,-157 436,-144 436,-144 436,-138 442,-132 448,-132 448,-132 752,-132 752,-132 758,-132 764,-138 764,-144 764,-144 764,-157 764,-157 764,-163 758,-169 752,-169\"/>\n",
+       "<text text-anchor=\"middle\" x=\"600\" y=\"-146.8\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">build_prompt(documents): question_prompt</text>\n",
+       "</g>\n",
+       "<!-- retrieve_documents&#45;&gt;build_prompt -->\n",
+       "<g id=\"edge12\" class=\"edge\">\n",
+       "<title>retrieve_documents&#45;&gt;build_prompt</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M851.72,-197.93C806.2,-189.53 751.6,-179.46 704.9,-170.85\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"705.53,-167.41 695.07,-169.03 704.26,-174.29 705.53,-167.41\"/>\n",
+       "</g>\n",
+       "<!-- input__return_embedding -->\n",
+       "<g id=\"node4\" class=\"node\">\n",
+       "<title>input__return_embedding</title>\n",
+       "<polygon fill=\"none\" stroke=\"black\" stroke-dasharray=\"5,2\" points=\"710.5,-301 515.5,-301 515.5,-264 710.5,-264 710.5,-301\"/>\n",
+       "<text text-anchor=\"middle\" x=\"613\" y=\"-278.8\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">input: return_embedding</text>\n",
+       "</g>\n",
+       "<!-- input__return_embedding&#45;&gt;retrieve_documents -->\n",
+       "<g id=\"edge2\" class=\"edge\">\n",
+       "<title>input__return_embedding&#45;&gt;retrieve_documents</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M704.71,-263.93C748.34,-255.57 800.64,-245.55 845.46,-236.96\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"846.33,-240.35 855.5,-235.03 845.02,-233.48 846.33,-240.35\"/>\n",
+       "</g>\n",
+       "<!-- input__scale_score -->\n",
+       "<g id=\"node5\" class=\"node\">\n",
+       "<title>input__scale_score</title>\n",
+       "<polygon fill=\"none\" stroke=\"black\" stroke-dasharray=\"5,2\" points=\"875,-301 729,-301 729,-264 875,-264 875,-301\"/>\n",
+       "<text text-anchor=\"middle\" x=\"802\" y=\"-278.8\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">input: scale_score</text>\n",
+       "</g>\n",
+       "<!-- input__scale_score&#45;&gt;retrieve_documents -->\n",
+       "<g id=\"edge3\" class=\"edge\">\n",
+       "<title>input__scale_score&#45;&gt;retrieve_documents</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M842.01,-263.84C859.28,-256.22 879.66,-247.22 897.84,-239.2\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"899.39,-242.34 907.12,-235.1 896.56,-235.94 899.39,-242.34\"/>\n",
+       "</g>\n",
+       "<!-- input__filters -->\n",
+       "<g id=\"node6\" class=\"node\">\n",
+       "<title>input__filters</title>\n",
+       "<polygon fill=\"none\" stroke=\"black\" stroke-dasharray=\"5,2\" points=\"1000.5,-301 893.5,-301 893.5,-264 1000.5,-264 1000.5,-301\"/>\n",
+       "<text text-anchor=\"middle\" x=\"947\" y=\"-278.8\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">input: filters</text>\n",
+       "</g>\n",
+       "<!-- input__filters&#45;&gt;retrieve_documents -->\n",
+       "<g id=\"edge4\" class=\"edge\">\n",
+       "<title>input__filters&#45;&gt;retrieve_documents</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M947,-263.67C947,-257.99 947,-251.55 947,-245.33\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"950.5,-245.23 947,-235.23 943.5,-245.23 950.5,-245.23\"/>\n",
+       "</g>\n",
+       "<!-- input__top_k -->\n",
+       "<g id=\"node7\" class=\"node\">\n",
+       "<title>input__top_k</title>\n",
+       "<polygon fill=\"none\" stroke=\"black\" stroke-dasharray=\"5,2\" points=\"1123.5,-301 1018.5,-301 1018.5,-264 1123.5,-264 1123.5,-301\"/>\n",
+       "<text text-anchor=\"middle\" x=\"1071\" y=\"-278.8\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">input: top_k</text>\n",
+       "</g>\n",
+       "<!-- input__top_k&#45;&gt;retrieve_documents -->\n",
+       "<g id=\"edge5\" class=\"edge\">\n",
+       "<title>input__top_k&#45;&gt;retrieve_documents</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M1036.79,-263.84C1022.42,-256.43 1005.55,-247.72 990.33,-239.86\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"991.59,-236.58 981.1,-235.1 988.38,-242.8 991.59,-236.58\"/>\n",
+       "</g>\n",
+       "<!-- generate_answer -->\n",
+       "<g id=\"node12\" class=\"node\">\n",
+       "<title>generate_answer</title>\n",
+       "<path fill=\"#b4d8e4\" stroke=\"black\" d=\"M470.5,-103C470.5,-103 165.5,-103 165.5,-103 159.5,-103 153.5,-97 153.5,-91 153.5,-91 153.5,-78 153.5,-78 153.5,-72 159.5,-66 165.5,-66 165.5,-66 470.5,-66 470.5,-66 476.5,-66 482.5,-72 482.5,-78 482.5,-78 482.5,-91 482.5,-91 482.5,-97 476.5,-103 470.5,-103\"/>\n",
+       "<text text-anchor=\"middle\" x=\"318\" y=\"-80.8\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">generate_answer(question_prompt): answer</text>\n",
+       "</g>\n",
+       "<!-- build_prompt&#45;&gt;generate_answer -->\n",
+       "<g id=\"edge13\" class=\"edge\">\n",
+       "<title>build_prompt&#45;&gt;generate_answer</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M522.57,-131.93C486.2,-123.67 442.69,-113.8 405.16,-105.28\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"405.78,-101.83 395.26,-103.03 404.24,-108.66 405.78,-101.83\"/>\n",
+       "</g>\n",
+       "<!-- input__template_variables -->\n",
+       "<g id=\"node9\" class=\"node\">\n",
+       "<title>input__template_variables</title>\n",
+       "<polygon fill=\"none\" stroke=\"black\" stroke-dasharray=\"5,2\" points=\"443.5,-235 244.5,-235 244.5,-198 443.5,-198 443.5,-235\"/>\n",
+       "<text text-anchor=\"middle\" x=\"344\" y=\"-212.8\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">input: template_variables</text>\n",
+       "</g>\n",
+       "<!-- input__template_variables&#45;&gt;build_prompt -->\n",
+       "<g id=\"edge6\" class=\"edge\">\n",
+       "<title>input__template_variables&#45;&gt;build_prompt</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M414.29,-197.93C447.03,-189.74 486.14,-179.97 520,-171.5\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"521.01,-174.85 529.87,-169.03 519.31,-168.06 521.01,-174.85\"/>\n",
+       "</g>\n",
+       "<!-- input__question -->\n",
+       "<g id=\"node10\" class=\"node\">\n",
+       "<title>input__question</title>\n",
+       "<polygon fill=\"none\" stroke=\"black\" stroke-dasharray=\"5,2\" points=\"590,-235 462,-235 462,-198 590,-198 590,-235\"/>\n",
+       "<text text-anchor=\"middle\" x=\"526\" y=\"-212.8\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">input: question</text>\n",
+       "</g>\n",
+       "<!-- input__question&#45;&gt;build_prompt -->\n",
+       "<g id=\"edge7\" class=\"edge\">\n",
+       "<title>input__question&#45;&gt;build_prompt</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M546.61,-197.67C554.46,-190.89 563.53,-183.04 571.95,-175.76\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"574.48,-178.2 579.75,-169.01 569.9,-172.91 574.48,-178.2\"/>\n",
+       "</g>\n",
+       "<!-- input__template -->\n",
+       "<g id=\"node11\" class=\"node\">\n",
+       "<title>input__template</title>\n",
+       "<polygon fill=\"none\" stroke=\"black\" stroke-dasharray=\"5,2\" points=\"737.5,-235 608.5,-235 608.5,-198 737.5,-198 737.5,-235\"/>\n",
+       "<text text-anchor=\"middle\" x=\"673\" y=\"-212.8\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">input: template</text>\n",
+       "</g>\n",
+       "<!-- input__template&#45;&gt;build_prompt -->\n",
+       "<g id=\"edge8\" class=\"edge\">\n",
+       "<title>input__template&#45;&gt;build_prompt</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M652.67,-197.67C644.93,-190.89 635.98,-183.04 627.67,-175.76\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"629.8,-172.97 619.97,-169.01 625.19,-178.23 629.8,-172.97\"/>\n",
+       "</g>\n",
+       "<!-- display_answer -->\n",
+       "<g id=\"node15\" class=\"node\">\n",
+       "<title>display_answer</title>\n",
+       "<path fill=\"#b4d8e4\" stroke=\"black\" d=\"M405.5,-37C405.5,-37 230.5,-37 230.5,-37 224.5,-37 218.5,-31 218.5,-25 218.5,-25 218.5,-12 218.5,-12 218.5,-6 224.5,0 230.5,0 230.5,0 405.5,0 405.5,0 411.5,0 417.5,-6 417.5,-12 417.5,-12 417.5,-25 417.5,-25 417.5,-31 411.5,-37 405.5,-37\"/>\n",
+       "<text text-anchor=\"middle\" x=\"318\" y=\"-14.8\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">display_answer(answer): </text>\n",
+       "</g>\n",
+       "<!-- generate_answer&#45;&gt;display_answer -->\n",
+       "<g id=\"edge14\" class=\"edge\">\n",
+       "<title>generate_answer&#45;&gt;display_answer</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M318,-65.67C318,-59.99 318,-53.55 318,-47.33\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"321.5,-47.23 318,-37.23 314.5,-47.23 321.5,-47.23\"/>\n",
+       "</g>\n",
+       "<!-- input__streaming_callback -->\n",
+       "<g id=\"node13\" class=\"node\">\n",
+       "<title>input__streaming_callback</title>\n",
+       "<polygon fill=\"none\" stroke=\"black\" stroke-dasharray=\"5,2\" points=\"200,-169 0,-169 0,-132 200,-132 200,-169\"/>\n",
+       "<text text-anchor=\"middle\" x=\"100\" y=\"-146.8\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">input: streaming_callback</text>\n",
+       "</g>\n",
+       "<!-- input__streaming_callback&#45;&gt;generate_answer -->\n",
+       "<g id=\"edge9\" class=\"edge\">\n",
+       "<title>input__streaming_callback&#45;&gt;generate_answer</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M159.86,-131.93C187.26,-123.88 219.9,-114.3 248.39,-105.94\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"249.67,-109.21 258.28,-103.03 247.69,-102.49 249.67,-109.21\"/>\n",
+       "</g>\n",
+       "<!-- input__generation_kwargs -->\n",
+       "<g id=\"node14\" class=\"node\">\n",
+       "<title>input__generation_kwargs</title>\n",
+       "<polygon fill=\"none\" stroke=\"black\" stroke-dasharray=\"5,2\" points=\"417.5,-169 218.5,-169 218.5,-132 417.5,-132 417.5,-169\"/>\n",
+       "<text text-anchor=\"middle\" x=\"318\" y=\"-146.8\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">input: generation_kwargs</text>\n",
+       "</g>\n",
+       "<!-- input__generation_kwargs&#45;&gt;generate_answer -->\n",
+       "<g id=\"edge10\" class=\"edge\">\n",
+       "<title>input__generation_kwargs&#45;&gt;generate_answer</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M318,-131.67C318,-125.99 318,-119.55 318,-113.33\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"321.5,-113.23 318,-103.23 314.5,-113.23 321.5,-113.23\"/>\n",
+       "</g>\n",
+       "</g>\n",
+       "</svg>\n"
+      ],
+      "text/plain": [
+       "<graphviz.graphs.Digraph at 0x7f4936158c90>"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from burr.core import action, State, ApplicationBuilder\n",
+    "\n",
+    "embed_text = HaystackAction(\n",
+    "    component=SentenceTransformersTextEmbedder(model=\"sentence-transformers/all-MiniLM-L6-v2\"),\n",
+    "    name=\"embed_text\",\n",
+    "    reads=[],\n",
+    "    writes={\"query_embedding\": \"embedding\"},\n",
+    ")\n",
+    "\n",
+    "retrieve_documents = HaystackAction(\n",
+    "    component=InMemoryEmbeddingRetriever(InMemoryDocumentStore()),\n",
+    "    name=\"retrieve_documents\",\n",
+    "    reads=[\"query_embedding\"],\n",
+    "    writes=[\"documents\"],\n",
+    ")\n",
+    "\n",
+    "build_prompt = HaystackAction(\n",
+    "    component=PromptBuilder(template=\"Document: {{documents}} Question: {{question}}\"),\n",
+    "    name=\"build_prompt\",\n",
+    "    reads=[\"documents\"],\n",
+    "    writes={\"question_prompt\": \"prompt\"},\n",
+    ")\n",
+    "\n",
+    "generate_answer = HaystackAction(\n",
+    "    component=OpenAIGenerator(model=\"gpt-4o-mini\"),\n",
+    "    name=\"generate_answer\",\n",
+    "    reads={\"prompt\": \"question_prompt\"},\n",
+    "    writes={\"answer\": \"replies\"}\n",
+    ")\n",
+    "\n",
+    "@action(reads=[\"answer\"], writes=[])\n",
+    "def display_answer(state: State) -> State:\n",
+    "    print(state[\"answer\"])\n",
+    "    return state\n",
+    "\n",
+    "\n",
+    "app = (\n",
+    "    ApplicationBuilder()\n",
+    "    .with_actions(\n",
+    "        embed_text,\n",
+    "        retrieve_documents,\n",
+    "        build_prompt,\n",
+    "        generate_answer,\n",
+    "        display_answer,\n",
+    "    )\n",
+    "    .with_transitions(\n",
+    "        (\"embed_text\", \"retrieve_documents\"),\n",
+    "        (\"retrieve_documents\", \"build_prompt\"),\n",
+    "        (\"build_prompt\", \"generate_answer\"),\n",
+    "        (\"generate_answer\", \"display_answer\"),\n",
+    "    )\n",
+    "    .with_entrypoint(\"embed_text\")\n",
+    "    .build()\n",
+    ")\n",
+    "app.visualize(include_state=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Converting a Haystack `Pipeline`\n",
+    "\n",
+    "If you have an existing Haystack `Pipeline`, you can convert it into a Burr `Graph` using in a single line of code using `haystack_pipeline_to_burr_graph()`.\n",
+    "\n",
+    "Next, we convert the `basic_rag_pipeline` defined at the beginning of the notebook. The resulting `Graph` can be passed to the `ApplicationBuilder.with_graph()` clause.\n",
+    "\n",
+    "The visualization should match the previous ones, but with different names (e.g., `generate_answer` is `llm`)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/svg+xml": [
+       "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n",
+       "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n",
+       " \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n",
+       "<!-- Generated by graphviz version 2.43.0 (0)\n",
+       " -->\n",
+       "<!-- Title: %3 Pages: 1 -->\n",
+       "<svg width=\"1286pt\" height=\"309pt\"\n",
+       " viewBox=\"0.00 0.00 1286.00 309.00\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n",
+       "<g id=\"graph0\" class=\"graph\" transform=\"scale(1 1) rotate(0) translate(4 305)\">\n",
+       "<title>%3</title>\n",
+       "<polygon fill=\"white\" stroke=\"transparent\" points=\"-4,4 -4,-305 1282,-305 1282,4 -4,4\"/>\n",
+       "<!-- text_embedder -->\n",
+       "<g id=\"node1\" class=\"node\">\n",
+       "<title>text_embedder</title>\n",
+       "<path fill=\"#b4d8e4\" stroke=\"black\" d=\"M1266,-235C1266,-235 1064,-235 1064,-235 1058,-235 1052,-229 1052,-223 1052,-223 1052,-210 1052,-210 1052,-204 1058,-198 1064,-198 1064,-198 1266,-198 1266,-198 1272,-198 1278,-204 1278,-210 1278,-210 1278,-223 1278,-223 1278,-229 1272,-235 1266,-235\"/>\n",
+       "<text text-anchor=\"middle\" x=\"1165\" y=\"-212.8\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">text_embedder(): embedding</text>\n",
+       "</g>\n",
+       "<!-- retriever -->\n",
+       "<g id=\"node3\" class=\"node\">\n",
+       "<title>retriever</title>\n",
+       "<path fill=\"#b4d8e4\" stroke=\"black\" d=\"M973.5,-169C973.5,-169 740.5,-169 740.5,-169 734.5,-169 728.5,-163 728.5,-157 728.5,-157 728.5,-144 728.5,-144 728.5,-138 734.5,-132 740.5,-132 740.5,-132 973.5,-132 973.5,-132 979.5,-132 985.5,-138 985.5,-144 985.5,-144 985.5,-157 985.5,-157 985.5,-163 979.5,-169 973.5,-169\"/>\n",
+       "<text text-anchor=\"middle\" x=\"857\" y=\"-146.8\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">retriever(embedding): documents</text>\n",
+       "</g>\n",
+       "<!-- text_embedder&#45;&gt;retriever -->\n",
+       "<g id=\"edge11\" class=\"edge\">\n",
+       "<title>text_embedder&#45;&gt;retriever</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M1080.43,-197.93C1040.45,-189.62 992.58,-179.67 951.42,-171.12\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"951.88,-167.64 941.38,-169.03 950.46,-174.5 951.88,-167.64\"/>\n",
+       "</g>\n",
+       "<!-- input__text -->\n",
+       "<g id=\"node2\" class=\"node\">\n",
+       "<title>input__text</title>\n",
+       "<polygon fill=\"none\" stroke=\"black\" stroke-dasharray=\"5,2\" points=\"1212.5,-301 1117.5,-301 1117.5,-264 1212.5,-264 1212.5,-301\"/>\n",
+       "<text text-anchor=\"middle\" x=\"1165\" y=\"-278.8\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">input: text</text>\n",
+       "</g>\n",
+       "<!-- input__text&#45;&gt;text_embedder -->\n",
+       "<g id=\"edge1\" class=\"edge\">\n",
+       "<title>input__text&#45;&gt;text_embedder</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M1165,-263.67C1165,-257.99 1165,-251.55 1165,-245.33\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"1168.5,-245.23 1165,-235.23 1161.5,-245.23 1168.5,-245.23\"/>\n",
+       "</g>\n",
+       "<!-- prompt_builder -->\n",
+       "<g id=\"node8\" class=\"node\">\n",
+       "<title>prompt_builder</title>\n",
+       "<path fill=\"#b4d8e4\" stroke=\"black\" d=\"M698.5,-103C698.5,-103 447.5,-103 447.5,-103 441.5,-103 435.5,-97 435.5,-91 435.5,-91 435.5,-78 435.5,-78 435.5,-72 441.5,-66 447.5,-66 447.5,-66 698.5,-66 698.5,-66 704.5,-66 710.5,-72 710.5,-78 710.5,-78 710.5,-91 710.5,-91 710.5,-97 704.5,-103 698.5,-103\"/>\n",
+       "<text text-anchor=\"middle\" x=\"573\" y=\"-80.8\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">prompt_builder(documents): prompt</text>\n",
+       "</g>\n",
+       "<!-- retriever&#45;&gt;prompt_builder -->\n",
+       "<g id=\"edge12\" class=\"edge\">\n",
+       "<title>retriever&#45;&gt;prompt_builder</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M779.02,-131.93C742.39,-123.67 698.57,-113.8 660.78,-105.28\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"661.33,-101.82 650.81,-103.03 659.79,-108.65 661.33,-101.82\"/>\n",
+       "</g>\n",
+       "<!-- input__return_embedding -->\n",
+       "<g id=\"node4\" class=\"node\">\n",
+       "<title>input__return_embedding</title>\n",
+       "<polygon fill=\"none\" stroke=\"black\" stroke-dasharray=\"5,2\" points=\"620.5,-235 425.5,-235 425.5,-198 620.5,-198 620.5,-235\"/>\n",
+       "<text text-anchor=\"middle\" x=\"523\" y=\"-212.8\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">input: return_embedding</text>\n",
+       "</g>\n",
+       "<!-- input__return_embedding&#45;&gt;retriever -->\n",
+       "<g id=\"edge2\" class=\"edge\">\n",
+       "<title>input__return_embedding&#45;&gt;retriever</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M614.71,-197.93C658.34,-189.57 710.64,-179.55 755.46,-170.96\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"756.33,-174.35 765.5,-169.03 755.02,-167.48 756.33,-174.35\"/>\n",
+       "</g>\n",
+       "<!-- input__scale_score -->\n",
+       "<g id=\"node5\" class=\"node\">\n",
+       "<title>input__scale_score</title>\n",
+       "<polygon fill=\"none\" stroke=\"black\" stroke-dasharray=\"5,2\" points=\"785,-235 639,-235 639,-198 785,-198 785,-235\"/>\n",
+       "<text text-anchor=\"middle\" x=\"712\" y=\"-212.8\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">input: scale_score</text>\n",
+       "</g>\n",
+       "<!-- input__scale_score&#45;&gt;retriever -->\n",
+       "<g id=\"edge3\" class=\"edge\">\n",
+       "<title>input__scale_score&#45;&gt;retriever</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M752.01,-197.84C769.28,-190.22 789.66,-181.22 807.84,-173.2\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"809.39,-176.34 817.12,-169.1 806.56,-169.94 809.39,-176.34\"/>\n",
+       "</g>\n",
+       "<!-- input__filters -->\n",
+       "<g id=\"node6\" class=\"node\">\n",
+       "<title>input__filters</title>\n",
+       "<polygon fill=\"none\" stroke=\"black\" stroke-dasharray=\"5,2\" points=\"910.5,-235 803.5,-235 803.5,-198 910.5,-198 910.5,-235\"/>\n",
+       "<text text-anchor=\"middle\" x=\"857\" y=\"-212.8\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">input: filters</text>\n",
+       "</g>\n",
+       "<!-- input__filters&#45;&gt;retriever -->\n",
+       "<g id=\"edge4\" class=\"edge\">\n",
+       "<title>input__filters&#45;&gt;retriever</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M857,-197.67C857,-191.99 857,-185.55 857,-179.33\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"860.5,-179.23 857,-169.23 853.5,-179.23 860.5,-179.23\"/>\n",
+       "</g>\n",
+       "<!-- input__top_k -->\n",
+       "<g id=\"node7\" class=\"node\">\n",
+       "<title>input__top_k</title>\n",
+       "<polygon fill=\"none\" stroke=\"black\" stroke-dasharray=\"5,2\" points=\"1033.5,-235 928.5,-235 928.5,-198 1033.5,-198 1033.5,-235\"/>\n",
+       "<text text-anchor=\"middle\" x=\"981\" y=\"-212.8\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">input: top_k</text>\n",
+       "</g>\n",
+       "<!-- input__top_k&#45;&gt;retriever -->\n",
+       "<g id=\"edge5\" class=\"edge\">\n",
+       "<title>input__top_k&#45;&gt;retriever</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M946.79,-197.84C932.42,-190.43 915.55,-181.72 900.33,-173.86\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"901.59,-170.58 891.1,-169.1 898.38,-176.8 901.59,-170.58\"/>\n",
+       "</g>\n",
+       "<!-- llm -->\n",
+       "<g id=\"node12\" class=\"node\">\n",
+       "<title>llm</title>\n",
+       "<path fill=\"#b4d8e4\" stroke=\"black\" d=\"M362.5,-37C362.5,-37 273.5,-37 273.5,-37 267.5,-37 261.5,-31 261.5,-25 261.5,-25 261.5,-12 261.5,-12 261.5,-6 267.5,0 273.5,0 273.5,0 362.5,0 362.5,0 368.5,0 374.5,-6 374.5,-12 374.5,-12 374.5,-25 374.5,-25 374.5,-31 368.5,-37 362.5,-37\"/>\n",
+       "<text text-anchor=\"middle\" x=\"318\" y=\"-14.8\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">llm(prompt): </text>\n",
+       "</g>\n",
+       "<!-- prompt_builder&#45;&gt;llm -->\n",
+       "<g id=\"edge13\" class=\"edge\">\n",
+       "<title>prompt_builder&#45;&gt;llm</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M502.98,-65.93C466.06,-56.66 420.99,-45.35 384.59,-36.21\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"385.12,-32.74 374.56,-33.7 383.41,-39.53 385.12,-32.74\"/>\n",
+       "</g>\n",
+       "<!-- input__template_variables -->\n",
+       "<g id=\"node9\" class=\"node\">\n",
+       "<title>input__template_variables</title>\n",
+       "<polygon fill=\"none\" stroke=\"black\" stroke-dasharray=\"5,2\" points=\"416.5,-169 217.5,-169 217.5,-132 416.5,-132 416.5,-169\"/>\n",
+       "<text text-anchor=\"middle\" x=\"317\" y=\"-146.8\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">input: template_variables</text>\n",
+       "</g>\n",
+       "<!-- input__template_variables&#45;&gt;prompt_builder -->\n",
+       "<g id=\"edge6\" class=\"edge\">\n",
+       "<title>input__template_variables&#45;&gt;prompt_builder</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M387.29,-131.93C420.03,-123.74 459.14,-113.97 493,-105.5\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"494.01,-108.85 502.87,-103.03 492.31,-102.06 494.01,-108.85\"/>\n",
+       "</g>\n",
+       "<!-- input__question -->\n",
+       "<g id=\"node10\" class=\"node\">\n",
+       "<title>input__question</title>\n",
+       "<polygon fill=\"none\" stroke=\"black\" stroke-dasharray=\"5,2\" points=\"563,-169 435,-169 435,-132 563,-132 563,-169\"/>\n",
+       "<text text-anchor=\"middle\" x=\"499\" y=\"-146.8\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">input: question</text>\n",
+       "</g>\n",
+       "<!-- input__question&#45;&gt;prompt_builder -->\n",
+       "<g id=\"edge7\" class=\"edge\">\n",
+       "<title>input__question&#45;&gt;prompt_builder</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M519.61,-131.67C527.46,-124.89 536.53,-117.04 544.95,-109.76\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"547.48,-112.2 552.75,-103.01 542.9,-106.91 547.48,-112.2\"/>\n",
+       "</g>\n",
+       "<!-- input__template -->\n",
+       "<g id=\"node11\" class=\"node\">\n",
+       "<title>input__template</title>\n",
+       "<polygon fill=\"none\" stroke=\"black\" stroke-dasharray=\"5,2\" points=\"710.5,-169 581.5,-169 581.5,-132 710.5,-132 710.5,-169\"/>\n",
+       "<text text-anchor=\"middle\" x=\"646\" y=\"-146.8\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">input: template</text>\n",
+       "</g>\n",
+       "<!-- input__template&#45;&gt;prompt_builder -->\n",
+       "<g id=\"edge8\" class=\"edge\">\n",
+       "<title>input__template&#45;&gt;prompt_builder</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M625.67,-131.67C617.93,-124.89 608.98,-117.04 600.67,-109.76\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"602.8,-106.97 592.97,-103.01 598.19,-112.23 602.8,-106.97\"/>\n",
+       "</g>\n",
+       "<!-- input__streaming_callback -->\n",
+       "<g id=\"node13\" class=\"node\">\n",
+       "<title>input__streaming_callback</title>\n",
+       "<polygon fill=\"none\" stroke=\"black\" stroke-dasharray=\"5,2\" points=\"200,-103 0,-103 0,-66 200,-66 200,-103\"/>\n",
+       "<text text-anchor=\"middle\" x=\"100\" y=\"-80.8\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">input: streaming_callback</text>\n",
+       "</g>\n",
+       "<!-- input__streaming_callback&#45;&gt;llm -->\n",
+       "<g id=\"edge9\" class=\"edge\">\n",
+       "<title>input__streaming_callback&#45;&gt;llm</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M159.86,-65.93C188.28,-57.58 222.35,-47.58 251.57,-39\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"252.67,-42.33 261.28,-36.15 250.7,-35.61 252.67,-42.33\"/>\n",
+       "</g>\n",
+       "<!-- input__generation_kwargs -->\n",
+       "<g id=\"node14\" class=\"node\">\n",
+       "<title>input__generation_kwargs</title>\n",
+       "<polygon fill=\"none\" stroke=\"black\" stroke-dasharray=\"5,2\" points=\"417.5,-103 218.5,-103 218.5,-66 417.5,-66 417.5,-103\"/>\n",
+       "<text text-anchor=\"middle\" x=\"318\" y=\"-80.8\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">input: generation_kwargs</text>\n",
+       "</g>\n",
+       "<!-- input__generation_kwargs&#45;&gt;llm -->\n",
+       "<g id=\"edge10\" class=\"edge\">\n",
+       "<title>input__generation_kwargs&#45;&gt;llm</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M318,-65.67C318,-59.99 318,-53.55 318,-47.33\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"321.5,-47.23 318,-37.23 314.5,-47.23 321.5,-47.23\"/>\n",
+       "</g>\n",
+       "</g>\n",
+       "</svg>\n"
+      ],
+      "text/plain": [
+       "<graphviz.graphs.Digraph at 0x7f4937a72dd0>"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from burr.integrations.haystack import haystack_pipeline_to_burr_graph\n",
+    "\n",
+    "haystack_graph = haystack_pipeline_to_burr_graph(basic_rag_pipeline)\n",
+    "app = (\n",
+    "    ApplicationBuilder()\n",
+    "    .with_graph(haystack_graph)\n",
+    "    .with_entrypoint(\"prompt_builder\")\n",
+    "    .build()\n",
+    ")\n",
+    "app.visualize(include_state=True)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/examples/haystack-integration/statemachine.png b/examples/haystack-integration/statemachine.png
new file mode 100644
index 00000000..907f4d28
Binary files /dev/null and b/examples/haystack-integration/statemachine.png differ
diff --git a/pyproject.toml b/pyproject.toml
index 8bbc631d..f32c279d 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -61,7 +61,8 @@ tests = [
   "pydantic[email]",
   "pyarrow",
   "redis",
-  "burr[opentelemetry]"
+  "burr[opentelemetry]",
+  "burr[haystack]"
 ]
 
 documentation = [
@@ -113,6 +114,10 @@ pydantic = [
   "pydantic"
 ]
 
+haystack = [
+  "haystack-ai"
+]
+
 cli = [
   "loguru",
   "click",
diff --git a/tests/integrations/test_burr_haystack.py b/tests/integrations/test_burr_haystack.py
new file mode 100644
index 00000000..3ddb124b
--- /dev/null
+++ b/tests/integrations/test_burr_haystack.py
@@ -0,0 +1,253 @@
+from haystack import Pipeline, component
+from haystack.components.embedders import SentenceTransformersTextEmbedder
+from haystack.components.retrievers.in_memory import InMemoryEmbeddingRetriever
+from haystack.document_stores.in_memory import InMemoryDocumentStore
+
+from burr.core import State, action
+from burr.core.graph import GraphBuilder
+from burr.integrations.haystack import HaystackAction, haystack_pipeline_to_burr_graph
+
+
+@component
+class MockComponent:
+    def __init__(self, required_init: str, optional_init: str = "default"):
+        self.required_init = required_init
+        self.optional_init = optional_init
+
+    @component.output_types(output_1=str, output_2=str)
+    def run(self, required_input: str, optional_input: str = "default") -> dict:
+        return {
+            "output_1": required_input,
+            "output_2": optional_input,
+        }
+
+
+@action(reads=["query_embedding"], writes=["documents"])
+def retrieve_documents(state: State) -> State:
+    query_embedding = state["query_embedding"]
+
+    document_store = InMemoryDocumentStore()
+    retriever = InMemoryEmbeddingRetriever(document_store)
+
+    results = retriever.run(query_embedding=query_embedding)
+    return state.update(documents=results["documents"])
+
+
+haystack_retrieve_documents = HaystackAction(
+    component=InMemoryEmbeddingRetriever(InMemoryDocumentStore()),
+    name="retrieve_documents",
+    reads=["query_embedding"],
+    writes=["documents"],
+)
+
+
+def test_input_socket_mapping():
+    # {input_socket_name: state_field}
+    reads = {"required_input": "foo"}
+
+    haction = HaystackAction(
+        component=MockComponent(required_init="init"), name="mock", reads=reads, writes=[]
+    )
+
+    assert haction.reads == list(set(reads.values())) == ["foo"]
+
+
+def test_input_socket_sequence():
+    # {input_socket_name: input_socket_name}
+    reads = ["required_input"]
+
+    haction = HaystackAction(
+        component=MockComponent(required_init="init"), name="mock", reads=reads, writes=[]
+    )
+
+    assert haction.reads == list(reads) == ["required_input"]
+
+
+def test_output_socket_mapping():
+    # {state_field: output_socket_name}
+    writes = {"bar": "output_1"}
+
+    haction = HaystackAction(
+        component=MockComponent(required_init="init"), name="mock", reads=[], writes=writes
+    )
+
+    assert haction.writes == list(writes.keys()) == ["bar"]
+
+
+def test_output_socket_sequence():
+    # {output_socket_name: output_socket_name}
+    writes = ["output_1"]
+
+    haction = HaystackAction(
+        component=MockComponent(required_init="init"), name="mock", reads=[], writes=writes
+    )
+
+    assert haction.writes == writes == ["output_1"]
+
+
+def test_get_component_source():
+    haction = HaystackAction(
+        component=MockComponent(required_init="init"), name="mock", reads=[], writes=[]
+    )
+
+    expected_source = """\
+@component
+class MockComponent:
+    def __init__(self, required_init: str, optional_init: str = "default"):
+        self.required_init = required_init
+        self.optional_init = optional_init
+
+    @component.output_types(output_1=str, output_2=str)
+    def run(self, required_input: str, optional_input: str = "default") -> dict:
+        return {
+            "output_1": required_input,
+            "output_2": optional_input,
+        }
+"""
+
+    assert haction.get_source() == expected_source
+
+
+def test_run_with_external_inputs():
+    state = State(initial_values={})
+    haction = HaystackAction(
+        component=MockComponent(required_init="init"), name="mock", reads=[], writes=[]
+    )
+
+    results = haction.run(state=state, required_input="as_input")
+
+    assert results == {"output_1": "as_input", "output_2": "default"}
+
+
+def test_run_with_state_inputs():
+    state = State(initial_values={"foo": "bar"})
+    haction = HaystackAction(
+        component=MockComponent(required_init="init"),
+        name="mock",
+        reads={"required_input": "foo"},
+        writes=[],
+    )
+
+    results = haction.run(state=state)
+
+    assert results == {"output_1": "bar", "output_2": "default"}
+
+
+def test_run_with_bound_params():
+    state = State(initial_values={})
+    haction = HaystackAction(
+        component=MockComponent(required_init="init"),
+        name="mock",
+        reads=[],
+        writes=[],
+        bound_params={"required_input": "baz"},
+    )
+
+    results = haction.run(state=state)
+
+    assert results == {"output_1": "baz", "output_2": "default"}
+
+
+def test_run_mixed_params():
+    state = State(initial_values={"foo": "bar"})
+    haction = HaystackAction(
+        component=MockComponent(required_init="init"),
+        name="mock",
+        reads={"required_input": "foo"},
+        writes=[],
+        bound_params={"optional_input": "baz"},
+    )
+
+    results = haction.run(state=state)
+
+    assert results == {"output_1": "bar", "output_2": "baz"}
+
+
+def test_run_with_sequence():
+    state = State(initial_values={"required_input": "bar"})
+    haction = HaystackAction(
+        component=MockComponent(required_init="init"),
+        name="mock",
+        reads=["required_input"],
+        writes=[],
+    )
+
+    results = haction.run(state=state)
+
+    assert results == {"output_1": "bar", "output_2": "default"}
+
+
+def test_update_with_writes_mapping():
+    state = State(initial_values={})
+    results = {"output_1": 1, "output_2": 2}
+    haction = HaystackAction(
+        component=MockComponent(required_init="init"),
+        name="mock",
+        reads=[],
+        writes={"foo": "output_1"},
+    )
+
+    new_state = haction.update(result=results, state=state)
+
+    assert new_state["foo"] == 1
+
+
+def test_update_with_writes_sequence():
+    state = State(initial_values={})
+    results = {"output_1": 1, "output_2": 2}
+    haction = HaystackAction(
+        component=MockComponent(required_init="init"),
+        name="mock",
+        reads=[],
+        writes=["output_1"],
+    )
+
+    new_state = haction.update(result=results, state=state)
+
+    assert new_state["output_1"] == 1
+
+
+def test_pipeline_converter():
+    # create haystack Pipeline
+    retriever = InMemoryEmbeddingRetriever(InMemoryDocumentStore())
+    text_embedder = SentenceTransformersTextEmbedder(model="sentence-transformers/all-MiniLM-L6-v2")
+
+    basic_rag_pipeline = Pipeline()
+    basic_rag_pipeline.add_component("text_embedder", text_embedder)
+    basic_rag_pipeline.add_component("retriever", retriever)
+    basic_rag_pipeline.connect("text_embedder.embedding", "retriever.query_embedding")
+
+    # create Burr application
+    embed_text = HaystackAction(
+        component=text_embedder,
+        name="text_embedder",
+        reads=[],
+        writes={"query_embedding": "embedding"},
+    )
+
+    retrieve_documents = HaystackAction(
+        component=retriever,
+        name="retriever",
+        reads=["query_embedding"],
+        writes=["documents"],
+    )
+
+    burr_graph = (
+        GraphBuilder()
+        .with_actions(embed_text, retrieve_documents)
+        .with_transitions(("text_embedder", "retriever"))
+        .build()
+    )
+
+    # convert the Haystack Pipeline to a Burr graph
+    haystack_graph = haystack_pipeline_to_burr_graph(basic_rag_pipeline)
+
+    converted_action_names = [action.name for action in haystack_graph.actions]
+    for graph_action in burr_graph.actions:
+        assert graph_action.name in converted_action_names
+
+    for burr_t in burr_graph.transitions:
+        assert any(
+            burr_t.from_.name == haystack_t.from_.name and burr_t.to.name == haystack_t.to.name
+            for haystack_t in haystack_graph.transitions
+        )