{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# How to stream from subgraphs\n", "\n", "If you have created a graph with subgraphs you may wish to stream things occurring inside those subgraphs (or you may not!). This guide will walk through how you can control the information that is streamed back from subgraphs.\n", "\n", "## Setup\n", "\n", "First let's install the required packages and set our API keys" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "%%capture --no-stderr\n", "%pip install -U langgraph langchain-openai" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import getpass\n", "import os\n", "\n", "\n", "def _set_env(var: str):\n", " if not os.environ.get(var):\n", " os.environ[var] = getpass.getpass(f\"{var}: \")\n", "\n", "\n", "_set_env(\"OPENAI_API_KEY\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "

Set up LangSmith for LangGraph development

\n", "

\n", " Sign up for LangSmith to quickly spot issues and improve the performance of your LangGraph projects. LangSmith lets you use trace data to debug, test, and monitor your LLM apps built with LangGraph — read more about how to get started here. \n", "

\n", "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Define subgraphs\n", "\n", "We are going to use the same subgraph from [this how-to](https://langchain-ai.github.io/langgraph/how-tos/subgraph/)." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "from typing import Optional, Annotated\n", "from typing_extensions import TypedDict\n", "from langgraph.checkpoint.memory import MemorySaver\n", "from langgraph.graph import StateGraph, START, END\n", "\n", "\n", "# The structure of the logs\n", "class Logs(TypedDict):\n", " id: str\n", " question: str\n", " answer: str\n", " grade: Optional[int]\n", " feedback: Optional[str]\n", "\n", "\n", "# Define custom reducer (see more on this in the \"Custom reducer\" section below)\n", "def add_logs(left: list[Logs], right: list[Logs]) -> list[Logs]:\n", " if not left:\n", " left = []\n", "\n", " if not right:\n", " right = []\n", "\n", " logs = left.copy()\n", " left_id_to_idx = {log[\"id\"]: idx for idx, log in enumerate(logs)}\n", " # update if the new logs are already in the state, otherwise append\n", " for log in right:\n", " idx = left_id_to_idx.get(log[\"id\"])\n", " if idx is not None:\n", " logs[idx] = log\n", " else:\n", " logs.append(log)\n", " return logs\n", "\n", "\n", "# Failure Analysis Subgraph\n", "class FailureAnalysisState(TypedDict):\n", " # keys shared with the parent graph (EntryGraphState)\n", " logs: Annotated[list[Logs], add_logs]\n", " failure_report: str\n", " # subgraph key\n", " failures: list[Logs]\n", "\n", "\n", "def get_failures(state: FailureAnalysisState):\n", " failures = [log for log in state[\"logs\"] if log[\"grade\"] == 0]\n", " return {\"failures\": failures}\n", "\n", "\n", "def generate_summary(state: FailureAnalysisState):\n", " failures = state[\"failures\"]\n", " # NOTE: you can implement custom summarization logic here\n", " failure_ids = [log[\"id\"] for log in failures]\n", " fa_summary = f\"Poor quality of retrieval for document IDs: {', '.join(failure_ids)}\"\n", " return {\"failure_report\": fa_summary}\n", "\n", "\n", "fa_builder = StateGraph(FailureAnalysisState)\n", "fa_builder.add_node(\"get_failures\", get_failures)\n", "fa_builder.add_node(\"generate_summary\", generate_summary)\n", "fa_builder.add_edge(START, \"get_failures\")\n", "fa_builder.add_edge(\"get_failures\", \"generate_summary\")\n", "fa_builder.add_edge(\"generate_summary\", END)\n", "\n", "\n", "# Summarization subgraph\n", "class QuestionSummarizationState(TypedDict):\n", " # keys that are shared with the parent graph (EntryGraphState)\n", " summary_report: str\n", " logs: Annotated[list[Logs], add_logs]\n", " # subgraph keys\n", " summary: str\n", "\n", "\n", "def generate_summary(state: QuestionSummarizationState):\n", " docs = state[\"logs\"]\n", " # NOTE: you can implement custom summarization logic here\n", " summary = \"Questions focused on usage of ChatOllama and Chroma vector store.\"\n", " return {\"summary\": summary}\n", "\n", "\n", "def send_to_slack(state: QuestionSummarizationState):\n", " summary = state[\"summary\"]\n", " # NOTE: you can implement custom logic here, for example sending the summary generated in the previous step to Slack\n", " return {\"summary_report\": summary}\n", "\n", "\n", "qs_builder = StateGraph(QuestionSummarizationState)\n", "qs_builder.add_node(\"generate_summary\", generate_summary)\n", "qs_builder.add_node(\"send_to_slack\", send_to_slack)\n", "qs_builder.add_edge(START, \"generate_summary\")\n", "qs_builder.add_edge(\"generate_summary\", \"send_to_slack\")\n", "qs_builder.add_edge(\"send_to_slack\", END)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Define parent graph" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "image/jpeg": "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", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Entry Graph\n", "class EntryGraphState(TypedDict):\n", " raw_logs: Annotated[list[Logs], add_logs]\n", " logs: Annotated[list[Logs], add_logs] # This will be used in subgraphs\n", " failure_report: str # This will be generated in the FA subgraph\n", " summary_report: str # This will be generated in the QS subgraph\n", "\n", "\n", "def select_logs(state):\n", " return {\"logs\": [log for log in state[\"raw_logs\"] if \"grade\" in log]}\n", "\n", "\n", "entry_builder = StateGraph(EntryGraphState)\n", "entry_builder.add_node(\"select_logs\", select_logs)\n", "entry_builder.add_node(\"question_summarization\", qs_builder.compile())\n", "entry_builder.add_node(\"failure_analysis\", fa_builder.compile())\n", "\n", "entry_builder.add_edge(START, \"select_logs\")\n", "entry_builder.add_edge(\"select_logs\", \"failure_analysis\")\n", "entry_builder.add_edge(\"select_logs\", \"question_summarization\")\n", "entry_builder.add_edge(\"failure_analysis\", END)\n", "entry_builder.add_edge(\"question_summarization\", END)\n", "\n", "graph = entry_builder.compile()\n", "\n", "from IPython.display import Image, display\n", "\n", "# Setting xray to 1 will show the internal structure of the nested graph\n", "display(Image(graph.get_graph(xray=1).draw_mermaid_png()))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Stream\n", "\n", "Now let's see how we can stream from our graph!\n", "\n", "### Define input\n", "\n", "First, let's define the input we will use for the rest of the notebook:" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "# Dummy logs\n", "dummy_logs = [\n", " Logs(\n", " id=\"1\",\n", " question=\"How can I import ChatOllama?\",\n", " grade=1,\n", " answer=\"To import ChatOllama, use: 'from langchain_community.chat_models import ChatOllama.'\",\n", " ),\n", " Logs(\n", " id=\"2\",\n", " question=\"How can I use Chroma vector store?\",\n", " answer=\"To use Chroma, define: rag_chain = create_retrieval_chain(retriever, question_answer_chain).\",\n", " grade=0,\n", " feedback=\"The retrieved documents discuss vector stores in general, but not Chroma specifically\",\n", " ),\n", " Logs(\n", " id=\"3\",\n", " question=\"How do I create react agent in langgraph?\",\n", " answer=\"from langgraph.prebuilt import create_react_agent\",\n", " ),\n", "]\n", "\n", "input = {\"raw_logs\": dummy_logs}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Stream normally\n", "\n", "First let us examine the output of streaming normally:" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "---------- Update from node select_logs ---------\n", "{'logs': [{'id': '1', 'question': 'How can I import ChatOllama?', 'grade': 1, 'answer': \"To import ChatOllama, use: 'from langchain_community.chat_models import ChatOllama.'\"}, {'id': '2', 'question': 'How can I use Chroma vector store?', 'answer': 'To use Chroma, define: rag_chain = create_retrieval_chain(retriever, question_answer_chain).', 'grade': 0, 'feedback': 'The retrieved documents discuss vector stores in general, but not Chroma specifically'}]}\n", "---------- Update from node failure_analysis ---------\n", "{'logs': [{'id': '1', 'question': 'How can I import ChatOllama?', 'grade': 1, 'answer': \"To import ChatOllama, use: 'from langchain_community.chat_models import ChatOllama.'\"}, {'id': '2', 'question': 'How can I use Chroma vector store?', 'answer': 'To use Chroma, define: rag_chain = create_retrieval_chain(retriever, question_answer_chain).', 'grade': 0, 'feedback': 'The retrieved documents discuss vector stores in general, but not Chroma specifically'}], 'failure_report': 'Poor quality of retrieval for document IDs: 2'}\n", "---------- Update from node question_summarization ---------\n", "{'logs': [{'id': '1', 'question': 'How can I import ChatOllama?', 'grade': 1, 'answer': \"To import ChatOllama, use: 'from langchain_community.chat_models import ChatOllama.'\"}, {'id': '2', 'question': 'How can I use Chroma vector store?', 'answer': 'To use Chroma, define: rag_chain = create_retrieval_chain(retriever, question_answer_chain).', 'grade': 0, 'feedback': 'The retrieved documents discuss vector stores in general, but not Chroma specifically'}], 'summary_report': 'Questions focused on usage of ChatOllama and Chroma vector store.'}\n" ] } ], "source": [ "for chunk in graph.stream(input, stream_mode=\"updates\"):\n", " node_name = list(chunk.keys())[0]\n", " print(f\"---------- Update from node {node_name} ---------\")\n", " print(chunk[node_name])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As you can see there are only 3 updates made to our overall graph state. The first one is by the `select_logs` node, and then we receive one update from each subgraph (note if you don't want to see the `log` update from each subgraph that you can set the [output schema](https://langchain-ai.github.io/langgraph/how-tos/input_output_schema/) to exclude it). What we do not see however, is the updates occurring *inside* each subgraph. The next section will explain how to do that.\n", "\n", "### Stream subgraph \n", "\n", "To show the updates occurring inside of each subgraph, we can simply set `subgraphs=True` to the streaming call:" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "---------- Update from node select_logs in parent graph ---------\n", "{'logs': [{'id': '1', 'question': 'How can I import ChatOllama?', 'grade': 1, 'answer': \"To import ChatOllama, use: 'from langchain_community.chat_models import ChatOllama.'\"}, {'id': '2', 'question': 'How can I use Chroma vector store?', 'answer': 'To use Chroma, define: rag_chain = create_retrieval_chain(retriever, question_answer_chain).', 'grade': 0, 'feedback': 'The retrieved documents discuss vector stores in general, but not Chroma specifically'}]}\n", "---------- Update from node get_failures in failure_analysis subgraph ---------\n", "{'failures': [{'id': '2', 'question': 'How can I use Chroma vector store?', 'answer': 'To use Chroma, define: rag_chain = create_retrieval_chain(retriever, question_answer_chain).', 'grade': 0, 'feedback': 'The retrieved documents discuss vector stores in general, but not Chroma specifically'}]}\n", "---------- Update from node generate_summary in failure_analysis subgraph ---------\n", "{'failure_report': 'Poor quality of retrieval for document IDs: 2'}\n", "---------- Update from node failure_analysis in parent graph ---------\n", "{'logs': [{'id': '1', 'question': 'How can I import ChatOllama?', 'grade': 1, 'answer': \"To import ChatOllama, use: 'from langchain_community.chat_models import ChatOllama.'\"}, {'id': '2', 'question': 'How can I use Chroma vector store?', 'answer': 'To use Chroma, define: rag_chain = create_retrieval_chain(retriever, question_answer_chain).', 'grade': 0, 'feedback': 'The retrieved documents discuss vector stores in general, but not Chroma specifically'}], 'failure_report': 'Poor quality of retrieval for document IDs: 2'}\n", "---------- Update from node generate_summary in question_summarization subgraph ---------\n", "{'summary': 'Questions focused on usage of ChatOllama and Chroma vector store.'}\n", "---------- Update from node send_to_slack in question_summarization subgraph ---------\n", "{'summary_report': 'Questions focused on usage of ChatOllama and Chroma vector store.'}\n", "---------- Update from node question_summarization in parent graph ---------\n", "{'logs': [{'id': '1', 'question': 'How can I import ChatOllama?', 'grade': 1, 'answer': \"To import ChatOllama, use: 'from langchain_community.chat_models import ChatOllama.'\"}, {'id': '2', 'question': 'How can I use Chroma vector store?', 'answer': 'To use Chroma, define: rag_chain = create_retrieval_chain(retriever, question_answer_chain).', 'grade': 0, 'feedback': 'The retrieved documents discuss vector stores in general, but not Chroma specifically'}], 'summary_report': 'Questions focused on usage of ChatOllama and Chroma vector store.'}\n" ] } ], "source": [ "# Format the namespace slightly nicer\n", "def format_namespace(namespace):\n", " return (\n", " namespace[-1].split(\":\")[0] + \" subgraph\"\n", " if len(namespace) > 0\n", " else \"parent graph\"\n", " )\n", "\n", "\n", "for namespace, chunk in graph.stream(input, stream_mode=\"updates\", subgraphs=True):\n", " node_name = list(chunk.keys())[0]\n", " print(\n", " f\"---------- Update from node {node_name} in {format_namespace(namespace)} ---------\"\n", " )\n", " print(chunk[node_name])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The first thing you will notice as different is that we are no longer just receiving chunks, but we also receive namespaces which tell us what subgraph we are currently inside of.\n", "\n", "If you look carefully at the logs you can see we are now receiving the updates made by nodes inside of each subgraph, for instance we now see updates to the `summary_report` state channel from the `get_failure` node which lives in the `failure_analysis` subgraph. When we didn't set `subgraphs=True` all we saw was the overall update made by the subgraph `failure_analysis`." ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "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": 4 }