From d19858a04a9da74a83a4ac3174f4ceef1610c249 Mon Sep 17 00:00:00 2001 From: Brace Sproul Date: Fri, 13 Dec 2024 11:57:07 -0800 Subject: [PATCH] fix(docs): Update HITL and add interrupt docs (#738) --- .gitignore | 1 + .vscode/settings.json | 3 +- docs/_scripts/notebook_convert.py | 123 +++ .../mdoutput/conf.json | 5 + .../mdoutput/index.md.j2 | 33 + docs/_scripts/notebook_hooks.py | 40 + docs/docs/concepts/breakpoints.md | 146 +++ docs/docs/concepts/human_in_the_loop.md | 912 +++++++++++++----- .../human_in_the_loop/approve-or-reject.png | Bin 0 -> 94081 bytes .../edit-graph-state-simple.png | Bin 0 -> 40187 bytes .../multi-turn-conversation.png | Bin 0 -> 41799 bytes .../human_in_the_loop/tool-call-review.png | Bin 0 -> 55595 bytes docs/docs/concepts/index.md | 2 + docs/docs/concepts/low_level.md | 6 +- docs/docs/concepts/persistence.md | 24 +- docs/docs/concepts/time-travel.md | 83 ++ docs/docs/concepts/v0-human-in-the-loop.md | 341 +++++++ docs/docs/how-tos/index.md | 1 + docs/mkdocs.yml | 8 +- examples/how-tos/breakpoints.ipynb | 7 + examples/how-tos/dynamic_breakpoints.ipynb | 11 +- examples/how-tos/edit-graph-state.ipynb | 5 + .../multi-agent-multi-turn-convo.ipynb | 447 +++++++++ examples/how-tos/review-tool-calls.ipynb | 482 +++++---- examples/how-tos/time-travel.ipynb | 17 +- examples/how-tos/wait-user-input.ipynb | 613 ++++++------ 26 files changed, 2601 insertions(+), 709 deletions(-) create mode 100644 docs/_scripts/notebook_convert.py create mode 100644 docs/_scripts/notebook_convert_templates/mdoutput/conf.json create mode 100644 docs/_scripts/notebook_convert_templates/mdoutput/index.md.j2 create mode 100644 docs/_scripts/notebook_hooks.py create mode 100644 docs/docs/concepts/breakpoints.md create mode 100644 docs/docs/concepts/img/human_in_the_loop/approve-or-reject.png create mode 100644 docs/docs/concepts/img/human_in_the_loop/edit-graph-state-simple.png create mode 100644 docs/docs/concepts/img/human_in_the_loop/multi-turn-conversation.png create mode 100644 docs/docs/concepts/img/human_in_the_loop/tool-call-review.png create mode 100644 docs/docs/concepts/time-travel.md create mode 100644 docs/docs/concepts/v0-human-in-the-loop.md create mode 100644 examples/how-tos/multi-agent-multi-turn-convo.ipynb diff --git a/.gitignore b/.gitignore index 3224c9cf2..4f21edc8e 100644 --- a/.gitignore +++ b/.gitignore @@ -20,3 +20,4 @@ coverage/ dist-cjs **/dist-cjs tmp/ +__pycache__ \ No newline at end of file diff --git a/.vscode/settings.json b/.vscode/settings.json index 3e0ded24d..78d07ea3d 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -5,5 +5,6 @@ "Checkpointers", "Pregel" ], - "typescript.tsdk": "node_modules/typescript/lib" + "typescript.tsdk": "node_modules/typescript/lib", + "python.languageServer": "None" } \ No newline at end of file diff --git a/docs/_scripts/notebook_convert.py b/docs/_scripts/notebook_convert.py new file mode 100644 index 000000000..6523372dc --- /dev/null +++ b/docs/_scripts/notebook_convert.py @@ -0,0 +1,123 @@ +import os +import re +from pathlib import Path + +import nbformat +from nbconvert.exporters import MarkdownExporter +from nbconvert.preprocessors import Preprocessor + + +class EscapePreprocessor(Preprocessor): + def preprocess_cell(self, cell, resources, cell_index): + if cell.cell_type == "markdown": + # rewrite markdown links to html links (excluding image links) + cell.source = re.sub( + r"(?\1', + cell.source, + ) + # Fix image paths in tags + cell.source = re.sub( + r' Path: + with open(notebook_path) as f: + nb = nbformat.read(f, as_version=4) + + body, _ = exporter.from_notebook_node(nb) + return body diff --git a/docs/_scripts/notebook_convert_templates/mdoutput/conf.json b/docs/_scripts/notebook_convert_templates/mdoutput/conf.json new file mode 100644 index 000000000..7adab7c92 --- /dev/null +++ b/docs/_scripts/notebook_convert_templates/mdoutput/conf.json @@ -0,0 +1,5 @@ +{ + "mimetypes": { + "text/markdown": true + } +} \ No newline at end of file diff --git a/docs/_scripts/notebook_convert_templates/mdoutput/index.md.j2 b/docs/_scripts/notebook_convert_templates/mdoutput/index.md.j2 new file mode 100644 index 000000000..00e1e0305 --- /dev/null +++ b/docs/_scripts/notebook_convert_templates/mdoutput/index.md.j2 @@ -0,0 +1,33 @@ +{% extends 'markdown/index.md.j2' %} + +{%- block traceback_line -%} +```output +{{ line.rstrip() | strip_ansi }} +``` +{%- endblock traceback_line -%} + +{%- block stream -%} +```output +{{ output.text.rstrip() }} +``` +{%- endblock stream -%} + +{%- block data_text scoped -%} +```output +{{ output.data['text/plain'].rstrip() }} +``` +{%- endblock data_text -%} + +{%- block data_html scoped -%} +```html +{{ output.data['text/html'] | safe }} +``` +{%- endblock data_html -%} + +{%- block data_jpg scoped -%} +![](data:image/jpg;base64,{{ output.data['image/jpeg'] }}) +{%- endblock data_jpg -%} + +{%- block data_png scoped -%} +![](data:image/png;base64,{{ output.data['image/png'] }}) +{%- endblock data_png -%} diff --git a/docs/_scripts/notebook_hooks.py b/docs/_scripts/notebook_hooks.py new file mode 100644 index 000000000..23c460e7a --- /dev/null +++ b/docs/_scripts/notebook_hooks.py @@ -0,0 +1,40 @@ +import logging +from typing import Any, Dict + +from mkdocs.structure.pages import Page +from mkdocs.structure.files import Files, File +from notebook_convert import convert_notebook + +logger = logging.getLogger(__name__) +logging.basicConfig() +logger.setLevel(logging.INFO) + + +class NotebookFile(File): + def is_documentation_page(self): + return True + + +def on_files(files: Files, **kwargs: Dict[str, Any]): + new_files = Files([]) + for file in files: + if file.src_path.endswith(".ipynb"): + new_file = NotebookFile( + path=file.src_path, + src_dir=file.src_dir, + dest_dir=file.dest_dir, + use_directory_urls=file.use_directory_urls, + ) + new_files.append(new_file) + else: + new_files.append(file) + return new_files + + +def on_page_markdown(markdown: str, page: Page, **kwargs: Dict[str, Any]): + if page.file.src_path.endswith(".ipynb"): + logger.info("Processing Jupyter notebook: %s", page.file.src_path) + body = convert_notebook(page.file.abs_src_path) + return body + + return markdown diff --git a/docs/docs/concepts/breakpoints.md b/docs/docs/concepts/breakpoints.md new file mode 100644 index 000000000..1d754ddd8 --- /dev/null +++ b/docs/docs/concepts/breakpoints.md @@ -0,0 +1,146 @@ +# Breakpoints + +Breakpoints pause graph execution at specific points and enable stepping through execution step by step. Breakpoints are powered by LangGraph's [**persistence layer**](./persistence.md), which saves the state after each graph step. Breakpoints can also be used to enable [**human-in-the-loop**](./human_in_the_loop.md) workflows, though we recommend using the [`interrupt` function](./human_in_the_loop.md#interrupt) for this purpose. + +## Requirements + +To use breakpoints, you will need to: + +1. [**Specify a checkpointer**](persistence.md#checkpoints) to save the graph state after each step. + +2. [**Set breakpoints**](#setting-breakpoints) to specify where execution should pause. + +3. **Run the graph** with a [**thread ID**](./persistence.md#threads) to pause execution at the breakpoint. + +4. **Resume execution** using `invoke`/`stream` (see [**The `Command` primitive**](./human_in_the_loop.md#the-command-primitive)). + +## Setting breakpoints + +There are two places where you can set breakpoints: + +1. **Before** or **after** a node executes by setting breakpoints at **compile time** or **run time**. We call these [**static breakpoints**](#static-breakpoints). + +2. **Inside** a node using the [`NodeInterrupt` error](#nodeinterrupt-error). + +### Static breakpoints + +Static breakpoints are triggered either **before** or **after** a node executes. You can set static breakpoints by specifying `interruptBefore` and `interruptAfter` at **"compile" time** or **run time**. + +=== "Compile time" + + ```typescript + const graph = graphBuilder.compile({ + interruptBefore: ["nodeA"], + interruptAfter: ["nodeB", "nodeC"], + checkpointer: ..., // Specify a checkpointer + }); + + const threadConfig = { + configurable: { + thread_id: "someThread" + } + }; + + // Run the graph until the breakpoint + await graph.invoke(inputs, threadConfig); + + // Optionally update the graph state based on user input + await graph.updateState(update, threadConfig); + + // Resume the graph + await graph.invoke(null, threadConfig); + ``` + +=== "Run time" + + ```typescript + await graph.invoke( + inputs, + { + configurable: { thread_id: "someThread" }, + interruptBefore: ["nodeA"], + interruptAfter: ["nodeB", "nodeC"] + } + ); + + const threadConfig = { + configurable: { + thread_id: "someThread" + } + }; + + // Run the graph until the breakpoint + await graph.invoke(inputs, threadConfig); + + // Optionally update the graph state based on user input + await graph.updateState(update, threadConfig); + + // Resume the graph + await graph.invoke(null, threadConfig); + ``` + + !!! note + + You cannot set static breakpoints at runtime for **sub-graphs**. + + If you have a sub-graph, you must set the breakpoints at compilation time. + +Static breakpoints can be especially useful for debugging if you want to step through the graph execution one +node at a time or if you want to pause the graph execution at specific nodes. + +### `NodeInterrupt` error + +We recommend that you [**use the `interrupt` function instead**](#the-interrupt-function) of the `NodeInterrupt` error if you're trying to implement +[human-in-the-loop](./human_in_the_loop.md) workflows. The `interrupt` function is easier to use and more flexible. + +??? node "`NodeInterrupt` error" + + The developer can define some *condition* that must be met for a breakpoint to be triggered. This concept of [dynamic breakpoints](./low_level.md#dynamic-breakpoints) is useful when the developer wants to halt the graph under *a particular condition*. This uses a `NodeInterrupt`, which is a special type of error that can be thrown from within a node based upon some condition. As an example, we can define a dynamic breakpoint that triggers when the `input` is longer than 5 characters. + + ```typescript + function myNode(state: typeof GraphAnnotation.State) { + if (state.input.length > 5) { + throw new NodeInterrupt(`Received input that is longer than 5 characters: ${state.input}`); + } + return state; + } + ``` + + Let's assume we run the graph with an input that triggers the dynamic breakpoint and then attempt to resume the graph execution simply by passing in `null` for the input. + + ```typescript + // Attempt to continue the graph execution with no change to state after we hit the dynamic breakpoint + for await (const event of await graph.stream(null, threadConfig)) { + console.log(event); + } + ``` + + The graph will *interrupt* again because this node will be *re-run* with the same graph state. We need to change the graph state such that the condition that triggers the dynamic breakpoint is no longer met. So, we can simply edit the graph state to an input that meets the condition of our dynamic breakpoint (< 5 characters) and re-run the node. + + ```typescript + // Update the state to pass the dynamic breakpoint + await graph.updateState({ input: "foo" }, threadConfig); + + for await (const event of await graph.stream(null, threadConfig)) { + console.log(event); + } + ``` + + Alternatively, what if we want to keep our current input and skip the node (`myNode`) that performs the check? To do this, we can simply perform the graph update with `"myNode"` (the node name) as the third positional argument, and pass in `null` for the values. This will make no update to the graph state, but run the update as `myNode`, effectively skipping the node and bypassing the dynamic breakpoint. + + ```typescript + // This update will skip the node `myNode` altogether + await graph.updateState(null, threadConfig, "myNode"); + + for await (const event of await graph.stream(null, threadConfig)) { + console.log(event); + } + ``` + +## Additional Resources 📚 + +- [**Conceptual Guide: Persistence**](persistence.md): Read the persistence guide for more context about persistence. + +- [**Conceptual Guide: Human-in-the-loop**](human_in_the_loop.md): Read the human-in-the-loop guide for more context on integrating human feedback into LangGraph applications using breakpoints. + +- [**How to View and Update Past Graph State**](/langgraphjs/how-tos/time-travel): Step-by-step instructions for working with graph state that demonstrate the **replay** and **fork** actions. diff --git a/docs/docs/concepts/human_in_the_loop.md b/docs/docs/concepts/human_in_the_loop.md index 9aa6c2542..e76c2634b 100644 --- a/docs/docs/concepts/human_in_the_loop.md +++ b/docs/docs/concepts/human_in_the_loop.md @@ -1,341 +1,817 @@ # Human-in-the-loop -Human-in-the-loop (or "on-the-loop") enhances agent capabilities through several common user interaction patterns. +!!! tip "This guide uses the new `interrupt` function." -Common interaction patterns include: + As of LangGraph 0.2.31, the recommended way to set breakpoints is using the [`interrupt` function](/langgraphjs/reference/functions/langgraph.interrupt-1.html) as it simplifies **human-in-the-loop** patterns. -(1) `Approval` - We can interrupt our agent, surface the current state to a user, and allow the user to accept an action. + If you're looking for the previous version of this conceptual guide, which relied on static breakpoints and `NodeInterrupt` exception, it is available [here](v0-human-in-the-loop.md). -(2) `Editing` - We can interrupt our agent, surface the current state to a user, and allow the user to edit the agent state. +A **human-in-the-loop** (or "on-the-loop") workflow integrates human input into automated processes, allowing for decisions, validation, or corrections at key stages. This is especially useful in **LLM-based applications**, where the underlying model may generate occasional inaccuracies. In low-error-tolerance scenarios like compliance, decision-making, or content generation, human involvement ensures reliability by enabling review, correction, or override of model outputs. -(3) `Input` - We can explicitly create a graph node to collect human input and pass that input directly to the agent state. +## Use cases -Use-cases for these interaction patterns include: +Key use cases for **human-in-the-loop** workflows in LLM-based applications include: -(1) `Reviewing tool calls` - We can interrupt an agent to review and edit the results of tool calls. +1. [**🛠️ Reviewing tool calls**](#review-tool-calls): Humans can review, edit, or approve tool calls requested by the LLM before tool execution. -(2) `Time Travel` - We can manually re-play and / or fork past actions of an agent. +2. **✅ Validating LLM outputs**: Humans can review, edit, or approve content generated by the LLM. -## Persistence +3. **💡 Providing context**: Enable the LLM to explicitly request human input for clarification or additional details or to support multi-turn conversations. -All of these interaction patterns are enabled by LangGraph's built-in [persistence](/langgraphjs/concepts/persistence) layer, which will write a checkpoint of the graph state at each step. Persistence allows the graph to stop so that a human can review and / or edit the current state of the graph and then resume with the human's input. -### Breakpoints +## `interrupt` -Adding a [breakpoint](/langgraphjs/concepts/low_level#breakpoints) at a specific location in the graph flow is one way to enable human-in-the-loop. In this case, the developer knows *where* in the workflow human input is needed and simply places a breakpoint prior to or following that particular graph node. - -Here, we compile our graph with a checkpointer and a breakpoint at the node we want to interrupt before, `step_for_human_in_the_loop`. We then perform one of the above interaction patterns, which will create a new checkpoint if a human edits the graph state. The new checkpoint is saved to the thread and we can resume the graph execution from there by passing in `null` as the input. +The [`interrupt` function](/langgraphjs/reference/functions/langgraph.interrupt-1.html) in LangGraph enables human-in-the-loop workflows by pausing the graph at a specific node, presenting information to a human, and resuming the graph with their input. This function is useful for tasks like approvals, edits, or collecting additional input. The [`interrupt` function](/langgraphjs/reference/functions/langgraph.interrupt-1.html) is used in conjunction with the [`Command`](/langgraphjs/reference/classes/langgraph.Command.html) object to resume the graph with a value provided by the human. ```typescript -// Compile our graph with a checkpointer and a breakpoint before "step_for_human_in_the_loop" -const graph = builder.compile({ checkpointer, interruptBefore: ["step_for_human_in_the_loop"] }); - -// Run the graph up to the breakpoint -const threadConfig = { configurable: { thread_id: "1" }, streamMode: "values" as const }; -for await (const event of await graph.stream(inputs, threadConfig)) { - console.log(event); +import { interrupt } from "@langchain/langgraph"; + +function humanNode(state: typeof GraphAnnotation.State) { + const value = interrupt( + // Any JSON serializable value to surface to the human. + // For example, a question or a piece of text or a set of keys in the state + { + text_to_revise: state.some_text + } + ); + // Update the state with the human's input or route the graph based on the input + return { + some_text: value + }; } + +const graph = workflow.compile({ + checkpointer // Required for `interrupt` to work +}); + +// Run the graph until the interrupt +const threadConfig = { configurable: { thread_id: "some_id" } }; +await graph.invoke(someInput, threadConfig); -// Perform some action that requires human in the loop +// Resume the graph with the human's input +await graph.invoke(new Command({ resume: valueFromHuman }), threadConfig); +``` -// Continue the graph execution from the current checkpoint -for await (const event of await graph.stream(null, threadConfig)) { - console.log(event); -} +```typescript +{ some_text: 'Edited text' } ``` -### Dynamic Breakpoints +??? "Full Code" -Alternatively, the developer can define some *condition* that must be met for a breakpoint to be triggered. This concept of [dynamic breakpoints](/langgraphjs/concepts/low_level#dynamic-breakpoints) is useful when the developer wants to halt the graph under *a particular condition*. This uses a [`NodeInterrupt`](/langgraphjs/reference/classes/langgraph.NodeInterrupt.html), which is a special type of error that can be raised from within a node based upon some condition. As an example, we can define a dynamic breakpoint that triggers when the `input` is longer than 5 characters. + Here's a full example of how to use `interrupt` in a graph, if you'd like + to see the code in action. -```typescript -function myNode(state: typeof GraphAnnotation.State): typeof GraphAnnotation.State { - if (state.input.length > 5) { - throw new NodeInterrupt(`Received input that is longer than 5 characters: ${state['input']}`); - } - return state; -} -``` + ```typescript + import { MemorySaver, Annotation, interrupt, Command, StateGraph } from "@langchain/langgraph"; -Let's assume we run the graph with an input that triggers the dynamic breakpoint and then attempt to resume the graph execution simply by passing in `null` for the input. + // Define the graph state + const StateAnnotation = Annotation.Root({ + some_text: Annotation() + }); -```typescript -// Attempt to continue the graph execution with no change to state after we hit the dynamic breakpoint -for await (const event of await graph.stream(null, threadConfig)) { - console.log(event); -} -``` + function humanNode(state: typeof StateAnnotation.State) { + const value = interrupt( + // Any JSON serializable value to surface to the human. + // For example, a question or a piece of text or a set of keys in the state + { + text_to_revise: state.some_text + } + ); + return { + // Update the state with the human's input + some_text: value + }; + } -The graph will *interrupt* again because this node will be *re-run* with the same graph state. We need to change the graph state such that the condition that triggers the dynamic breakpoint is no longer met. So, we can simply edit the graph state to an input that meets the condition of our dynamic breakpoint (< 5 characters) and re-run the node. + // Build the graph + const workflow = new StateGraph(StateAnnotation) + // Add the human-node to the graph + .addNode("human_node", humanNode) + .addEdge("__start__", "human_node") -```typescript -// Update the state to pass the dynamic breakpoint -await graph.updateState(threadConfig, { input: "foo" }); -for await (const event of await graph.stream(null, threadConfig)) { - console.log(event); -} -``` + // A checkpointer is required for `interrupt` to work. + const checkpointer = new MemorySaver(); + const graph = workflow.compile({ + checkpointer + }); -Alternatively, what if we want to keep our current input and skip the node (`myNode`) that performs the check? To do this, we can simply perform the graph update with `"myNode"` as the third positional argument, and pass in `null` for the values. This will make no update to the graph state, but run the update as `myNode`, effectively skipping the node and bypassing the dynamic breakpoint. + // Using stream() to directly surface the `__interrupt__` information. + for await (const chunk of await graph.stream( + { some_text: "Original text" }, + threadConfig + )) { + console.log(chunk); + } -```typescript -// This update will skip the node `myNode` altogether -await graph.updateState(threadConfig, null, "myNode"); -for await (const event of await graph.stream(null, threadConfig)) { - console.log(event); -} -``` + // Resume using Command + for await (const chunk of await graph.stream( + new Command({ resume: "Edited text" }), + threadConfig + )) { + console.log(chunk); + } + ``` -See [our guide](/langgraphjs/how-tos/dynamic_breakpoints) for a detailed how-to on doing this! + ```typescript + { + __interrupt__: [ + { + value: { question: 'Please revise the text', some_text: 'Original text' }, + resumable: true, + ns: ['human_node:10fe492f-3688-c8c6-0d0a-ec61a43fecd6'], + when: 'during' + } + ] + } + { human_node: { some_text: 'Edited text' } } + ``` -## Interaction Patterns -### Approval +## Requirements -![](./img/human_in_the_loop/approval.png) +To use `interrupt` in your graph, you need to: -Sometimes we want to approve certain steps in our agent's execution. - -We can interrupt our agent at a [breakpoint](/langgraphjs/concepts/low_level#breakpoints) prior to the step that we want to approve. +1. [**Specify a checkpointer**](persistence.md#checkpoints) to save the graph state after each step. -This is generally recommended for sensitive actions (e.g., using external APIs or writing to a database). - -With persistence, we can surface the current agent state as well as the next step to a user for review and approval. - -If approved, the graph resumes execution from the last saved checkpoint, which is saved to the thread: +2. **Call `interrupt()`** in the appropriate place. See the [Design Patterns](#design-patterns) section for examples. -```typescript -// Compile our graph with a checkpointer and a breakpoint before the step to approve -const graph = builder.compile({ checkpointer, interruptBefore: ["node_2"] }); +3. **Run the graph** with a [**thread ID**](./persistence.md#threads) until the `interrupt` is hit. -// Run the graph up to the breakpoint -for await (const event of await graph.stream(inputs, threadConfig)) { - console.log(event); -} - -// ... Get human approval ... +4. **Resume execution** using `invoke`/`stream` (see [**The `Command` primitive**](#the-command-primitive)). -// If approved, continue the graph execution from the last saved checkpoint -for await (const event of await graph.stream(null, threadConfig)) { - console.log(event); -} -``` +## Design Patterns -See [our guide](/langgraphjs/how-tos/breakpoints) for a detailed how-to on doing this! +There are typically three different **actions** that you can do with a human-in-the-loop workflow: -### Editing +1. **Approve or Reject**: Pause the graph before a critical step, such as an API call, to review and approve the action. If the action is rejected, you can prevent the graph from executing the step, and potentially take an alternative action. This pattern often involve **routing** the graph based on the human's input. -![](./img/human_in_the_loop/edit_graph_state.png) +2. **Edit Graph State**: Pause the graph to review and edit the graph state. This is useful for correcting mistakes or updating the state with additional information. This pattern often involves **updating** the state with the human's input. -Sometimes we want to review and edit the agent's state. - -As with approval, we can interrupt our agent at a [breakpoint](/langgraphjs/concepts/low_level#breakpoints) prior to the step we want to check. - -We can surface the current state to a user and allow the user to edit the agent state. - -This can, for example, be used to correct the agent if it made a mistake (e.g., see the section on tool calling below). +3. **Get Input**: Explicitly request human input at a particular step in the graph. This is useful for collecting additional information or context to inform the agent's decision-making process or for supporting **multi-turn conversations**. -We can edit the graph state by forking the current checkpoint, which is saved to the thread. +Below we show different design patterns that can be implemented using these **actions**. -We can then proceed with the graph from our forked checkpoint as done before. +### Approve or Reject -```typescript -// Compile our graph with a checkpointer and a breakpoint before the step to review -const graph = builder.compile({ checkpointer, interruptBefore: ["node_2"] }); +
-// Run the graph up to the breakpoint -for await (const event of await graph.stream(inputs, threadConfig)) { - console.log(event); -} - -// Review the state, decide to edit it, and create a forked checkpoint with the new state -await graph.updateState(threadConfig, { state: "new state" }); +![image](img/human_in_the_loop/approve-or-reject.png){: style="max-height:400px"} + +
Depending on the human's approval or rejection, the graph can proceed with the action or take an alternative path.
+ +
+ +Pause the graph before a critical step, such as an API call, to review and approve the action. If the action is rejected, you can prevent the graph from executing the step, and potentially take an alternative action. -// Continue the graph execution from the forked checkpoint -for await (const event of await graph.stream(null, threadConfig)) { - console.log(event); +```typescript +import { interrupt, Command } from "@langchain/langgraph"; + +function humanApproval(state: typeof GraphAnnotation.State): Command { + const isApproved = interrupt({ + question: "Is this correct?", + // Surface the output that should be + // reviewed and approved by the human. + llm_output: state.llm_output + }); + + if (isApproved) { + return new Command({ goto: "some_node" }); + } else { + return new Command({ goto: "another_node" }); + } } -``` -See [this guide](/langgraphjs/how-tos/edit-graph-state) for a detailed how-to on doing this! +// Add the node to the graph in an appropriate location +// and connect it to the relevant nodes. +graphBuilder.addNode("human_approval", humanApproval); -### Input +const graph = graphBuilder.compile({ checkpointer }); -![](./img/human_in_the_loop/wait_for_input.png) +// After running the graph and hitting the interrupt, the graph will pause. +// Resume it with either an approval or rejection. +const threadConfig = { configurable: { thread_id: "some_id" } }; +await graph.invoke(new Command({ resume: true }), threadConfig); +``` -Sometimes we want to explicitly get human input at a particular step in the graph. - -We can create a graph node designated for this (e.g., `human_input` in our example diagram). - -As with approval and editing, we can interrupt our agent at a [breakpoint](/langgraphjs/concepts/low_level#breakpoints) prior to this node. - -We can then perform a state update that includes the human input, just as we did with editing state. +See [how to review tool calls](/langgraphjs/how-tos/review-tool-calls) for a more detailed example. -But, we add one thing: +### Review & Edit State -We can use `"human_input"` as the node with the state update to specify that the state update *should be treated as a node*. +
-This is subtle, but important: +![image](img/human_in_the_loop/edit-graph-state-simple.png){: style="max-height:400px"} -With editing, the user makes a decision about whether or not to edit the graph state. +
A human can review and edit the state of the graph. This is useful for correcting mistakes or updating the state with additional information. -With input, we explicitly define a node in our graph for collecting human input! +
-The state update with the human input then runs *as this node*. +
```typescript -// Compile our graph with a checkpointer and a breakpoint before the step to collect human input -const graph = builder.compile({ checkpointer, interruptBefore: ["human_input"] }); - -// Run the graph up to the breakpoint -for await (const event of await graph.stream(inputs, threadConfig)) { - console.log(event); +import { interrupt } from "@langchain/langgraph"; + +function humanEditing(state: typeof GraphAnnotation.State): Command { + const result = interrupt({ + // Interrupt information to surface to the client. + // Can be any JSON serializable value. + task: "Review the output from the LLM and make any necessary edits.", + llm_generated_summary: state.llm_generated_summary + }); + + // Update the state with the edited text + return { + llm_generated_summary: result.edited_text + }; } - -// Update the state with the user input as if it was the human_input node -await graph.updateState(threadConfig, { user_input: userInput }, "human_input"); -// Continue the graph execution from the checkpoint created by the human_input node -for await (const event of await graph.stream(null, threadConfig)) { - console.log(event); +// Add the node to the graph in an appropriate location +// and connect it to the relevant nodes. +graphBuilder.addNode("human_editing", humanEditing); + +const graph = graphBuilder.compile({ checkpointer }); + +// After running the graph and hitting the interrupt, the graph will pause. +// Resume it with the edited text. +const threadConfig = { configurable: { thread_id: "some_id" } }; +await graph.invoke( + new Command({ resume: { edited_text: "The edited text" } }), + threadConfig +); +``` + +See [How to wait for user input using interrupt](/langgraphjs/how-tos/wait-user-input) for a more detailed example. + +### Review Tool Calls + +
+ +![image](img/human_in_the_loop/tool-call-review.png){: style="max-height:400px"} + +
A human can review and edit the output from the LLM before proceeding. This is particularly +critical in applications where the tool calls requested by the LLM may be sensitive or require human oversight. + +
+ +
+ +```typescript +import { interrupt, Command } from "@langchain/langgraph"; + +function humanReviewNode(state: typeof GraphAnnotation.State): Command { + // This is the value we'll be providing via Command.resume() + const humanReview = interrupt({ + question: "Is this correct?", + // Surface tool calls for review + tool_call: toolCall + }); + + const [reviewAction, reviewData] = humanReview; + + // Approve the tool call and continue + if (reviewAction === "continue") { + return new Command({ goto: "run_tool" }); + } + // Modify the tool call manually and then continue + else if (reviewAction === "update") { + const updatedMsg = getUpdatedMsg(reviewData); + // Remember that to modify an existing message you will need + // to pass the message with a matching ID. + return new Command({ + goto: "run_tool", + update: { messages: [updatedMsg] } + }); + } + // Give natural language feedback, and then pass that back to the agent + else if (reviewAction === "feedback") { + const feedbackMsg = getFeedbackMsg(reviewData); + return new Command({ + goto: "call_llm", + update: { messages: [feedbackMsg] } + }); + } } ``` -See [this guide](/langgraphjs/how-tos/wait-user-input) for a detailed how-to on doing this! +See [how to review tool calls](/langgraphjs/how-tos/review-tool-calls) for a more detailed example. -## Use-cases +### Multi-turn conversation -### Reviewing Tool Calls +
-Some user interaction patterns combine the above ideas. +![image](img/human_in_the_loop/multi-turn-conversation.png){: style="max-height:400px"} -For example, many agents use [tool calling](https://js.langchain.com/docs/modules/agents/tools/) to make decisions. +
A multi-turn conversation architecture where an agent and human node cycle back and forth until the agent decides to hand off the conversation to another agent or another part of the system. -Tool calling presents a challenge because the agent must get two things right: +
-(1) The name of the tool to call +
-(2) The arguments to pass to the tool +A **multi-turn conversation** involves multiple back-and-forth interactions between an agent and a human, which can allow the agent to gather additional information from the human in a conversational manner. -Even if the tool call is correct, we may also want to apply discretion: +This design pattern is useful in an LLM application consisting of [multiple agents](./multi_agent.md). One or more agents may need to carry out multi-turn conversations with a human, where the human provides input or feedback at different stages of the conversation. For simplicity, the agent implementation below is illustrated as a single node, but in reality it may be part of a larger graph consisting of multiple nodes and include a conditional edge. -(3) The tool call may be a sensitive operation that we want to approve +=== "Using a human node per agent" -With these points in mind, we can combine the above ideas to create a human-in-the-loop review of a tool call. + In this pattern, each agent has its own human node for collecting user input. -```typescript -// Compile our graph with a checkpointer and a breakpoint before the step to review the tool call from the LLM -const graph = builder.compile({ checkpointer, interruptBefore: ["human_review"] }); + This can be achieved by either naming the human nodes with unique names (e.g., "human for agent 1", "human for agent 2") or by + using subgraphs where a subgraph contains a human node and an agent node. -// Run the graph up to the breakpoint -for await (const event of await graph.stream(inputs, threadConfig)) { - console.log(event); -} - -// Review the tool call and update it, if needed, as the human_review node -await graph.updateState(threadConfig, { tool_call: "updated tool call" }, "human_review"); + ```typescript + import { interrupt } from "@langchain/langgraph"; + + function humanInput(state: typeof GraphAnnotation.State) { + const humanMessage = interrupt("human_input"); + + return { + messages: [ + { + role: "human", + content: humanMessage + } + ] + }; + } + + function agent(state: typeof GraphAnnotation.State) { + // Agent logic + // ... + } + + graphBuilder.addNode("human_input", humanInput); + graphBuilder.addEdge("human_input", "agent"); + + const graph = graphBuilder.compile({ checkpointer }); + + // After running the graph and hitting the interrupt, the graph will pause. + // Resume it with the human's input. + await graph.invoke( + new Command({ resume: "hello!" }), + threadConfig + ); + ``` + +=== "Sharing human node across multiple agents" + + In this pattern, a single human node is used to collect user input for multiple agents. The active agent is determined from the state, so after human input is collected, the graph can route to the correct agent. + + ```typescript + import { interrupt, Command, MessagesAnnotation } from "@langchain/langgraph"; + + function humanNode(state: typeof MessagesAnnotation.State): Command { + /** + * A node for collecting user input. + */ + const userInput = interrupt("Ready for user input."); + + // Determine the **active agent** from the state, so + // we can route to the correct agent after collecting input. + // For example, add a field to the state or use the last active agent. + // or fill in `name` attribute of AI messages generated by the agents. + const activeAgent = ...; + + return new Command({ + goto: activeAgent, + update: { + messages: [{ + role: "human", + content: userInput, + }] + } + }); + } + ``` + +See [how to implement multi-turn conversations](/langgraphjs/how-tos/multi-agent-multi-turn-convo) for a more detailed example. + +### Validating human input -// Otherwise, approve the tool call and proceed with the graph execution with no edits +If you need to validate the input provided by the human within the graph itself (rather than on the client side), you can achieve this by using multiple interrupt calls within a single node. -// Continue the graph execution from either: -// (1) the forked checkpoint created by human_review or -// (2) the checkpoint saved when the tool call was originally made (no edits in human_review) -for await (const event of await graph.stream(null, threadConfig)) { - console.log(event); +```typescript +import { interrupt } from "@langchain/langgraph"; + +function humanNode(state: typeof GraphAnnotation.State) { + /** + * Human node with validation. + */ + let question = "What is your age?"; + + while (true) { + const answer = interrupt(question); + + // Validate answer, if the answer isn't valid ask for input again. + if (typeof answer !== "number" || answer < 0) { + question = `'${answer}' is not a valid age. What is your age?`; + continue; + } else { + // If the answer is valid, we can proceed. + break; + } + } + + console.log(`The human in the loop is ${answer} years old.`); + + return { + age: answer + }; } ``` -See [this guide](/langgraphjs/how-tos/review-tool-calls) for a detailed how-to on doing this! +## The `Command` primitive -### Time Travel +When using the `interrupt` function, the graph will pause at the interrupt and wait for user input. -When working with agents, we often want to closely examine their decision making process: +Graph execution can be resumed using the [Command](/langgraphjs/reference/classes/langgraph.Command.html) primitive which can be passed through the `invoke` or `stream` methods. -(1) Even when they arrive at a desired final result, the reasoning that led to that result is often important to examine. +The `Command` primitive provides several options to control and modify the graph's state during resumption: -(2) When agents make mistakes, it is often valuable to understand why. +1. **Pass a value to the `interrupt`**: Provide data, such as a user's response, to the graph using `new Command({ resume: value })`. Execution resumes from the beginning of the node where the `interrupt` was used, however, this time the `interrupt(...)` call will return the value passed in the `new Command({ resume: value })` instead of pausing the graph. -(3) In either of the above cases, it is useful to manually explore alternative decision making paths. + ```typescript + // Resume graph execution with the user's input. + await graph.invoke(new Command({ resume: { age: "25" } }), threadConfig); + ``` -Collectively, we call these debugging concepts `time-travel` and they are composed of `replaying` and `forking`. +2. **Update the graph state**: Modify the graph state using `Command({ goto: ..., update: ... })`. Note that resumption starts from the beginning of the node where the `interrupt` was used. Execution resumes from the beginning of the node where the `interrupt` was used, but with the updated state. -#### Replaying + ```typescript + // Update the graph state and resume. + // You must provide a `resume` value if using an `interrupt`. + await graph.invoke( + new Command({ resume: "Let's go!!!", update: { foo: "bar" } }), + threadConfig + ); + ``` -![](./img/human_in_the_loop/replay.png) +By leveraging `Command`, you can resume graph execution, handle user inputs, and dynamically adjust the graph's state. -Sometimes we want to simply replay past actions of an agent. - -Above, we showed the case of executing an agent from the current state (or checkpoint) of the graph. +## Using with `invoke` -We do this by simply passing in `null` for the input with a `threadConfig`. +When you use `stream` to run the graph, you will receive an `Interrupt` event that let you know the `interrupt` was triggered. + +`invoke` does not return the interrupt information. To access this information, you must use the [getState](/langgraphjs/reference/classes/langgraph.CompiledStateGraph.html#getState) method to retrieve the graph state after calling `invoke`. ```typescript -const threadConfig = { configurable: { thread_id: "1" } }; -for await (const event of await graph.stream(null, threadConfig)) { - console.log(event); -} -``` +// Run the graph up to the interrupt +const result = await graph.invoke(inputs, threadConfig); -Now, we can modify this to replay past actions from a *specific* checkpoint by passing in the checkpoint ID. +// Get the graph state to get interrupt information. +const state = await graph.getState(threadConfig); -To get a specific checkpoint ID, we can easily get all of the checkpoints in the thread and filter to the one we want. +// Print the state values +console.log(state.values); + +// Print the pending tasks +console.log(state.tasks); + +// Resume the graph with the user's input. +await graph.invoke(new Command({ resume: { age: "25" } }), threadConfig); +``` ```typescript -const allCheckpoints = []; -for await (const state of app.getStateHistory(threadConfig)) { - allCheckpoints.push(state); -} +{ foo: 'bar' } // State values + +[ + { + id: '5d8ffc92-8011-0c9b-8b59-9d3545b7e553', + name: 'node_foo', + path: ['__pregel_pull', 'node_foo'], + error: null, + interrupts: [{ + value: 'value_in_interrupt', + resumable: true, + ns: ['node_foo:5d8ffc92-8011-0c9b-8b59-9d3545b7e553'], + when: 'during' + }], + state: null, + result: null + } +] // Pending tasks. interrupts ``` -Each checkpoint has a unique ID, which we can use to replay from a specific checkpoint. +## How does resuming from an interrupt work? -Assume from reviewing the checkpoints that we want to replay from one, `xxx`. +A critical aspect of using `interrupt` is understanding how resuming works. When you resume execution after an `interrupt`, graph execution starts from the **beginning** of the **graph node** where the last `interrupt` was triggered. -We just pass in the checkpoint ID when we run the graph. +**All** code from the beginning of the node to the `interrupt` will be re-executed. ```typescript -const config = { configurable: { thread_id: '1', checkpoint_id: 'xxx' }, streamMode: "values" as const }; -for await (const event of await graph.stream(null, config)) { - console.log(event); +let counter = 0; + +function node(state: State) { + // All the code from the beginning of the node to the interrupt will be re-executed + // when the graph resumes. + counter += 1; + + console.log(`> Entered the node: ${counter} # of times`); + + // Pause the graph and wait for user input. + const answer = interrupt(); + + console.log("The value of counter is:", counter); + // ... } ``` - -Importantly, the graph knows which checkpoints have been previously executed. -So, it will re-play any previously executed nodes rather than re-executing them. +Upon **resuming** the graph, the counter will be incremented a second time, resulting in the following output: -See [this additional conceptual guide](https://langchain-ai.github.io/langgraph/concepts/persistence/#replay) for related context on replaying. +```typescript +> Entered the node: 2 # of times +The value of counter is: 2 +``` -See [this guide](/langgraphjs/how-tos/time-travel) for a detailed how-to on doing time-travel! +## Common Pitfalls -#### Forking +### Side-effects -![](./img/human_in_the_loop/forking.png) +Place code with side effects, such as API calls, **after** the `interrupt` to avoid duplication, as these are re-triggered every time the node is resumed. -Sometimes we want to fork past actions of an agent, and explore different paths through the graph. +=== "Side effects before interrupt (BAD)" -`Editing`, as discussed above, is *exactly* how we do this for the *current* state of the graph! + This code will re-execute the API call another time when the node is resumed from + the `interrupt`. + This can be problematic if the API call is not idempotent or is just expensive. -But, what if we want to fork *past* states of the graph? + ```typescript + import { interrupt } from "@langchain/langgraph"; -For example, let's say we want to edit a particular checkpoint, `xxx`. + function humanNode(state: typeof GraphAnnotation.State) { + /** + * Human node with validation. + */ + apiCall(); // This code will be re-executed when the node is resumed. -We pass this `checkpoint_id` when we update the state of the graph. + const answer = interrupt(question); + } + ``` -```typescript -const config = { configurable: { thread_id: "1", checkpoint_id: "xxx" } }; -await graph.updateState(config, { state: "updated state" }); -``` +=== "Side effects after interrupt (OK)" -This creates a new forked checkpoint, `xxx-fork`, which we can then run the graph from. + ```typescript + import { interrupt } from "@langchain/langgraph"; + + function humanNode(state: typeof GraphAnnotation.State) { + /** + * Human node with validation. + */ + + const answer = interrupt(question); + + apiCall(answer); // OK as it's after the interrupt + } + ``` + +=== "Side effects in a separate node (OK)" + + ```typescript + import { interrupt } from "@langchain/langgraph"; + + function humanNode(state: typeof GraphAnnotation.State) { + /** + * Human node with validation. + */ + + const answer = interrupt(question); + + return { + answer + }; + } + + function apiCallNode(state: typeof GraphAnnotation.State) { + apiCall(); // OK as it's in a separate node + } + ``` + +### Subgraphs called as functions + +When invoking a subgraph [as a function](low_level.md#as-a-function), the **parent graph** will resume execution from the **beginning of the node** where the subgraph was invoked (and where an `interrupt` was triggered). Similarly, the **subgraph**, will resume from the **beginning of the node** where the `interrupt()` function was called. + +For example, ```typescript -const config = { configurable: { thread_id: '1', checkpoint_id: 'xxx-fork' }, streamMode: "values" as const }; -for await (const event of await graph.stream(null, config)) { - console.log(event); +async function nodeInParentGraph(state: typeof GraphAnnotation.State) { + someCode(); // <-- This will re-execute when the subgraph is resumed. + // Invoke a subgraph as a function. + // The subgraph contains an `interrupt` call. + const subgraphResult = await subgraph.invoke(someInput); + ... } ``` -See [this additional conceptual guide](/langgraphjs/concepts/persistence/#update-state) for related context on forking. +??? "**Example: Parent and Subgraph Execution Flow**" + + Say we have a parent graph with 3 nodes: + + **Parent Graph**: `node_1` → `node_2` (subgraph call) → `node_3` + + And the subgraph has 3 nodes, where the second node contains an `interrupt`: + + **Subgraph**: `sub_node_1` → `sub_node_2` (`interrupt`) → `sub_node_3` + + When resuming the graph, the execution will proceed as follows: + + 1. **Skip `node_1`** in the parent graph (already executed, graph state was saved in snapshot). + 2. **Re-execute `node_2`** in the parent graph from the start. + 3. **Skip `sub_node_1`** in the subgraph (already executed, graph state was saved in snapshot). + 4. **Re-execute `sub_node_2`** in the subgraph from the beginning. + 5. Continue with `sub_node_3` and subsequent nodes. + + Here is abbreviated example code that you can use to understand how subgraphs work with interrupts. + It counts the number of times each node is entered and prints the count. + + ```typescript + import { + StateGraph, + START, + interrupt, + Command, + MemorySaver, + Annotation + } from "@langchain/langgraph"; + + const GraphAnnotation = Annotation.Root({ + stateCounter: Annotation({ + reducer: (a, b) => a + b, + default: () => 0 + }) + }) + + let counterNodeInSubgraph = 0; + + function nodeInSubgraph(state: typeof GraphAnnotation.State) { + counterNodeInSubgraph += 1; // This code will **NOT** run again! + console.log(`Entered 'nodeInSubgraph' a total of ${counterNodeInSubgraph} times`); + return {}; + } + + let counterHumanNode = 0; + + async function humanNode(state: typeof GraphAnnotation.State) { + counterHumanNode += 1; // This code will run again! + console.log(`Entered humanNode in sub-graph a total of ${counterHumanNode} times`); + const answer = await interrupt("what is your name?"); + console.log(`Got an answer of ${answer}`); + return {}; + } + + const checkpointer = new MemorySaver(); + + const subgraphBuilder = new StateGraph(GraphAnnotation) + .addNode("some_node", nodeInSubgraph) + .addNode("human_node", humanNode) + .addEdge(START, "some_node") + .addEdge("some_node", "human_node") + const subgraph = subgraphBuilder.compile({ checkpointer }); + + let counterParentNode = 0; + + async function parentNode(state: typeof GraphAnnotation.State) { + counterParentNode += 1; // This code will run again on resuming! + console.log(`Entered 'parentNode' a total of ${counterParentNode} times`); + + // Please note that we're intentionally incrementing the state counter + // in the graph state as well to demonstrate that the subgraph update + // of the same key will not conflict with the parent graph (until + const subgraphState = await subgraph.invoke(state); + return subgraphState; + } + + const builder = new StateGraph(GraphAnnotation) + .addNode("parent_node", parentNode) + .addEdge(START, "parent_node") + + // A checkpointer must be enabled for interrupts to work! + const graph = builder.compile({ checkpointer }); + + const config = { + configurable: { + thread_id: crypto.randomUUID(), + } + }; + + for await (const chunk of await graph.stream({ stateCounter: 1 }, config)) { + console.log(chunk); + } + + console.log('--- Resuming ---'); + + for await (const chunk of await graph.stream(new Command({ resume: "35" }), config)) { + console.log(chunk); + } + ``` + + This will print out + + ```typescript + --- First invocation --- + In parent node: { foo: 'bar' } + Entered 'parentNode' a total of 1 times + Entered 'nodeInSubgraph' a total of 1 times + Entered humanNode in sub-graph a total of 1 times + { __interrupt__: [{ value: 'what is your name?', resumable: true, ns: ['parent_node:0b23d72f-aaba-0329-1a59-ca4f3c8bad3b', 'human_node:25df717c-cb80-57b0-7410-44e20aac8f3c'], when: 'during' }] } + + --- Resuming --- + In parent node: { foo: 'bar' } + Entered 'parentNode' a total of 2 times + Entered humanNode in sub-graph a total of 2 times + Got an answer of 35 + { parent_node: null } + ``` + + +### Using multiple interrupts + +Using multiple interrupts within a **single** node can be helpful for patterns like [validating human input](#validating-human-input). However, using multiple interrupts in the same node can lead to unexpected behavior if not handled carefully. + +When a node contains multiple interrupt calls, LangGraph keeps a list of resume values specific to the task executing the node. Whenever execution resumes, it starts at the beginning of the node. For each interrupt encountered, LangGraph checks if a matching value exists in the task's resume list. Matching is **strictly index-based**, so the order of interrupt calls within the node is critical. + +To avoid issues, refrain from dynamically changing the node's structure between executions. This includes adding, removing, or reordering interrupt calls, as such changes can result in mismatched indices. These problems often arise from unconventional patterns, such as mutating state via `Command.resume(...).update(SOME_STATE_MUTATION)` or relying on global variables to modify the node's structure dynamically. + +??? "Example of incorrect code" + + ```typescript + import { v4 as uuidv4 } from "uuid"; + import { + StateGraph, + MemorySaver, + START, + interrupt, + Command, + Annotation + } from "@langchain/langgraph"; + + const GraphAnnotation = Annotation.Root({ + name: Annotation(), + age: Annotation() + }); + + function humanNode(state: typeof GraphAnnotation.State) { + let name; + if (!state.name) { + name = interrupt("what is your name?"); + } else { + name = "N/A"; + } + + let age; + if (!state.age) { + age = interrupt("what is your age?"); + } else { + age = "N/A"; + } + + console.log(`Name: ${name}. Age: ${age}`); + + return { + age, + name, + }; + } + + const builder = new StateGraph(GraphAnnotation) + .addNode("human_node", humanNode); + .addEdge(START, "human_node"); + + // A checkpointer must be enabled for interrupts to work! + const checkpointer = new MemorySaver(); + + const graph = builder.compile({ checkpointer }); + + const config = { + configurable: { + thread_id: uuidv4(), + } + }; + + for await (const chunk of await graph.stream({ age: undefined, name: undefined }, config)) { + console.log(chunk); + } + + for await (const chunk of await graph.stream( + Command({ resume: "John", update: { name: "foo" } }), + config + )) { + console.log(chunk); + } + ``` + + ```typescript + { __interrupt__: [{ + value: 'what is your name?', + resumable: true, + ns: ['human_node:3a007ef9-c30d-c357-1ec1-86a1a70d8fba'], + when: 'during' + }]} + Name: N/A. Age: John + { human_node: { age: 'John', name: 'N/A' } } + ``` + +## Additional Resources 📚 + +- [**Conceptual Guide: Persistence**](persistence.md#replay): Read the persistence guide for more context on replaying. + +- [**How to Guides: Human-in-the-loop**](/langgraphjs/how-tos/#human-in-the-loop): Learn how to implement human-in-the-loop workflows in LangGraph. -See [this guide](/langgraphjs/how-tos/time-travel) for a detailed how-to on doing time-travel! \ No newline at end of file +- [**How to implement multi-turn conversations**](/langgraphjs/how-tos/multi-agent-multi-turn-convo): Learn how to implement multi-turn conversations in LangGraph. diff --git a/docs/docs/concepts/img/human_in_the_loop/approve-or-reject.png b/docs/docs/concepts/img/human_in_the_loop/approve-or-reject.png new file mode 100644 index 0000000000000000000000000000000000000000..0ba06b1a40a907531940c524fe499d8756e626d3 GIT binary patch literal 94081 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 O|5O#PC{)N2Lt>av6#FC`~&Hz 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�%y5zCFVcP^wk3|@fu2IZ6eOur=R%?Wp? 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 z%0A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 z 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 eoS~mPKGbh}Ai~D$Iqf|I5O})!xvX=0.2.29`. + This functionality requires `@langchain/langgraph>=0.2.31`. It can be convenient to combine control flow (edges) and state updates (nodes). For example, you might want to BOTH perform state updates AND decide which node to go to next in the SAME node rather than use a conditional edge. LangGraph provides a way to do so by returning a [`Command`](https://langchain-ai.github.io/langgraphjs/reference/classes/langgraph.Command.html) object from node functions: @@ -434,6 +434,10 @@ Use `Command` when you need to **both** update the graph state **and** route to Use [conditional edges](#conditional-edges) to route between nodes conditionally without updating the state. +### Human-in-the-loop + +`Command` is an important part of human-in-the-loop workflows: when using `interrupt()` to collect user input, `Command` is then used to supply the input and resume execution via `new Command({ resume: "User input" })`. Check out [this conceptual guide](/langgraphjs/concepts/human_in_the_loop) for more information. + ## Persistence LangGraph provides built-in persistence for your agent's state using [checkpointers](/langgraphjs/reference/classes/checkpoint.BaseCheckpointSaver.html). Checkpointers save snapshots of the graph state at every superstep, allowing resumption at any time. This enables features like human-in-the-loop interactions, memory management, and fault-tolerance. You can even directly manipulate a graph's state after its execution using the appropriate `get` and `update` methods. For more details, see the [conceptual guide](/langgraphjs/concepts/persistence) for more information. diff --git a/docs/docs/concepts/persistence.md b/docs/docs/concepts/persistence.md index ff7e953b2..4e16e9399 100644 --- a/docs/docs/concepts/persistence.md +++ b/docs/docs/concepts/persistence.md @@ -25,11 +25,9 @@ Checkpoint is a snapshot of the graph state saved at each super-step and is repr Let's see what checkpoints are saved when a simple graph is invoked as follows: ```typescript -import { StateGraph, START, END } from "langgraph"; -import { MemorySaver } from "langgraph/checkpoint"; -import { Annotation } from "@langchain/core/utils/types"; +import { StateGraph, START, END, MemorySaver, Annotation } from "@langchain/langgraph"; -const GraphAnnotation = Annotation.Object({ +const GraphAnnotation = Annotation.Root({ foo: Annotation bar: Annotation({ reducer: (a, b) => [...a, ...b], @@ -46,11 +44,11 @@ function nodeB(state: typeof GraphAnnotation.State) { } const workflow = new StateGraph(GraphAnnotation); -workflow.addNode("nodeA", nodeA); -workflow.addNode("nodeB", nodeB); -workflow.addEdge(START, "nodeA"); -workflow.addEdge("nodeA", "nodeB"); -workflow.addEdge("nodeB", END); + .addNode("nodeA", nodeA) + .addNode("nodeB", nodeB) + .addEdge(START, "nodeA") + .addEdge("nodeA", "nodeB") + .addEdge("nodeB", END); const checkpointer = new MemorySaver(); const graph = workflow.compile({ checkpointer }); @@ -169,9 +167,9 @@ These are the values that will be used to update the state. Note that this updat Let's assume you have defined the state of your graph with the following schema (see full example above): ```typescript -import { Annotation } from "@langchain/core/utils/types"; +import { Annotation } from "@langchain/langgraph"; -const GraphAnnotation = Annotation.Object({ +const GraphAnnotation = Annotation.Root({ foo: Annotation bar: Annotation({ reducer: (a, b) => [...a, ...b], @@ -236,14 +234,14 @@ We use the `store.put` method to save memories to our namespace in the store. Wh import { v4 as uuid4 } from 'uuid'; const memoryId = uuid4(); -const memory = { food_preference : "I like pizza" }; +const memory = { food_preference: "I like pizza" }; await inMemoryStore.put(namespaceForMemory, memoryId, memory); ``` We can read out memories in our namespace using `store.search`, which will return all memories for a given user as a list. The most recent memory is the last in the list. ```ts -const memories = inMemoryStore.search(namespaceForMemory); +const memories = await inMemoryStore.search(namespaceForMemory); console.log(memories.at(-1)); /* diff --git a/docs/docs/concepts/time-travel.md b/docs/docs/concepts/time-travel.md new file mode 100644 index 000000000..3314b19da --- /dev/null +++ b/docs/docs/concepts/time-travel.md @@ -0,0 +1,83 @@ +# Time Travel ⏱️ + +!!! note "Prerequisites" + + This guide assumes that you are familiar with LangGraph's checkpoints and states. If not, please review the [persistence](./persistence.md) concept first. + +When working with non-deterministic systems that make model-based decisions (e.g., agents powered by LLMs), it can be useful to examine their decision-making process in detail: + +1. 🤔 **Understand Reasoning**: Analyze the steps that led to a successful result. + +2. 🐞 **Debug Mistakes**: Identify where and why errors occurred. + +3. 🔍 **Explore Alternatives**: Test different paths to uncover better solutions. + +We call these debugging techniques **Time Travel**, composed of two key actions: [**Replaying**](#replaying) 🔁 and [**Forking**](#forking) 🔀. + +## Replaying + +![](./img/human_in_the_loop/replay.png) + +Replaying allows us to revisit and reproduce an agent's past actions. This can be done either from the current state (or checkpoint) of the graph or from a specific checkpoint. + +To replay from the current state, simply pass `null` as the input along with a `threadConfig`: + +```typescript +const threadConfig = { configurable: { thread_id: "1" }, streamMode: "values" }; + +for await (const event of await graph.stream(null, threadConfig)) { + console.log(event); +} +``` + +To replay actions from a specific checkpoint, start by retrieving all checkpoints for the thread: + +```typescript +const allCheckpoints = []; + +for await (const state of graph.getStateHistory(threadConfig)) { + allCheckpoints.push(state); +} +``` + +Each checkpoint has a unique ID. After identifying the desired checkpoint, for instance, `xyz`, include its ID in the configuration: + +```typescript +const threadConfig = { configurable: { thread_id: '1', checkpoint_id: 'xyz' }, streamMode: "values" }; + +for await (const event of await graph.stream(null, threadConfig)) { + console.log(event); +} +``` + +The graph efficiently replays previously executed nodes instead of re-executing them, leveraging its awareness of prior checkpoint executions. + +## Forking + +![](./img/human_in_the_loop/forking.png) + +Forking allows you to revisit an agent's past actions and explore alternative paths within the graph. + +To edit a specific checkpoint, such as `xyz`, provide its `checkpoint_id` when updating the graph's state: + +```typescript +const threadConfig = { configurable: { thread_id: "1", checkpoint_id: "xyz" } }; + +graph.updateState(threadConfig, { state: "updated state" }); +``` + +This creates a new forked checkpoint, xyz-fork, from which you can continue running the graph: + +```typescript +const threadConfig = { configurable: { thread_id: '1', checkpoint_id: 'xyz-fork' }, streamMode: "values" }; + +for await (const event of await graph.stream(null, threadConfig)) { + console.log(event); +} +``` + +## Additional Resources 📚 + +- [**Conceptual Guide: Persistence**](https://langchain-ai.github.io/langgraphjs/concepts/persistence/#replay): Read the persistence guide for more context on replaying. + +- [**How to View and Update Past Graph State**](/langgraphjs/how-tos/time-travel): Step-by-step instructions for working with graph state that demonstrate the **replay** and **fork** actions. diff --git a/docs/docs/concepts/v0-human-in-the-loop.md b/docs/docs/concepts/v0-human-in-the-loop.md new file mode 100644 index 000000000..3d69baee4 --- /dev/null +++ b/docs/docs/concepts/v0-human-in-the-loop.md @@ -0,0 +1,341 @@ +# Human-in-the-loop + +Human-in-the-loop (or "on-the-loop") enhances agent capabilities through several common user interaction patterns. + +Common interaction patterns include: + +(1) `Approval` - We can interrupt our agent, surface the current state to a user, and allow the user to accept an action. + +(2) `Editing` - We can interrupt our agent, surface the current state to a user, and allow the user to edit the agent state. + +(3) `Input` - We can explicitly create a graph node to collect human input and pass that input directly to the agent state. + +Use-cases for these interaction patterns include: + +(1) `Reviewing tool calls` - We can interrupt an agent to review and edit the results of tool calls. + +(2) `Time Travel` - We can manually re-play and / or fork past actions of an agent. + +## Persistence + +All of these interaction patterns are enabled by LangGraph's built-in [persistence](/langgraphjs/concepts/persistence) layer, which will write a checkpoint of the graph state at each step. Persistence allows the graph to stop so that a human can review and / or edit the current state of the graph and then resume with the human's input. + +### Breakpoints + +Adding a [breakpoint](/langgraphjs/concepts/low_level#breakpoints) at a specific location in the graph flow is one way to enable human-in-the-loop. In this case, the developer knows *where* in the workflow human input is needed and simply places a breakpoint prior to or following that particular graph node. + +Here, we compile our graph with a checkpointer and a breakpoint at the node we want to interrupt before, `step_for_human_in_the_loop`. We then perform one of the above interaction patterns, which will create a new checkpoint if a human edits the graph state. The new checkpoint is saved to the thread and we can resume the graph execution from there by passing in `null` as the input. + +```typescript +// Compile our graph with a checkpointer and a breakpoint before "step_for_human_in_the_loop" +const graph = builder.compile({ checkpointer, interruptBefore: ["step_for_human_in_the_loop"] }); + +// Run the graph up to the breakpoint +const threadConfig = { configurable: { thread_id: "1" }, streamMode: "values" as const }; +for await (const event of await graph.stream(inputs, threadConfig)) { + console.log(event); +} + +// Perform some action that requires human in the loop + +// Continue the graph execution from the current checkpoint +for await (const event of await graph.stream(null, threadConfig)) { + console.log(event); +} +``` + +### Dynamic Breakpoints + +Alternatively, the developer can define some *condition* that must be met for a breakpoint to be triggered. This concept of [dynamic breakpoints](/langgraphjs/concepts/low_level#dynamic-breakpoints) is useful when the developer wants to halt the graph under *a particular condition*. This uses a [`NodeInterrupt`](/langgraphjs/reference/classes/langgraph.NodeInterrupt.html), which is a special type of error that can be raised from within a node based upon some condition. As an example, we can define a dynamic breakpoint that triggers when the `input` is longer than 5 characters. + +```typescript +function myNode(state: typeof GraphAnnotation.State): typeof GraphAnnotation.State { + if (state.input.length > 5) { + throw new NodeInterrupt(`Received input that is longer than 5 characters: ${state['input']}`); + } + return state; +} +``` + +Let's assume we run the graph with an input that triggers the dynamic breakpoint and then attempt to resume the graph execution simply by passing in `null` for the input. + +```typescript +// Attempt to continue the graph execution with no change to state after we hit the dynamic breakpoint +for await (const event of await graph.stream(null, threadConfig)) { + console.log(event); +} +``` + +The graph will *interrupt* again because this node will be *re-run* with the same graph state. We need to change the graph state such that the condition that triggers the dynamic breakpoint is no longer met. So, we can simply edit the graph state to an input that meets the condition of our dynamic breakpoint (< 5 characters) and re-run the node. + +```typescript +// Update the state to pass the dynamic breakpoint +await graph.updateState(threadConfig, { input: "foo" }); +for await (const event of await graph.stream(null, threadConfig)) { + console.log(event); +} +``` + +Alternatively, what if we want to keep our current input and skip the node (`myNode`) that performs the check? To do this, we can simply perform the graph update with `"myNode"` as the third positional argument, and pass in `null` for the values. This will make no update to the graph state, but run the update as `myNode`, effectively skipping the node and bypassing the dynamic breakpoint. + +```typescript +// This update will skip the node `myNode` altogether +await graph.updateState(threadConfig, null, "myNode"); +for await (const event of await graph.stream(null, threadConfig)) { + console.log(event); +} +``` + +See [our guide](/langgraphjs/how-tos/dynamic_breakpoints) for a detailed how-to on doing this! + +## Interaction Patterns + +### Approval + +![](./img/human_in_the_loop/approval.png) + +Sometimes we want to approve certain steps in our agent's execution. + +We can interrupt our agent at a [breakpoint](/langgraphjs/concepts/low_level#breakpoints) prior to the step that we want to approve. + +This is generally recommended for sensitive actions (e.g., using external APIs or writing to a database). + +With persistence, we can surface the current agent state as well as the next step to a user for review and approval. + +If approved, the graph resumes execution from the last saved checkpoint, which is saved to the thread: + +```typescript +// Compile our graph with a checkpointer and a breakpoint before the step to approve +const graph = builder.compile({ checkpointer, interruptBefore: ["node_2"] }); + +// Run the graph up to the breakpoint +for await (const event of await graph.stream(inputs, threadConfig)) { + console.log(event); +} + +// ... Get human approval ... + +// If approved, continue the graph execution from the last saved checkpoint +for await (const event of await graph.stream(null, threadConfig)) { + console.log(event); +} +``` + +See [our guide](/langgraphjs/how-tos/breakpoints) for a detailed how-to on doing this! + +### Editing + +![](./img/human_in_the_loop/edit_graph_state.png) + +Sometimes we want to review and edit the agent's state. + +As with approval, we can interrupt our agent at a [breakpoint](/langgraphjs/concepts/low_level#breakpoints) prior to the step we want to check. + +We can surface the current state to a user and allow the user to edit the agent state. + +This can, for example, be used to correct the agent if it made a mistake (e.g., see the section on tool calling below). + +We can edit the graph state by forking the current checkpoint, which is saved to the thread. + +We can then proceed with the graph from our forked checkpoint as done before. + +```typescript +// Compile our graph with a checkpointer and a breakpoint before the step to review +const graph = builder.compile({ checkpointer, interruptBefore: ["node_2"] }); + +// Run the graph up to the breakpoint +for await (const event of await graph.stream(inputs, threadConfig)) { + console.log(event); +} + +// Review the state, decide to edit it, and create a forked checkpoint with the new state +await graph.updateState(threadConfig, { state: "new state" }); + +// Continue the graph execution from the forked checkpoint +for await (const event of await graph.stream(null, threadConfig)) { + console.log(event); +} +``` + +See [this guide](/langgraphjs/how-tos/edit-graph-state) for a detailed how-to on doing this! + +### Input + +![](./img/human_in_the_loop/wait_for_input.png) + +Sometimes we want to explicitly get human input at a particular step in the graph. + +We can create a graph node designated for this (e.g., `human_input` in our example diagram). + +As with approval and editing, we can interrupt our agent at a [breakpoint](/langgraphjs/concepts/low_level#breakpoints) prior to this node. + +We can then perform a state update that includes the human input, just as we did with editing state. + +But, we add one thing: + +We can use `"human_input"` as the node with the state update to specify that the state update *should be treated as a node*. + +This is subtle, but important: + +With editing, the user makes a decision about whether or not to edit the graph state. + +With input, we explicitly define a node in our graph for collecting human input! + +The state update with the human input then runs *as this node*. + +```typescript +// Compile our graph with a checkpointer and a breakpoint before the step to collect human input +const graph = builder.compile({ checkpointer, interruptBefore: ["human_input"] }); + +// Run the graph up to the breakpoint +for await (const event of await graph.stream(inputs, threadConfig)) { + console.log(event); +} + +// Update the state with the user input as if it was the human_input node +await graph.updateState(threadConfig, { user_input: userInput }, "human_input"); + +// Continue the graph execution from the checkpoint created by the human_input node +for await (const event of await graph.stream(null, threadConfig)) { + console.log(event); +} +``` + +See [this guide](/langgraphjs/how-tos/wait-user-input) for a detailed how-to on doing this! + +## Use-cases + +### Reviewing Tool Calls + +Some user interaction patterns combine the above ideas. + +For example, many agents use [tool calling](https://js.langchain.com/docs/modules/agents/tools/) to make decisions. + +Tool calling presents a challenge because the agent must get two things right: + +(1) The name of the tool to call + +(2) The arguments to pass to the tool + +Even if the tool call is correct, we may also want to apply discretion: + +(3) The tool call may be a sensitive operation that we want to approve + +With these points in mind, we can combine the above ideas to create a human-in-the-loop review of a tool call. + +```typescript +// Compile our graph with a checkpointer and a breakpoint before the step to review the tool call from the LLM +const graph = builder.compile({ checkpointer, interruptBefore: ["human_review"] }); + +// Run the graph up to the breakpoint +for await (const event of await graph.stream(inputs, threadConfig)) { + console.log(event); +} + +// Review the tool call and update it, if needed, as the human_review node +await graph.updateState(threadConfig, { tool_call: "updated tool call" }, "human_review"); + +// Otherwise, approve the tool call and proceed with the graph execution with no edits + +// Continue the graph execution from either: +// (1) the forked checkpoint created by human_review or +// (2) the checkpoint saved when the tool call was originally made (no edits in human_review) +for await (const event of await graph.stream(null, threadConfig)) { + console.log(event); +} +``` + +See [this guide](/langgraphjs/how-tos/review-tool-calls) for a detailed how-to on doing this! + +### Time Travel + +When working with agents, we often want to closely examine their decision making process: + +(1) Even when they arrive at a desired final result, the reasoning that led to that result is often important to examine. + +(2) When agents make mistakes, it is often valuable to understand why. + +(3) In either of the above cases, it is useful to manually explore alternative decision making paths. + +Collectively, we call these debugging concepts `time-travel` and they are composed of `replaying` and `forking`. + +#### Replaying + +![](./img/human_in_the_loop/replay.png) + +Sometimes we want to simply replay past actions of an agent. + +Above, we showed the case of executing an agent from the current state (or checkpoint) of the graph. + +We do this by simply passing in `null` for the input with a `threadConfig`. + +```typescript +const threadConfig = { configurable: { thread_id: "1" } }; +for await (const event of await graph.stream(null, threadConfig)) { + console.log(event); +} +``` + +Now, we can modify this to replay past actions from a *specific* checkpoint by passing in the checkpoint ID. + +To get a specific checkpoint ID, we can easily get all of the checkpoints in the thread and filter to the one we want. + +```typescript +const allCheckpoints = []; +for await (const state of app.getStateHistory(threadConfig)) { + allCheckpoints.push(state); +} +``` + +Each checkpoint has a unique ID, which we can use to replay from a specific checkpoint. + +Assume from reviewing the checkpoints that we want to replay from one, `xxx`. + +We just pass in the checkpoint ID when we run the graph. + +```typescript +const config = { configurable: { thread_id: '1', checkpoint_id: 'xxx' }, streamMode: "values" as const }; +for await (const event of await graph.stream(null, config)) { + console.log(event); +} +``` + +Importantly, the graph knows which checkpoints have been previously executed. + +So, it will re-play any previously executed nodes rather than re-executing them. + +See [this additional conceptual guide](https://langchain-ai.github.io/langgraph/concepts/persistence/#replay) for related context on replaying. + +See [this guide](/langgraphjs/how-tos/time-travel) for a detailed how-to on doing time-travel! + +#### Forking + +![](./img/human_in_the_loop/forking.png) + +Sometimes we want to fork past actions of an agent, and explore different paths through the graph. + +`Editing`, as discussed above, is *exactly* how we do this for the *current* state of the graph! + +But, what if we want to fork *past* states of the graph? + +For example, let's say we want to edit a particular checkpoint, `xxx`. + +We pass this `checkpoint_id` when we update the state of the graph. + +```typescript +const config = { configurable: { thread_id: "1", checkpoint_id: "xxx" } }; +await graph.updateState(config, { state: "updated state" }); +``` + +This creates a new forked checkpoint, `xxx-fork`, which we can then run the graph from. + +```typescript +const config = { configurable: { thread_id: '1', checkpoint_id: 'xxx-fork' }, streamMode: "values" as const }; +for await (const event of await graph.stream(null, config)) { + console.log(event); +} +``` + +See [this additional conceptual guide](/langgraphjs/concepts/persistence/#update-state) for related context on forking. + +See [this guide](/langgraphjs/how-tos/time-travel) for a detailed how-to on doing time-travel! diff --git a/docs/docs/how-tos/index.md b/docs/docs/how-tos/index.md index 1a51e84ce..91ce370aa 100644 --- a/docs/docs/how-tos/index.md +++ b/docs/docs/how-tos/index.md @@ -88,6 +88,7 @@ These guides show how to use different streaming modes. ### Multi-agent - [How to build a multi-agent network](multi-agent-network.ipynb) +- [How to add multi-turn conversation in a multi-agent application](multi-agent-multi-turn-convo.ipynb) See the [multi-agent tutorials](../tutorials/index.md#multi-agent-systems) for implementations of other multi-agent architectures. diff --git a/docs/mkdocs.yml b/docs/mkdocs.yml index 8501cf293..f01a7a8eb 100644 --- a/docs/mkdocs.yml +++ b/docs/mkdocs.yml @@ -51,11 +51,6 @@ plugins: - search: separator: '[\s\u200b\-_,:!=\[\]()"`/]+|\.(?!\d)|&[lg]t;|(?!\b)(?=[A-Z][a-z])' - autorefs - - mkdocs-jupyter: - ignore_h1_titles: true - execute: false - include_source: True - include_requirejs: true - typedoc: # One level of globbing is intentional source: "../libs/*/*.d.ts" @@ -274,7 +269,8 @@ markdown_extensions: - github-callouts extra_css: - css/mkdocstrings.css - +hooks: + - _scripts/notebook_hooks.py extra: social: - icon: fontawesome/brands/python diff --git a/examples/how-tos/breakpoints.ipynb b/examples/how-tos/breakpoints.ipynb index b240d01c0..6e6d83f47 100644 --- a/examples/how-tos/breakpoints.ipynb +++ b/examples/how-tos/breakpoints.ipynb @@ -12,6 +12,13 @@ "source": [ "# How to add breakpoints\n", "\n", + "!!! tip \"Prerequisites\"\n", + "\n", + " This guide assumes familiarity with the following concepts:ddd\n", + "\n", + " * [Breakpoints](/langgraphjs/concepts/breakpoints)\n", + " * [LangGraph Glossary](/langgraphjs/concepts/low_level)\n", + "\n", "Human-in-the-loop (HIL) interactions are crucial for [agentic systems](/langgraphjs/concepts/agentic_concepts/#human-in-the-loop). [Breakpoints](/langgraphjs/concepts/low_level/#breakpoints) are a common HIL interaction pattern, allowing the graph to stop at specific steps and seek human approval before proceeding (e.g., for sensitive actions).\n", "\n", "Breakpoints are built on top of LangGraph [checkpoints](/langgraphjs/concepts/low_level/#checkpointer), which save the graph's state after each node execution. Checkpoints are saved in [threads](/langgraphjs/concepts/low_level/#threads) that preserve graph state and can be accessed after a graph has finished execution. This allows for graph execution to pause at specific points, await human approval, and then resume execution from the last checkpoint.\n", diff --git a/examples/how-tos/dynamic_breakpoints.ipynb b/examples/how-tos/dynamic_breakpoints.ipynb index f9f7eecbf..56fe5b3b8 100644 --- a/examples/how-tos/dynamic_breakpoints.ipynb +++ b/examples/how-tos/dynamic_breakpoints.ipynb @@ -5,7 +5,16 @@ "id": "ee54cde3-7e4d-43f4-b921-e7141ea0f19e", "metadata": {}, "source": [ - "# How to add dynamic breakpoints" + "# How to add dynamic breakpoints\n", + "\n", + "!!! note\n", + " For **human-in-the-loop** workflows use the new [`interrupt()`](/langgraphjs/reference/functions/langgraph.interrupt-1.html) function for **human-in-the-loop** workflows. Please review the [Human-in-the-loop conceptual guide](/langgraphjs/concepts/human_in_the_loop) for more information about design patterns with `interrupt`.\n", + "\n", + "!!! tip \"Prerequisites\"\n", + " This guide assumes familiarity with the following concepts:\n", + "\n", + " * [Breakpoints](/langgraphjs/concepts/breakpoints)\n", + " * [LangGraph Glossary](/langgraphjs/concepts/low_level)" ] }, { diff --git a/examples/how-tos/edit-graph-state.ipynb b/examples/how-tos/edit-graph-state.ipynb index d0d0b87d3..af07a8032 100644 --- a/examples/how-tos/edit-graph-state.ipynb +++ b/examples/how-tos/edit-graph-state.ipynb @@ -12,6 +12,11 @@ "source": [ "# How to edit graph state\n", "\n", + "!!! tip \"Prerequisites\"\n", + " * [Human-in-the-loop](/langgraphjs/concepts/human_in_the_loop)\n", + " * [Breakpoints](/langgraphjs/concepts/breakpoints)\n", + " * [LangGraph Glossary](/langgraphjs/concepts/low_level)\n", + "\n", "Human-in-the-loop (HIL) interactions are crucial for [agentic systems](/langgraphjs/concepts/agentic_concepts/#human-in-the-loop). Manually updating the graph state a common HIL interaction pattern, allowing the human to edit actions (e.g., what tool is being called or how it is being called).\n", "\n", "We can implement this in LangGraph using a [breakpoint](/langgraphjs/how-tos/breakpoints/): breakpoints allow us to interrupt graph execution before a specific step. At this breakpoint, we can manually update the graph state and then resume from that spot to continue. \n", diff --git a/examples/how-tos/multi-agent-multi-turn-convo.ipynb b/examples/how-tos/multi-agent-multi-turn-convo.ipynb new file mode 100644 index 000000000..6c7d5d015 --- /dev/null +++ b/examples/how-tos/multi-agent-multi-turn-convo.ipynb @@ -0,0 +1,447 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "id": "a2b182eb-1e31-43c8-85b1-706508dfa370", + "metadata": {}, + "source": [ + "# How to add multi-turn conversation in a multi-agent application\n", + "\n", + "!!! info \"Prerequisites\"\n", + " This guide assumes familiarity with the following:\n", + "\n", + " - [Node](/langgraphjs/concepts/low_level/#nodes)\n", + " - [Command](/langgraphjs/concepts/low_level/#command)\n", + " - [Multi-agent systems](/langgraphjs/concepts/multi_agent)\n", + " - [Human-in-the-loop](/langgraphjs/concepts/human_in_the_loop)\n", + "\n", + "\n", + "In this how-to guide, we’ll build an application that allows an end-user to engage in a *multi-turn conversation* with one or more agents. We'll create a node that uses an [`interrupt`](/langgraphjs/reference/functions/langgraph.interrupt-1.html) to collect user input and routes back to the **active** agent.\n", + "\n", + "The agents will be implemented as nodes in a graph that executes agent steps and determines the next action: \n", + "\n", + "1. **Wait for user input** to continue the conversation, or \n", + "2. **Route to another agent** (or back to itself, such as in a loop) via a [**handoff**](/langgraphjs/concepts/multi_agent/#handoffs).\n", + "\n", + "```typescript\n", + "function human(state: typeof MessagesAnnotation.State): Command {\n", + " const userInput: string = interrupt(\"Ready for user input.\");\n", + "\n", + " // Determine the active agent\n", + " const activeAgent = ...; \n", + "\n", + " return new Command({\n", + " update: {\n", + " messages: [{\n", + " role: \"human\",\n", + " content: userInput,\n", + " }]\n", + " },\n", + " goto: activeAgent,\n", + " });\n", + "}\n", + "\n", + "function agent(state: typeof MessagesAnnotation.State): Command {\n", + " // The condition for routing/halting can be anything, e.g. LLM tool call / structured output, etc.\n", + " const goto = getNextAgent(...); // 'agent' / 'anotherAgent'\n", + "\n", + " if (goto) {\n", + " return new Command({\n", + " goto,\n", + " update: { myStateKey: \"myStateValue\" }\n", + " });\n", + " } else {\n", + " return new Command({\n", + " goto: \"human\"\n", + " });\n", + " }\n", + "}\n", + "```\n" + ] + }, + { + "cell_type": "markdown", + "id": "faaa4444-cd06-4813-b9ca-c9700fe12cb7", + "metadata": {}, + "source": [ + "## Setup\n", + "\n", + "First, let's install the required packages" + ] + }, + { + "cell_type": "raw", + "id": "05038da0-31df-4066-a1a4-c4ccb5db4d3a", + "metadata": { + "vscode": { + "languageId": "raw" + } + }, + "source": [ + "npm install @langchain/langgraph @langchain/openai @langchain/core uuid zod" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "0bcff5d4-130e-426d-9285-40d0f72c7cd3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Time Travel: LangGraphJS\n" + ] + } + ], + "source": [ + "// process.env.OPENAI_API_KEY = \"sk_...\";\n", + "\n", + "// Optional, add tracing in LangSmith\n", + "// process.env.LANGCHAIN_API_KEY = \"ls__...\";\n", + "process.env.LANGCHAIN_CALLBACKS_BACKGROUND = \"true\";\n", + "process.env.LANGCHAIN_TRACING_V2 = \"true\";\n", + "process.env.LANGCHAIN_PROJECT = \"Time Travel: LangGraphJS\";" + ] + }, + { + "cell_type": "markdown", + "id": "c3ec6e48-85dc-4905-ba50-985e5d4788e6", + "metadata": {}, + "source": [ + "" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "6696b398-559d-4250-bb76-ebb7c97ce5f3", + "metadata": {}, + "source": [ + "## Travel Recommendations Example\n", + "\n", + "In this example, we will build a team of travel assistant agents that can communicate with each other via handoffs.\n", + "\n", + "We will create 3 agents:\n", + "\n", + "* `travelAdvisor`: can help with general travel destination recommendations. Can ask `sightseeingAdvisor` and `hotelAdvisor` for help.\n", + "* `sightseeingAdvisor`: can help with sightseeing recommendations. Can ask `travelAdvisor` and `hotelAdvisor` for help.\n", + "* `hotelAdvisor`: can help with hotel recommendations. Can ask `sightseeingAdvisor` and `hotelAdvisor` for help.\n", + "\n", + "This is a fully-connected network - every agent can talk to any other agent. \n", + "\n", + "To implement the handoffs between the agents we'll be using LLMs with structured output. Each agent's LLM will return an output with both its text response (`response`) as well as which agent to route to next (`goto`). If the agent has enough information to respond to the user, the `goto` will be set to `human` to route back and collect information from a human.\n", + "\n", + "Now, let's define our agent nodes and graph!" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "aa4bdbff-9461-46cc-aee9-8a22d3c3d9ec", + "metadata": {}, + "outputs": [], + "source": [ + "import { z } from \"zod\";\n", + "import { ChatOpenAI } from \"@langchain/openai\";\n", + "import { BaseMessage } from \"@langchain/core/messages\";\n", + "import {\n", + " MessagesAnnotation,\n", + " StateGraph,\n", + " START,\n", + " Command,\n", + " interrupt,\n", + " MemorySaver\n", + "} from \"@langchain/langgraph\";\n", + "\n", + "const model = new ChatOpenAI({ model: \"gpt-4o\" });\n", + "\n", + "\n", + "/**\n", + " * Call LLM with structured output to get a natural language response as well as a target agent (node) to go to next.\n", + " * @param messages list of messages to pass to the LLM\n", + " * @param targetAgentNodes list of the node names of the target agents to navigate to\n", + " */\n", + "function callLlm(messages: BaseMessage[], targetAgentNodes: string[]) {\n", + " // define the schema for the structured output:\n", + " // - model's text response (`response`)\n", + " // - name of the node to go to next (or 'finish')\n", + " const outputSchema = z.object({\n", + " response: z.string().describe(\"A human readable response to the original question. Does not need to be a final response. Will be streamed back to the user.\"),\n", + " goto: z.enum([\"finish\", ...targetAgentNodes]).describe(\"The next agent to call, or 'finish' if the user's query has been resolved. Must be one of the specified values.\"),\n", + " })\n", + " return model.withStructuredOutput(outputSchema, { name: \"Response\" }).invoke(messages)\n", + "}\n", + "\n", + "async function travelAdvisor(\n", + " state: typeof MessagesAnnotation.State\n", + "): Promise {\n", + " const systemPrompt = \n", + " \"You are a general travel expert that can recommend travel destinations (e.g. countries, cities, etc). \" +\n", + " \"If you need specific sightseeing recommendations, ask 'sightseeingAdvisor' for help. \" +\n", + " \"If you need hotel recommendations, ask 'hotelAdvisor' for help. \" +\n", + " \"If you have enough information to respond to the user, return 'finish'. \" +\n", + " \"Never mention other agents by name.\";\n", + "\n", + " const messages = [{\"role\": \"system\", \"content\": systemPrompt}, ...state.messages] as BaseMessage[];\n", + " const targetAgentNodes = [\"sightseeingAdvisor\", \"hotelAdvisor\"];\n", + " const response = await callLlm(messages, targetAgentNodes);\n", + " const aiMsg = {\"role\": \"ai\", \"content\": response.response, \"name\": \"travelAdvisor\"};\n", + " \n", + " let goto = response.goto;\n", + " if (goto === \"finish\") {\n", + " goto = \"human\";\n", + " }\n", + "\n", + " return new Command({goto, update: { \"messages\": [aiMsg] } });\n", + "}\n", + "\n", + "async function sightseeingAdvisor(\n", + " state: typeof MessagesAnnotation.State\n", + "): Promise {\n", + " const systemPrompt = \n", + " \"You are a travel expert that can provide specific sightseeing recommendations for a given destination. \" +\n", + " \"If you need general travel help, go to 'travelAdvisor' for help. \" +\n", + " \"If you need hotel recommendations, go to 'hotelAdvisor' for help. \" +\n", + " \"If you have enough information to respond to the user, return 'finish'. \" +\n", + " \"Never mention other agents by name.\";\n", + "\n", + " const messages = [{\"role\": \"system\", \"content\": systemPrompt}, ...state.messages] as BaseMessage[];\n", + " const targetAgentNodes = [\"travelAdvisor\", \"hotelAdvisor\"];\n", + " const response = await callLlm(messages, targetAgentNodes);\n", + " const aiMsg = {\"role\": \"ai\", \"content\": response.response, \"name\": \"sightseeingAdvisor\"};\n", + " \n", + " let goto = response.goto;\n", + " if (goto === \"finish\") {\n", + " goto = \"human\";\n", + " }\n", + "\n", + " return new Command({ goto, update: {\"messages\": [aiMsg] } });\n", + "}\n", + "\n", + "async function hotelAdvisor(\n", + " state: typeof MessagesAnnotation.State\n", + "): Promise {\n", + " const systemPrompt = \n", + " \"You are a travel expert that can provide hotel recommendations for a given destination. \" +\n", + " \"If you need general travel help, ask 'travelAdvisor' for help. \" +\n", + " \"If you need specific sightseeing recommendations, ask 'sightseeingAdvisor' for help. \" +\n", + " \"If you have enough information to respond to the user, return 'finish'. \" +\n", + " \"Never mention other agents by name.\";\n", + "\n", + " const messages = [{\"role\": \"system\", \"content\": systemPrompt}, ...state.messages] as BaseMessage[];\n", + " const targetAgentNodes = [\"travelAdvisor\", \"sightseeingAdvisor\"];\n", + " const response = await callLlm(messages, targetAgentNodes);\n", + " const aiMsg = {\"role\": \"ai\", \"content\": response.response, \"name\": \"hotelAdvisor\"};\n", + " \n", + " let goto = response.goto;\n", + " if (goto === \"finish\") {\n", + " goto = \"human\";\n", + " }\n", + "\n", + " return new Command({ goto, update: {\"messages\": [aiMsg] } });\n", + "}\n", + "\n", + "function humanNode(\n", + " state: typeof MessagesAnnotation.State\n", + "): Command {\n", + " const userInput: string = interrupt(\"Ready for user input.\");\n", + "\n", + " let activeAgent: string | undefined = undefined;\n", + "\n", + " // Look up the active agent\n", + " for (let i = state.messages.length - 1; i >= 0; i--) {\n", + " if (state.messages[i].name) {\n", + " activeAgent = state.messages[i].name;\n", + " break;\n", + " }\n", + " }\n", + "\n", + " if (!activeAgent) {\n", + " throw new Error(\"Could not determine the active agent.\");\n", + " }\n", + "\n", + " return new Command({\n", + " goto: activeAgent,\n", + " update: {\n", + " \"messages\": [\n", + " {\n", + " \"role\": \"human\",\n", + " \"content\": userInput,\n", + " }\n", + " ]\n", + " }\n", + " });\n", + "}\n", + "\n", + "const builder = new StateGraph(MessagesAnnotation)\n", + " .addNode(\"travelAdvisor\", travelAdvisor, {\n", + " ends: [\"sightseeingAdvisor\", \"hotelAdvisor\"]\n", + " })\n", + " .addNode(\"sightseeingAdvisor\", sightseeingAdvisor, {\n", + " ends: [\"human\", \"travelAdvisor\", \"hotelAdvisor\"]\n", + " })\n", + " .addNode(\"hotelAdvisor\", hotelAdvisor, {\n", + " ends: [\"human\", \"travelAdvisor\", \"sightseeingAdvisor\"]\n", + " })\n", + " // This adds a node to collect human input, which will route\n", + " // back to the active agent.\n", + " .addNode(\"human\", humanNode, {\n", + " ends: [\"hotelAdvisor\", \"sightseeingAdvisor\", \"travelAdvisor\", \"human\"]\n", + " })\n", + " // We'll always start with a general travel advisor.\n", + " .addEdge(START, \"travelAdvisor\")\n", + "\n", + "const checkpointer = new MemorySaver()\n", + "const graph = builder.compile({ checkpointer })" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "9d96a3c0", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "/9j/4AAQSkZJRgABAQAAAQABAAD/4gHYSUNDX1BST0ZJTEUAAQEAAAHIAAAAAAQwAABtbnRyUkdCIFhZWiAH4AABAAEAAAAAAABhY3NwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAA9tYAAQAAAADTLQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlkZXNjAAAA8AAAACRyWFlaAAABFAAAABRnWFlaAAABKAAAABRiWFlaAAABPAAAABR3dHB0AAABUAAAABRyVFJDAAABZAAAAChnVFJDAAABZAAAAChiVFJDAAABZAAAAChjcHJ0AAABjAAAADxtbHVjAAAAAAAAAAEAAAAMZW5VUwAAAAgAAAAcAHMAUgBHAEJYWVogAAAAAAAAb6IAADj1AAADkFhZWiAAAAAAAABimQAAt4UAABjaWFlaIAAAAAAAACSgAAAPhAAAts9YWVogAAAAAAAA9tYAAQAAAADTLXBhcmEAAAAAAAQAAAACZmYAAPKnAAANWQAAE9AAAApbAAAAAAAAAABtbHVjAAAAAAAAAAEAAAAMZW5VUwAAACAAAAAcAEcAbwBvAGcAbABlACAASQBuAGMALgAgADIAMAAxADb/2wBDAAMCAgMCAgMDAwMEAwMEBQgFBQQEBQoHBwYIDAoMDAsKCwsNDhIQDQ4RDgsLEBYQERMUFRUVDA8XGBYUGBIUFRT/2wBDAQMEBAUEBQkFBQkUDQsNFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBT/wAARCACkAnsDASIAAhEBAxEB/8QAHQABAAMBAQEBAQEAAAAAAAAAAAQFBgcIAwECCf/EAFAQAAAGAQEEBQYICQkIAwEAAAABAgMEBQYRBxIhlBMWVdHTFBciMUFUCBU2UXR1lbQyNTdWcYGys9QjMzRCYXORobEkJkRidoOT8CVDY8T/xAAZAQEBAAMBAAAAAAAAAAAAAAAAAQIDBAX/xAAwEQEAAQEFBQYGAwEAAAAAAAAAAQMCERMhURIxkaHSBDNBYXHBFFJigbHRsvDxwv/aAAwDAQACEQMRAD8A/wBUwAAAVz2SVMZxTbtpCacTwNC5CCMv1GYpdoMp3oqWtQ4tpm1n+SPqbVuqNomHnlJIy4lvdESTMuOij00ERGMUzaCQipgpSXqSmMgiL/IdtOhZmzFq3O/RcvFoetVJ2xA5pHeHWqk7Ygc0jvFB1bqOy4XLo7g6t1HZcLl0dw2YNHWeS5L/AK1UnbEDmkd4daqTtiBzSO8UHVuo7LhcujuDq3UdlwuXR3Bg0dZ5GS/61UnbEDmkd4daqTtiBzSO8UHVuo7LhcujuDq3UdlwuXR3Bg0dZ5GS/wCtVJ2xA5pHeHWqk7Ygc0jvFB1bqOy4XLo7g6t1HZcLl0dwYNHWeRkv+tVJ2xA5pHeHWqk7Ygc0jvFB1bqOy4XLo7g6t1HZcLl0dwYNHWeRk1kOwi2KDXEksykFwNTLhLIv8BIHNr6FGxhuPc1kZqDMYksIWqOgkdM0t1CFoWRF6RGkz019RkRl6h0kc9alFOItWZyn2/1JgAAHMgAAACNNsolahKpcpmKlR6Ep5wkEf+JiSOZ4xAiZNWt3llEYmz5284bshtKzbbNZ7jSdS9FKS0LQvWZGZ6mZmfTRpRUibVqco9/8WG361UnbEDmkd4daqTtiBzSO8UHVuo7LhcujuDq3UdlwuXR3DowaOs8lyX/Wqk7Ygc0jvDrVSdsQOaR3ig6t1HZcLl0dwdW6jsuFy6O4MGjrPIyX/Wqk7Ygc0jvDrVSdsQOaR3ig6t1HZcLl0dwdW6jsuFy6O4MGjrPIyX/Wqk7Ygc0jvDrVSdsQOaR3ig6t1HZcLl0dwdW6jsuFy6O4MGjrPIyX/Wqk7Ygc0jvDrVSdsQOaR3ig6t1HZcLl0dwdW6jsuFy6O4MGjrPIyX/Wqk7Ygc0jvDrVSdsQOaR3ig6t1HZcLl0dwdW6jsuFy6O4MGjrPIyX/Wqk7Ygc0jvDrVSdsQOaR3ig6t1HZcLl0dwdW6jsuFy6O4MGjrPIyX/Wqk7Ygc0jvDrVSdsQOaR3ig6t1HZcLl0dwdW6jsuFy6O4MGjrPIyX/Wqk7Ygc0jvDrVSdsQOaR3ig6t1HZcLl0dwdW6jsuFy6O4MGjrPIyaOPkVVLeS0xZw3nVHolDchClH+giMWIxDuLUr7am3KiA4hXA0qjIMj/AMhO2fzXnoNnCedW+VbPciNOOK3lm3uocQRn6z3ScJOp8TJJGZmepnqqUbMWJt2J3apdo1IAA40AAAAfilEhJqUZJSRamZ+oh+jFZir41yeqpX/TrlRX5r7B/gvLQtpLaVfOkt9Rmn1GZJ+YbqVPFtbN/wDYWM2hVlNMkzI7eARl6yOSjvH51qpO2IHNI7xnyxqoIiIqqEREWhEUdHD/ACH71bqOy4XLo7h14NHWeS5L/rVSdsQOaR3h1qpO2IHNI7xQdW6jsuFy6O4OrdR2XC5dHcGDR1nkZL/rVSdsQOaR3h1qpO2IHNI7xQdW6jsuFy6O4OrdR2XC5dHcGDR1nkZL/rVSdsQOaR3h1qpO2IHNI7xQdW6jsuFy6O4OrdR2XC5dHcGDR1nkZL/rVSdsQOaR3h1qpO2IHNI7xQdW6jsuFy6O4OrdR2XC5dHcGDR1nkZL/rVSdsQOaR3h1qpO2IHNI7xQdW6jsuFy6O4OrdR2XC5dHcGDR1nkZL/rVSdsQOaR3j+kZPTOKJKbaCpR8CIpKDM/8xnurdR2XC5dHcPxWM06kmk6qCaTLQyOMjiX+AmDR1nkZNoR6kP0Y3CXTgX13RtcIEVqPLjtexknTdSptPzJI2TURezeMi0IiItkOSrTwrez/c4vSYuAABqQAAABWvZJUR3FNu2sJtxPA0rkIIy/VqKXaBKcNNJVpWpti0nHGkGhW6o2ksOumkjLiW8baUnp7DMRUYxTtpJKamClJeoijIIi/wAh206FmbMWrc79Fy8Wh61UnbEDmkd4daqTtiBzSO8UHVuo7LhcujuDq3UdlwuXR3DZg0dZ5Lkv+tVJ2xA5pHeHWqk7Ygc0jvFB1bqOy4XLo7g6t1HZcLl0dwYNHWeRkv8ArVSdsQOaR3h1qpO2IHNI7xQdW6jsuFy6O4OrdR2XC5dHcGDR1nkZL/rVSdsQOaR3j+kZPTOLJKLaCpR8CJMlBmf+Yz3Vuo7LhcujuH4rGadaTSqqgqSZaGRxkaGX+AmDR1nkZNqAxuDunBurykbPSDETHkxm/Yyl0lkbafmSRtGZF7N8yLQiIi2Q5KtPCt7P9zi9Ji4AAGpGO2gfjXDPrhf3CWJwg7QPxrhn1wv7hLE4epHd2PT3lZ8AAARABm9omf1ezHEZuRXBSFwoym2+iiN9I86444lttCE6lqpS1pItTIuPEyIc02kbfbvG8bxSzrcHvmH7TI41TJr7GMwiQltSi3iQXTkg1rI9EKJRp1JWploMZmIHbwHOcw2zHhdfClysGy+a27CKdKKBBae+L0aGakvKJ3d306Hqls1nw1LUtBGvfhBUNXZ4xX11Xc5NKyWrXb1aKaOhZSGE9GfrccQSDNLhKI1aJ0IyMyPQjXwOngOO4Vtpvck215ZiErELWNV1qIXQzNyORRTcZccUqQZPmZks0kSOjSr1ekResdiFibwAAFGez35NOfSYv3hsdEHO89+TTn0mL94bHRBr7R3Vj1n/AJZeAAAOBiAAAA5zs6+RFP8A3Bf6mOjDnOzr5EU/9wX+pj0Oz91b9Y/FpfBowAcyxXbvCzhFo/RYrk8+uitylxrJENpMewUw4ba22FKdL0zWRkknCQR6Hx0IzLK9HTQHDcN+ENDb2e4S8trIs6yC9r3bBtivq2Gprkdtei33WUuk02kjUhOhLPeMyIiM9RVWnwkX7G+2UXFBXXU3Hcni3Di6WHDZemSlMGylk/wtG9NXFHq4kiI9F8S0LHagehwHB83+Es4xh+JXuKY/Z2J2eStUc+C/HbRKiLS6aHo6kLdQSXzNJpTxNPtMyLQxrJe3aFHyiHjrWK5NNuFw402dGhxGnTq0PqNKCkGTumuqVak2a9CSZ+riLtQOmAOXZR8ISkxmyuGU0eQ3NdSKNFvc1UAnodeokktaXFb5KUaEmSlE2le6R8dD4D75Ft4qKe0eg1dJfZe5GjNS5rmOw0yG4jTid9s1qUtOqlI9IkI3lbpkemhlqvgdKAcdVtug2e0LHirplmvHZeNS75o2oLColk0nojJSXVOE6hxslabhoIj6TieqRPwz4RFHmlnjMVFJf1MbJo6pFPYWkRDUebutdKpCTJxSkqJG8ot5KSUSTNJqLQzbUDqYDkFH8JqgyPJMdrIFFkC4GQS3olXeOxmm4Ew2kLUtaFqcJW7o2emqSNXrSSh85G2Sc38IdjFSbb6pm0dSuXoWvxyprytLW98xRknw1/CWRewNqB2MBxPbP8IRnE6nOKrHKy8tr6kqXnpFlVQUPxal9TClsm+paiIzL0VmlKV6J4qLQWuIbdqp/EbqRdqlx52MUkO1tnX2m0E+27F6bpmSSrRSTNLidNE+kky09QbUX3Dq4DiMjb9ErM2sZNyV7QUVfh5ZA9XT66PuLSpbZ9Il1t1TnSp3jaNo0kneJRkZ6EZ6E9vVXCwt/I7jHsjoGykMxItfYQU+Vz3ntOiRHQ2tZOKUZkRFqWnHXTQ9G1A6aA5FN+EzjdPi+UW9xUX1JJxsoy7GmnxW0zUNPuEhp1JJcNC0GZnxSs9N1RevQj6FiOSuZXVqnOUtpRJ6Q0NsWzaG3XEaEZOElK1bqT19StFFoeqSFviRdiFs7/nsp+uFfd2BNELZ3/PZT9cK+7sDK13Vv7fmGUbpbAAAeWxAAAAYm/8AykVn1TJ/fMDbDE3/AOUis+qZP75gdnZe8n0n8LCzAByHbJtPtdnu0XZtEhMWFjXWzlg3MqquIh+RLNuOSmiTvabu6o94z3kloR7x6EN0zcjrwDlqfhGYyrDG77yO4KU5aKo0UHkf/wAkdgkz1jdFvbu+REatd7d3eO9oMvtF+Eyuq2XZDdY9j9o1klNYw6+dTW0ZtD8Hp3G91xxPSklSVoXohSFqI1KTrwJWk2oHegHPbrbLGoKukXKxnITv7jpTi4yxHZdsd1s9HFqJLptJQRGgzUbmnppL1noMlebcHL+Ts/Xjjsyp8rzAqG7rbGIlElnSI+6phxKiVunqlpZKQfEjLRWhmG1A7eA45tg2yTsD2hYhVwm211KXESskeURf7NEfdTDjnr7NX3d8zL+rHX7NddHm+2esw3Jo+OsU13k96uN5a9BoIiX1xY+8aSddNS0kkjMlEREZqVoehGF8DoADiPweNt7uaYthNbkbkp/J7qjeuCsHGGmo8lLcg2nEJ3DLRxBKbM07hFuqI9T46Iu3+HlGY4EqAd5UY/bt2chL8iBGVEsW46XC1NzpTdaIuj6VJpR6aVo101MibUXXjtwDlmO/CKx+8w6zy2VU3uP4vDhFYIt7aGltiWwZmSVM7i1KUZ8NEmSVHvJ4cSH90nwgKizkWMSwoMhxmxiVbly3Bu4aGXZkVv8ADWzuuKSZlqkjQo0qLeLUiDagdQAYnZdtTjbWKZu3rqK6rKl+MxJizLVhtlEpLhGejZJcUr0dNDMyIj1I0moj1G2F3itxb8oWSfV1f+8ljajFYt+ULJPq6v8A3ksbUaO1d79rP8YZWt4AAORiAAAMbnv46w36zd+5SRPEDPfx1hv1m79ykiePUju7Hp7ys+AA5d8IbPbPZziVHa1jzzSl5FWRJKI0YpDr0ZySlLzaEGlRmpSDMi3S3tT4GRiOr4SVBFx3KbKxpb+ol40qKVhUToraJiUSFkhlxJE4aFIUZnxJfDdVqWpaDC+NyOsgMLmu2GmwS5n1k+NPefh47MyZxUZtCknGjKQlxBarI+kM1lulpofHVRDLNfCarZFrXVrOF5i7Ntoip1S0Veyn4xYTumpbZqeIkbpKSZk90Z+kXDUyI18DsYDmze3OvssHqcmo8ayXJGLF1xgoNZBSqVGcbUpDqXkrWlLZpUhST1VxMuGupCGr4R+NuUeLWMKtvLJzI5UmBEr4sIvKkSmCWbrLralJ3FJNtaTMz3S01MyT6QXwOqgMrs72jV+0msnyYcSdWya6a5XTq6yaS3IiyEElRoWSVKSforQojSoyMlFoY1Qu8VuJ/L7JvoUD9qSNqMVify+yb6FA/akjajR2rvftZ/jDK1vAAByMWO2gfjXDPrhf3CWJwg7QPxrhn1wv7hLE4epHd2PT3lZ8FNk2Z4/hUVqVkN7W0MZ5fRtvWcxuMha9Nd0jWZEZ6EZ6F8wzvn82Y6flGxL7ci+INw6w2+RE62hwi4kS0kY+XxdE1/orP/jIY5o5rmGfYdtLxG4osfcxzajMeZSbuNRLqKapDPSIJatd4yTuke8Rnp6RJLVJmRlzSPsw2jea+MTldIky6TMot9S45Z2zciW3XMqR/sqpZqNBr/nTTvLURFukaj9nphqIwwrebZbbVppqlJEY+oxmzfvHmvaPgWXbRMt+NLnZ8eQVk2jTEgVE+3jpj0c3pHekefQSjS4akqaMnGycUncMiL2iz2Q7Msqx7INlMq2pzhM4/hUiinrOSy50cknYxIIt1RmolpZWojItCLQj0PgPQIBsxfeONHDv9nW27L8lep2pmH5DEgOSro7BiOipKKh1Lqn0uqSZo3VEreTrpoeo1be3nZm6tKEbRMUWtRkSUpu4xmZ/MXpjcqSS0mlREpJloZGWpGPh8XRPdmf/ABkLdduGPjbdNm0yQ0wxtBxV991RIbabuoylLUZ6ERES9TMz9g3A+BV8UjIyjMkZe0myH3Fz8Rns9+TTn0mL94bHRBzvPfk059Ji/eGx0QYdo7qx6z/yy8AAAcDEAAABznZ18iKf+4L/AFMdGHOdnXyIp/7gv9THodn7q36x+LS+DRjgWzzCssrNtK7eDiTuA4w+iYq6ifG7UqHaSFKT0D7DCDPonOClLUaUa66GRnxPvoCzF6PFq8TzLZJjOyDyFr4lzKDQTKywQ1Z1nSqYN1tfRk1JeQhZErdX0iFK3TIiNJkrhvdjmPxMid2L3uG105GJY/DvYEx6xfZU+3IWtpBmo0LMnTW608e+1qn28CMiHesnwbG81aZbyLH6u+bZPeaRZwm5JNn86SWk9P1C0gwI1XDZiQ47USKykkNMMIJCG0l6iSkuBF/YQxixcPOdlslzJnFryRDp0SrSJtJPLIVcqW0g58RLyFESV7xpQpSd4yJZloZcdB9drWNZznNnUW2PbPpWN5khhhMbKW72O2qCXTmbseW2hZ9O1uFrukThGaz03TLU/RwC7I8sr2Ev45nWYHO2PUW0qJe3L1vDvZb8VtcZL5kpxh8niNeiFbxpNsl6kZFoRj7ZNsIVju1DKLZvZJSbS6O8RFcgk87FYdqnGWEsGyon/wD6TJtCiNvU08S3T4D1AAbEDiOS7LLI80xl+joI1fSQMRtqs40NxpDMZ9/yc2mUJ1SZke4v0iToWnHTUhDp9l+SRsa+DxEfrCJ7FUspukG+0fkulW6wrjvaL/lFJT6G969fVxHegF2YHiLZhbdUslwaryBixsqOqtZMbE4NdaVUyO1JcJ1LSFrafN5wkoUtCVrQgkmrVZFpw1y/g9bRV7Lfjo8inHnfxoWXdV92D5J8adL0nRdP0e/pu/yWvS7unD8HgPRtXs4xKju3Lmtxelr7h3XfsItey1IXr69XEpJR6/pGiGMWNR5myDDtomP1m1yhp8J6wV2dJlWMScm0jMLhSJENDLkd9K1FruqQW6pBqI9eJl6ys8s2AW+USdmjiDREiorYtNlsVSkmb8Njo5LbepHof8uybR7uvoyF+zUx6GAXZgcezXCrqXtet8hZxpjI6ZzCnakocmS021MkKlb/AJOre1MiUjXVRpNPH9Q5nWbHs/8AiN6TDpHqquocjrb3G8Ot7lEtxCWW1oksJkEpaW0LJ0zbSalEk0/1SPh6tAJsxI8ubQNlue7VI+e5LKxn4ksbKvqqesoVz2HXlsx55SXnnXEr6Ij9JW6RLM9En7TIh6jABYi4BC2d/wA9lP1wr7uwJohbO/57KfrhX3dgZ2u6t/b8wyjdLYAADy2IAAADE3/5SKz6pk/vmBthib/8pFZ9Uyf3zA7Oy95PpP4WFmOcZ3iNtc7YNmF3DidNV0y7M57/AEiE9CTsXcb9EzJStVcPRI9PboQ6OA3TF6PNL+yLMqu+ssrgUzc6xrdoErIIVW5Lab+MIL8BuMs0L1NKHNd40k5u/gHrpqRj+Mk2RZxtAxvaveyadikvsmVU/FlA/NbcUhuvcJ1JPOoM2yW6rfLgZkkt3U/WPTIDHZgecNp2zu/2i5Dh+d2WzGLeqr48qtsMMuJkR13o3FIU3IZcNRs76VI4kai1SrTUjEm32X2kXEMItMU2bVmMWVPlCLuZi8CXHaN5omno5q6VJE2bu44hWmunomnePQtfQwBswPN1j8H3K9p8jabY32R2OJ9ZpCq9qpjNwpDTlewjciqWtTbi0GozccMkLSZG57FD9waq2qYTlCcrmYV8fz8loq6HcxUWsZp6BOiE6g17ylmhbThOb/oKUoj/AKvz+kADZgeXUbA8zlfBw2f1EIkY9tAoTWx0hvIc6BiSbjEot9KjSejL3SloZ+k0jTjwHR8h2ay67PNkjmP1SXMdxWLYRXU9KhBMtqhpaYToo9Vamnd1Ij09Z6DrYBswPJJbDM2yikzWmrsb83WNz6xlyLjsy3bnQztmpaJCXGEtmomGFE3uKIt3XeI9wtBsrnE872r5Ud/c4n1Sap8bs66HBdsmJL06XLQhJ6KbUaUtJJotDWZGZq1Mi4j0IAbMDJ7JKKbi+ynC6ayY8lsa6lhRJLG8lXRutsIQtOqTMj0URlqRmXzDWAAyjIVuLflCyT6ur/3ksbUYrFvyhZJ9XV/7yWNqNHau9+1n+MMrW8AAHIxAAAGNz38dYb9Zu/cpIniBnv46w36zd+5SRPHqR3dj095WfBzjbliNtmNJjEeoieVuwsoqbF9PSIRuR2ZSHHV+kZa7qSM9C1M/YRmMBtb2N5Pm9/tUcrojSWbnH6mPWvvvoSh+TGkvPKaMiM1J9aC3jIi9P1noenoYBhNmJR5pzfEdoO03KMktncIcoY0jZ5b0EVmTZxXXnJz62jQg9xw0pSrdPRW9pwPe3eBDawMAvmdoeySzXA0g0WNzYFi70zf8g+4iISEab2qtTac4pIyLd4nxLXsICbI8qK2O5lFpcdj2eKO5PQR7++m2WLtWTDJSikSluQ317zhNuISk1GbalakbhHumadClbLtjWX41aYAmZjTFTDpMtu7J5uJMacYYiSor3Qm3xJSkkt4mtN0laoM90k6GPUIBswOcbKsRtsay3abMsYnk0W5yAp0FfSIV0zPkcdve0SZmn021lorQ+GumhkOjgAyiLhW4n8vsm+hQP2pI2oxWJ/L7JvoUD9qSNqNHau9+1n+MMrW8AAHIxZDaGnoV43PX6MWDadK+57G0rjPskoz9hbzqOP8AaJg0DzLcllxp1CXWnEmlaFlqlRHwMjI/WQzC9mGNrVqUFxsvYlqW8hJfoSlZEQ7qdaxsRZt3xdpF/nrC5eL7gI3mtxv3STz8jxA81uN+6SefkeINmLQ1nhHUuSSAjea3G/dJPPyPEDzW437pJ5+R4gYtDWeEdRkkgMHtQwmqooWOrgJkxVyb+viPGU1899lx4krRxWfrLhr/AJkNn5rcb90k8/I8QMWhrPCOoySQEbzW437pJ5+R4gea3G/dJPPyPEDFoazwjqMkkBG81uN+6SefkeIHmtxv3STz8jxAxaGs8I6jJU5og5dZHgt+nKlzYzbTaeKlaPIWo9PmShKlH8xJMx0IU1Jh9Pjz634EJLUhadw31rU45u8PR3lmZkXAuGvsL5hcjnrVbNuIs2N0e/8AiToAADlQAAABzvA2zi4zGguejJgqXFfbPgaFpUZHqX9paKL5yURlwMh0QUlzhVLkEopM2ClcrdJBvtLU04aS9STUgyMyLjwM/aY6qNWzYibNvdN27yv9NVjSUcBG81uN+6SefkeIHmtxv3STz8jxB0YtDWeEdS5JICN5rcb90k8/I8QPNbjfuknn5HiBi0NZ4R1GSSAjea3G/dJPPyPEDzW437pJ5+R4gYtDWeEdRkkgI3mtxv3STz8jxA81uN+6SefkeIGLQ1nhHUZJICN5rcb90k8/I8QPNbjfuknn5HiBi0NZ4R1GSSAjea3G/dJPPyPEDzW437pJ5+R4gYtDWeEdRkkgI3mtxv3STz8jxA81uN+6SefkeIGLQ1nhHUZJICN5rcb90k8/I8QPNbjfuknn5HiBi0NZ4R1GSSAjea3G/dJPPyPEDzW437pJ5+R4gYtDWeEdRkkiJs4QbkW6mp4x51m48wv2LQSG294vnIzbUZH7S0MuBj6I2X40lWqq9byfa2/KedQf6UqWZH+shqEIS0hKEJJCElolKS0Ii+YhrqVrGxNmxfN+sXe8mUbn9AADhYgAAAMVk6fJc7pZTvoR3oMmIlw/welNbS0o1+dSUrMi/wCRQ2ojWFdFtobkSYw3JjOabzTqdUnoepfrIyIyP2GRGN1GpFO3tTu/awpQEc9l2Nmf9DfL+xM6QRF+olj881uN+6SefkeIOzFoazwjqXJJARvNbjfuknn5HiB5rcb90k8/I8QMWhrPCOoySQEbzW437pJ5+R4gea3G/dJPPyPEDFoazwjqMkkBG81uN+6SefkeIHmtxv3STz8jxAxaGs8I6jJJARvNbjfuknn5HiB5rcb90k8/I8QMWhrPCOoySQEbzW437pJ5+R4gea3G/dJPPyPEDFoazwjqMkkBG81uN+6SefkeIP0tl+Nkf9CfUXqMlzX1Ef6SNehhi0NZ4R1Jkj4ejynMcknN+lG6CJCJwvwTcbN9SyI/bp0qSP5j1L1kY2Y+EKDHrYjUWIw3HjtFuoaaSSUpL+wiH3HHWqYlvajy5RcTN4AANKAAADH7Qk9DIxqev0YsOyNT7nsbSuO80lSj9hb60Fr/AMwmi/fYblMuMvNpdZcSaFtrSSkqSZaGRkfrIyGZXswxtZ6lBdbL2JamPoSX6CSsiId1OtY2Is274u0i/wA9YXKd77gI3mtxv3STz8jxA81uN+6SefkeINmLQ1nhHUuSSAjea3G/dJPPyPEDzW437pJ5+R4gYtDWeEdRkkgI3mtxv3STz8jxA81uN+6SefkeIGLQ1nhHUZJICN5rcb90k8/I8QfpbLsbI+MJ9Re1K5r6iP8ASRr0MMWhrPCOpMkfDUHIy3JZzfpRjRFhk4X4KnG+lUsiP26dKkj+YyMvWRjZj4QoUeuitRorLceO0ndQ00kkpSXzERD7jjrVMS3tR5couJm8AAGlAAAAAAAAAAHPds5kVfiepa/7z1ftIv8AiE/OOhDnu2b8X4p/1PV/1tP+IT/7oOhAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOe7Zj0r8U/6nq/6pH/AMQn/wB1HQhz3bMWtfinEi/3nq/Xp7wn5x0IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB/DzqGGluuKJDaEmpSj9REXrMYZu5yLI2W58CdEqID6ScjsuQzfeNsy1SpaukIiMy47pFw101Mb6dKal833RGq3N4AwnR5Z+ccT7LLxA6PLPzjifZZeIN3w31xz/Rd5t2AwnR5Z+ccT7LLxA6PLPzjifZZeIHw31xz/Rd5t2AwnR5Z+ccT7LLxA6PLPzjifZZeIHw31xz/AEXebyl8Ov4S+0XYnntJVR6SklYw69Gt6yY80/0q3WFEa2nFJdJJ+mWuhEXorT7eI9Z7F8hybLdluN3eYwYdZkVjFKVJhwUrS0ylajU2nRalKJXRmjeIz/C3vV6hz/arsRLbRFpo+V2USe1Uz0WEYirSSe+n1oUfScUKLgpPt0L5huujyz844n2WXiB8N9cc/wBF3m3YDCdHln5xxPssvEDo8s/OOJ9ll4gfDfXHP9F3m3YDCdHln5xxPssvEDo8s/OOJ9ll4gfDfXHP9F3m3YDCdHln5xxPssvEH6SMrIy1yKIZfN8Vl4gfDfXHP9F3m3QDN43kMuRYPVFqTJ2LTJSEPxkmhuQ2Z7pmSDMzQpJ6EZGZl6STIz1Mk6Qc1uxNO1syAAA1oAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAq8p+TNv9De/YMZ7GeON1X0Rr9ghocp+TFv9De/YMZ7Gfk3U/RGv2CHo0e5n19l8FkACmxHMKrOab41ppByoByH4xOm2pGq2XVtOFooiPgtCi19umoqLkAAUAAZvO88r9ntXCn2LMl5mXYxaxCYqUqUTsh5LSDPeUXokpZGZ+vTXQj9Qg0gDN5vtCpNnjNO7dyfJk21mxUxdCI96Q8Zkgj48C4GZn7CIxpAABm8Izyvz1m6cr2ZLKaq1lU7/AJSlKTU8wvcWpO6o9UGfqM9D+ciE7Icg6vprj+LLCz8smtQtK9jpTY6Q9Omd4lutJ9alcdC9gXi2AAFAAABUwTPzmQi14fFEnh/3mBuRhoP5TYX1PJ/fRxuRp7Vvs+nvKz4AAA4kAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVeU/Ji3+hvfsGM9jPybqfojX7BDQ5T8mLf6G9+wYz2M/Jup+iNfsEPRo9zPr7L4J0hhuUw4y8hLrLiTQtCi1JSTLQyMh4diYxiVF8DbaWmphVlfkvT2USeUZKEykoatFpbQ4RelohBtkRH6iNI9zDNydmuIzJlnLkYrSPyrRHRT33K5lS5aNSPddUadXC1Sk9Fa8Ul8wlqL0cU2x4LiGNR8QwOtxajWvJLF6UqZfvOlEJ1iP6b0ncWlUl1STIiSpXpHqozI06jAYQmRD2KKyyFPZuHtmOZz3oz1epbjSqpK9yUyyalrV0fk7q1JI1KPRCC1PQeucjxSkzCAmDfU8C7hJWThRrGKiQ2Sy9St1ZGWpanxH7CxalrI81iHUQIrE3+lNMRkIS/6BI9MiLRXoESeOvAiL1CbOY8fZdCtJ9BhdxayodLWbSslkWdw/dtOriJZOMoquJJJt1pRo6NDfomtJdJ6yMtSOwyDCkbOdnc6SWWUNnjyMyx91UGhbWzAplty2em4OSHuj3iU0o07ySL16ekPW1pQVl3UuVVjXRJ9Y4gm1wpTCXGVJL1JNCiNJkWhcNPYIULBcarcedoYmPVUWidIycrGYTSIyyP1kbRJ3T10L1kGwPOW3SdJ2r7Rb7HazGrnKa6gx92K1IpFRt2JazEpW08o3nm9TbaQg0mneMulVrpw1iddajblkuyhjPnW4+LWOPzJbtdLe6GNLvGHmmXWHeJEvoi6ZSUH+nT1D1FSY1T40iQmoqoNUmS4TryYUdDJOrJJJJSt0i1PdSktT9iSL2Cum7NsRs6pdZMxall1q5Kpqob9cytlT6jM1Omg06GszMzNWmpmZ8Q2R5NxOLWbOsRlbR6JHS1OFZ7cNPlEWb/SU77pMvEk9TNZI/kXS4n/NGNFa7PyqsQ2R5He17acxuM+iXM15adXI7kxZrWyR+wkIbYb0/wDxIenIGH0NVUSqqFSV0OrlGtUiCxEbQw8a+CzWgi3Vb3t1Lj7RLsqavuPJfL4Mad5K+iVH8pZS50LyfwXEake6stT0UXEtQ2Mh5HioZ2WZ1lDFUisy3L8gjX8qiymsmm9ORIbbW6cSYzqZegoiQhRalqkk7qTMfXCYWJ47O2D22CTkS8syB5JXjrMxTz9jFVCcXLdlkaj3lIeJs9VFqlXAtPUPUVTgmNUNzLt6zHaqutpevlE+JCaafe1PU99xKSUrU+PEwpsDxnHbaXaVOO1NZZzNfKZsOC0y8/qep760pI1cePEw2Rxz4GeAUVTsexvJWYDa8hmxpDT1m7qt82jkqMmiUf4LZbiNEloWqddNTMz9ACHUU1fj9czX1cGNWwGCMmosNlLTTZGZme6lJERcTM+Be0TBlEXRcKmD+U2F9Tyf30cbkYaD+U2F9Tyf30cbka+1b7Pp7ys+AAAOJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFXlBGeM25FxPyN79gxnsZ4Y3VfRGv2CGzWhLiFJUklJUWhkZakZDEJxrIqBtEKoKtn1rKSRHKc84w60gi0JBmlCyXoXAlaJPTTXUyNR99C1ZmxNiZum+9lGcXLYBUeSZp2bQ/ab38OHkmadm0P2m9/Djfsx80cYLluAqPJM07NoftN7+HDyTNOzaH7Te/hw2Y+aOMFy3AVHkmadm0P2m9/Dh5JmnZtD9pvfw4bMfNHGC5bgKjyTNOzaH7Te/hw8kzTs2h+03v4cNmPmjjBctwFR5JmnZtD9pvfw4eSZp2bQ/ab38OGzHzRxguW4Co8kzTs2h+03v4cPJM07NoftN7+HDZj5o4wXLcBUeSZp2bQ/ab38OP1MPMzUWtdREXtMrJ4//wCcNmPmjjBc/YKT85kI9D0Koklr/wB5gbgZ7HMckQZb1nZvNP2jzZM6MJMmmWyPXcTrxPU+JqP18OBEQ0I4+0W4tWoizndFySAADlQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAf//Z" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import * as tslab from \"tslab\";\n", + "\n", + "const drawableGraph = graph.getGraph();\n", + "const image = await drawableGraph.drawMermaidPng();\n", + "const arrayBuffer = await image.arrayBuffer();\n", + "\n", + "await tslab.display.png(new Uint8Array(arrayBuffer));" + ] + }, + { + "cell_type": "markdown", + "id": "af856e1b-41fc-4041-8cbf-3818a60088e0", + "metadata": {}, + "source": [ + "### Test multi-turn conversation\n", + "\n", + "Let's test a multi turn conversation with this application." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "161e0cf1-d13a-4026-8f89-bdab67d1ad4d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "--- Conversation Turn 1 ---\n", + "\n", + "User: {\"messages\":[{\"role\":\"user\",\"content\":\"i wanna go somewhere warm in the caribbean\"}]}\n", + "\n", + "travelAdvisor: The Caribbean is a fantastic choice for a warm getaway! Some popular destinations you might consider include Jamaica, the Dominican Republic, and the Bahamas. Each destination offers beautiful beaches, warm weather, and a plethora of activities to enjoy in a tropical setting. Aruba and Barbados are also great choices if you prefer lively beach towns with vibrant nightlife and cultural richness.\n", + "\n", + "Would you like recommendations on sightseeing or places to stay in any of these Caribbean destinations?\n", + "\n", + "--- Conversation Turn 2 ---\n", + "\n", + "User: {\"lg_name\":\"Command\",\"lc_direct_tool_output\":true,\"resume\":\"could you recommend a nice hotel in one of the areas and tell me which area it is.\",\"goto\":[]}\n", + "\n", + "travelAdvisor: The Caribbean is a fantastic choice for a warm getaway! Some popular destinations you might consider include Jamaica, the Dominican Republic, and the Bahamas. Each destination offers beautiful beaches, warm weather, and a plethora of activities to enjoy in a tropical setting. Aruba and Barbados are also great choices if you prefer lively beach towns with vibrant nightlife and cultural richness.\n", + "\n", + "Would you like recommendations on sightseeing or places to stay in any of these Caribbean destinations?\n", + "travelAdvisor: Let's focus on Jamaica, known for its beautiful beaches and vibrant culture, perfect for a warm Caribbean escape. I'll find a nice hotel for you there.\n", + "hotelAdvisor: In Jamaica, consider staying at the \"Round Hill Hotel and Villas\" located in Montego Bay. It's a luxurious resort offering a private beach, beautiful villas, and a spa. Montego Bay is known for its stunning beaches, lively nightlife, and rich history with plantations and cultural sites to explore.\n", + "\n", + "--- Conversation Turn 3 ---\n", + "\n", + "User: {\"lg_name\":\"Command\",\"lc_direct_tool_output\":true,\"resume\":\"could you recommend something to do near the hotel?\",\"goto\":[]}\n", + "\n", + "hotelAdvisor: In Jamaica, consider staying at the \"Round Hill Hotel and Villas\" located in Montego Bay. It's a luxurious resort offering a private beach, beautiful villas, and a spa. Montego Bay is known for its stunning beaches, lively nightlife, and rich history with plantations and cultural sites to explore.\n", + "hotelAdvisor: Let's find some sightseeing recommendations or activities around Round Hill Hotel and Villas in Montego Bay, Jamaica for you.\n", + "sightseeingAdvisor: While staying at the Round Hill Hotel and Villas in Montego Bay, you can explore a variety of activities nearby:\n", + "\n", + "1. **Doctor’s Cave Beach**: One of Montego Bay’s most famous beaches, it’s perfect for swimming and enjoying the sun.\n", + "\n", + "2. **Rose Hall Great House**: Visit this historic plantation house, rumored to be haunted, for a tour of the beautiful grounds and a taste of Jamaican history.\n", + "\n", + "3. **Martha Brae River**: Enjoy rafting on this beautiful river, surrounded by lush Jamaican flora. It's a peaceful and scenic way to experience the natural beauty of the area.\n", + "\n", + "4. **Dunn’s River Falls**: Although a bit farther than the other attractions, these stunning waterfalls in Ocho Rios are worth the visit for a unique climbing experience.\n", + "\n", + "5. **Montego Bay Marine Park**: Explore the coral reefs and marine life through snorkeling or diving adventures.\n" + ] + } + ], + "source": [ + "import { Command } from \"@langchain/langgraph\";\n", + "import { v4 as uuidv4 } from \"uuid\";\n", + "\n", + "const threadConfig = { configurable: { thread_id: uuidv4() }, streamMode: \"values\" as const };\n", + "\n", + "const inputs = [\n", + " // 1st round of conversation\n", + " {\n", + " messages: [\n", + " { role: \"user\", content: \"i wanna go somewhere warm in the caribbean\" }\n", + " ]\n", + " },\n", + " // Since we're using `interrupt`, we'll need to resume using the Command primitive.\n", + " // 2nd round of conversation\n", + " new Command({\n", + " resume: \"could you recommend a nice hotel in one of the areas and tell me which area it is.\"\n", + " }),\n", + " // Third round of conversation\n", + " new Command({ resume: \"could you recommend something to do near the hotel?\" }),\n", + "]\n", + "\n", + "let iter = 0;\n", + "for await (const userInput of inputs) {\n", + " iter += 1;\n", + " console.log(`\\n--- Conversation Turn ${iter} ---\\n`);\n", + " console.log(`User: ${JSON.stringify(userInput)}\\n`);\n", + "\n", + " for await (const update of await graph.stream(userInput, threadConfig)) {\n", + " const lastMessage = update.messages ? update.messages[update.messages.length - 1] : undefined;\n", + " if (lastMessage && lastMessage._getType() === \"ai\") {\n", + " console.log(`${lastMessage.name}: ${lastMessage.content}`)\n", + " }\n", + " }\n", + "}\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "TypeScript", + "language": "typescript", + "name": "tslab" + }, + "language_info": { + "codemirror_mode": { + "mode": "typescript", + "name": "javascript", + "typescript": true + }, + "file_extension": ".ts", + "mimetype": "text/typescript", + "name": "typescript", + "version": "3.7.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/how-tos/review-tool-calls.ipynb b/examples/how-tos/review-tool-calls.ipynb index ee3bb4ec9..8fe8956e9 100644 --- a/examples/how-tos/review-tool-calls.ipynb +++ b/examples/how-tos/review-tool-calls.ipynb @@ -6,6 +6,14 @@ "source": [ "# Review Tool Calls\n", "\n", + "!!! tip \"Prerequisites\"\n", + "\n", + " This guide assumes familiarity with the following concepts:\n", + "\n", + " * [Tool calling](https://js.langchain.com/docs/concepts/tool_calling/)\n", + " * [Human-in-the-loop](/langgraphjs/concepts/human_in_the_loop)\n", + " * [LangGraph Glossary](/langgraphjs/concepts/low_level) \n", + "\n", "Human-in-the-loop (HIL) interactions are crucial for [agentic systems](https://langchain-ai.github.io/langgraphjs/concepts/agentic_concepts/#human-in-the-loop). A common pattern is to add some human in the loop step after certain tool calls. These tool calls often lead to either a function call or saving of some information. Examples include:\n", "\n", "- A tool call to execute SQL, which will then be run by the tool\n", @@ -19,8 +27,45 @@ "2. Modify the tool call manually and then continue\n", "3. Give natural language feedback, and then pass that back to the agent instead of continuing\n", "\n", - "We can implement this in LangGraph using a [breakpoint](https://langchain-ai.github.io/langgraphjs/how-tos/breakpoints/): breakpoints allow us to interrupt graph execution before a specific step. At this breakpoint, we can manually update the graph state taking one of the three options above\n", + "We can implement these in LangGraph using the [`interrupt()`](/langgraphjs/reference/functions/langgraph.interrupt-1.html) function. `interrupt` allows us to stop graph execution to collect input from a user and continue execution with collected input:\n", + "\n", + "```typescript\n", + "function humanReviewNode(state: typeof GraphAnnotation.State) {\n", + " // this is the value we'll be providing via new Command({ resume: })\n", + " const humanReview = interrupt({\n", + " question: \"Is this correct?\",\n", + " // Surface tool calls for review\n", + " tool_call,\n", + " });\n", + "\n", + " const [reviewAction, reviewData] = humanReview;\n", "\n", + " // Approve the tool call and continue\n", + " if (reviewAction === \"continue\") {\n", + " return new Command({ goto: \"run_tool\" });\n", + " }\n", + " \n", + " // Modify the tool call manually and then continue\n", + " if (reviewAction === \"update\") {\n", + " const updatedMsg = getUpdatedMsg(reviewData);\n", + " return new Command({ goto: \"run_tool\", update: { messages: [updatedMsg] } });\n", + " }\n", + " \n", + " // Give natural language feedback, and then pass that back to the agent\n", + " if (reviewAction === \"feedback\") {\n", + " const feedbackMsg = getFeedbackMsg(reviewData);\n", + " return new Command({ goto: \"call_llm\", update: { messages: [feedbackMsg] } });\n", + " }\n", + " \n", + " throw new Error(\"Unreachable\");\n", + "}\n", + "```\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ "## Setup\n", "\n", "First we need to install the packages required\n", @@ -60,7 +105,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -69,93 +114,138 @@ " StateGraph,\n", " START,\n", " END,\n", - " MemorySaver\n", + " MemorySaver,\n", + " Command,\n", + " interrupt\n", "} from \"@langchain/langgraph\";\n", "import { ChatAnthropic } from \"@langchain/anthropic\";\n", "import { tool } from '@langchain/core/tools';\n", "import { z } from 'zod';\n", - "import { type AIMessage, isAIMessage } from '@langchain/core/messages';\n", - "import { ToolNode } from '@langchain/langgraph/prebuilt'\n", + "import { AIMessage, ToolMessage } from '@langchain/core/messages';\n", + "import { ToolCall } from '@langchain/core/messages/tool';\n", "\n", - "const getWeather = tool((input) => {\n", - " const city = input.city;\n", + "const weatherSearch = tool((input: { city: string }) => {\n", " console.log(\"----\");\n", - " console.log(`Searching for: ${city}`);\n", + " console.log(`Searching for: ${input.city}`);\n", " console.log(\"----\");\n", " return \"Sunny!\";\n", "}, {\n", - " name: 'get_weather',\n", - " description: 'Call to get the current weather.',\n", + " name: 'weather_search',\n", + " description: 'Search for the weather',\n", " schema: z.object({\n", - " city: z.string().describe(\"City to get the weather for.\"),\n", + " city: z.string()\n", " })\n", - "})\n", + "});\n", "\n", - "const tools = [getWeather];\n", - "\n", - "const model = new ChatAnthropic({ model: \"claude-3-5-sonnet-20240620\" });\n", - "const modelWithTools = model.bindTools([getWeather]);\n", + "const model = new ChatAnthropic({ \n", + " model: \"claude-3-5-sonnet-latest\"\n", + "}).bindTools([weatherSearch]);\n", "\n", "const callLLM = async (state: typeof MessagesAnnotation.State) => {\n", - " const response = await modelWithTools.invoke(state.messages);\n", - " return { messages: [response] };\n", - "}\n", + " const response = await model.invoke(state.messages);\n", + " return { messages: [response] };\n", + "};\n", + "\n", + "const humanReviewNode = async (state: typeof MessagesAnnotation.State): Promise => {\n", + " const lastMessage = state.messages[state.messages.length - 1] as AIMessage;\n", + " const toolCall = lastMessage.tool_calls![lastMessage.tool_calls!.length - 1];\n", "\n", - "const humanReviewNode = async (state: typeof MessagesAnnotation.State) => {\n", - " // Node waits for human input and then goes to next node\n", - " return { messages: [] };\n", + " const humanReview = interrupt<\n", + " {\n", + " question: string;\n", + " toolCall: ToolCall;\n", + " },\n", + " {\n", + " action: string;\n", + " data: any;\n", + " }>({\n", + " question: \"Is this correct?\",\n", + " toolCall: toolCall\n", + " });\n", + "\n", + " const reviewAction = humanReview.action;\n", + " const reviewData = humanReview.data;\n", + "\n", + " if (reviewAction === \"continue\") {\n", + " return new Command({ goto: \"run_tool\" });\n", + " }\n", + " else if (reviewAction === \"update\") {\n", + " const updatedMessage = {\n", + " role: \"ai\",\n", + " content: lastMessage.content,\n", + " tool_calls: [{\n", + " id: toolCall.id,\n", + " name: toolCall.name,\n", + " args: reviewData\n", + " }],\n", + " id: lastMessage.id\n", + " };\n", + " return new Command({ goto: \"run_tool\", update: { messages: [updatedMessage] } });\n", + " }\n", + " else if (reviewAction === \"feedback\") {\n", + " const toolMessage = new ToolMessage({\n", + " name: toolCall.name,\n", + " content: reviewData,\n", + " tool_call_id: toolCall.id\n", + " })\n", + " return new Command({ goto: \"call_llm\", update: { messages: [toolMessage] }});\n", + " }\n", + " throw new Error(\"Invalid review action\");\n", "};\n", "\n", - "function routeAfterLLM(state: typeof MessagesAnnotation.State): typeof END | \"human_review_node\" {\n", - " const lastMessage: AIMessage = state.messages[state.messages.length - 1];\n", - " if (lastMessage.tool_calls?.length === 0) {\n", - " return END;\n", - " } else {\n", - " return \"human_review_node\";\n", - " }\n", - "}\n", + "const runTool = async (state: typeof MessagesAnnotation.State) => {\n", + " const newMessages: ToolMessage[] = [];\n", + " const tools = { weather_search: weatherSearch };\n", + " const lastMessage = state.messages[state.messages.length - 1] as AIMessage;\n", + " const toolCalls = lastMessage.tool_calls!;\n", + "\n", + " for (const toolCall of toolCalls) {\n", + " const tool = tools[toolCall.name as keyof typeof tools];\n", + " const result = await tool.invoke(toolCall.args);\n", + " newMessages.push(new ToolMessage({\n", + " name: toolCall.name,\n", + " content: result,\n", + " tool_call_id: toolCall.id\n", + " }));\n", + " }\n", + " return { messages: newMessages };\n", + "};\n", "\n", - "function routeAfterHuman(state: typeof MessagesAnnotation.State): \"tools\" | \"llm\" {\n", - " if (isAIMessage(state.messages[state.messages.length - 1])) {\n", - " return \"tools\";\n", - " } else {\n", - " return \"llm\";\n", - " }\n", - "}\n", + "const routeAfterLLM = (state: typeof MessagesAnnotation.State): typeof END | \"human_review_node\" => {\n", + " const lastMessage = state.messages[state.messages.length - 1] as AIMessage;\n", + " if (!lastMessage.tool_calls?.length) {\n", + " return END;\n", + " }\n", + " return \"human_review_node\";\n", + "};\n", "\n", - "// State will be { messages: Messages[] }\n", "const workflow = new StateGraph(MessagesAnnotation)\n", - " // Define the two nodes we will cycle between\n", - " .addNode(\"llm\", callLLM)\n", - " .addNode(\"tools\", new ToolNode(tools))\n", - " .addNode(\"human_review_node\", humanReviewNode)\n", - " .addEdge(START, \"llm\")\n", + " .addNode(\"call_llm\", callLLM)\n", + " .addNode(\"run_tool\", runTool)\n", + " .addNode(\"human_review_node\", humanReviewNode, {\n", + " ends: [\"run_tool\", \"call_llm\"]\n", + " })\n", + " .addEdge(START, \"call_llm\")\n", " .addConditionalEdges(\n", - " \"llm\",\n", + " \"call_llm\",\n", " routeAfterLLM,\n", " [\"human_review_node\", END]\n", " )\n", - " .addConditionalEdges(\n", - " \"human_review_node\",\n", - " routeAfterHuman,\n", - " [\"tools\", \"llm\"]\n", - " )\n", - " .addEdge(\"tools\", \"llm\");\n", + " .addEdge(\"run_tool\", \"call_llm\");\n", "\n", - "// Setup memory\n", "const memory = new MemorySaver();\n", "\n", - "const graph = workflow.compile({ interruptBefore: [\"human_review_node\"], checkpointer: memory });" + "const graph = workflow.compile({ checkpointer: memory });" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 15, "metadata": {}, "outputs": [ { "data": { - "image/png": "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" + "image/png": "/9j/4AAQSkZJRgABAQAAAQABAAD/4gHYSUNDX1BST0ZJTEUAAQEAAAHIAAAAAAQwAABtbnRyUkdCIFhZWiAH4AABAAEAAAAAAABhY3NwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAA9tYAAQAAAADTLQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlkZXNjAAAA8AAAACRyWFlaAAABFAAAABRnWFlaAAABKAAAABRiWFlaAAABPAAAABR3dHB0AAABUAAAABRyVFJDAAABZAAAAChnVFJDAAABZAAAAChiVFJDAAABZAAAAChjcHJ0AAABjAAAADxtbHVjAAAAAAAAAAEAAAAMZW5VUwAAAAgAAAAcAHMAUgBHAEJYWVogAAAAAAAAb6IAADj1AAADkFhZWiAAAAAAAABimQAAt4UAABjaWFlaIAAAAAAAACSgAAAPhAAAts9YWVogAAAAAAAA9tYAAQAAAADTLXBhcmEAAAAAAAQAAAACZmYAAPKnAAANWQAAE9AAAApbAAAAAAAAAABtbHVjAAAAAAAAAAEAAAAMZW5VUwAAACAAAAAcAEcAbwBvAGcAbABlACAASQBuAGMALgAgADIAMAAxADb/2wBDAAMCAgMCAgMDAwMEAwMEBQgFBQQEBQoHBwYIDAoMDAsKCwsNDhIQDQ4RDgsLEBYQERMUFRUVDA8XGBYUGBIUFRT/2wBDAQMEBAUEBQkFBQkUDQsNFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBT/wAARCAEIAU4DASIAAhEBAxEB/8QAHQABAQACAwEBAQAAAAAAAAAAAAYFBwMECAIBCf/EAFQQAAEEAQICAwkLCgQCBwkAAAEAAgMEBQYRBxITIZUUFhciMUFUVdMIFTZRUlZ1kZTR0iMyNTdhdLKztNRxc4HjCUIkJkNEU3KTMzRXYpKiscHD/8QAGQEBAQADAQAAAAAAAAAAAAAAAAECAwQF/8QAMREBAAECAwUHAwQDAQAAAAAAAAEDEQJRkRITITFSBBQzQXGhwWHR0iIyQmKBscLw/9oADAMBAAIRAxEAPwD+qaIiAiIgIiICIiD8c4MaXOIa0DcknYALGHVGGaSDl6AI8oNln3qd1eRmNVY/C2QJMaKklyau782Z4kY1geP+Zo3ceU9RPKfMF+jTOHAAGJogDqA7mZ9y7sFDBsxixzPHJbR5qHvqwvrih9pZ96d9WF9cUPtLPvU93tYf1VR+zs+5O9rD+qqP2dn3LPc0c59jgoe+rC+uKH2ln3p31YX1xQ+0s+9T3e1h/VVH7Oz7k72sP6qo/Z2fcm5o5z7HBQ99WF9cUPtLPvTvqwvrih9pZ96nu9rD+qqP2dn3J3tYf1VR+zs+5NzRzn2OCh76sL64ofaWfenfVhfXFD7Sz71Pd7WH9VUfs7PuTvaw/qqj9nZ9ybmjnPscFD31YX1xQ+0s+9O+rC+uKH2ln3qe72sP6qo/Z2fcne1h/VVH7Oz7k3NHOfY4LGvZitxNlglZNE7yPjcHA/6hci19BDDpjVuCGOhjqQZWxJUtQQtDY3kQSzNk5R1cwMRG/lIcd99htsFctalu5i08Ji/x8EiIi0IIiIC6dzM4/HPDLd6tVeesNmmawn6yulrTMS6e0dncrAGuno0J7MYd5C5kbnDf/UKcp6SxdeACenBdsu8aa1Zia+WZ/lLnOI6yST+weQbDqXXSo4cWHbxzwX1VHfVhfXFD7Sz7076sL64ofaWfep7vaw/qqj9nZ9yd7WH9VUfs7PuW7c0c59jgoe+rC+uKH2ln3p31YX1xQ+0s+9T3e1h/VVH7Oz7k72sP6qo/Z2fcm5o5z7HBQ99WF9cUPtLPvTvqwvrih9pZ96nu9rD+qqP2dn3J3tYf1VR+zs+5NzRzn2OCh76sL64ofaWfenfVhfXFD7Sz71Pd7WH9VUfs7PuTvaw/qqj9nZ9ybmjnPscFD31YX1xQ+0s+9clbUGLuStigyVSeV3kZHO1zj/oCprvaw/qqj9nZ9y+J9J4WxE6OTE0ix3xV2gj9oIG4P7Qm5o5z7HBcIprh/kbF/AyMtSvsS1LlmmJpDu57I5XNYXHzu5Q0E+cgnzqlXFUwTTxzgnyJ4CIi1oIiICIiAiIgIiIIjNfrJq/RMn85iyixea/WTV+iZP5zFlF6s/sweiyIiLFBFHcSOKGO4aQ4htmhksxkMvb7ioYzEwtksWJAxz3bB7mNADWOJLnDyKD1lx6zeD1/w8xWP0TnblDUNG5cs1e54GXWujDOWMCSdga5nMXSA+ZzOUnxgMZmIG7UWtdbcdMfw/zktTL6b1LFiIJYYbGo2UGuxsBlLQ0uk5+ctBe0FzWEA7gnqK5L3G2jBxGyOiaOnc/mszj21ZbTqFeEwRRT78shkfK0AN26wfG8vKHAO2XgbGRaj9z/AMYc3xXpZp+Y0xkMMaeTu1orUrIW1yyKw6NsPizPcZWgDnO3LzB3KSNltxWJvxBERUYTM/CrRX0pL/QW1fKBzPwq0V9KS/0FtXy1dq/h6f8AUrPkIiLhQREQS3FT9WOrvoi3/JeuZcPFT9WOrvoi3/JeuZejS8GPWf8AUL5CLr5G7HjMfZuShzoq8TpXBg3cQ0Enb9vUtTYb3TWEzekcdqiPTWpa2n8jLSgqX7VaCNs0lmZsLWtb03N4j3+M7bl2BLS/q3szEI3Ci13rzjngOHWSz9LKVshI/CYNmoLMlaJjmmu6Z8Ia3d4JeHRuJBAG23Xv1Ln0hxhx+rNWy6bkw2bwGUNH3yrR5mq2EXKoeGGWPle4jZzmAseGvHMN2hLwL1F1slbfQx1q1HVmvSQRPkbVrcvSzEAkMZzFreY7bDcgbnrI8q0rwp90e7NcDm681rhruCjhiY99hsDDDefJK5jGVI2SySOPNyM2eGklw8vWQvYbzRatpe6K02yrqB+oKOX0ZZwdBuUtUs/VbHM6q4lrZoxG94kBeOTZp5g4gEAkLD5v3QUWQ0prCtWxGd0dqmnpy5msdDn6UcT52RxO2ljAdI13I8s5mO2cOYbt2U2oG6kWA4e5S1nNA6ayV2Xp7tzGVrE8vKG88j4mucdgABuSeoDZZ9UdThp+iMp9LXf5zlXKR4afojKfS13+c5Vy5u0+Nj9WWLmIiLmYiIiAiIgIiICIiCIzX6yav0TJ/OYsosXmv1k1fomT+cxZRerP7MHosprU3E7R2i78dHUOrMHgrskYmZWyeShryOjJIDw17gS0lrhv5NwfiWKPHnhmGB54iaUDCSA737rbEjbcfn/tH1q1lqwTuDpIY5HAbbvaCV8e91T0aH/0wsOKNQ8Tc5pzi9pZlTTWJxvFiOrbjksRYHUFaGzjXcr+jsRyiQckm4IGz2nbm2J2IMxX0XxOwNHhBqTI406z1JpyDI1ctTZkIWWHR2WtETulkLWSOjbHG153HMdyN16JirxV9+iiZHv5eRoG65Fjs35jyHxg4Ja116eIMdjQ8epM3lZWWMFnr2WhbDjKzY4iKkcbnF0cgeyVvM1oa8ybueAt4aC0tmKHGTiJqS9jnUcbm6eHbUe+WN7nPhinErCGOJBaZGjc9R36iQtmIkYYibjSPDGxkuDLtVYzWNGphNLHNZDKVdV28rWiqSts2ekjicxzw9j/AMo5p3G27eoncKy8PnDH/wCI2ku3KvtFdSRMmZyyMa9vxOG4XD73VD/3WH/0wraY5CawXF3QuqMrBjMNrXTuWyU/N0VOjlYJppOVpc7lY15J2aCTsOoAnzKtXDHSrxPD2QRMcPI5rACFzKjCZn4VaK+lJf6C2r5QOZ+FWivpSX+gtq+WvtX8PT/qVnyERFwoIiIJbip+rHV30Rb/AJL1zLh4qfqx1d9EW/5L1zL0aXgx6z/qF8mP1DVlvYDJ1oG8801WWNjdwN3FhAG56vKVpK1wp1PL7ljRemYKEQ1XgYMPadjZbDGtkmqSwySQ9KCWgno3NDty3fbr261v1EmLo8rcUeHvETinc4j5IaLkxAy2iYsJjak+SqyTS2G2pZC15bIWMOz9/wA4t228bclo2lq3GS4PjTp3W2Tlq4zSuL07epXsrdtxQxQTSz1TG1xe4HxuR3XttuAN9yN9rr5kjbKwte0PafK1w3BU2RH4vjRw+zmRr0MdrvTWQvWHiOGrVy9eSWVx8jWta8kk/EFpHC8KteO4FUtBT6cip5fSF6tkMXkJshE+nl3V7nTMYA0l8YewbeO0bF3xBemWUa0bg5teJrh1ghgBC51bX5jzDr7hHrjjtkNS5vJYOLRU7dPR4nE469disvsWG3YbhkldCXNbHzV42Abk7OcSB1BZbUOhNc8bNRS5LOaaZoevQ0xlcRUhs5CG1Jat3Y2Mc4mEuAhYIxsXbOJP5oXohFNmBIcIa+Yo8MdNUs/iveXMUqMdOxT7oZOGmIdGHB7CQQ4NDx5wHAHYgqvRFlHAdThp+iMp9LXf5zlXKR4afojKfS13+c5Vy5u0+Nj9WWLmIiLmYiIiAiIgIiICIiCK1Ew1df4uzL4kFihNVjkP5plD2PDN/jLQ4gecMd8SySzOSxlTM0pKl6tHbrSbc0UrQ5p2O4P+IIBB8xAKnTwu02f+6WR+wX7AH1dIvQwVqc4YjHeJjhwi/wAwy4S7KLreC3TnotrtCz7RPBbpz0W12hZ9ost5QznSPyTg7KLreC3TnotrtCz7RPBbpz0W12hZ9om8oZzpH5HB2UUHqHROLp8U9G4uEWo8fep5GSzB3dYPSOj7n6M78+4253+Qjffz+az8FunPRbXaFn2ibyhnOkfkcHZRdbwW6c9FtdoWfaJ4LdOei2u0LPtE3lDOdI/I4Oyi63gt056La7Qs+0TwW6c9FtdoWfaJvKGc6R+RwY+8zu3WWloIvHlqWZbszW9fJF3NNEHH4t3StA+Pr+Iq8WNwuncbp6ORmPqMrdKeaRw3c9583M47k+U+U+dZJctepFSY2eURb3mfkkREXOgiIgwGv8dPmNCajoVmGSzaxtmGJjRuXOdE4AD/AFK6ePvwZSlDbrPEkErQ5rh/+D8RHkI8xCq1O5Hh9gMpalszUCyaV3PI6vPJDzu+M8jhues9ZXZSq4MOHYx3z4f+jJfo/EXW8FunPRbXaFn2ieC3TnotrtCz7Rbt5QznSPyODsout4LdOei2u0LPtE8FunPRbXaFn2ibyhnOkfkcHZRQea0Ri63FvSeJiFpmNuYnKWLFbu6wekkikpCN2/P1colkG2435/Iduqz8FunPRbXaFn2ib2hnOkfkcHZRdbwW6c9FtdoWfaJ4LdOei2u0LPtE3lDOdI/I4Oyvxzgxpc4hrQNySeoBdfwW6c9FtdoWfaL7i4Y6ajcC7HusNB36OzZlmYf8WveQf9Qm9oZzpH5HB88NYnDT09nYiK5ftWoSRtzxPmcWPH7HN2cD5w4KrTyIuGpj3mOceZM3kREWtBERAREQEREBERAREQEREBERBr3X21HiTw0yLgBHJeuYxzyQA0y05JW7/wCLqwb/AIuC2Eo7izp67qHRVk4qMS5vHSw5TGs5uXpLNeRsrIy7zCTkMZPyZHLP6b1BS1XgMfmcdIZaV6Bk8TiNncrhvs4eZw8hHmII8yDJIiICIiAiIgIiICIiAiIgIiICIiDX1twyHH7GNaOY4nTNp0hBHi912q4Zv1b9fcUm3X5j5fNsFa94Ubajtai1wdzDqCwxmNdzbh2OrgsrvafO2Vzp52n5NhvnWwkBERAREQEREBERAREQEREBERAREQEREBERAREQFr148FOduWnbt0XlbDrMzmt8XE3JHufLK74q8znFznf9nIXOceSRxj2EviWJk8b45GNkjeC1zHDcOB8oIQfaLXnR3+ErdoIZstoZg6q8LHy3MQN/Ixo3M1YDyMA54ttm9IwhsN3j8jUy1GC7Rsw3ac7BJFYryCSORp8jmuHUQfjCDsIiICIiAiIgIiICIiAiIgKA1ZYl4hX7GkcZI9mKYQzPZGPqAi/5qUbv/FkHU8jrjjcetr3xkfkupr/Eed9HSk8lPBMfyW9TtaC2Xb86Klvvzu8xnIMbd9m9I4OEdjgsFQ0zia+MxlZtSlACGRtJPWSXOc5x3LnOcS5znElxJJJJJQduvXiqwRwQRshhjaGMjjaGtY0DYAAeQAeZciIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgKFymh8jp+/YzGiZ4KVqeR09zB2jyY/IPcd3PJa1zq8xP/asBDiSXxyHlLbpEHm/UPu4NK6Z426a4a5HEXsdk77xBlJ7z2xtxU79ugjO3M2UP3a4va4Nax7Hbu3cG+kF4i1V/w/dAcQ9YZnPY/K53HMlvTmSaxdNx89gSOErg5/jgB4I3e5znEEnzE+lsPi9W4jE0qJ1ZFdNaFkPdNrGh0svKAOZ5Eg3cdtydusrsjs0/yxRE/wCfiFs2OihOTVvzipdl/wC6nJq35xUuy/8AdV7t/ePf7Fvqu0UJyat+cVLsv/dTk1b84qXZf+6ndv7x7/Yt9V2ihOTVvzipdl/7qcmrfnFS7L/3U7t/ePf7Fvqu0UJyat+cVLsv/dTk1b84qXZf+6ndv7x7/Yt9WsOKfu1tGcIuOtDQWdmdFRONfPeyMELpu5bbi11eFwadwHMD9yGu65IfzRzkbJOmsvxKY2TVkDsRp52/LpdkjXSWWkDqvSMJa4eXeCMlh6w90oPK3zBrH/h/6VzOpMnq/Uufzeo57M8l3IxxvZXlm3PM4sdsQCBvs3YA7Abt8q9p4WGtXw1CKnLLPTjrxthlsTvnkewNAaXSSEve4jYlziXE9ZJJWmpRmnab3j6Ew7UEEdaGOGGNsUUbQxkbAA1rQNgAB5AF9oi0IIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiDXmhSTgH7nf8A6dd/qpVQKf0L+gH/AL9d/qpVQL2K3iYvWVnnIiItSCLXGa474DBad15mbFPJPq6NuCjkGRxRl8rzHE/eIF4DhtOz84tO4PV5N9jqXuCKbt68x9PiFjdHPhsnJ38dPk4pWtb0IiikjY4OPNvzEyt2AaRsD1jzuHmvMfxL0lV1Di4bMFKzLPEyO21rZAYpnwu3DXOGxdG4jr8hHk8iXFIiIqOnmf0Pe/yJP4Sspog76LwBPWfe+v8Ay2rF5r9D3/8AIk/hKymh/gVp/wCj6/8ALasa3g/5+GXkzaIi85iIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiDXmhf0A/wDfrv8AVSqgU/oX9AP/AH67/VSqgXsVvExesrPOXmHhxh9B6x1XrTOcQrVKfW2M1ZZrQjLXzDLj4I5gKUcDS9vLG5nI4Fo/KF535vItd8T8lSt6qyfEDFRaf0xkcVratiGzSWp35m6+O3HDMd+lDI4XM5z0XI4FgLurdew8pw+0tm85BmsjprEX8xBsIchaoRSWI9uscsjmlw2/YVxX+GmkMrkL1+7pXCXL1+LobdqxjoXy2I+rxJHFu729Q6juOoLmnDwR5g4jWoRw291JQ6Vnd0eZZbfW5h0jYTVpbSFvl5Tyu6/J1FevKN6tk6cNunYitVZ2CSKeB4eyRpG4c1w6iD8YXTk0xhpr9u9JiaL7tuv3JZsurMMk0P8A4T3bbuZ/8p6lK3OGeUjn6PA64y2lMPG1sdbDYnH40VarWtA5YxJVc4AkE7Fx6ydthsBYiYEvqm5BQ91doY2Zo64taYyleDpXBvSy90VHcjd/K7lBOw69gtK4Gtj9R8EuDmFsSNsRt4jWad+rHMWubzS5Muik5SCOZrhu0+VruvcFerMXouJlLHsz1o6uv0JzYrZLL1K3Twv8zmdFExrCB1AtaD8ZK7I0Tp0WTZGBxgsOujImbuOPnNoNLRPvy79IGkjn/O2JG6k4bjyBq3hfpnCad90VPj8Y2jLpSaK1gHQSvb71SdwQ2C6sN9oiZHEnl236geoAL2dibD7eKpTyHeSWFj3H4yWgldSxpLBW4svFPhcfNFl/0kySrG5t3xAz8sCPyniAN8bfqAHkWUjjbFG1jGhjGgNa1o2AA8gAVjDYdXNfoe//AJEn8JWU0P8AArT/ANH1/wCW1YvNfoe//kSfwlZTQ/wK0/8AR9f+W1Wt4P8An4ZeTNoiLzmIiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiwHfSMlNXjwlf33hmNmN2QhlYateSLxS2R3NzEl/ibMDti1++3Kgm9DNLcA8EEHu675f3qVUCw1TSmpMHXHcljFZGSwXWLMMjZKkTLDyXSuiI6Uhjnku5XcxBLvGIIDfvuXWnqzA9qTf2y9jFOGpinHhxRx+tmUxebssixPcutPVmB7Um/tk7l1p6swPak39ssdmOqNY+5ZlkWJ7l1p6swPak39sncutPVmB7Um/tk2Y6o1j7lmWRYnuXWnqzA9qTf2ydy609WYHtSb+2TZjqjWPuWZZFie5daerMD2pN/bJ3LrT1Zge1Jv7ZNmOqNY+5Z2sz+h73+RJ/CVlNEAt0XgARsRj6+4P+W1YF2ndSZyN9PKDG42hKCyc0bEliV7D5WtLo2Bm43HN17DydfWMjRy1/TFCpWz1eN8UFWaWxmMfEIqULYj1B0bpHSMLo/GG3O0FrgXDxebRXxYYwRgibze5yiyoRcVW1DerQ2a00divMwSRzRODmPaRuHNI6iCDuCFyrgYiIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIi4rFqGpGHzyshYXtjDpHBoLnODWt3PnLiAB5yQEHKsFl9Ux1Jb1HGV3ZrOVYopnYyvKxj2tkfysc9zyGsb1Od1nmLWO5WuIDTwMOR1ZCx5bYwuHnhsQzVpmOhvyEuLI5GSMk/It5Q546uk8dm/RlrmnN4/H18VSgqVY+ighjbGxu5cQ1rQ0bk9Z6gBuevqQYl+mp8tYkfmrvdcEV+O5RrVeeuyER/mCQtfvMebxzzeLuG+Lu3c51jGxMaxjQxjRs1rRsAPiC+kQEREBERAREQEREBERAREQT2T0vLGMjb0/bZh8zbjhYJ5o32K35I+LzV+dretu7CWlri3Yc3it25JNVRY226HMxDDslvMo0Z55mmO457eZnKQfFJIczlcAeYbDm5mk51fhAcOsb+frQfqKcjw13TQgGGcZ8XF3TLPjp3vlnke/x2Nglkk2Y0O5gGO8UB4DSxrADlcVl4MvWjljD4ZTFHLJVnAbPBztDg2Rnla7Y+QoO8iIgIiICIiAiIgIiICIiAiIgIiICIiAiIg62Ru+99Kax0MlhzGktghAMkrvM1u5A3J6huQPjIHWsZUwpyVlmQzETJ5Wyx2qdOxHG/3ueIiw8jhvvIeeXd4PkfyjqG56mOEWp9S2b8hxeQx+Jl6HHPh5pJ69sCSO05zj4rXcrhGA0czR0oLvHLW06AiIgIiICIiAiIgIiICIiAiIgIiICIiAsTlcCLczrlKVuNyxEUZvxwse98TJOfon7jxmHd426iBI8tLXHmWWRB0MPkpclXkNilLjrMUj4pK8zmuPiuIa9rmkgseAHNPUdnAODXBzW99TOsGMwrG6miGMqTUGgXr2QDmhmPDg+wOdvkLWgvbzAt3bseXmLhStcHtDmkOaRuCDuCEH6iIgIiICIiAiKbyXEDD427LVJu254ncsgoY+ey2N3yXOjY5oP7N9/wBi2YKeOpNsEX9FtdSIpLwm4n0TN9iW/ZJ4TcT6Jm+xLfslt7tX6J0XZnJWopLwm4n0TN9iW/ZJ4TcT6Jm+xLfsk7tX6J0NmclaikvCbifRM32Jb9knhNxPomb7Et+yTu1fonQ2ZyVqKS8JuJ9EzfYlv2SeE3E+iZvsS37JO7V+idDZnJWqS4mcV9KcHcBDm9YZduFxc1ltRll8MkoMrmucG7RtcRuGO6yNury9YTwm4n0TN9iW/ZLX/Hqnpvjdwo1BpC5TzDX3YCas78Hb/IWG+NE//wBl1bOA328xI86d2r9E6GzOTucBfdAaF4pxOwmndT0M/na0Ut663G4+etCA+bdz/wApG0bl0g36+ZxLj8a3CvIXuHOHNP3PPDS0M9jMtFq7MT9NfEeItSCKNm7Yog5sZB2Bc4ked/7F6Q8JuJ9EzfYlv2Sd2r9E6GzOStRSXhNxPomb7Et+yTwm4n0TN9iW/ZJ3av0TobM5K1FJeE3E+iZvsS37JPCbifRM32Jb9kndq/ROhszkrUUl4TcT6Jm+xLfsk8JuJ9EzfYlv2Sd2r9E6GzOStRSXhNxPomb7Et+yTwm4n0TN9iW/ZJ3av0TobM5K1FKM4mYT86YZKlEPzp7mLswxMHl3c90Ya0dR3JIA85VU1wc0EEEHrBHnWrHSx0/34ZhJiY5v1ERa0EREBEXQzOdo6fqCxfn6GNzuRjWsc98jtieVjGgue7YE7NBOwJ8yyjDOKbYYvI76KTdxMxLXEGpmtwdurC2z/wDzX54TcT6Jm+xLfslv7tX6J0XZlWopLwm4n0TN9iW/ZJ4TcT6Jm+xLfsk7tX6J0XZnJxcVeKej+Eumo8prbLQ4fEXJxQbNPA+Zj5Xse4MLWNd5WseesbdX7VLcCPdB6K4t46phsDqinqLP4/HRSZI46hYr1w4BrHuaJI2hrS8nlZvvt/gVg/dF4vT3HXhDntJz0sw21PF01Cd+Et/kbTOuJ2/RdQJ8Un5LnKD9xJoGj7nrhQ6tmsZl4tWZec2sn0eHtSCMN3bFCHNjIcGt3O4873J3av0TobM5PWaKS8JuJ9EzfYlv2SeE3E+iZvsS37JO7V+idDZnJWopLwm4n0TN9iW/ZJ4TcT6Jm+xLfsk7tX6J0NmclaixWE1PjtQmZlOV/Tw7dLXsQvhlYCSASx4DtiWu2dtsdjsTssqtGLDiwTs4otLF0M/ZfSwWRsRHllirSSNPxENJCltJwR1tMYpkbQ1vcsbj1eUloJJ/aSSSfOSVSaq+DGY/c5v4Cp7TXwcxX7pF/AF3UfBn1+F8mSREWaCIiAiIgIiICIiAiIgIiICIiAiIgIiIC6/DN/8A1XdA3qiq3rlaFvmZGyzI1jR8Qa0BoHmAAXYXV4ZfB+59LZD+rlUqeBi9Y+V8laiIvNQREQFEZJ/dHEmZkg5u5cTC6Lfr5DLNKH7fFv0LN/8AyhW6hrf6zsl9D0/51pdnZueKfp8wsebLIiLegiIgIiICIiAiIgw2Uf3NqrSUzPFlkvS1XOHlMbq0z3NP7C6KM7fGxp8yvFA5z4R6O+lnf0dlXy1dq5YPT5llPKGL1V8GMx+5zfwFT2mvg5iv3SL+AKh1V8GMx+5zfwFT2mvg5iv3SL+ALOj4M+vwnkyS8k+5219rPQvCvhB741cHPo3OWWYSJlbpvfCCSTpjFM55PRuaXMILA0FocPGd1r1stQYf3P3vTw44caU9/ul7z8rWyfdfce3dfRGQ8nJ0nib9J5d3bbeQ7qTE3vCMPZ475+HgRmdatp405WlqF+JjhMUnQGIZZtMOI5+bm6M778wHN17bdSwutOPPEHC4niVqLGUdNS4PROa9731LUdjum9HyQPO0jX8sTgJ/zi14d8lu3jZjPe5oy+TweZ03S10cfpO/mhnGY44lsssUhtttPiM3SDmiMgcQA1rgSN3OALTms97n7370TxO0/wC/3Q9+uVdk+6e4+buPeOuzk5ekHSf+7777t/O8nV14/qHDR4m6wwWrtS6X1VJphl6rpw6ho5Ov01alE0PfG6OyXueeVrg0mRu27STyg9SkdEe6Wz2Ws6ux144XLWcfpmfUeOyWLx12nVmEZLTG5lnZ0jeYsIkjdyuBPkKveJnAOpxOz+dvXstLVrZXTLtOurwwgvjJsdMJw8u2OxAHIW7Hby9eyxXgD1Dk8/ezee13HlMhd05b01IyHCsrwMgm5XMexglJD2vaS7dzg4HYBmyv6hwaI4u61s6h4bs1NVwPvVrqhLYqx4pkzZqMrKwshsj3uIlDmc3kazlI28byneS1bY4TyYatw0vxXJ8lLw/pSsbTrVmCXKE0TWDWF8rWxuO/MOZxG/USPzlk6vE7NWLUMT+GGr67JHhpmlfjOSME7czuW6TsPKdgT+wqxeOY1jgfdBayrcHMrxQ1JSwjcDU7qr18XjoJ+6rU7bprQOMhkcI2ud4paGPP/MD18g4sFxz4k5e3exNbDUctk7GKtWsfbi05l6FWtbiYHMr2O6ms6RsnW1r2Padx1t6wr7GcAca3gZZ4ZZfIS5GhYNkvuwR9zyNdLafZY9g3ds6Nz27Hc7lgO3Xss3w/0lrPTtp79T67bquu2AQQwsxEdIg7j8rI5r3F79ht1cres+KpEYuAhYONmY4knDVtFx4tsNvSj8/k5spDLM2q6TxK9faORhDjIyxzAnfaE7bE7qF09x9t6a4b8K9O6bxdHF5HKabZl5SMXkcnVo1xysaxkFfpJnFz3EAveA0NO7iSAd1cPOCmH4bM1kMXK/fUmQmvPL29VZrwdoWDf8xr3SuA6uuRylKXucbuncLoN+m9YOw2qtK4n3kGXdjmzwX6p5S6OWuZB1czGubtIC0+cpbEMZpf3Q+oZrOkbGpcLBg8Jfyl/B371inaqAzxwCerYhbOGPbDK1srSHsJDhtzdR34tHe6cyGvsVpaDG4mGjqTM6k7gdj70b94sZ0Zti1y8wO7qboiCTt0knk2HKrnW/BY8UOE/ebrDOy5iy+eKxNl46rK7y5k4k2Yxh2YOTeMdZPKdySd9+xPwhwuI4ou4kVKck2UqYJ2KixtVjAHhrg5rmczmtEnK0RjcgbbAkAJbENirzlDx415Dp+fWFulp3vWpaqk0/ZqQxz92SQ++BqNna8v5GuaXM3YWuDtnHmbuGjZkPFHNyzMY7hdrGJrnAF734zlb+07XSdv8AsDP7n7p+FuU0d7/cvd2oXZ7u3uP8zfItu9FydJ1/m8nNzDy823mVm88hO6i4365dS19qrT2LwUujtFXbNO1Uvmbu/IdygG2+J7XBkQb44aHNfzFh35dwunr3inq3iXhuIlbQ9fCRaWweJfFdu5kTOmuSy0+mdHAI3AR8kcjN3PDt3O2DdhuqDU/uc8hmJdV4zGa1nwujdV23XMxhmY9ksz3yBrbAgsFwMTZQ3xgWP2LnEbbr71B7nrJjK6nfo/WXeph9TVG18nipMWy4znbAIBLC4vaYyY2tBBDgeXfqKx/UNe4fj3ltO6Z0Ho/TcVaKzS0hir169cwuRyjB0sAEcLY6TCWkiNzi97gNiAA477b84R61yHELQGMzmVw8+ByMxkjno2IpIy1zJHM52tka14Y/lD28zQeVw361DRe59yunLGn8npDWh0/naOBq6fv2JsW23WyMMDdo3uhMjSyQHmIcHnYO2O4W28FSuY3C0auQyD8tehhbHPfkibE6w8DYvLGgNbuevYdQWWGJ8x3l1eGXwfufS2Q/q5V2l1eGXwfufS2Q/q5VnU8DF6x8r5K1EReYgiIgKGt/rOyX0PT/nWlcqGt/rOyX0PT/nWl29l54/T5hY82WRFKap1tktO5FlWponUOo4nRiQ28U6kImkkjkPTWY3cw2B6m7dY6/LttRVrU/HfjLa4ZT6aw+Krxy5zUEs4gmsUbV2KvFCwOlkdBVa6WQ+Oxoa3YeNuXABZTwq5zf8AVVrP/wCvF/3yxGptI5DjGcLnK1bN8NdV6atPkxl7JQ1bPM2WPkmY6KKd7XxPbsCC5rt2gg9SxmbxwERF7orW8mn68bcBSGak1PRwUN67jr+Po3YrLHETRxztbMwscOVwPOPF6ieYEZXIcftR6Iq69xmocdjMxqfA2MbWxwxLZK1fIPvnkrtc2R7zGQ8ODjzHqG4+JV+S4T53U2F05X1Fq8ZXJYjUVbPG4zFsgZI2E7iuyNr/ABGnc+MXPPWfL5ulrH3PdTWmU15ctZqes7UsWLNd9WENlx1ii574pmvLiHnne07EDqaRud+qWxCV0S3WTPdUxjWkmDmvnRMpidgY5o4g03ot2uErnEkHfxgeseYL0KtMYzh7qzROtHa/zubtcRMpFhzhGYzDYivReWOnZL0oMlgM3HKdwXefq222NI3inm3HY8LNZN6idy/F/wB6rHDmNhoonC8RMvlspWqT8O9U4mGV3K67dfjzDEPjd0dt79v/ACtJVssr3GEznwj0d9LO/o7KvlA5z4R6O+lnf0dlXy19q5YPT5llPKGL1V8GMx+5zfwFT2mvg5iv3SL+AKrylIZLG26hdyieF8XN8XM0j/8Aa15jdW4nT2OqY3OZCphclVhZDLXvTNhJLWgFzOY+Mw+UOBPUevY7gbOzxOOnOHDF5uc4VSKd8I2k/nRhu0IvxJ4RtJ/OjDdoRfiW/cVemdJS05KJFO+EbSfzow3aEX4k8I2k/nRhu0IvxJuKvTOklpyUSKd8I2k/nRhu0IvxJ4RtJ/OjDdoRfiTcVemdJLTkokU74RtJ/OjDdoRfiTwjaT+dGG7Qi/Em4q9M6SWnJRIp3wjaT+dGG7Qi/EnhG0n86MN2hF+JNxV6Z0ktOSiRTvhG0n86MN2hF+JPCNpP50YbtCL8Sbir0zpJaclEinfCNpP50YbtCL8SeEbSfzow3aEX4k3FXpnSS05KJFO+EbSfzow3aEX4k8I2k/nRhu0IvxJuKvTOklpyUSKd8I2k/nRhu0IvxJ4RtJ/OjDdoRfiTcVemdJLTkokU74RtJ/OjDdoRfiTwjaT+dGG7Qi/Em4q9M6SWnJRLq8Mvg/c+lsh/VyrEt4g6alH5DO0Lsm+zYac7bErz17BrGEucTsdgASVR6FxdjE6eay3F3PZsWLFx8O4Ji6WZ8gYSCRuA4A7EjcHbq2WqthnBRmMcWmZj5XlHFQIiLy2IiIgKGt/rOyX0PT/nWlcqH1QW6f1Uc3aBZjLFJlSW1sS2u6N73tMh/wCVrhI7xttgW7Ejcb9nZf3YsPnMfMLDKop53ETSjHFrtT4ZrgdiDfi3H/3L88I2k/nRhu0IvxLt3FXpnSS05KJFO+EbSfzow3aEX4k8I2k/nRhu0IvxJuKvTOklpyUSKd8I2k/nRhu0IvxJ4RtJ/OjDdoRfiTcVemdJLTkokU74RtJ/OjDdoRfiTwjaT+dGG7Qi/Em4q9M6SWnJRIp3wjaT+dGG7Qi/EnhG0n86MN2hF+JNxV6Z0ktOTnznwj0d9LO/o7Kvlr+lZg1fqPDSYyRtyljLElqe7F40Id0UkTY2vHU55MhJA35Q082xczfYC5O1cJwYZ5xHzKz5C/HNDhsQCP2oi4WL56GP5DfqToY/kN+pEVuHQx/Ib9SdDH8hv1IiXDoY/kN+pOhj+Q36kRLh0MfyG/UnQx/Ib9SIlw6GP5DfqToY/kN+pES4dDH8hv1J0MfyG/UiJcOhj+Q36k6GP5DfqREuHQx/Ib9SdDH8hv1IiXDoY/kN+pOhj+Q36kRLh0MfyG/UnQx/Ib9SIlx+tja07hoB/YF9IigIiICIiAiIg+OiZ8hv1J0MfyG/UiK3DoY/kN+pOhj+Q36kRLh0MfyG/UnQx/Ib9SIlw6GP5DfqToY/kN+pES4dDH8hv1J0MfyG/UiJcfQAA2HUF+oig//Z" }, "metadata": {}, "output_type": "display_data" @@ -182,7 +272,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -192,7 +282,7 @@ "================================ human Message (1) =================================\n", "hi!\n", "================================ ai Message (1) =================================\n", - "Hello! Welcome! How can I assist you today? Is there anything specific you'd like to know or discuss?\n" + "Hello! I'm here to help you. I can assist you with checking the weather for different cities. Would you like to know the weather for a specific location? Just let me know which city you're interested in and I'll look that up for you.\n" ] } ], @@ -218,7 +308,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -245,7 +335,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -258,12 +348,12 @@ "[\n", " {\n", " type: 'text',\n", - " text: 'To get the weather in San Francisco, I can use the get_weather function. Let me fetch that information for you.'\n", + " text: 'Let me check the weather in San Francisco for you.'\n", " },\n", " {\n", " type: 'tool_use',\n", - " id: 'toolu_01TZ9HWpeQbgRnkoV5zhLAoB',\n", - " name: 'get_weather',\n", + " id: 'toolu_01PTn9oqTP6EdFabfhfvELuy',\n", + " name: 'weather_search',\n", " input: { city: 'San Francisco' }\n", " }\n", "]\n" @@ -292,7 +382,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -312,12 +402,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "To approve the tool call, we can just continue the thread with no edits. To do this, we just create a new run with no inputs." + "To approve the tool call, we can just continue the thread with no edits. To do so, we need to let `human_review_node` know what value to use for the `human_review` variable we defined inside the node. We can provide this value by invoking the graph with a `new Command({ resume: })` input. Since we're approving the tool call, we'll provide `resume` value of `{ action: \"continue\" }` to navigate to `run_tool` node:" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -328,12 +418,12 @@ "[\n", " {\n", " type: 'text',\n", - " text: 'To get the weather in San Francisco, I can use the get_weather function. Let me fetch that information for you.'\n", + " text: 'Let me check the weather in San Francisco for you.'\n", " },\n", " {\n", " type: 'tool_use',\n", - " id: 'toolu_01TZ9HWpeQbgRnkoV5zhLAoB',\n", - " name: 'get_weather',\n", + " id: 'toolu_01PTn9oqTP6EdFabfhfvELuy',\n", + " name: 'weather_search',\n", " input: { city: 'San Francisco' }\n", " }\n", "]\n", @@ -343,17 +433,20 @@ "================================ tool Message (1) =================================\n", "Sunny!\n", "================================ ai Message (1) =================================\n", - "Great news! The current weather in San Francisco is sunny. It's a beautiful day in the city by the bay. Is there anything else you'd like to know about the weather or any other information I can help you with?\n" + "It's sunny in San Francisco right now!\n" ] } ], "source": [ - "stream = await graph.stream(null, config);\n", - "\n", - "for await (const event of stream) {\n", - " const recentMsg = event.messages[event.messages.length - 1];\n", - " console.log(`================================ ${recentMsg._getType()} Message (1) =================================`)\n", - " console.log(recentMsg.content);\n", + "import { Command } from \"@langchain/langgraph\";\n", + "\n", + "for await (const event of await graph.stream(\n", + " new Command({ resume: { action: \"continue\" } }),\n", + " config\n", + ")) {\n", + " const recentMsg = event.messages[event.messages.length - 1];\n", + " console.log(`================================ ${recentMsg._getType()} Message (1) =================================`)\n", + " console.log(recentMsg.content);\n", "}" ] }, @@ -368,7 +461,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -381,12 +474,12 @@ "[\n", " {\n", " type: 'text',\n", - " text: \"Certainly! I can help you check the weather in San Francisco. To get this information, I'll need to use the weather tool. Let me do that for you right away.\"\n", + " text: 'Let me check the weather in San Francisco for you.'\n", " },\n", " {\n", " type: 'tool_use',\n", - " id: 'toolu_01PCbjHE6kxf7aXPTEFbkaZz',\n", - " name: 'get_weather',\n", + " id: 'toolu_01T7ykQ45XyGpzRB7MkPtSAE',\n", + " name: 'weather_search',\n", " input: { city: 'San Francisco' }\n", " }\n", "]\n" @@ -415,7 +508,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -435,63 +528,71 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "To edit the tool call, we first need to update the state. We can do this by passing a message in with the **same** id of the message we want to overwrite. This will have the effect of **replacing** that old message. Note that this is only possible because of the **reducer** we are using that replaces messages with the same ID." + "To edit the tool call, we will use `Command` with a different resume value of `{ action: \"update\", data: }`. This will do the following:\n", + "\n", + "* combine existing tool call with user-provided tool call arguments and update the existing AI message with the new tool call\n", + "* navigate to `run_tool` node with the updated AI message and continue execution" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Current Tool Call ID:\n", - "toolu_01PCbjHE6kxf7aXPTEFbkaZz\n", + "================================ ai Message (1) =================================\n", + "[\n", + " {\n", + " type: 'text',\n", + " text: 'Let me check the weather in San Francisco for you.'\n", + " },\n", + " {\n", + " type: 'tool_use',\n", + " id: 'toolu_01T7ykQ45XyGpzRB7MkPtSAE',\n", + " name: 'weather_search',\n", + " input: { city: 'San Francisco' }\n", + " }\n", + "]\n", + "================================ ai Message (1) =================================\n", + "[\n", + " {\n", + " type: 'text',\n", + " text: 'Let me check the weather in San Francisco for you.'\n", + " },\n", + " {\n", + " type: 'tool_use',\n", + " id: 'toolu_01T7ykQ45XyGpzRB7MkPtSAE',\n", + " name: 'weather_search',\n", + " input: { city: 'San Francisco' }\n", + " }\n", + "]\n", "----\n", - "Searching for: San Francisco, USA\n", + "Searching for: San Francisco\n", "----\n", "================================ tool Message (1) =================================\n", "Sunny!\n", "================================ ai Message (1) =================================\n", - "Great news! The current weather in San Francisco is sunny. It's a beautiful day in the city by the bay. Is there anything else you'd like to know about the weather or any other information I can help you with?\n" + "It's sunny in San Francisco right now!\n" ] } ], "source": [ - "console.log(\"Current Tool Call ID:\");\n", - "const currentContent = state.values[\"messages\"][state.values[\"messages\"].length-1].content;\n", - "const currrentID = state.values[\"messages\"][state.values[\"messages\"].length-1].id;\n", - "const toolCallID = state.values[\"messages\"][state.values[\"messages\"].length-1].tool_calls[0][\"id\"];\n", - "console.log(toolCallID);\n", - "\n", - "let newMessage = {\n", - " role: \"assistant\",\n", - " content: currentContent,\n", - " tool_calls: [\n", - " {\n", - " id: toolCallID,\n", - " name: \"get_weather\",\n", - " args: {\n", - " city: \"San Francisco, USA\"\n", - " }\n", + "for await (const event of await graph.stream(\n", + " new Command({\n", + " resume: {\n", + " action: \"update\",\n", + " data: { city: \"San Francisco\" }\n", " }\n", - " ],\n", - " id: currrentID\n", - "};\n", - "\n", - "// Update the state with the correct config, values, and specify the node we are acting as\n", - "await graph.updateState(config, { messages: [newMessage] }, \"human_review_node\");\n", - "\n", - "stream = await graph.stream(null, config);\n", - "\n", - "// Let's now continue executing from here\n", - "for await (const event of stream) {\n", - " const recentMsg = event.messages[event.messages.length - 1];\n", - " console.log(`================================ ${recentMsg._getType()} Message (1) =================================`)\n", - " console.log(recentMsg.content);\n", - "}" + " }),\n", + " config\n", + ")) {\n", + " const recentMsg = event.messages[event.messages.length - 1];\n", + " console.log(`================================ ${recentMsg._getType()} Message (1) =================================`)\n", + " console.log(recentMsg.content);\n", + "}\n" ] }, { @@ -514,7 +615,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 24, "metadata": {}, "outputs": [ { @@ -522,24 +623,18 @@ "output_type": "stream", "text": [ "================================ human Message (1) =================================\n", - "what's the weather in SF?\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "what's the weather in SF?\n", "================================ ai Message (1) =================================\n", "[\n", " {\n", " type: 'text',\n", - " text: \"Certainly! I can help you check the weather in San Francisco. To get this information, I'll need to use the weather tool available to me. Let me fetch that data for you.\"\n", + " text: \"I'll help you check the weather in San Francisco.\"\n", " },\n", " {\n", " type: 'tool_use',\n", - " id: 'toolu_01NMNPP7upggjzNqh8m2cKGm',\n", - " name: 'get_weather',\n", - " input: { city: 'San Francisco' }\n", + " id: 'toolu_014cwxD65wDwQdNg6xqsticF',\n", + " name: 'weather_search',\n", + " input: { city: 'SF' }\n", " }\n", "]\n" ] @@ -567,7 +662,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 25, "metadata": {}, "outputs": [ { @@ -587,47 +682,66 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "To give feedback about the tool call, we first need to update the state. We can do this by passing a message in with the same **tool call id** of the tool call we want to respond to. Note that this is a **different** ID from above." + "To give feedback about the tool call, we will use `Command` with a different resume value of `{ action: \"feedback\", data: }`. This will do the following:\n", + "\n", + "* create a new tool message that combines existing tool call from LLM with the with user-provided feedback as content\n", + "* navigate to `call_llm` node with the updated tool message and continue execution" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 26, "metadata": {}, "outputs": [ { - "name": "stderr", + "name": "stdout", "output_type": "stream", "text": [ - "8:5 - Type '{ role: string; name: string; content: string; tool_call_id: any; }' is not assignable to type '{ role: string; content: any; tool_calls: { id: any; name: string; args: { city: string; }; }[]; id: any; }'.\n", - "8:5 - Object literal may only specify known properties, and 'name' does not exist in type '{ role: string; content: any; tool_calls: { id: any; name: string; args: { city: string; }; }[]; id: any; }'.\n" + "================================ ai Message (1) =================================\n", + "[\n", + " {\n", + " type: 'text',\n", + " text: \"I'll help you check the weather in San Francisco.\"\n", + " },\n", + " {\n", + " type: 'tool_use',\n", + " id: 'toolu_014cwxD65wDwQdNg6xqsticF',\n", + " name: 'weather_search',\n", + " input: { city: 'SF' }\n", + " }\n", + "]\n", + "================================ tool Message (1) =================================\n", + "User requested changes: use format for location\n", + "================================ ai Message (1) =================================\n", + "[\n", + " {\n", + " type: 'text',\n", + " text: 'I apologize for the error. Let me search again with the proper format.'\n", + " },\n", + " {\n", + " type: 'tool_use',\n", + " id: 'toolu_01Jnm7sSZsiwv65YM4KsvfXk',\n", + " name: 'weather_search',\n", + " input: { city: 'San Francisco, USA' }\n", + " }\n", + "]\n" ] } ], "source": [ - "console.log(\"Current Tool Call ID:\");\n", - "const stateMessages = state.values.messages;\n", - "const toolCallId = stateMessages[stateMessages.length - 1].tool_calls[0].id;\n", - "console.log(toolCallId);\n", - "\n", - "const toolMessage = {\n", - " role: \"tool\",\n", - " name: \"get_weather\",\n", - " content: \"User requested changes: pass in the most likely country this city is referring to as well\",\n", - " tool_call_id: toolCallId,\n", - "};\n", - "\n", - "// Update the state with the correct config, values, and specify the node we are acting as\n", - "await graph.updateState(config, { messages: [toolMessage] }, \"human_review_node\");\n", - "\n", - "stream = await graph.stream(null, config);\n", - "\n", - "// Let's now continue executing from here\n", - "for await (const event of stream) {\n", - " const recentMsg = event.messages[event.messages.length - 1];\n", - " console.log(`================================ ${recentMsg._getType()} Message (1) =================================`)\n", - " console.log(recentMsg.content);\n", - "}" + "for await (const event of await graph.stream(\n", + " new Command({\n", + " resume: {\n", + " action: \"feedback\",\n", + " data: \"User requested changes: use format for location\"\n", + " }\n", + " }),\n", + " config\n", + ")) {\n", + " const recentMsg = event.messages[event.messages.length - 1];\n", + " console.log(`================================ ${recentMsg._getType()} Message (1) =================================`)\n", + " console.log(recentMsg.content);\n", + "}\n" ] }, { @@ -639,55 +753,63 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 'human_review_node' ]\n" + ] + } + ], + "source": [ + "state = await graph.getState(config);\n", + "console.log(state.next);\n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[ 'human_review_node' ]\n", "================================ ai Message (1) =================================\n", "[\n", " {\n", " type: 'text',\n", - " text: 'I apologize for the oversight. It seems the function requires more specific information. Let me try again with a more detailed request.'\n", + " text: 'I apologize for the error. Let me search again with the proper format.'\n", " },\n", " {\n", " type: 'tool_use',\n", - " id: 'toolu_01Q92V4EztnVv6qsUHABGP8V',\n", - " name: 'get_weather',\n", + " id: 'toolu_01Jnm7sSZsiwv65YM4KsvfXk',\n", + " name: 'weather_search',\n", " input: { city: 'San Francisco, USA' }\n", " }\n", "]\n", "----\n", "Searching for: San Francisco, USA\n", "----\n", - "[\n", - " ToolMessage {\n", - " \"content\": \"Sunny!\",\n", - " \"name\": \"get_weather\",\n", - " \"additional_kwargs\": {},\n", - " \"response_metadata\": {},\n", - " \"tool_call_id\": \"toolu_01Q92V4EztnVv6qsUHABGP8V\"\n", - " }\n", - "]\n", "================================ tool Message (1) =================================\n", "Sunny!\n", "================================ ai Message (1) =================================\n", - "Great news! Based on the information I've received, the weather in San Francisco, USA is currently sunny!\n", - "\n", - "Is there anything else you'd like to know about the weather in San Francisco or any other location?\n" + "The weather in San Francisco is currently sunny!\n" ] } ], "source": [ - "state = await graph.getState(config);\n", - "console.log(state.next);\n", - "\n", - "stream = await graph.stream(null, config);\n", - "\n", - "for await (const event of stream) {\n", + "for await (const event of await graph.stream(\n", + " new Command({\n", + " resume: {\n", + " action: \"continue\",\n", + " }\n", + " }),\n", + " config\n", + ")) {\n", " const recentMsg = event.messages[event.messages.length - 1];\n", " console.log(`================================ ${recentMsg._getType()} Message (1) =================================`)\n", " console.log(recentMsg.content);\n", diff --git a/examples/how-tos/time-travel.ipynb b/examples/how-tos/time-travel.ipynb index 3dc35e824..d10f7399a 100644 --- a/examples/how-tos/time-travel.ipynb +++ b/examples/how-tos/time-travel.ipynb @@ -7,6 +7,14 @@ "source": [ "# How to view and update past graph state\n", "\n", + "!!! tip \"Prerequisites\"\n", + "\n", + " This guide assumes familiarity with the following concepts:\n", + "\n", + " * [Time Travel](/langgraphjs/concepts/time-travel)\n", + " * [Breakpoints](/langgraphjs/concepts/breakpoints)\n", + " * [LangGraph Glossary](/langgraphjs/concepts/low_level)\n", + "\n", "Once you start [checkpointing](./persistence.ipynb) your graphs, you can easily\n", "**get** or **update** the state of the agent at any point in time. This permits\n", "a few things:\n", @@ -276,7 +284,7 @@ "const callModel = async (\n", " state: typeof StateAnnotation.State,\n", " config?: RunnableConfig,\n", - ") => {\n", + "): Promise> => {\n", " const { messages } = state;\n", " const response = await boundModel.invoke(messages, config);\n", " return { messages: [response] };\n", @@ -325,8 +333,9 @@ } ], "source": [ + "\n", "let config = { configurable: { thread_id: \"conversation-num-1\" } };\n", - "let inputs = { messages: [{ role: \"user\", content: \"Hi I'm Jo.\" }] };\n", + "let inputs = { messages: [{ role: \"user\", content: \"Hi I'm Jo.\" }] } as any;\n", "for await (\n", " const { messages } of await graph.stream(inputs, {\n", " ...config,\n", @@ -482,7 +491,7 @@ } ], "source": [ - "inputs = { messages: [{ role: \"user\", content: \"What's the weather like in SF currently?\" }] };\n", + "inputs = { messages: [{ role: \"user\", content: \"What's the weather like in SF currently?\" }] } as any;\n", "for await (\n", " const { messages } of await graph.stream(inputs, {\n", " ...config,\n", @@ -561,7 +570,7 @@ " interruptBefore: [\"tools\"],\n", "});\n", "\n", - "inputs = { messages: [{ role: \"user\", content: \"What's the weather like in SF currently?\" }] };\n", + "inputs = { messages: [{ role: \"user\", content: \"What's the weather like in SF currently?\" }] } as any;\n", "for await (\n", " const { messages } of await graphWithInterrupt.stream(inputs, {\n", " ...config,\n", diff --git a/examples/how-tos/wait-user-input.ipynb b/examples/how-tos/wait-user-input.ipynb index 9f8220215..a21e81251 100644 --- a/examples/how-tos/wait-user-input.ipynb +++ b/examples/how-tos/wait-user-input.ipynb @@ -12,9 +12,17 @@ "source": [ "# How to wait for user input\n", "\n", + "!!! tip \"Prerequisites\"\n", + "\n", + " This guide assumes familiarity with the following concepts:\n", + "\n", + " * [Human-in-the-loop](../../../concepts/human_in_the_loop)\n", + " * [Breakpoints](../../../concepts/breakpoints)\n", + " * [LangGraph Glossary](../../../concepts/low_level)\n", + "\n", "Human-in-the-loop (HIL) interactions are crucial for [agentic systems](/langgraphjs/concepts/agentic_concepts/#human-in-the-loop). Waiting for human input is a common HIL interaction pattern, allowing the agent to ask the user clarifying questions and await input before proceeding. \n", "\n", - "We can implement this in LangGraph using a [breakpoint](/langgraphjs/how-tos/human_in_the_loop/breakpoints/): breakpoints allow us to stop graph execution at a specific step. At this breakpoint, we can wait for human input. Once we have input from the user, we can add it to the graph state and proceed.\n", + "We can implement these in LangGraph using the [`interrupt()`](/langgraphjs/reference/functions/langgraph.interrupt-1.html) function. `interrupt` allows us to stop graph execution to collect input from a user and continue execution with collected input.\n", "\n", "![Screenshot 2024-07-08 at 5.26.26 PM.png](attachment:02ae42da-d1a4-4849-984a-6ab0bbf759bd.png)" ] @@ -53,46 +61,45 @@ "source": [ "## Simple Usage\n", "\n", - "Let's look at very basic usage of this. One intuitive approach is simply to create a node, `humanFeedback`, that will get user feedback. This allows us to place our feedback gathering at a specific, chosen point in our graph.\n", - " \n", - "1) We specify the [breakpoint](/langgraphjs/concepts/low_level/#breakpoints) using `interruptBefore` our `humanFeedback` node.\n", + "Let's explore a basic example of using human feedback. A straightforward approach is to create a node, **`human_feedback`**, designed specifically to collect user input. This allows us to gather feedback at a specific, chosen point in our graph.\n", "\n", - "2) We set up a [checkpointer](/langgraphjs/concepts/low_level/#checkpointer) to save the state of the graph up until this node.\n", + "Steps:\n", "\n", - "3) We use `.updateState()` to update the state of the graph with the human response we get.\n", - "\n", - "* We [use the `asNode` parameter](/langgraphjs/concepts/low_level/#update-state) to apply this state update as the specified node, `humanFeedback`.\n", - "* The graph will then resume execution as if the `humanFeedback` node just acted." + "1. **Call `interrupt()`** inside the **`human_feedback`** node. \n", + "2. We set up a [checkpointer](/langgraphjs/concepts/low_level/#persistence) to save the state of the graph up until this node.\n", + "3. **Use `new Command({ resume: ... })`** to provide the requested value to the **`human_feedback`** node and resume execution." ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 3, "id": "58eae42d-be32-48da-8d0a-ab64471657d9", "metadata": {}, "outputs": [], "source": [ - "import { StateGraph, Annotation, START, END } from \"@langchain/langgraph\";\n", - "import { MemorySaver } from \"@langchain/langgraph\";\n", + "import { StateGraph, Annotation, START, END, interrupt, MemorySaver } from \"@langchain/langgraph\";\n", "\n", "const StateAnnotation = Annotation.Root({\n", " input: Annotation,\n", " userFeedback: Annotation\n", "});\n", "\n", - "const step1 = (state: typeof StateAnnotation.State) => {\n", + "const step1 = (_state: typeof StateAnnotation.State) => {\n", " console.log(\"---Step 1---\");\n", - " return state;\n", + " return {};\n", "}\n", "\n", - "const humanFeedback = (state: typeof StateAnnotation.State) => {\n", + "const humanFeedback = (_state: typeof StateAnnotation.State) => {\n", " console.log(\"--- humanFeedback ---\");\n", - " return state;\n", + " const feedback: string = interrupt(\"Please provide feedback\");\n", + " return {\n", + " userFeedback: feedback\n", + " };\n", "}\n", "\n", - "const step3 = (state: typeof StateAnnotation.State) => {\n", + "const step3 = (_state: typeof StateAnnotation.State) => {\n", " console.log(\"---Step 3---\");\n", - " return state;\n", + " return {};\n", "}\n", "\n", "const builder = new StateGraph(StateAnnotation)\n", @@ -111,19 +118,18 @@ "// Add \n", "const graph = builder.compile({\n", " checkpointer: memory,\n", - " interruptBefore: [\"humanFeedback\"]\n", "});" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 4, "id": "9e990a56", "metadata": {}, "outputs": [ { "data": { - "image/png": "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" + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -149,7 +155,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 5, "id": "eb8e7d47-e7c9-4217-b72c-08394a2c4d3e", "metadata": {}, "outputs": [ @@ -159,7 +165,7 @@ "text": [ "--- hello world ---\n", "---Step 1---\n", - "--- hello world ---\n", + "--- humanFeedback ---\n", "--- GRAPH INTERRUPTED ---\n" ] } @@ -190,7 +196,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, "id": "2165a1bc-1c5b-411f-9e9c-a2b9627e5d56", "metadata": {}, "outputs": [ @@ -198,68 +204,29 @@ "name": "stdout", "output_type": "stream", "text": [ - "--- State after update ---\n", - "{\n", - " values: { input: 'hello world', userFeedback: 'Go to step 3!!' },\n", - " next: [ 'humanFeedback' ],\n", - " metadata: { source: 'update', step: 2, writes: { step1: [Object] } },\n", - " config: {\n", - " configurable: {\n", - " thread_id: '1',\n", - " checkpoint_id: '1ef5e8fb-89dd-6360-8002-5ff9e3c15c57'\n", - " }\n", - " },\n", - " createdAt: '2024-08-20T01:01:24.246Z',\n", - " parentConfig: undefined\n", - "}\n", - "[ 'humanFeedback' ]\n" - ] - } - ], - "source": [ - "// You should replace this with actual user input from a source, e.g stdin\n", - "const userInput = \"Go to step 3!!\";\n", - "\n", - "// We now update the state as if we are the humanFeedback node\n", - "await graph.updateState(config, { \"userFeedback\": userInput, asNode: \"humanFeedback\" });\n", - " \n", - "// We can check the state\n", - "console.log(\"--- State after update ---\")\n", - "console.log(await graph.getState(config));\n", - "\n", - "// We can check the next node, showing that it is node 3 (which follows human_feedback)\n", - "(await graph.getState(config)).next" - ] - }, - { - "cell_type": "markdown", - "id": "ccc4a84a-02f2-4b79-a5a5-22173645526d", - "metadata": {}, - "source": [ - "We can proceed after our breakpoint - " - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "3cca588f-e8d8-416b-aba7-0f3ae5e51598", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ + "{ input: 'hello world' }\n", + "\n", + "====\n", + "\n", "--- humanFeedback ---\n", - "--- hello world ---\n", - "---Step 3---\n", - "--- hello world ---\n" + "{ input: 'hello world', userFeedback: 'go to step 3! ' }\n", + "\n", + "====\n", + "\n", + "---Step 3---\n" ] } ], "source": [ + "import { Command } from \"@langchain/langgraph\";\n", + "\n", "// Continue the graph execution\n", - "for await (const event of await graph.stream(null, config)) {\n", - " console.log(`--- ${event.input} ---`);\n", + "for await (const event of await graph.stream(\n", + " new Command({ resume: \"go to step 3! \"}),\n", + " config,\n", + ")) {\n", + " console.log(event);\n", + " console.log(\"\\n====\\n\");\n", "}" ] }, @@ -273,7 +240,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "2b83e5ca-8497-43ca-bff7-7203e654c4d3", "metadata": {}, "outputs": [ @@ -281,7 +248,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "{ input: 'hello world', userFeedback: 'Go to step 3!!' }\n" + "{ input: 'hello world', userFeedback: 'go to step 3! ' }\n" ] } ], @@ -305,7 +272,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 11, "id": "f5319e01", "metadata": {}, "outputs": [], @@ -313,18 +280,11 @@ "// Set up the tool\n", "import { ChatAnthropic } from \"@langchain/anthropic\";\n", "import { tool } from \"@langchain/core/tools\";\n", - "import { StateGraph, Annotation, START, END, messagesStateReducer } from \"@langchain/langgraph\";\n", - "import { MemorySaver } from \"@langchain/langgraph\";\n", + "import { StateGraph, MessagesAnnotation, START, END, MemorySaver } from \"@langchain/langgraph\";\n", "import { ToolNode } from \"@langchain/langgraph/prebuilt\";\n", - "import { BaseMessage, AIMessage } from \"@langchain/core/messages\";\n", + "import { AIMessage, ToolMessage } from \"@langchain/core/messages\";\n", "import { z } from \"zod\";\n", "\n", - "const GraphMessagesAnnotation = Annotation.Root({\n", - " messages: Annotation({\n", - " reducer: messagesStateReducer,\n", - " }),\n", - "});\n", - "\n", "const search = tool((_) => {\n", " return \"It's sunny in San Francisco, but you better look out if you're a Gemini 😈.\";\n", "}, {\n", @@ -334,7 +294,7 @@ "})\n", "\n", "const tools = [search]\n", - "const toolNode = new ToolNode(tools)\n", + "const toolNode = new ToolNode(tools)\n", "\n", "// Set up the model\n", "const model = new ChatAnthropic({ model: \"claude-3-5-sonnet-20240620\" })\n", @@ -353,7 +313,7 @@ "// Define nodes and conditional edges\n", "\n", "// Define the function that determines whether to continue or not\n", - "function shouldContinue(state: typeof GraphMessagesAnnotation.State): \"action\" | \"askHuman\" | typeof END {\n", + "function shouldContinue(state: typeof MessagesAnnotation.State): \"action\" | \"askHuman\" | typeof END {\n", " const lastMessage = state.messages[state.messages.length - 1];\n", " const castLastMessage = lastMessage as AIMessage;\n", " // If there is no function call, then we finish\n", @@ -373,7 +333,7 @@ "\n", "\n", "// Define the function that calls the model\n", - "async function callModel(state: typeof GraphMessagesAnnotation.State): Promise> {\n", + "async function callModel(state: typeof MessagesAnnotation.State): Promise> {\n", " const messages = state.messages;\n", " const response = await modelWithTools.invoke(messages);\n", " // We return an object with a messages property, because this will get added to the existing list\n", @@ -382,12 +342,18 @@ "\n", "\n", "// We define a fake node to ask the human\n", - "function askHuman(state: typeof GraphMessagesAnnotation.State): Partial {\n", - " return state;\n", + "function askHuman(state: typeof MessagesAnnotation.State): Partial {\n", + " const toolCallId = (state.messages[state.messages.length - 1] as AIMessage).tool_calls[0].id;\n", + " const location: string = interrupt(\"Please provide your location:\");\n", + " const newToolMessage = new ToolMessage({\n", + " tool_call_id: toolCallId,\n", + " content: location,\n", + " })\n", + " return { messages: [newToolMessage] };\n", "}\n", "\n", "// Define a new graph\n", - "const messagesWorkflow = new StateGraph(GraphMessagesAnnotation)\n", + "const messagesWorkflow = new StateGraph(MessagesAnnotation)\n", " // Define the two nodes we will cycle between\n", " .addNode(\"agent\", callModel)\n", " .addNode(\"action\", toolNode)\n", @@ -418,19 +384,18 @@ "// meaning you can use it as you would any other runnable\n", "const messagesApp = messagesWorkflow.compile({\n", " checkpointer: messagesMemory,\n", - " interruptBefore: [\"askHuman\"]\n", "});" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 12, "id": "4b816850", "metadata": {}, "outputs": [ { "data": { - "image/png": "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" + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -460,7 +425,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 13, "id": "cfd140f0-a5a6-4697-8115-322242f197b5", "metadata": {}, "outputs": [ @@ -475,15 +440,13 @@ "[\n", " {\n", " type: 'text',\n", - " text: \"Certainly! I'll use the askHuman tool to ask the user about their location, and then use the search tool to look up the weather for that location. Let's start by asking the user where they are.\"\n", + " text: \"Certainly! I'll use the askHuman tool to ask the user about their location, and then I'll use the search tool to look up the weather for that location. Let's start by asking the user where they are.\"\n", " },\n", " {\n", " type: 'tool_use',\n", - " id: 'toolu_01RN181HAAL5BcnMXkexbA1r',\n", + " id: 'toolu_01VG19hoPDUqsHuAk6Jp2L8J',\n", " name: 'askHuman',\n", - " input: {\n", - " input: 'Where are you located? Please provide your city and country.'\n", - " }\n", + " input: { input: 'Where are you currently located?' }\n", " }\n", "]\n", "next: [ 'askHuman' ]\n" @@ -509,73 +472,36 @@ "console.log(\"next: \", (await messagesApp.getState(config2)).next)" ] }, - { - "cell_type": "markdown", - "id": "cc168c90-a374-4280-a9a6-8bc232dbb006", - "metadata": {}, - "source": [ - "We now want to update this thread with a response from the user. We then can kick off another run. \n", - "\n", - "Because we are treating this as a tool call, we will need to update the state as if it is a response from a tool call. In order to do this, we will need to check the state to get the ID of the tool call." - ] - }, { "cell_type": "code", - "execution_count": 4, - "id": "63598092-d565-4170-9773-e092d345f8c1", + "execution_count": 15, + "id": "ea9a777b", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "next before update state: [ 'askHuman' ]\n", - "next AFTER update state: [ 'agent' ]\n" + "[ 'askHuman' ]\n" ] } ], "source": [ - "import { ToolMessage } from \"@langchain/core/messages\";\n", - "\n", - "const currentState = await messagesApp.getState(config2);\n", - "\n", - "const toolCallId = currentState.values.messages[currentState.values.messages.length - 1].tool_calls[0].id;\n", - "\n", - "// We now create the tool call with the id and the response we want\n", - "const toolMessage = new ToolMessage({\n", - " tool_call_id: toolCallId,\n", - " content: \"san francisco\"\n", - "});\n", - "\n", - "console.log(\"next before update state: \", (await messagesApp.getState(config2)).next)\n", - "\n", - "// We now update the state\n", - "// Notice that we are also specifying `asNode: \"askHuman\"`\n", - "// This will apply this update as this node,\n", - "// which will make it so that afterwards it continues as normal\n", - "await messagesApp.updateState(config2, { messages: [toolMessage] }, \"askHuman\");\n", - "\n", - "// We can check the state\n", - "// We can see that the state currently has the `agent` node next\n", - "// This is based on how we define our graph,\n", - "// where after the `askHuman` node goes (which we just triggered)\n", - "// there is an edge to the `agent` node\n", - "console.log(\"next AFTER update state: \", (await messagesApp.getState(config2)).next)\n", - "// await messagesApp.getState(config)" + "console.log((await messagesApp.getState(config2)).next)" ] }, { "cell_type": "markdown", - "id": "6a30c9fb-2a40-45cc-87ba-406c11c9f0cf", + "id": "cc168c90-a374-4280-a9a6-8bc232dbb006", "metadata": {}, "source": [ - "We can now tell the agent to continue. We can just pass in `None` as the input to the graph, since no additional input is needed" + "You can see that our graph got interrupted inside the `askHuman` node, which is now waiting for a `location` to be provided. We can provide this value by invoking the graph with a `new Command({ resume: \"\" })` input:" ] }, { "cell_type": "code", - "execution_count": 5, - "id": "a9f599b5-1a55-406b-a76b-f52b3ca06975", + "execution_count": 17, + "id": "63598092-d565-4170-9773-e092d345f8c1", "metadata": {}, "outputs": [ { @@ -585,29 +511,29 @@ "{\n", " messages: [\n", " HumanMessage {\n", - " \"id\": \"a80d5763-0f27-4a00-9e54-8a239b499ea1\",\n", + " \"id\": \"ae6dcdd1-1671-46fd-9a58-ae7a6720a4fe\",\n", " \"content\": \"Use the search tool to ask the user where they are, then look up the weather there\",\n", " \"additional_kwargs\": {},\n", " \"response_metadata\": {}\n", " },\n", " AIMessage {\n", - " \"id\": \"msg_01CsrDn46VqNXrdkpVHbcMKA\",\n", + " \"id\": \"msg_01BhcZosXt3R48jjrLJzuFmq\",\n", " \"content\": [\n", " {\n", " \"type\": \"text\",\n", - " \"text\": \"Certainly! I'll use the askHuman tool to ask the user about their location, and then use the search tool to look up the weather for that location. Let's start by asking the user where they are.\"\n", + " \"text\": \"Certainly! I'll use the askHuman tool to ask the user about their location, and then I'll use the search tool to look up the weather for that location. Let's start by asking the user where they are.\"\n", " },\n", " {\n", " \"type\": \"tool_use\",\n", - " \"id\": \"toolu_01RN181HAAL5BcnMXkexbA1r\",\n", + " \"id\": \"toolu_01VG19hoPDUqsHuAk6Jp2L8J\",\n", " \"name\": \"askHuman\",\n", " \"input\": {\n", - " \"input\": \"Where are you located? Please provide your city and country.\"\n", + " \"input\": \"Where are you currently located?\"\n", " }\n", " }\n", " ],\n", " \"additional_kwargs\": {\n", - " \"id\": \"msg_01CsrDn46VqNXrdkpVHbcMKA\",\n", + " \"id\": \"msg_01BhcZosXt3R48jjrLJzuFmq\",\n", " \"type\": \"message\",\n", " \"role\": \"assistant\",\n", " \"model\": \"claude-3-5-sonnet-20240620\",\n", @@ -615,17 +541,17 @@ " \"stop_sequence\": null,\n", " \"usage\": {\n", " \"input_tokens\": 465,\n", - " \"output_tokens\": 108\n", + " \"output_tokens\": 106\n", " }\n", " },\n", " \"response_metadata\": {\n", - " \"id\": \"msg_01CsrDn46VqNXrdkpVHbcMKA\",\n", + " \"id\": \"msg_01BhcZosXt3R48jjrLJzuFmq\",\n", " \"model\": \"claude-3-5-sonnet-20240620\",\n", " \"stop_reason\": \"tool_use\",\n", " \"stop_sequence\": null,\n", " \"usage\": {\n", " \"input_tokens\": 465,\n", - " \"output_tokens\": 108\n", + " \"output_tokens\": 106\n", " },\n", " \"type\": \"message\",\n", " \"role\": \"assistant\"\n", @@ -634,31 +560,168 @@ " {\n", " \"name\": \"askHuman\",\n", " \"args\": {\n", - " \"input\": \"Where are you located? Please provide your city and country.\"\n", + " \"input\": \"Where are you currently located?\"\n", " },\n", - " \"id\": \"toolu_01RN181HAAL5BcnMXkexbA1r\",\n", + " \"id\": \"toolu_01VG19hoPDUqsHuAk6Jp2L8J\",\n", + " \"type\": \"tool_call\"\n", + " }\n", + " ],\n", + " \"invalid_tool_calls\": []\n", + " }\n", + " ]\n", + "}\n", + "\n", + "====\n", + "\n", + "{\n", + " messages: [\n", + " HumanMessage {\n", + " \"id\": \"ae6dcdd1-1671-46fd-9a58-ae7a6720a4fe\",\n", + " \"content\": \"Use the search tool to ask the user where they are, then look up the weather there\",\n", + " \"additional_kwargs\": {},\n", + " \"response_metadata\": {}\n", + " },\n", + " AIMessage {\n", + " \"id\": \"msg_01BhcZosXt3R48jjrLJzuFmq\",\n", + " \"content\": [\n", + " {\n", + " \"type\": \"text\",\n", + " \"text\": \"Certainly! I'll use the askHuman tool to ask the user about their location, and then I'll use the search tool to look up the weather for that location. Let's start by asking the user where they are.\"\n", + " },\n", + " {\n", + " \"type\": \"tool_use\",\n", + " \"id\": \"toolu_01VG19hoPDUqsHuAk6Jp2L8J\",\n", + " \"name\": \"askHuman\",\n", + " \"input\": {\n", + " \"input\": \"Where are you currently located?\"\n", + " }\n", + " }\n", + " ],\n", + " \"additional_kwargs\": {\n", + " \"id\": \"msg_01BhcZosXt3R48jjrLJzuFmq\",\n", + " \"type\": \"message\",\n", + " \"role\": \"assistant\",\n", + " \"model\": \"claude-3-5-sonnet-20240620\",\n", + " \"stop_reason\": \"tool_use\",\n", + " \"stop_sequence\": null,\n", + " \"usage\": {\n", + " \"input_tokens\": 465,\n", + " \"output_tokens\": 106\n", + " }\n", + " },\n", + " \"response_metadata\": {\n", + " \"id\": \"msg_01BhcZosXt3R48jjrLJzuFmq\",\n", + " \"model\": \"claude-3-5-sonnet-20240620\",\n", + " \"stop_reason\": \"tool_use\",\n", + " \"stop_sequence\": null,\n", + " \"usage\": {\n", + " \"input_tokens\": 465,\n", + " \"output_tokens\": 106\n", + " },\n", + " \"type\": \"message\",\n", + " \"role\": \"assistant\"\n", + " },\n", + " \"tool_calls\": [\n", + " {\n", + " \"name\": \"askHuman\",\n", + " \"args\": {\n", + " \"input\": \"Where are you currently located?\"\n", + " },\n", + " \"id\": \"toolu_01VG19hoPDUqsHuAk6Jp2L8J\",\n", + " \"type\": \"tool_call\"\n", + " }\n", + " ],\n", + " \"invalid_tool_calls\": []\n", + " },\n", + " ToolMessage {\n", + " \"id\": \"2c38a43c-7aef-4765-9ddb-5ff202a817f9\",\n", + " \"content\": \"San Francisco\",\n", + " \"additional_kwargs\": {},\n", + " \"response_metadata\": {},\n", + " \"tool_call_id\": \"toolu_01VG19hoPDUqsHuAk6Jp2L8J\"\n", + " }\n", + " ]\n", + "}\n", + "\n", + "====\n", + "\n", + "{\n", + " messages: [\n", + " HumanMessage {\n", + " \"id\": \"ae6dcdd1-1671-46fd-9a58-ae7a6720a4fe\",\n", + " \"content\": \"Use the search tool to ask the user where they are, then look up the weather there\",\n", + " \"additional_kwargs\": {},\n", + " \"response_metadata\": {}\n", + " },\n", + " AIMessage {\n", + " \"id\": \"msg_01BhcZosXt3R48jjrLJzuFmq\",\n", + " \"content\": [\n", + " {\n", + " \"type\": \"text\",\n", + " \"text\": \"Certainly! I'll use the askHuman tool to ask the user about their location, and then I'll use the search tool to look up the weather for that location. Let's start by asking the user where they are.\"\n", + " },\n", + " {\n", + " \"type\": \"tool_use\",\n", + " \"id\": \"toolu_01VG19hoPDUqsHuAk6Jp2L8J\",\n", + " \"name\": \"askHuman\",\n", + " \"input\": {\n", + " \"input\": \"Where are you currently located?\"\n", + " }\n", + " }\n", + " ],\n", + " \"additional_kwargs\": {\n", + " \"id\": \"msg_01BhcZosXt3R48jjrLJzuFmq\",\n", + " \"type\": \"message\",\n", + " \"role\": \"assistant\",\n", + " \"model\": \"claude-3-5-sonnet-20240620\",\n", + " \"stop_reason\": \"tool_use\",\n", + " \"stop_sequence\": null,\n", + " \"usage\": {\n", + " \"input_tokens\": 465,\n", + " \"output_tokens\": 106\n", + " }\n", + " },\n", + " \"response_metadata\": {\n", + " \"id\": \"msg_01BhcZosXt3R48jjrLJzuFmq\",\n", + " \"model\": \"claude-3-5-sonnet-20240620\",\n", + " \"stop_reason\": \"tool_use\",\n", + " \"stop_sequence\": null,\n", + " \"usage\": {\n", + " \"input_tokens\": 465,\n", + " \"output_tokens\": 106\n", + " },\n", + " \"type\": \"message\",\n", + " \"role\": \"assistant\"\n", + " },\n", + " \"tool_calls\": [\n", + " {\n", + " \"name\": \"askHuman\",\n", + " \"args\": {\n", + " \"input\": \"Where are you currently located?\"\n", + " },\n", + " \"id\": \"toolu_01VG19hoPDUqsHuAk6Jp2L8J\",\n", " \"type\": \"tool_call\"\n", " }\n", " ],\n", " \"invalid_tool_calls\": []\n", " },\n", " ToolMessage {\n", - " \"id\": \"9159f841-0e15-4366-96a9-cc5ee0662da0\",\n", - " \"content\": \"san francisco\",\n", + " \"id\": \"2c38a43c-7aef-4765-9ddb-5ff202a817f9\",\n", + " \"content\": \"San Francisco\",\n", " \"additional_kwargs\": {},\n", " \"response_metadata\": {},\n", - " \"tool_call_id\": \"toolu_01RN181HAAL5BcnMXkexbA1r\"\n", + " \"tool_call_id\": \"toolu_01VG19hoPDUqsHuAk6Jp2L8J\"\n", " },\n", " AIMessage {\n", - " \"id\": \"msg_017hfZ8kdhX5nKD97THKWpPx\",\n", + " \"id\": \"msg_01R9CcAiHwyvcPLadSnjVe4R\",\n", " \"content\": [\n", " {\n", " \"type\": \"text\",\n", - " \"text\": \"Thank you for providing your location. Now, I'll use the search tool to look up the weather in San Francisco.\"\n", + " \"text\": \"Thank you for letting me know that you're in San Francisco. Now, I'll use the search tool to look up the weather in San Francisco for you.\"\n", " },\n", " {\n", " \"type\": \"tool_use\",\n", - " \"id\": \"toolu_01QCcxzRjojWW5JqQp7WTN82\",\n", + " \"id\": \"toolu_018ZKbrzSuYYDgcUTFH6vj9v\",\n", " \"name\": \"search\",\n", " \"input\": {\n", " \"input\": \"current weather in San Francisco\"\n", @@ -666,25 +729,25 @@ " }\n", " ],\n", " \"additional_kwargs\": {\n", - " \"id\": \"msg_017hfZ8kdhX5nKD97THKWpPx\",\n", + " \"id\": \"msg_01R9CcAiHwyvcPLadSnjVe4R\",\n", " \"type\": \"message\",\n", " \"role\": \"assistant\",\n", " \"model\": \"claude-3-5-sonnet-20240620\",\n", " \"stop_reason\": \"tool_use\",\n", " \"stop_sequence\": null,\n", " \"usage\": {\n", - " \"input_tokens\": 587,\n", - " \"output_tokens\": 81\n", + " \"input_tokens\": 584,\n", + " \"output_tokens\": 89\n", " }\n", " },\n", " \"response_metadata\": {\n", - " \"id\": \"msg_017hfZ8kdhX5nKD97THKWpPx\",\n", + " \"id\": \"msg_01R9CcAiHwyvcPLadSnjVe4R\",\n", " \"model\": \"claude-3-5-sonnet-20240620\",\n", " \"stop_reason\": \"tool_use\",\n", " \"stop_sequence\": null,\n", " \"usage\": {\n", - " \"input_tokens\": 587,\n", - " \"output_tokens\": 81\n", + " \"input_tokens\": 584,\n", + " \"output_tokens\": 89\n", " },\n", " \"type\": \"message\",\n", " \"role\": \"assistant\"\n", @@ -695,58 +758,48 @@ " \"args\": {\n", " \"input\": \"current weather in San Francisco\"\n", " },\n", - " \"id\": \"toolu_01QCcxzRjojWW5JqQp7WTN82\",\n", + " \"id\": \"toolu_018ZKbrzSuYYDgcUTFH6vj9v\",\n", " \"type\": \"tool_call\"\n", " }\n", " ],\n", " \"invalid_tool_calls\": [],\n", " \"usage_metadata\": {\n", - " \"input_tokens\": 587,\n", - " \"output_tokens\": 81,\n", - " \"total_tokens\": 668\n", + " \"input_tokens\": 584,\n", + " \"output_tokens\": 89,\n", + " \"total_tokens\": 673\n", " }\n", " }\n", " ]\n", "}\n", - "================================ ai Message (1) =================================\n", - "[\n", - " {\n", - " type: 'text',\n", - " text: \"Thank you for providing your location. Now, I'll use the search tool to look up the weather in San Francisco.\"\n", - " },\n", - " {\n", - " type: 'tool_use',\n", - " id: 'toolu_01QCcxzRjojWW5JqQp7WTN82',\n", - " name: 'search',\n", - " input: { input: 'current weather in San Francisco' }\n", - " }\n", - "]\n", + "\n", + "====\n", + "\n", "{\n", " messages: [\n", " HumanMessage {\n", - " \"id\": \"a80d5763-0f27-4a00-9e54-8a239b499ea1\",\n", + " \"id\": \"ae6dcdd1-1671-46fd-9a58-ae7a6720a4fe\",\n", " \"content\": \"Use the search tool to ask the user where they are, then look up the weather there\",\n", " \"additional_kwargs\": {},\n", " \"response_metadata\": {}\n", " },\n", " AIMessage {\n", - " \"id\": \"msg_01CsrDn46VqNXrdkpVHbcMKA\",\n", + " \"id\": \"msg_01BhcZosXt3R48jjrLJzuFmq\",\n", " \"content\": [\n", " {\n", " \"type\": \"text\",\n", - " \"text\": \"Certainly! I'll use the askHuman tool to ask the user about their location, and then use the search tool to look up the weather for that location. Let's start by asking the user where they are.\"\n", + " \"text\": \"Certainly! I'll use the askHuman tool to ask the user about their location, and then I'll use the search tool to look up the weather for that location. Let's start by asking the user where they are.\"\n", " },\n", " {\n", " \"type\": \"tool_use\",\n", - " \"id\": \"toolu_01RN181HAAL5BcnMXkexbA1r\",\n", + " \"id\": \"toolu_01VG19hoPDUqsHuAk6Jp2L8J\",\n", " \"name\": \"askHuman\",\n", " \"input\": {\n", - " \"input\": \"Where are you located? Please provide your city and country.\"\n", + " \"input\": \"Where are you currently located?\"\n", " }\n", " }\n", " ],\n", " \"additional_kwargs\": {\n", - " \"id\": \"msg_01CsrDn46VqNXrdkpVHbcMKA\",\n", + " \"id\": \"msg_01BhcZosXt3R48jjrLJzuFmq\",\n", " \"type\": \"message\",\n", " \"role\": \"assistant\",\n", " \"model\": \"claude-3-5-sonnet-20240620\",\n", @@ -754,17 +807,17 @@ " \"stop_sequence\": null,\n", " \"usage\": {\n", " \"input_tokens\": 465,\n", - " \"output_tokens\": 108\n", + " \"output_tokens\": 106\n", " }\n", " },\n", " \"response_metadata\": {\n", - " \"id\": \"msg_01CsrDn46VqNXrdkpVHbcMKA\",\n", + " \"id\": \"msg_01BhcZosXt3R48jjrLJzuFmq\",\n", " \"model\": \"claude-3-5-sonnet-20240620\",\n", " \"stop_reason\": \"tool_use\",\n", " \"stop_sequence\": null,\n", " \"usage\": {\n", " \"input_tokens\": 465,\n", - " \"output_tokens\": 108\n", + " \"output_tokens\": 106\n", " },\n", " \"type\": \"message\",\n", " \"role\": \"assistant\"\n", @@ -773,31 +826,31 @@ " {\n", " \"name\": \"askHuman\",\n", " \"args\": {\n", - " \"input\": \"Where are you located? Please provide your city and country.\"\n", + " \"input\": \"Where are you currently located?\"\n", " },\n", - " \"id\": \"toolu_01RN181HAAL5BcnMXkexbA1r\",\n", + " \"id\": \"toolu_01VG19hoPDUqsHuAk6Jp2L8J\",\n", " \"type\": \"tool_call\"\n", " }\n", " ],\n", " \"invalid_tool_calls\": []\n", " },\n", " ToolMessage {\n", - " \"id\": \"9159f841-0e15-4366-96a9-cc5ee0662da0\",\n", - " \"content\": \"san francisco\",\n", + " \"id\": \"2c38a43c-7aef-4765-9ddb-5ff202a817f9\",\n", + " \"content\": \"San Francisco\",\n", " \"additional_kwargs\": {},\n", " \"response_metadata\": {},\n", - " \"tool_call_id\": \"toolu_01RN181HAAL5BcnMXkexbA1r\"\n", + " \"tool_call_id\": \"toolu_01VG19hoPDUqsHuAk6Jp2L8J\"\n", " },\n", " AIMessage {\n", - " \"id\": \"msg_017hfZ8kdhX5nKD97THKWpPx\",\n", + " \"id\": \"msg_01R9CcAiHwyvcPLadSnjVe4R\",\n", " \"content\": [\n", " {\n", " \"type\": \"text\",\n", - " \"text\": \"Thank you for providing your location. Now, I'll use the search tool to look up the weather in San Francisco.\"\n", + " \"text\": \"Thank you for letting me know that you're in San Francisco. Now, I'll use the search tool to look up the weather in San Francisco for you.\"\n", " },\n", " {\n", " \"type\": \"tool_use\",\n", - " \"id\": \"toolu_01QCcxzRjojWW5JqQp7WTN82\",\n", + " \"id\": \"toolu_018ZKbrzSuYYDgcUTFH6vj9v\",\n", " \"name\": \"search\",\n", " \"input\": {\n", " \"input\": \"current weather in San Francisco\"\n", @@ -805,25 +858,25 @@ " }\n", " ],\n", " \"additional_kwargs\": {\n", - " \"id\": \"msg_017hfZ8kdhX5nKD97THKWpPx\",\n", + " \"id\": \"msg_01R9CcAiHwyvcPLadSnjVe4R\",\n", " \"type\": \"message\",\n", " \"role\": \"assistant\",\n", " \"model\": \"claude-3-5-sonnet-20240620\",\n", " \"stop_reason\": \"tool_use\",\n", " \"stop_sequence\": null,\n", " \"usage\": {\n", - " \"input_tokens\": 587,\n", - " \"output_tokens\": 81\n", + " \"input_tokens\": 584,\n", + " \"output_tokens\": 89\n", " }\n", " },\n", " \"response_metadata\": {\n", - " \"id\": \"msg_017hfZ8kdhX5nKD97THKWpPx\",\n", + " \"id\": \"msg_01R9CcAiHwyvcPLadSnjVe4R\",\n", " \"model\": \"claude-3-5-sonnet-20240620\",\n", " \"stop_reason\": \"tool_use\",\n", " \"stop_sequence\": null,\n", " \"usage\": {\n", - " \"input_tokens\": 587,\n", - " \"output_tokens\": 81\n", + " \"input_tokens\": 584,\n", + " \"output_tokens\": 89\n", " },\n", " \"type\": \"message\",\n", " \"role\": \"assistant\"\n", @@ -834,58 +887,56 @@ " \"args\": {\n", " \"input\": \"current weather in San Francisco\"\n", " },\n", - " \"id\": \"toolu_01QCcxzRjojWW5JqQp7WTN82\",\n", + " \"id\": \"toolu_018ZKbrzSuYYDgcUTFH6vj9v\",\n", " \"type\": \"tool_call\"\n", " }\n", " ],\n", " \"invalid_tool_calls\": [],\n", " \"usage_metadata\": {\n", - " \"input_tokens\": 587,\n", - " \"output_tokens\": 81,\n", - " \"total_tokens\": 668\n", + " \"input_tokens\": 584,\n", + " \"output_tokens\": 89,\n", + " \"total_tokens\": 673\n", " }\n", " },\n", " ToolMessage {\n", - " \"id\": \"0bf52bcd-ffbd-4f82-9ee1-7ba2108f0d27\",\n", + " \"id\": \"149f5ca7-db60-425c-a903-2b163ca8480e\",\n", " \"content\": \"It's sunny in San Francisco, but you better look out if you're a Gemini 😈.\",\n", " \"name\": \"search\",\n", " \"additional_kwargs\": {},\n", " \"response_metadata\": {},\n", - " \"tool_call_id\": \"toolu_01QCcxzRjojWW5JqQp7WTN82\"\n", + " \"tool_call_id\": \"toolu_018ZKbrzSuYYDgcUTFH6vj9v\"\n", " }\n", " ]\n", "}\n", - "================================ tool Message (1) =================================\n", - "{\n", - " name: 'search',\n", - " content: \"It's sunny in San Francisco, but you better look out if you're a Gemini 😈.\"\n", - "}\n", + "\n", + "====\n", + "\n", "{\n", " messages: [\n", " HumanMessage {\n", - " \"id\": \"a80d5763-0f27-4a00-9e54-8a239b499ea1\",\n", + " \"id\": \"ae6dcdd1-1671-46fd-9a58-ae7a6720a4fe\",\n", " \"content\": \"Use the search tool to ask the user where they are, then look up the weather there\",\n", " \"additional_kwargs\": {},\n", " \"response_metadata\": {}\n", " },\n", " AIMessage {\n", - " \"id\": \"msg_01CsrDn46VqNXrdkpVHbcMKA\",\n", + " \"id\": \"msg_01BhcZosXt3R48jjrLJzuFmq\",\n", " \"content\": [\n", " {\n", " \"type\": \"text\",\n", - " \"text\": \"Certainly! I'll use the askHuman tool to ask the user about their location, and then use the search tool to look up the weather for that location. Let's start by asking the user where they are.\"\n", + " \"text\": \"Certainly! I'll use the askHuman tool to ask the user about their location, and then I'll use the search tool to look up the weather for that location. Let's start by asking the user where they are.\"\n", " },\n", " {\n", " \"type\": \"tool_use\",\n", - " \"id\": \"toolu_01RN181HAAL5BcnMXkexbA1r\",\n", + " \"id\": \"toolu_01VG19hoPDUqsHuAk6Jp2L8J\",\n", " \"name\": \"askHuman\",\n", " \"input\": {\n", - " \"input\": \"Where are you located? Please provide your city and country.\"\n", + " \"input\": \"Where are you currently located?\"\n", " }\n", " }\n", " ],\n", " \"additional_kwargs\": {\n", - " \"id\": \"msg_01CsrDn46VqNXrdkpVHbcMKA\",\n", + " \"id\": \"msg_01BhcZosXt3R48jjrLJzuFmq\",\n", " \"type\": \"message\",\n", " \"role\": \"assistant\",\n", " \"model\": \"claude-3-5-sonnet-20240620\",\n", @@ -893,17 +944,17 @@ " \"stop_sequence\": null,\n", " \"usage\": {\n", " \"input_tokens\": 465,\n", - " \"output_tokens\": 108\n", + " \"output_tokens\": 106\n", " }\n", " },\n", " \"response_metadata\": {\n", - " \"id\": \"msg_01CsrDn46VqNXrdkpVHbcMKA\",\n", + " \"id\": \"msg_01BhcZosXt3R48jjrLJzuFmq\",\n", " \"model\": \"claude-3-5-sonnet-20240620\",\n", " \"stop_reason\": \"tool_use\",\n", " \"stop_sequence\": null,\n", " \"usage\": {\n", " \"input_tokens\": 465,\n", - " \"output_tokens\": 108\n", + " \"output_tokens\": 106\n", " },\n", " \"type\": \"message\",\n", " \"role\": \"assistant\"\n", @@ -912,31 +963,31 @@ " {\n", " \"name\": \"askHuman\",\n", " \"args\": {\n", - " \"input\": \"Where are you located? Please provide your city and country.\"\n", + " \"input\": \"Where are you currently located?\"\n", " },\n", - " \"id\": \"toolu_01RN181HAAL5BcnMXkexbA1r\",\n", + " \"id\": \"toolu_01VG19hoPDUqsHuAk6Jp2L8J\",\n", " \"type\": \"tool_call\"\n", " }\n", " ],\n", " \"invalid_tool_calls\": []\n", " },\n", " ToolMessage {\n", - " \"id\": \"9159f841-0e15-4366-96a9-cc5ee0662da0\",\n", - " \"content\": \"san francisco\",\n", + " \"id\": \"2c38a43c-7aef-4765-9ddb-5ff202a817f9\",\n", + " \"content\": \"San Francisco\",\n", " \"additional_kwargs\": {},\n", " \"response_metadata\": {},\n", - " \"tool_call_id\": \"toolu_01RN181HAAL5BcnMXkexbA1r\"\n", + " \"tool_call_id\": \"toolu_01VG19hoPDUqsHuAk6Jp2L8J\"\n", " },\n", " AIMessage {\n", - " \"id\": \"msg_017hfZ8kdhX5nKD97THKWpPx\",\n", + " \"id\": \"msg_01R9CcAiHwyvcPLadSnjVe4R\",\n", " \"content\": [\n", " {\n", " \"type\": \"text\",\n", - " \"text\": \"Thank you for providing your location. Now, I'll use the search tool to look up the weather in San Francisco.\"\n", + " \"text\": \"Thank you for letting me know that you're in San Francisco. Now, I'll use the search tool to look up the weather in San Francisco for you.\"\n", " },\n", " {\n", " \"type\": \"tool_use\",\n", - " \"id\": \"toolu_01QCcxzRjojWW5JqQp7WTN82\",\n", + " \"id\": \"toolu_018ZKbrzSuYYDgcUTFH6vj9v\",\n", " \"name\": \"search\",\n", " \"input\": {\n", " \"input\": \"current weather in San Francisco\"\n", @@ -944,25 +995,25 @@ " }\n", " ],\n", " \"additional_kwargs\": {\n", - " \"id\": \"msg_017hfZ8kdhX5nKD97THKWpPx\",\n", + " \"id\": \"msg_01R9CcAiHwyvcPLadSnjVe4R\",\n", " \"type\": \"message\",\n", " \"role\": \"assistant\",\n", " \"model\": \"claude-3-5-sonnet-20240620\",\n", " \"stop_reason\": \"tool_use\",\n", " \"stop_sequence\": null,\n", " \"usage\": {\n", - " \"input_tokens\": 587,\n", - " \"output_tokens\": 81\n", + " \"input_tokens\": 584,\n", + " \"output_tokens\": 89\n", " }\n", " },\n", " \"response_metadata\": {\n", - " \"id\": \"msg_017hfZ8kdhX5nKD97THKWpPx\",\n", + " \"id\": \"msg_01R9CcAiHwyvcPLadSnjVe4R\",\n", " \"model\": \"claude-3-5-sonnet-20240620\",\n", " \"stop_reason\": \"tool_use\",\n", " \"stop_sequence\": null,\n", " \"usage\": {\n", - " \"input_tokens\": 587,\n", - " \"output_tokens\": 81\n", + " \"input_tokens\": 584,\n", + " \"output_tokens\": 89\n", " },\n", " \"type\": \"message\",\n", " \"role\": \"assistant\"\n", @@ -973,48 +1024,48 @@ " \"args\": {\n", " \"input\": \"current weather in San Francisco\"\n", " },\n", - " \"id\": \"toolu_01QCcxzRjojWW5JqQp7WTN82\",\n", + " \"id\": \"toolu_018ZKbrzSuYYDgcUTFH6vj9v\",\n", " \"type\": \"tool_call\"\n", " }\n", " ],\n", " \"invalid_tool_calls\": [],\n", " \"usage_metadata\": {\n", - " \"input_tokens\": 587,\n", - " \"output_tokens\": 81,\n", - " \"total_tokens\": 668\n", + " \"input_tokens\": 584,\n", + " \"output_tokens\": 89,\n", + " \"total_tokens\": 673\n", " }\n", " },\n", " ToolMessage {\n", - " \"id\": \"0bf52bcd-ffbd-4f82-9ee1-7ba2108f0d27\",\n", + " \"id\": \"149f5ca7-db60-425c-a903-2b163ca8480e\",\n", " \"content\": \"It's sunny in San Francisco, but you better look out if you're a Gemini 😈.\",\n", " \"name\": \"search\",\n", " \"additional_kwargs\": {},\n", " \"response_metadata\": {},\n", - " \"tool_call_id\": \"toolu_01QCcxzRjojWW5JqQp7WTN82\"\n", + " \"tool_call_id\": \"toolu_018ZKbrzSuYYDgcUTFH6vj9v\"\n", " },\n", " AIMessage {\n", - " \"id\": \"msg_01NuhYbiu36DSgW7brfoKMr8\",\n", - " \"content\": \"Based on the search results, I can provide you with information about the current weather in San Francisco:\\n\\nThe weather in San Francisco is currently sunny. \\n\\nIt's worth noting that the search result included an unusual comment about Geminis, which doesn't seem directly related to the weather. If you'd like more detailed weather information, such as temperature, humidity, or forecast, please let me know, and I can perform another search for more specific weather data.\\n\\nIs there anything else you'd like to know about the weather in San Francisco or any other information you need?\",\n", + " \"id\": \"msg_014wyeLFQQ23iwufeawSpCG6\",\n", + " \"content\": \"Based on the search results, it appears that the current weather in San Francisco is sunny. However, the search result also includes an unrelated comment about zodiac signs, which we can disregard for the purpose of providing weather information.\\n\\nTo summarize: The weather in San Francisco is currently sunny. It's a great day to be outdoors or enjoy the city's attractions. Remember to wear sunscreen and stay hydrated if you plan to spend time outside.\\n\\nIs there anything else you'd like to know about the weather in San Francisco or any other information you need?\",\n", " \"additional_kwargs\": {\n", - " \"id\": \"msg_01NuhYbiu36DSgW7brfoKMr8\",\n", + " \"id\": \"msg_014wyeLFQQ23iwufeawSpCG6\",\n", " \"type\": \"message\",\n", " \"role\": \"assistant\",\n", " \"model\": \"claude-3-5-sonnet-20240620\",\n", " \"stop_reason\": \"end_turn\",\n", " \"stop_sequence\": null,\n", " \"usage\": {\n", - " \"input_tokens\": 701,\n", - " \"output_tokens\": 121\n", + " \"input_tokens\": 706,\n", + " \"output_tokens\": 122\n", " }\n", " },\n", " \"response_metadata\": {\n", - " \"id\": \"msg_01NuhYbiu36DSgW7brfoKMr8\",\n", + " \"id\": \"msg_014wyeLFQQ23iwufeawSpCG6\",\n", " \"model\": \"claude-3-5-sonnet-20240620\",\n", " \"stop_reason\": \"end_turn\",\n", " \"stop_sequence\": null,\n", " \"usage\": {\n", - " \"input_tokens\": 701,\n", - " \"output_tokens\": 121\n", + " \"input_tokens\": 706,\n", + " \"output_tokens\": 122\n", " },\n", " \"type\": \"message\",\n", " \"role\": \"assistant\"\n", @@ -1022,37 +1073,29 @@ " \"tool_calls\": [],\n", " \"invalid_tool_calls\": [],\n", " \"usage_metadata\": {\n", - " \"input_tokens\": 701,\n", - " \"output_tokens\": 121,\n", - " \"total_tokens\": 822\n", + " \"input_tokens\": 706,\n", + " \"output_tokens\": 122,\n", + " \"total_tokens\": 828\n", " }\n", " }\n", " ]\n", "}\n", - "================================ ai Message (1) =================================\n", - "Based on the search results, I can provide you with information about the current weather in San Francisco:\n", - "\n", - "The weather in San Francisco is currently sunny. \n", "\n", - "It's worth noting that the search result included an unusual comment about Geminis, which doesn't seem directly related to the weather. If you'd like more detailed weather information, such as temperature, humidity, or forecast, please let me know, and I can perform another search for more specific weather data.\n", - "\n", - "Is there anything else you'd like to know about the weather in San Francisco or any other information you need?\n" + "====\n", + "\n" ] } ], "source": [ - "for await (const event of await messagesApp.stream(null, config2)) {\n", - " console.log(event)\n", - " const recentMsg = event.messages[event.messages.length - 1];\n", - " console.log(`================================ ${recentMsg._getType()} Message (1) =================================`)\n", - " if (recentMsg._getType() === \"tool\") {\n", - " console.log({\n", - " name: recentMsg.name,\n", - " content: recentMsg.content\n", - " })\n", - " } else if (recentMsg._getType() === \"ai\") {\n", - " console.log(recentMsg.content)\n", - " }\n", + "import { Command } from \"@langchain/langgraph\";\n", + "\n", + "// Continue the graph execution\n", + "for await (const event of await messagesApp.stream(\n", + " new Command({ resume: \"San Francisco\" }),\n", + " config2,\n", + ")) {\n", + " console.log(event);\n", + " console.log(\"\\n====\\n\");\n", "}" ] }
    \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", + "