From 381700e6d4e567d464425c5b16eef28d5ecbc880 Mon Sep 17 00:00:00 2001 From: Brace Sproul Date: Mon, 26 Aug 2024 13:59:26 -0700 Subject: [PATCH] docs[patch]: Convert full URL links to relative links (#384) --- docs/docs/concepts/agentic_concepts.md | 2 +- docs/docs/concepts/low_level.md | 34 +- docs/mkdocs.yml | 9 + examples/how-tos/branching.ipynb | 810 +++---- examples/how-tos/breakpoints.ipynb | 4 +- examples/how-tos/define-state.ipynb | 428 ++-- .../dynamically-returning-directly.ipynb | 934 +++---- examples/how-tos/edit-graph-state.ipynb | 1472 ++++++------ examples/how-tos/human-in-the-loop.ipynb | 928 +++---- .../manage-ecosystem-dependencies.ipynb | 244 +- examples/how-tos/managing-agent-steps.ipynb | 6 +- examples/how-tos/map-reduce.ipynb | 498 ++-- examples/how-tos/persistence-postgres.ipynb | 1962 +++++++-------- examples/how-tos/persistence.ipynb | 1136 ++++----- examples/how-tos/respond-in-format.ipynb | 2 +- examples/how-tos/stream-tokens.ipynb | 12 +- examples/how-tos/stream-updates.ipynb | 2 +- examples/how-tos/stream-values.ipynb | 2 +- .../streaming-tokens-without-langchain.ipynb | 706 +++--- examples/how-tos/subgraph.ipynb | 4 +- examples/how-tos/time-travel.ipynb | 18 +- examples/how-tos/tool-calling-errors.ipynb | 6 +- examples/how-tos/tool-calling.ipynb | 6 +- .../how-tos/use-in-web-environments.ipynb | 628 ++--- examples/how-tos/wait-user-input.ipynb | 2136 ++++++++--------- examples/quickstart.ipynb | 558 ++--- 26 files changed, 6280 insertions(+), 6267 deletions(-) diff --git a/docs/docs/concepts/agentic_concepts.md b/docs/docs/concepts/agentic_concepts.md index bd40492c..765ef7a6 100644 --- a/docs/docs/concepts/agentic_concepts.md +++ b/docs/docs/concepts/agentic_concepts.md @@ -78,7 +78,7 @@ This "reflection" step often uses an LLM, but doesn't have to. A good example of One of the most common agent architectures is what is commonly called the ReAct agent architecture. In this architecture, an LLM is called repeatedly in a while-loop. At each step the agent decides which tools to call, and what the inputs to those tools should be. Those tools are then executed, and the outputs are fed back into the LLM as observations. The while-loop terminates when the agent decides it is not worth calling any more tools. -One of the few high level, pre-built agents we have in LangGraph - you can use it with [`createReactAgent`](https://langchain-ai.github.io/langgraphjs/reference/functions/langgraph_prebuilt.createReactAgent.html) +One of the few high level, pre-built agents we have in LangGraph - you can use it with [`createReactAgent`](/langgraphjs/reference/functions/langgraph_prebuilt.createReactAgent.html) This is named after and based on the [ReAct](https://arxiv.org/abs/2210.03629) paper. However, there are several differences between this paper and our implementation: diff --git a/docs/docs/concepts/low_level.md b/docs/docs/concepts/low_level.md index 3c67baaf..29461270 100644 --- a/docs/docs/concepts/low_level.md +++ b/docs/docs/concepts/low_level.md @@ -4,7 +4,7 @@ At its core, LangGraph models agent workflows as graphs. You define the behavior of your agents using three key components: -1. [`State`](#state): A shared data structure that represents the current snapshot of your application. It is represented by an [`annotations`](https://langchain-ai.github.io/langgraphjs/reference/functions/langgraph.Annotation-1.html) object. +1. [`State`](#state): A shared data structure that represents the current snapshot of your application. It is represented by an [`annotations`](/langgraphjs/reference/functions/langgraph.Annotation-1.html) object. 2. [`Nodes`](#nodes): JavaScript/TypeScript functions that encode the logic of your agents. They receive the current `State` as input, perform some computation or side-effect, and return an updated `State`. @@ -22,6 +22,10 @@ A super-step can be considered a single iteration over the graph nodes. Nodes th The `StateGraph` class is the main graph class to uses. This is parameterized by a user defined `State` object. (defined using the `Annotation` object and passed as the first argument) +### MessageGraph + +The `MessageGraph` class is a special type of graph. The `State` of a `MessageGraph` is ONLY an array of messages. This class is rarely used except for chatbots, as most applications require the `State` to be more complex than an array of messages. + ### Compiling your graph To build your graph, you first define the [state](#state), you then add [nodes](#nodes) and [edges](#edges), and then you compile it. What exactly is compiling your graph and why is it needed? @@ -36,11 +40,11 @@ You **MUST** compile your graph before you can use it. ## State -The first thing you do when you define a graph is define the `State` of the graph. The `State` consists of the [schema of the graph](#schema) as well as [`reducer` functions](#reducers) which specify how to apply updates to the state. The schema of the `State` will be the input schema to all `Nodes` and `Edges` in the graph, and should be defined using an [`Annotation`](https://langchain-ai.github.io/langgraphjs/reference/functions/langgraph.Annotation-1.html) object. All `Nodes` will emit updates to the `State` which are then applied using the specified `reducer` function. +The first thing you do when you define a graph is define the `State` of the graph. The `State` consists of the [schema of the graph](#schema) as well as [`reducer` functions](#reducers) which specify how to apply updates to the state. The schema of the `State` will be the input schema to all `Nodes` and `Edges` in the graph, and should be defined using an [`Annotation`](/langgraphjs/reference/functions/langgraph.Annotation-1.html) object. All `Nodes` will emit updates to the `State` which are then applied using the specified `reducer` function. ### Schema -The way to specify the schema of a graph is by defining an [`Annotation`](https://langchain-ai.github.io/langgraphjs/reference/functions/langgraph.Annotation-1.html) object, where each key is an item in the state. +The way to specify the schema of a graph is by defining an [`Annotation`](/langgraphjs/reference/functions/langgraph.Annotation-1.html) object, where each key is an item in the state. ### Reducers @@ -81,7 +85,7 @@ In this example, we've updated our `bar` field to be an object containing a `red ### MessageState -`MessageState` is one of the few opinionated components in LangGraph. `MessageState` is a special state designed to make it easy to use a list of messages as a key in your state. Specifically, `MessageState` is defined as: +`MessageState` is one of the few opinionated components in LangGraph. `MessageState` is a special state designed to make it easy to use an array of messages as a key in your state. Specifically, `MessageState` is defined as: ```typescript import { BaseMessage } from "@langchain/core/messages"; @@ -102,9 +106,9 @@ export class MessageGraph extends StateGraph { } ``` -What this is doing is creating a `State` with a single key `messages`. This is a list of `BaseMessage`s, with [`messagesStateReducer`](https://langchain-ai.github.io/langgraphjs/reference/functions/langgraph.messagesStateReducer.html) as a reducer. `messagesStateReducer` basically adds messages to the existing list (it also does some nice extra things, like convert from OpenAI message format to the standard LangChain message format, handle updates based on message IDs, etc). +What this is doing is creating a `State` with a single key `messages`. This is an array of `BaseMessage`s, with [`messagesStateReducer`](/langgraphjs/reference/functions/langgraph.messagesStateReducer.html) as a reducer. `messagesStateReducer` basically adds messages to the existing list (it also does some nice extra things, like convert from OpenAI message format to the standard LangChain message format, handle updates based on message IDs, etc). -We often see a list of messages being a key component of state, so this prebuilt state is intended to make it easy to use messages. Typically, there is more state to track than just messages, so we see people extend this state and add more fields, like: +We often see an array of messages being a key component of state, so this prebuilt state is intended to make it easy to use messages. Typically, there is more state to track than just messages, so we see people extend this state and add more fields, like: ```typescript import { Annotation, MessagesAnnotation } from "@langchain/langgraph"; @@ -119,7 +123,7 @@ const StateWithDocuments = Annotation.Root({ In LangGraph, nodes are typically JavaScript/TypeScript functions (sync or `async`) where the **first** positional argument is the [state](#state), and (optionally), the **second** positional argument is a "config", containing optional [configurable parameters](#configuration) (such as a `thread_id`). -Similar to `NetworkX`, you add these nodes to a graph using the [addNode](https://langchain-ai.github.io/langgraphjs/reference/classes/langgraph.StateGraph.html#addNode) method: +Similar to `NetworkX`, you add these nodes to a graph using the [addNode](/langgraphjs/reference/classes/langgraph.StateGraph.html#addNode) method: ```typescript import { RunnableConfig } from "@langchain/core/runnables"; @@ -184,7 +188,7 @@ A node can have MULTIPLE outgoing edges. If a node has multiple out-going edges, ### Normal Edges -If you **always** want to go from node A to node B, you can use the [addEdge](https://langchain-ai.github.io/langgraphjs/reference/classes/langgraph.StateGraph.html#addEdge) method directly. +If you **always** want to go from node A to node B, you can use the [addEdge](/langgraphjs/reference/classes/langgraph.StateGraph.html#addEdge) method directly. ```typescript graph.addEdge("nodeA", "nodeB"); @@ -192,7 +196,7 @@ graph.addEdge("nodeA", "nodeB"); ### Conditional Edges -If you want to **optionally** route to 1 or more edges (or optionally terminate), you can use the [addConditionalEdges](https://langchain-ai.github.io/langgraphjs/reference/classes/langgraph.StateGraph.html#addConditionalEdges) method. This method accepts the name of a node and a "routing function" to call after that node is executed: +If you want to **optionally** route to 1 or more edges (or optionally terminate), you can use the [addConditionalEdges](/langgraphjs/reference/classes/langgraph.StateGraph.html#addConditionalEdges) method. This method accepts the name of a node and a "routing function" to call after that node is executed: ```typescript graph.addConditionalEdges("nodeA", routingFunction); @@ -200,7 +204,7 @@ graph.addConditionalEdges("nodeA", routingFunction); Similar to nodes, the `routingFunction` accept the current `state` of the graph and return a value. -By default, the return value `routingFunction` is used as the name of the node (or a list of nodes) to send the state to next. All those nodes will be run in parallel as a part of the next superstep. +By default, the return value `routingFunction` is used as the name of the node (or an array of nodes) to send the state to next. All those nodes will be run in parallel as a part of the next superstep. You can optionally provide an object that maps the `routingFunction`'s output to the name of the next node. @@ -213,7 +217,7 @@ graph.addConditionalEdges("nodeA", routingFunction, { ### Entry Point -The entry point is the first node(s) that are run when the graph starts. You can use the [`addEdge`](https://langchain-ai.github.io/langgraphjs/reference/classes/langgraph.StateGraph.html#addEdge) method from the virtual [`START`](https://langchain-ai.github.io/langgraphjs/reference/variables/langgraph.START.html) node to the first node to execute to specify where to enter the graph. +The entry point is the first node(s) that are run when the graph starts. You can use the [`addEdge`](/langgraphjs/reference/classes/langgraph.StateGraph.html#addEdge) method from the virtual [`START`](/langgraphjs/reference/variables/langgraph.START.html) node to the first node to execute to specify where to enter the graph. ```typescript import { START } from "@langchain/langgraph" @@ -223,7 +227,7 @@ graph.addEdge(START, "nodeA") ### Conditional Entry Point -A conditional entry point lets you start at different nodes depending on custom logic. You can use [`addConditionalEdges`](https://langchain-ai.github.io/langgraphjs/reference/classes/langgraph.StateGraph.html#addConditionalEdges) from the virtual [`START`](https://langchain-ai.github.io/langgraphjs/reference/variables/langgraph.START.html) node to accomplish this. +A conditional entry point lets you start at different nodes depending on custom logic. You can use [`addConditionalEdges`](/langgraphjs/reference/classes/langgraph.StateGraph.html#addConditionalEdges) from the virtual [`START`](/langgraphjs/reference/variables/langgraph.START.html) node to accomplish this. ```typescript import { START } from "@langchain/langgraph" @@ -242,9 +246,9 @@ graph.addConditionalEdges(START, routingFunction, { ## `Send` -By default, `Nodes` and `Edges` are defined ahead of time and operate on the same shared state. However, there can be cases where the exact edges are not known ahead of time and/or you may want different versions of `State` to exist at the same time. A common of example of this is with `map-reduce` design patterns. In this design pattern, a first node may generate a list of objects, and you may want to apply some other node to all those objects. The number of objects may be unknown ahead of time (meaning the number of edges may not be known) and the input `State` to the downstream `Node` should be different (one for each generated object). +By default, `Nodes` and `Edges` are defined ahead of time and operate on the same shared state. However, there can be cases where the exact edges are not known ahead of time and/or you may want different versions of `State` to exist at the same time. A common of example of this is with `map-reduce` design patterns. In this design pattern, a first node may generate an array of objects, and you may want to apply some other node to all those objects. The number of objects may be unknown ahead of time (meaning the number of edges may not be known) and the input `State` to the downstream `Node` should be different (one for each generated object). -To support this design pattern, LangGraph supports returning [`Send`](https://langchain-ai.github.io/langgraphjs/reference/classes/langgraph.Send.html) objects from conditional edges. `Send` takes two arguments: first is the name of the node, and second is the state to pass to that node. +To support this design pattern, LangGraph supports returning [`Send`](/langgraphjs/reference/classes/langgraph.Send.html) objects from conditional edges. `Send` takes two arguments: first is the name of the node, and second is the state to pass to that node. ```typescript const continueToJokes = (state: { subjects: string[] }) => { @@ -256,7 +260,7 @@ graph.addConditionalEdges("nodeA", continueToJokes); ## Checkpointer -LangGraph has a built-in persistence layer, implemented through [checkpointers](https://langchain-ai.github.io/langgraphjs/reference/classes/checkpoint.BaseCheckpointSaver.html). When you use a checkpointer with a graph, you can interact with the state of that graph. When you use a checkpointer with a graph, you can interact with and manage the graph's state. The checkpointer saves a _checkpoint_ of the graph state at every super-step, enabling several powerful capabilities: +LangGraph has a built-in persistence layer, implemented through [checkpointers](/langgraphjs/reference/classes/checkpoint.BaseCheckpointSaver.html). When you use a checkpointer with a graph, you can interact with the state of that graph. When you use a checkpointer with a graph, you can interact with and manage the graph's state. The checkpointer saves a _checkpoint_ of the graph state at every super-step, enabling several powerful capabilities: First, checkpointers facilitate [human-in-the-loop workflows](agentic_concepts.md#human-in-the-loop) workflows by allowing humans to inspect, interrupt, and approve steps. Checkpointers are needed for these workflows as the human has to be able to view the state of a graph at any point in time, and the graph has to be to resume execution after the human has made any updates to the state. diff --git a/docs/mkdocs.yml b/docs/mkdocs.yml index 1154267e..dfc4f6ba 100644 --- a/docs/mkdocs.yml +++ b/docs/mkdocs.yml @@ -114,6 +114,7 @@ nav: - Stream LLM tokens: "how-tos/stream-tokens.ipynb" - Stream LLM tokens without LangChain models: "how-tos/streaming-tokens-without-langchain.ipynb" - Stream events from within a tool: "how-tos/streaming-events-from-within-tools.ipynb" + - Stream from the final node: "how-tos/streaming-from-final-node.ipynb" - Tool calling: - Call tools using ToolNode: "how-tos/tool-calling.ipynb" - Handle tool calling errors: "how-tos/tool-calling-errors.ipynb" @@ -195,3 +196,11 @@ extra: link: https://github.com/langchain-ai/langgraphjs - icon: fontawesome/brands/twitter link: https://twitter.com/LangChainAI + +validation: + omitted_files: warn + unrecognized_links: warn + nav: + not_found: warn + links: + not_found: warn \ No newline at end of file diff --git a/examples/how-tos/branching.ipynb b/examples/how-tos/branching.ipynb index 5b5020ae..83276357 100644 --- a/examples/how-tos/branching.ipynb +++ b/examples/how-tos/branching.ipynb @@ -1,414 +1,414 @@ { - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# How to create branches for parallel node execution\n", - "\n", - "LangGraph natively supports fan-out and fan-in using either regular edges or\n", - "[conditionalEdges](https://langchain-ai.github.io/langgraphjs/reference/classes/langgraph.StateGraph.html#addConditionalEdges).\n", - "\n", - "This lets you run nodes in parallel to speed up your total graph execution.\n", - "\n", - "Below are some examples showing how to add create branching dataflows that work\n", - "for you.\n", - "\n", - "## Setup\n", - "\n", - "First, install LangGraph.js\n", - "\n", - "```bash\n", - "yarn add @langchain/langgraph\n", - "```\n", - "\n", - "This guide will use OpenAI's GPT-4o model. We will optionally set our API key\n", - "for [LangSmith tracing](https://smith.langchain.com/), which will give us\n", - "best-in-class observability.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ + "cells": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "Branching: 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_CALLBACKS_BACKGROUND = \"true\";\n", - "process.env.LANGCHAIN_TRACING_V2 = \"true\";\n", - "process.env.LANGCHAIN_PROJECT = \"Branching: LangGraphJS\";" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Fan out, fan in\n", - "\n", - "First, we will make a simple graph that branches out and back in. When merging\n", - "back in, the state updates from all branches are applied by your **reducer**\n", - "(the `aggregate` method below).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# How to create branches for parallel node execution\n", + "\n", + "LangGraph natively supports fan-out and fan-in using either regular edges or\n", + "[conditionalEdges](/langgraphjs/reference/classes/langgraph.StateGraph.html#addConditionalEdges).\n", + "\n", + "This lets you run nodes in parallel to speed up your total graph execution.\n", + "\n", + "Below are some examples showing how to add create branching dataflows that work\n", + "for you.\n", + "\n", + "## Setup\n", + "\n", + "First, install LangGraph.js\n", + "\n", + "```bash\n", + "yarn add @langchain/langgraph\n", + "```\n", + "\n", + "This guide will use OpenAI's GPT-4o model. We will optionally set our API key\n", + "for [LangSmith tracing](https://smith.langchain.com/), which will give us\n", + "best-in-class observability.\n" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Adding I'm A to \n", - "Adding I'm B to I'm A\n", - "Adding I'm C to I'm A\n", - "Adding I'm D to I'm A,I'm B,I'm C\n", - "Base Result: { aggregate: [ \"I'm A\", \"I'm B\", \"I'm C\", \"I'm D\" ] }\n" - ] - } - ], - "source": [ - "import { END, START, StateGraph, Annotation } from \"@langchain/langgraph\";\n", - "\n", - "const GraphState = Annotation.Root({\n", - " aggregate: Annotation({\n", - " reducer: (x, y) => x.concat(y),\n", - " })\n", - "})\n", - "\n", - "// Define the ReturnNodeValue class\n", - "class ReturnNodeValue {\n", - " private _value: string;\n", - "\n", - " constructor(value: string) {\n", - " this._value = value;\n", - " }\n", - "\n", - " public call(state: typeof GraphState.State) {\n", - " console.log(`Adding ${this._value} to ${state.aggregate}`);\n", - " return { aggregate: [this._value] };\n", - " }\n", - "}\n", - "\n", - "// Create the graph\n", - "const nodeA = new ReturnNodeValue(\"I'm A\");\n", - "const nodeB = new ReturnNodeValue(\"I'm B\");\n", - "const nodeC = new ReturnNodeValue(\"I'm C\");\n", - "const nodeD = new ReturnNodeValue(\"I'm D\");\n", - "\n", - "const builder = new StateGraph(GraphState)\n", - " .addNode(\"a\", nodeA.call.bind(nodeA))\n", - " .addEdge(START, \"a\")\n", - " .addNode(\"b\", nodeB.call.bind(nodeB))\n", - " .addNode(\"c\", nodeC.call.bind(nodeC))\n", - " .addNode(\"d\", nodeD.call.bind(nodeD))\n", - " .addEdge(\"a\", \"b\")\n", - " .addEdge(\"a\", \"c\")\n", - " .addEdge(\"b\", \"d\")\n", - " .addEdge(\"c\", \"d\")\n", - " .addEdge(\"d\", END);\n", - "\n", - "const graph = builder.compile();\n", - "\n", - "// Invoke the graph\n", - "const baseResult = await graph.invoke({ aggregate: [] });\n", - "console.log(\"Base Result: \", baseResult);\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Conditional Branching\n", - "\n", - "If your fan-out is not deterministic, you can use\n", - "[addConditionalEdges](https://langchain-ai.github.io/langgraphjs/reference/classes/index.StateGraph.html#addConditionalEdges)\n", - "directly.\n", - "\n", - "If you have a known \"sink\" node that the conditional branches will route to\n", - "afterwards, you can provide `then=` when creating the\n", - "conditional edges.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Branching: 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_CALLBACKS_BACKGROUND = \"true\";\n", + "process.env.LANGCHAIN_TRACING_V2 = \"true\";\n", + "process.env.LANGCHAIN_PROJECT = \"Branching: LangGraphJS\";" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Adding I'm A to \n", - "Adding I'm B to I'm A\n", - "Adding I'm C to I'm A\n", - "Adding I'm E to I'm A,I'm B,I'm C\n", - "Result 1: { aggregate: [ \"I'm A\", \"I'm B\", \"I'm C\", \"I'm E\" ], which: 'bc' }\n" - ] - } - ], - "source": [ - "const GraphStateConditionalBranching = Annotation.Root({\n", - " aggregate: Annotation({\n", - " reducer: (x, y) => x.concat(y),\n", - " }),\n", - " which: Annotation({\n", - " reducer: (x: string, y: string) => (y ?? x),\n", - " })\n", - "})\n", - "\n", - "// Create the graph\n", - "const nodeA2 = new ReturnNodeValue(\"I'm A\");\n", - "const nodeB2 = new ReturnNodeValue(\"I'm B\");\n", - "const nodeC2 = new ReturnNodeValue(\"I'm C\");\n", - "const nodeD2 = new ReturnNodeValue(\"I'm D\");\n", - "const nodeE2 = new ReturnNodeValue(\"I'm E\");\n", - "// Define the route function\n", - "function routeCDorBC(state: typeof GraphStateConditionalBranching.State): string[] {\n", - " if (state.which === \"cd\") {\n", - " return [\"c\", \"d\"];\n", - " }\n", - " return [\"b\", \"c\"];\n", - "}\n", - "\n", - "const builder2 = new StateGraph(GraphStateConditionalBranching)\n", - " .addNode(\"a\", nodeA2.call.bind(nodeA2))\n", - " .addEdge(START, \"a\")\n", - " .addNode(\"b\", nodeB2.call.bind(nodeB2))\n", - " .addNode(\"c\", nodeC2.call.bind(nodeC2))\n", - " .addNode(\"d\", nodeD2.call.bind(nodeD2))\n", - " .addNode(\"e\", nodeE2.call.bind(nodeE2))\n", - " // Add conditional edges\n", - " .addConditionalEdges(\"a\", routeCDorBC, { b: \"b\", c: \"c\", d: \"d\" })\n", - " .addEdge(\"b\", \"e\")\n", - " .addEdge(\"c\", \"e\")\n", - " .addEdge(\"d\", \"e\")\n", - " .addEdge(\"e\", END);\n", - "\n", - "const graph2 = builder2.compile();\n", - "\n", - "// Invoke the graph\n", - "let g2result = await graph2.invoke({ aggregate: [], which: \"bc\" });\n", - "console.log(\"Result 1: \", g2result);\n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Fan out, fan in\n", + "\n", + "First, we will make a simple graph that branches out and back in. When merging\n", + "back in, the state updates from all branches are applied by your **reducer**\n", + "(the `aggregate` method below).\n" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Adding I'm A to \n", - "Adding I'm C to I'm A\n", - "Adding I'm D to I'm A\n", - "Adding I'm E to I'm A,I'm C,I'm D\n", - "Result 2: { aggregate: [ \"I'm A\", \"I'm C\", \"I'm D\", \"I'm E\" ], which: 'cd' }\n" - ] - } - ], - "source": [ - "g2result = await graph2.invoke({ aggregate: [], which: \"cd\" });\n", - "console.log(\"Result 2: \", g2result);\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Stable Sorting\n", - "\n", - "When fanned out, nodes are run in parallel as a single \"superstep\". The updates\n", - "from each superstep are all applied to the state in sequence once the superstep\n", - "has completed.\n", - "\n", - "If you need consistent, predetermined ordering of updates from a parallel\n", - "superstep, you should write the outputs (along with an identifying key) to a\n", - "separate field in your state, then combine them in the \"sink\" node by adding\n", - "regular `edge`s from each of the fanout nodes to the rendezvous point.\n", - "\n", - "For instance, suppose I want to order the outputs of the parallel step by\n", - "\"reliability\".\n" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Adding I'm A to \n", + "Adding I'm B to I'm A\n", + "Adding I'm C to I'm A\n", + "Adding I'm D to I'm A,I'm B,I'm C\n", + "Base Result: { aggregate: [ \"I'm A\", \"I'm B\", \"I'm C\", \"I'm D\" ] }\n" + ] + } + ], + "source": [ + "import { END, START, StateGraph, Annotation } from \"@langchain/langgraph\";\n", + "\n", + "const GraphState = Annotation.Root({\n", + " aggregate: Annotation({\n", + " reducer: (x, y) => x.concat(y),\n", + " })\n", + "})\n", + "\n", + "// Define the ReturnNodeValue class\n", + "class ReturnNodeValue {\n", + " private _value: string;\n", + "\n", + " constructor(value: string) {\n", + " this._value = value;\n", + " }\n", + "\n", + " public call(state: typeof GraphState.State) {\n", + " console.log(`Adding ${this._value} to ${state.aggregate}`);\n", + " return { aggregate: [this._value] };\n", + " }\n", + "}\n", + "\n", + "// Create the graph\n", + "const nodeA = new ReturnNodeValue(\"I'm A\");\n", + "const nodeB = new ReturnNodeValue(\"I'm B\");\n", + "const nodeC = new ReturnNodeValue(\"I'm C\");\n", + "const nodeD = new ReturnNodeValue(\"I'm D\");\n", + "\n", + "const builder = new StateGraph(GraphState)\n", + " .addNode(\"a\", nodeA.call.bind(nodeA))\n", + " .addEdge(START, \"a\")\n", + " .addNode(\"b\", nodeB.call.bind(nodeB))\n", + " .addNode(\"c\", nodeC.call.bind(nodeC))\n", + " .addNode(\"d\", nodeD.call.bind(nodeD))\n", + " .addEdge(\"a\", \"b\")\n", + " .addEdge(\"a\", \"c\")\n", + " .addEdge(\"b\", \"d\")\n", + " .addEdge(\"c\", \"d\")\n", + " .addEdge(\"d\", END);\n", + "\n", + "const graph = builder.compile();\n", + "\n", + "// Invoke the graph\n", + "const baseResult = await graph.invoke({ aggregate: [] });\n", + "console.log(\"Base Result: \", baseResult);\n" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Adding I'm A to \n", - "Adding I'm B to I'm A\n", - "Adding I'm C to I'm A\n", - "Result 1: {\n", - " aggregate: [ \"I'm A\", \"I'm C\", \"I'm B\", \"I'm E\" ],\n", - " which: 'bc',\n", - " fanoutValues: []\n", - "}\n" - ] - } - ], - "source": [ - "type ScoredValue = {\n", - " value: string;\n", - " score: number;\n", - "};\n", - "\n", - "const reduceFanouts = (left?: ScoredValue[], right?: ScoredValue[]) => {\n", - " if (!left) {\n", - " left = [];\n", - " }\n", - " if (!right || right?.length === 0) {\n", - " // Overwrite. Similar to redux.\n", - " return [];\n", - " }\n", - " return left.concat(right);\n", - "};\n", - "\n", - "const GraphStateStableSorting = Annotation.Root({\n", - " aggregate: Annotation({\n", - " reducer: (x, y) => x.concat(y),\n", - " }),\n", - " which: Annotation({\n", - " reducer: (x: string, y: string) => (y ?? x),\n", - " }),\n", - " fanoutValues: Annotation({\n", - " reducer: reduceFanouts,\n", - " }),\n", - "})\n", - "\n", - "\n", - "class ParallelReturnNodeValue {\n", - " private _value: string;\n", - " private _score: number;\n", - "\n", - " constructor(nodeSecret: string, score: number) {\n", - " this._value = nodeSecret;\n", - " this._score = score;\n", - " }\n", - "\n", - " public call(state: typeof GraphStateStableSorting.State) {\n", - " console.log(`Adding ${this._value} to ${state.aggregate}`);\n", - " return { fanoutValues: [{ value: this._value, score: this._score }] };\n", - " }\n", - "}\n", - "\n", - "// Create the graph\n", - "\n", - "const nodeA3 = new ReturnNodeValue(\"I'm A\");\n", - "\n", - "const nodeB3 = new ParallelReturnNodeValue(\"I'm B\", 0.1);\n", - "const nodeC3 = new ParallelReturnNodeValue(\"I'm C\", 0.9);\n", - "const nodeD3 = new ParallelReturnNodeValue(\"I'm D\", 0.3);\n", - "\n", - "const aggregateFanouts = (state: typeof GraphStateStableSorting.State) => {\n", - " // Sort by score (reversed)\n", - " state.fanoutValues.sort((a, b) => b.score - a.score);\n", - " return {\n", - " aggregate: state.fanoutValues.map((v) => v.value).concat([\"I'm E\"]),\n", - " fanoutValues: [],\n", - " };\n", - "};\n", - "\n", - "// Define the route function\n", - "function routeBCOrCD(state: typeof GraphStateStableSorting.State): string[] {\n", - " if (state.which === \"cd\") {\n", - " return [\"c\", \"d\"];\n", - " }\n", - " return [\"b\", \"c\"];\n", - "}\n", - "\n", - "const builder3 = new StateGraph(GraphStateStableSorting)\n", - " .addNode(\"a\", nodeA3.call.bind(nodeA3))\n", - " .addEdge(START, \"a\")\n", - " .addNode(\"b\", nodeB3.call.bind(nodeB3))\n", - " .addNode(\"c\", nodeC3.call.bind(nodeC3))\n", - " .addNode(\"d\", nodeD3.call.bind(nodeD3))\n", - " .addNode(\"e\", aggregateFanouts)\n", - " .addConditionalEdges(\"a\", routeBCOrCD, { b: \"b\", c: \"c\", d: \"d\" })\n", - " .addEdge(\"b\", \"e\")\n", - " .addEdge(\"c\", \"e\")\n", - " .addEdge(\"d\", \"e\")\n", - " .addEdge(\"e\", END);\n", - "\n", - "const graph3 = builder3.compile();\n", - "\n", - "// Invoke the graph\n", - "let g3result = await graph3.invoke({ aggregate: [], which: \"bc\" });\n", - "console.log(\"Result 1: \", g3result);\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Our aggregateFanouts \"sink\" node in this case took the mapped values and then\n", - "sorted them in a consistent way. Notice that, because it returns an empty array\n", - "for `fanoutValues`, our `reduceFanouts` reducer function decided to overwrite\n", - "the previous values in the state.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Conditional Branching\n", + "\n", + "If your fan-out is not deterministic, you can use\n", + "[addConditionalEdges](/langgraphjs/reference/classes/index.StateGraph.html#addConditionalEdges)\n", + "directly.\n", + "\n", + "If you have a known \"sink\" node that the conditional branches will route to\n", + "afterwards, you can provide `then=` when creating the\n", + "conditional edges.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Adding I'm A to \n", + "Adding I'm B to I'm A\n", + "Adding I'm C to I'm A\n", + "Adding I'm E to I'm A,I'm B,I'm C\n", + "Result 1: { aggregate: [ \"I'm A\", \"I'm B\", \"I'm C\", \"I'm E\" ], which: 'bc' }\n" + ] + } + ], + "source": [ + "const GraphStateConditionalBranching = Annotation.Root({\n", + " aggregate: Annotation({\n", + " reducer: (x, y) => x.concat(y),\n", + " }),\n", + " which: Annotation({\n", + " reducer: (x: string, y: string) => (y ?? x),\n", + " })\n", + "})\n", + "\n", + "// Create the graph\n", + "const nodeA2 = new ReturnNodeValue(\"I'm A\");\n", + "const nodeB2 = new ReturnNodeValue(\"I'm B\");\n", + "const nodeC2 = new ReturnNodeValue(\"I'm C\");\n", + "const nodeD2 = new ReturnNodeValue(\"I'm D\");\n", + "const nodeE2 = new ReturnNodeValue(\"I'm E\");\n", + "// Define the route function\n", + "function routeCDorBC(state: typeof GraphStateConditionalBranching.State): string[] {\n", + " if (state.which === \"cd\") {\n", + " return [\"c\", \"d\"];\n", + " }\n", + " return [\"b\", \"c\"];\n", + "}\n", + "\n", + "const builder2 = new StateGraph(GraphStateConditionalBranching)\n", + " .addNode(\"a\", nodeA2.call.bind(nodeA2))\n", + " .addEdge(START, \"a\")\n", + " .addNode(\"b\", nodeB2.call.bind(nodeB2))\n", + " .addNode(\"c\", nodeC2.call.bind(nodeC2))\n", + " .addNode(\"d\", nodeD2.call.bind(nodeD2))\n", + " .addNode(\"e\", nodeE2.call.bind(nodeE2))\n", + " // Add conditional edges\n", + " .addConditionalEdges(\"a\", routeCDorBC, { b: \"b\", c: \"c\", d: \"d\" })\n", + " .addEdge(\"b\", \"e\")\n", + " .addEdge(\"c\", \"e\")\n", + " .addEdge(\"d\", \"e\")\n", + " .addEdge(\"e\", END);\n", + "\n", + "const graph2 = builder2.compile();\n", + "\n", + "// Invoke the graph\n", + "let g2result = await graph2.invoke({ aggregate: [], which: \"bc\" });\n", + "console.log(\"Result 1: \", g2result);\n" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Adding I'm A to \n", - "Adding I'm C to I'm A\n", - "Adding I'm D to I'm A\n", - "Result 2: {\n", - " aggregate: [ \"I'm A\", \"I'm C\", \"I'm D\", \"I'm E\" ],\n", - " which: 'cd',\n", - " fanoutValues: []\n", - "}\n" - ] + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Adding I'm A to \n", + "Adding I'm C to I'm A\n", + "Adding I'm D to I'm A\n", + "Adding I'm E to I'm A,I'm C,I'm D\n", + "Result 2: { aggregate: [ \"I'm A\", \"I'm C\", \"I'm D\", \"I'm E\" ], which: 'cd' }\n" + ] + } + ], + "source": [ + "g2result = await graph2.invoke({ aggregate: [], which: \"cd\" });\n", + "console.log(\"Result 2: \", g2result);\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Stable Sorting\n", + "\n", + "When fanned out, nodes are run in parallel as a single \"superstep\". The updates\n", + "from each superstep are all applied to the state in sequence once the superstep\n", + "has completed.\n", + "\n", + "If you need consistent, predetermined ordering of updates from a parallel\n", + "superstep, you should write the outputs (along with an identifying key) to a\n", + "separate field in your state, then combine them in the \"sink\" node by adding\n", + "regular `edge`s from each of the fanout nodes to the rendezvous point.\n", + "\n", + "For instance, suppose I want to order the outputs of the parallel step by\n", + "\"reliability\".\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Adding I'm A to \n", + "Adding I'm B to I'm A\n", + "Adding I'm C to I'm A\n", + "Result 1: {\n", + " aggregate: [ \"I'm A\", \"I'm C\", \"I'm B\", \"I'm E\" ],\n", + " which: 'bc',\n", + " fanoutValues: []\n", + "}\n" + ] + } + ], + "source": [ + "type ScoredValue = {\n", + " value: string;\n", + " score: number;\n", + "};\n", + "\n", + "const reduceFanouts = (left?: ScoredValue[], right?: ScoredValue[]) => {\n", + " if (!left) {\n", + " left = [];\n", + " }\n", + " if (!right || right?.length === 0) {\n", + " // Overwrite. Similar to redux.\n", + " return [];\n", + " }\n", + " return left.concat(right);\n", + "};\n", + "\n", + "const GraphStateStableSorting = Annotation.Root({\n", + " aggregate: Annotation({\n", + " reducer: (x, y) => x.concat(y),\n", + " }),\n", + " which: Annotation({\n", + " reducer: (x: string, y: string) => (y ?? x),\n", + " }),\n", + " fanoutValues: Annotation({\n", + " reducer: reduceFanouts,\n", + " }),\n", + "})\n", + "\n", + "\n", + "class ParallelReturnNodeValue {\n", + " private _value: string;\n", + " private _score: number;\n", + "\n", + " constructor(nodeSecret: string, score: number) {\n", + " this._value = nodeSecret;\n", + " this._score = score;\n", + " }\n", + "\n", + " public call(state: typeof GraphStateStableSorting.State) {\n", + " console.log(`Adding ${this._value} to ${state.aggregate}`);\n", + " return { fanoutValues: [{ value: this._value, score: this._score }] };\n", + " }\n", + "}\n", + "\n", + "// Create the graph\n", + "\n", + "const nodeA3 = new ReturnNodeValue(\"I'm A\");\n", + "\n", + "const nodeB3 = new ParallelReturnNodeValue(\"I'm B\", 0.1);\n", + "const nodeC3 = new ParallelReturnNodeValue(\"I'm C\", 0.9);\n", + "const nodeD3 = new ParallelReturnNodeValue(\"I'm D\", 0.3);\n", + "\n", + "const aggregateFanouts = (state: typeof GraphStateStableSorting.State) => {\n", + " // Sort by score (reversed)\n", + " state.fanoutValues.sort((a, b) => b.score - a.score);\n", + " return {\n", + " aggregate: state.fanoutValues.map((v) => v.value).concat([\"I'm E\"]),\n", + " fanoutValues: [],\n", + " };\n", + "};\n", + "\n", + "// Define the route function\n", + "function routeBCOrCD(state: typeof GraphStateStableSorting.State): string[] {\n", + " if (state.which === \"cd\") {\n", + " return [\"c\", \"d\"];\n", + " }\n", + " return [\"b\", \"c\"];\n", + "}\n", + "\n", + "const builder3 = new StateGraph(GraphStateStableSorting)\n", + " .addNode(\"a\", nodeA3.call.bind(nodeA3))\n", + " .addEdge(START, \"a\")\n", + " .addNode(\"b\", nodeB3.call.bind(nodeB3))\n", + " .addNode(\"c\", nodeC3.call.bind(nodeC3))\n", + " .addNode(\"d\", nodeD3.call.bind(nodeD3))\n", + " .addNode(\"e\", aggregateFanouts)\n", + " .addConditionalEdges(\"a\", routeBCOrCD, { b: \"b\", c: \"c\", d: \"d\" })\n", + " .addEdge(\"b\", \"e\")\n", + " .addEdge(\"c\", \"e\")\n", + " .addEdge(\"d\", \"e\")\n", + " .addEdge(\"e\", END);\n", + "\n", + "const graph3 = builder3.compile();\n", + "\n", + "// Invoke the graph\n", + "let g3result = await graph3.invoke({ aggregate: [], which: \"bc\" });\n", + "console.log(\"Result 1: \", g3result);\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Our aggregateFanouts \"sink\" node in this case took the mapped values and then\n", + "sorted them in a consistent way. Notice that, because it returns an empty array\n", + "for `fanoutValues`, our `reduceFanouts` reducer function decided to overwrite\n", + "the previous values in the state.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Adding I'm A to \n", + "Adding I'm C to I'm A\n", + "Adding I'm D to I'm A\n", + "Result 2: {\n", + " aggregate: [ \"I'm A\", \"I'm C\", \"I'm D\", \"I'm E\" ],\n", + " which: 'cd',\n", + " fanoutValues: []\n", + "}\n" + ] + } + ], + "source": [ + "let g3result2 = await graph3.invoke({ aggregate: [], which: \"cd\" });\n", + "console.log(\"Result 2: \", g3result2);\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" } - ], - "source": [ - "let g3result2 = await graph3.invoke({ aggregate: [], which: \"cd\" });\n", - "console.log(\"Result 2: \", g3result2);\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": 4 -} + "nbformat": 4, + "nbformat_minor": 4 +} \ No newline at end of file diff --git a/examples/how-tos/breakpoints.ipynb b/examples/how-tos/breakpoints.ipynb index 791bc81f..a41177d4 100644 --- a/examples/how-tos/breakpoints.ipynb +++ b/examples/how-tos/breakpoints.ipynb @@ -12,9 +12,9 @@ "source": [ "# How to add breakpoints\n", "\n", - "Human-in-the-loop (HIL) interactions are crucial for [agentic systems](https://langchain-ai.github.io/langgraph/concepts/agentic_concepts/#human-in-the-loop). [Breakpoints](https://langchain-ai.github.io/langgraph/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", + "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](https://langchain-ai.github.io/langgraphjs/concepts/#checkpoints), which save the graph's state after each node execution. Checkpoints are saved in [threads](https://langchain-ai.github.io/langgraph/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", + "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", "\n", "![Screenshot 2024-07-03 at 1.32.19 PM.png](attachment:b5aa6d4c-8dfd-490d-a53c-69c1368cd5b5.png)" ] diff --git a/examples/how-tos/define-state.ipynb b/examples/how-tos/define-state.ipynb index ef29e4c4..299171ba 100644 --- a/examples/how-tos/define-state.ipynb +++ b/examples/how-tos/define-state.ipynb @@ -1,216 +1,216 @@ { - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# How to define graph state\n", - "\n", - "This how to guide will cover how to define the state of your graph. This implementation has changed, and there is a new recommended method of defining the state of your graph. This new method is through the [`Annotation`](https://langchain-ai.github.io/langgraphjs/reference/functions/langgraph.Annotation-1.html) function.\n", - "\n", - "## Prerequisites\n", - "\n", - "- [State conceptual guide](https://langchain-ai.github.io/langgraphjs/concepts/low_level/#state) - Conceptual guide on defining the state of your graph.\n", - "- [Building graphs](https://langchain-ai.github.io/langgraphjs/tutorials/quickstart/) - This how to assumes you have a basic understanding of how to build graphs.\n", - "\n", - "## Setup\n", - "\n", - "This guide requires installing the `@langchain/langgraph`, and `@langchain/core` packages:\n", - "\n", - "```bash\n", - "npm install @langchain/langgraph @langchain/core\n", - "```\n", - "\n", - "## Getting started\n", - "\n", - "The `Annotation` function is the recommended way to define your graph state for new `StateGraph` graphs. The `Annotation.Root` function is used to create the top-level state object, where each field represents a channel in the graph.\n", - "\n", - "Here's an example of how to define a simple graph state with one channel called `messages`:" - ] + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# How to define graph state\n", + "\n", + "This how to guide will cover how to define the state of your graph. This implementation has changed, and there is a new recommended method of defining the state of your graph. This new method is through the [`Annotation`](/langgraphjs/reference/functions/langgraph.Annotation-1.html) function.\n", + "\n", + "## Prerequisites\n", + "\n", + "- [State conceptual guide](/langgraphjs/concepts/low_level/#state) - Conceptual guide on defining the state of your graph.\n", + "- [Building graphs](/langgraphjs/tutorials/quickstart/) - This how to assumes you have a basic understanding of how to build graphs.\n", + "\n", + "## Setup\n", + "\n", + "This guide requires installing the `@langchain/langgraph`, and `@langchain/core` packages:\n", + "\n", + "```bash\n", + "npm install @langchain/langgraph @langchain/core\n", + "```\n", + "\n", + "## Getting started\n", + "\n", + "The `Annotation` function is the recommended way to define your graph state for new `StateGraph` graphs. The `Annotation.Root` function is used to create the top-level state object, where each field represents a channel in the graph.\n", + "\n", + "Here's an example of how to define a simple graph state with one channel called `messages`:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import { BaseMessage } from \"@langchain/core/messages\";\n", + "import { Annotation } from \"@langchain/langgraph\";\n", + "\n", + "const GraphAnnotation = Annotation.Root({\n", + " // Define a 'messages' channel to store an array of BaseMessage objects\n", + " messages: Annotation({\n", + " // Reducer function: Combines the current state with new messages\n", + " reducer: (currentState, updateValue) => currentState.concat(updateValue),\n", + " // Default function: Initialize the channel with an empty array\n", + " default: () => [],\n", + " })\n", + "});" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Each channel can optionally have `reducer` and `default` functions:\n", + "- The `reducer` function defines how new values are combined with the existing state.\n", + "- The `default` function provides an initial value for the channel.\n", + "\n", + "For more information on reducers, see the [reducers conceptual guide](/langgraphjs/concepts/low_level/#reducers)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "const QuestionAnswerAnnotation = Annotation.Root({\n", + " question: Annotation,\n", + " answer: Annotation,\n", + "});" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Above, all we're doing is defining the channels, and then passing the un-instantiated `Annotation` function as the value. It is important to note we always pass in the TypeScript type of each channel as the first generics argument to `Annotation`. Doing this ensures our graph state is type safe, and we can get the proper types when defining our nodes. Below shows how you can extract the typings from the `Annotation` function:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "type QuestionAnswerAnnotationType = typeof QuestionAnswerAnnotation.State;" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is equivalent to the following type:\n", + "\n", + "```typescript\n", + "type QuestionAnswerAnnotationType = {\n", + " question: string;\n", + " answer: string;\n", + "}\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Merging states\n", + "\n", + "If you have two graph state annotations, you can merge the two into a single annotation by using the `spec` value:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "const MergedAnnotation = Annotation.Root({\n", + " ...QuestionAnswerAnnotation.spec,\n", + " ...GraphAnnotation.spec,\n", + "})" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The type of the merged annotation is the intersection of the two annotations:\n", + "\n", + "```typescript\n", + "type MergedAnnotation = {\n", + " messages: BaseMessage[];\n", + " question: string;\n", + " answer: string;\n", + "}\n", + "```\n", + "\n", + "Finally, instantiating your graph using the annotations is as simple as passing the annotation to the `StateGraph` constructor:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "import { StateGraph } from \"@langchain/langgraph\";\n", + "\n", + "const workflow = new StateGraph(MergedAnnotation);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## State channels\n", + "\n", + "The `Annotation` function is a convince wrapper around the low level implementation of how states are defined in LangGraph. Defining state using the `channels` object (which is what `Annotation` is a wrapper of) is still possible, although not recommended for most cases. The below example shows how to implement a graph using this pattern:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "import { StateGraph } from \"@langchain/langgraph\";\n", + "\n", + "interface WorkflowChannelsState {\n", + " messages: BaseMessage[];\n", + " question: string;\n", + " answer: string;\n", + "}\n", + "\n", + "const workflowWithChannels = new StateGraph({\n", + " channels: {\n", + " messages: {\n", + " reducer: (currentState, updateValue) => currentState.concat(updateValue),\n", + " default: () => [],\n", + " },\n", + " question: null,\n", + " answer: null,\n", + " }\n", + "});" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Above, we set the value of `question` and `answer` to `null`, as it does not contain a default value. To set a default value, the channel should be implemented how the `messages` key is, with the `default` factory returing the default value. The `reducer` function is optional, and can be added to the channel object if needed." + ] + } + ], + "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" + } }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import { BaseMessage } from \"@langchain/core/messages\";\n", - "import { Annotation } from \"@langchain/langgraph\";\n", - "\n", - "const GraphAnnotation = Annotation.Root({\n", - " // Define a 'messages' channel to store an array of BaseMessage objects\n", - " messages: Annotation({\n", - " // Reducer function: Combines the current state with new messages\n", - " reducer: (currentState, updateValue) => currentState.concat(updateValue),\n", - " // Default function: Initialize the channel with an empty array\n", - " default: () => [],\n", - " })\n", - "});" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Each channel can optionally have `reducer` and `default` functions:\n", - "- The `reducer` function defines how new values are combined with the existing state.\n", - "- The `default` function provides an initial value for the channel.\n", - "\n", - "For more information on reducers, see the [reducers conceptual guide](https://langchain-ai.github.io/langgraphjs/concepts/low_level/#reducers)" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "const QuestionAnswerAnnotation = Annotation.Root({\n", - " question: Annotation,\n", - " answer: Annotation,\n", - "});" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Above, all we're doing is defining the channels, and then passing the un-instantiated `Annotation` function as the value. It is important to note we always pass in the TypeScript type of each channel as the first generics argument to `Annotation`. Doing this ensures our graph state is type safe, and we can get the proper types when defining our nodes. Below shows how you can extract the typings from the `Annotation` function:" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "type QuestionAnswerAnnotationType = typeof QuestionAnswerAnnotation.State;" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "This is equivalent to the following type:\n", - "\n", - "```typescript\n", - "type QuestionAnswerAnnotationType = {\n", - " question: string;\n", - " answer: string;\n", - "}\n", - "```" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Merging states\n", - "\n", - "If you have two graph state annotations, you can merge the two into a single annotation by using the `spec` value:" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "const MergedAnnotation = Annotation.Root({\n", - " ...QuestionAnswerAnnotation.spec,\n", - " ...GraphAnnotation.spec,\n", - "})" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The type of the merged annotation is the intersection of the two annotations:\n", - "\n", - "```typescript\n", - "type MergedAnnotation = {\n", - " messages: BaseMessage[];\n", - " question: string;\n", - " answer: string;\n", - "}\n", - "```\n", - "\n", - "Finally, instantiating your graph using the annotations is as simple as passing the annotation to the `StateGraph` constructor:\n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "import { StateGraph } from \"@langchain/langgraph\";\n", - "\n", - "const workflow = new StateGraph(MergedAnnotation);" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## State channels\n", - "\n", - "The `Annotation` function is a convince wrapper around the low level implementation of how states are defined in LangGraph. Defining state using the `channels` object (which is what `Annotation` is a wrapper of) is still possible, although not recommended for most cases. The below example shows how to implement a graph using this pattern:" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "import { StateGraph } from \"@langchain/langgraph\";\n", - "\n", - "interface WorkflowChannelsState {\n", - " messages: BaseMessage[];\n", - " question: string;\n", - " answer: string;\n", - "}\n", - "\n", - "const workflowWithChannels = new StateGraph({\n", - " channels: {\n", - " messages: {\n", - " reducer: (currentState, updateValue) => currentState.concat(updateValue),\n", - " default: () => [],\n", - " },\n", - " question: null,\n", - " answer: null,\n", - " }\n", - "});" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Above, we set the value of `question` and `answer` to `null`, as it does not contain a default value. To set a default value, the channel should be implemented how the `messages` key is, with the `default` factory returing the default value. The `reducer` function is optional, and can be added to the channel object if needed." - ] - } - ], - "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": 2 -} + "nbformat": 4, + "nbformat_minor": 2 +} \ No newline at end of file diff --git a/examples/how-tos/dynamically-returning-directly.ipynb b/examples/how-tos/dynamically-returning-directly.ipynb index 122a0e44..a177a54e 100644 --- a/examples/how-tos/dynamically-returning-directly.ipynb +++ b/examples/how-tos/dynamically-returning-directly.ipynb @@ -1,473 +1,473 @@ { - "cells": [ - { - "cell_type": "markdown", - "id": "cd47f365", - "metadata": {}, - "source": [ - "# How to let agent return tool results directly\n", - "\n", - "A typical ReAct loop follows user -> assistant -> tool -> assistant ..., ->\n", - "user. In some cases, you don't need to call the LLM after the tool completes,\n", - "the user can view the results directly themselves.\n", - "\n", - "In this example we will build a conversational ReAct agent where the LLM can\n", - "optionally decide to return the result of a tool call as the final answer. This\n", - "is useful in cases where you have tools that can sometimes generate responses\n", - "that are acceptable as final answers, and you want to use the LLM to determine\n", - "when that is the case\n", - "\n", - "## Setup\n", - "\n", - "First we need to install the required packages:\n", - "\n", - "```bash\n", - "yarn add @langchain/langgraph @langchain/openai\n", - "```\n", - "\n", - "Next, we need to set API keys for OpenAI (the LLM we will use). Optionally, we\n", - "can set API key for [LangSmith tracing](https://smith.langchain.com/), which\n", - "will give us best-in-class observability.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "bff262dd", - "metadata": { - "lines_to_next_cell": 2 - }, - "outputs": [ + "cells": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "Direct Return: 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 = \"Direct Return: LangGraphJS\";" - ] - }, - { - "cell_type": "markdown", - "id": "f3c02963", - "metadata": {}, - "source": [ - "## Set up the tools\n", - "\n", - "We will first define the tools we want to use. For this simple example, we will\n", - "use a simple placeholder \"search engine\". However, it is really easy to create\n", - "your own tools - see documentation\n", - "[here](https://js.langchain.com/docs/modules/agents/tools/dynamic) on how to do\n", - "that.\n", - "\n", - "To add a 'return_direct' option, we will create a custom zod schema to use\n", - "**instead of** the schema that would be automatically inferred by the tool.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "c6e93e06", - "metadata": {}, - "outputs": [], - "source": [ - "import { DynamicStructuredTool } from \"@langchain/core/tools\";\n", - "import { z } from \"zod\";\n", - "\n", - "const SearchTool = z.object({\n", - " query: z.string().describe(\"query to look up online\"),\n", - " // **IMPORTANT** We are adding an **extra** field here\n", - " // that isn't used directly by the tool - it's used by our\n", - " // graph instead to determine whether or not to return the\n", - " // result directly to the user\n", - " return_direct: z.boolean()\n", - " .describe(\n", - " \"Whether or not the result of this should be returned directly to the user without you seeing what it is\",\n", - " )\n", - " .default(false),\n", - "});\n", - "\n", - "const searchTool = new DynamicStructuredTool({\n", - " name: \"search\",\n", - " description: \"Call to surf the web.\",\n", - " // We are overriding the default schema here to\n", - " // add an extra field\n", - " schema: SearchTool,\n", - " func: async ({}: { query: string }) => {\n", - " // This is a placeholder for the actual implementation\n", - " // Don't let the LLM know this though 😊\n", - " return \"It's sunny in San Francisco, but you better look out if you're a Gemini 😈.\";\n", - " },\n", - "});\n", - "\n", - "const tools = [searchTool];" - ] - }, - { - "cell_type": "markdown", - "id": "f443c375", - "metadata": {}, - "source": [ - "We can now wrap these tools in a simple ToolExecutor.\\\n", - "This is a real simple class that takes in a ToolInvocation and calls that tool,\n", - "returning the output. A ToolInvocation is any type with `tool` and `toolInput`\n", - "attribute.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "82f3a772", - "metadata": { - "lines_to_next_cell": 2 - }, - "outputs": [], - "source": [ - "import { ToolNode } from \"@langchain/langgraph/prebuilt\";\n", - "import { BaseMessage } from \"@langchain/core/messages\";\n", - "\n", - "const toolNode = new ToolNode<{ messages: BaseMessage[] }>(tools);" - ] - }, - { - "cell_type": "markdown", - "id": "e07a9312", - "metadata": {}, - "source": [ - "## Set up the model\n", - "\n", - "Now we need to load the chat model we want to use.\\\n", - "Importantly, this should satisfy two criteria:\n", - "\n", - "1. It should work with messages. We will represent all agent state in the form\n", - " of messages, so it needs to be able to work well with them.\n", - "2. It should support\n", - " [tool calling](https://js.langchain.com/v0.2/docs/concepts/#functiontool-calling).\n", - "\n", - "Note: these model requirements are not requirements for using LangGraph - they\n", - "are just requirements for this one example.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "f9263d46", - "metadata": { - "lines_to_next_cell": 2 - }, - "outputs": [], - "source": [ - "import { ChatOpenAI } from \"@langchain/openai\";\n", - "\n", - "const model = new ChatOpenAI({\n", - " temperature: 0,\n", - " model: \"gpt-3.5-turbo\",\n", - "});\n", - "// This formats the tools as json schema for the model API.\n", - "// The model then uses this like a system prompt.\n", - "const boundModel = model.bindTools(tools);" - ] - }, - { - "cell_type": "markdown", - "id": "4dbab039", - "metadata": {}, - "source": [ - "## Define the agent state\n", - "\n", - "The main type of graph in `langgraph` is the\n", - "[StateGraph](https://langchain-ai.github.io/langgraphjs/reference/classes/langgraph.StateGraph.html).\n", - "\n", - "This graph is parameterized by a state object that it passes around to each\n", - "node. Each node then returns operations to update that state. These operations\n", - "can either SET specific attributes on the state (e.g. overwrite the existing\n", - "values) or ADD to the existing attribute. Whether to set or add is denoted in\n", - "the state object you construct the graph with.\n", - "\n", - "For this example, the state we will track will just be a list of messages. We\n", - "want each node to just add messages to that list. Therefore, we will define the\n", - "state as follows:" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "c85e2d40", - "metadata": { - "lines_to_next_cell": 2 - }, - "outputs": [], - "source": [ - "import { Annotation } from \"@langchain/langgraph\";\n", - "import { BaseMessage } from \"@langchain/core/messages\";\n", - "\n", - "const AgentState = Annotation.Root({\n", - " messages: Annotation({\n", - " reducer: (x, y) => x.concat(y),\n", - " }),\n", - "});" - ] - }, - { - "cell_type": "markdown", - "id": "fc4b9760", - "metadata": {}, - "source": [ - "## Define the nodes\n", - "\n", - "We now need to define a few different nodes in our graph. In `langgraph`, a node\n", - "can be either a function or a\n", - "[runnable](https://js.langchain.com/docs/expression_language/). There are two\n", - "main nodes we need for this:\n", - "\n", - "1. The agent: responsible for deciding what (if any) actions to take.\n", - "2. A function to invoke tools: if the agent decides to take an action, this node\n", - " will then execute that action.\n", - "\n", - "We will also need to define some edges. Some of these edges may be conditional.\n", - "The reason they are conditional is that based on the output of a node, one of\n", - "several paths may be taken. The path that is taken is not known until that node\n", - "is run (the LLM decides).\n", - "\n", - "1. Conditional Edge: after the agent is called, we should either: a. If the\n", - " agent said to take an action, then the function to invoke tools should be\n", - " called b. If the agent said that it was finished, then it should finish\n", - "2. Normal Edge: after the tools are invoked, it should always go back to the\n", - " agent to decide what to do next\n", - "\n", - "Let's define the nodes, as well as a function to decide how what conditional\n", - "edge to take.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "c3da4bde", - "metadata": { - "lines_to_next_cell": 2 - }, - "outputs": [], - "source": [ - "import { RunnableConfig } from \"@langchain/core/runnables\";\n", - "import { END } from \"@langchain/langgraph\";\n", - "import { AIMessage } from \"@langchain/core/messages\";\n", - "\n", - "// Define the function that determines whether to continue or not\n", - "const shouldContinue = (state: typeof AgentState.State) => {\n", - " const { messages } = state;\n", - " const lastMessage = messages[messages.length - 1] as AIMessage;\n", - " // If there is no function call, then we finish\n", - " if (!lastMessage?.tool_calls?.length) {\n", - " return END;\n", - " } // Otherwise if there is, we check if it's suppose to return direct\n", - " else {\n", - " const args = lastMessage.tool_calls[0].args;\n", - " if (args?.return_direct) {\n", - " return \"final\";\n", - " } else {\n", - " return \"tools\";\n", - " }\n", - " }\n", - "};\n", - "\n", - "// Define the function that calls the model\n", - "const callModel = async (state: typeof AgentState.State, config?: RunnableConfig) => {\n", - " const messages = state.messages;\n", - " const response = await boundModel.invoke(messages, config);\n", - " // We return an object, because this will get added to the existing list\n", - " return { messages: [response] };\n", - "};" - ] - }, - { - "cell_type": "markdown", - "id": "cbd38eae", - "metadata": {}, - "source": [ - "## Define the graph\n", - "\n", - "We can now put it all together and define the graph!\n" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "7f830fef", - "metadata": {}, - "outputs": [], - "source": [ - "import { START, StateGraph } from \"@langchain/langgraph\";\n", - "\n", - "// Define a new graph\n", - "const workflow = new StateGraph(AgentState)\n", - " // Define the two nodes we will cycle between\n", - " .addNode(\"agent\", callModel)\n", - " // Note the \"action\" and \"final\" nodes are identical!\n", - " .addNode(\"tools\", toolNode)\n", - " .addNode(\"final\", toolNode)\n", - " // Set the entrypoint as `agent`\n", - " .addEdge(START, \"agent\")\n", - " // We now add a conditional edge\n", - " .addConditionalEdges(\n", - " // First, we define the start node. We use `agent`.\n", - " \"agent\",\n", - " // Next, we pass in the function that will determine which node is called next.\n", - " shouldContinue,\n", - " )\n", - " // We now add a normal edge from `tools` to `agent`.\n", - " .addEdge(\"tools\", \"agent\")\n", - " .addEdge(\"final\", END);\n", - "\n", - "// Finally, we compile it!\n", - "const app = workflow.compile();" - ] - }, - { - "cell_type": "markdown", - "id": "ac83bfea", - "metadata": {}, - "source": [ - "## Use it!\n", - "\n", - "We can now use it! This now exposes the\n", - "[same interface](https://js.langchain.com/docs/expression_language/) as all\n", - "other LangChain runnables.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "9ba5e47a", - "metadata": {}, - "outputs": [ + "cell_type": "markdown", + "id": "cd47f365", + "metadata": {}, + "source": [ + "# How to let agent return tool results directly\n", + "\n", + "A typical ReAct loop follows user -> assistant -> tool -> assistant ..., ->\n", + "user. In some cases, you don't need to call the LLM after the tool completes,\n", + "the user can view the results directly themselves.\n", + "\n", + "In this example we will build a conversational ReAct agent where the LLM can\n", + "optionally decide to return the result of a tool call as the final answer. This\n", + "is useful in cases where you have tools that can sometimes generate responses\n", + "that are acceptable as final answers, and you want to use the LLM to determine\n", + "when that is the case\n", + "\n", + "## Setup\n", + "\n", + "First we need to install the required packages:\n", + "\n", + "```bash\n", + "yarn add @langchain/langgraph @langchain/openai\n", + "```\n", + "\n", + "Next, we need to set API keys for OpenAI (the LLM we will use). Optionally, we\n", + "can set API key for [LangSmith tracing](https://smith.langchain.com/), which\n", + "will give us best-in-class observability.\n" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "[human]: what is the weather in sf\n", - "-----\n", - "\n", - "[ai]: \n", - "Tools: \n", - "- search({\"query\":\"weather in San Francisco\"})\n", - "-----\n", - "\n", - "[tool]: It's sunny in San Francisco, but you better look out if you're a Gemini 😈.\n", - "-----\n", - "\n", - "[ai]: The weather in San Francisco is sunny.\n", - "-----\n", - "\n" - ] - } - ], - "source": [ - "import { HumanMessage, isAIMessage } from \"@langchain/core/messages\";\n", - "\n", - "const prettyPrint = (message: BaseMessage) => {\n", - " let txt = `[${message._getType()}]: ${message.content}`;\n", - " if (\n", - " isAIMessage(message) && (message as AIMessage)?.tool_calls?.length || 0 > 0\n", - " ) {\n", - " const tool_calls = (message as AIMessage)?.tool_calls\n", - " ?.map((tc) => `- ${tc.name}(${JSON.stringify(tc.args)})`)\n", - " .join(\"\\n\");\n", - " txt += ` \\nTools: \\n${tool_calls}`;\n", - " }\n", - " console.log(txt);\n", - "};\n", - "\n", - "const inputs = { messages: [new HumanMessage(\"what is the weather in sf\")] };\n", - "for await (const output of await app.stream(inputs, { streamMode: \"values\" })) {\n", - " const lastMessage = output.messages[output.messages.length - 1];\n", - " prettyPrint(lastMessage);\n", - " console.log(\"-----\\n\");\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "779e0d88", - "metadata": {}, - "outputs": [ + "cell_type": "code", + "execution_count": 1, + "id": "bff262dd", + "metadata": { + "lines_to_next_cell": 2 + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Direct Return: 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 = \"Direct Return: LangGraphJS\";" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "[human]: what is the weather in sf? return this result directly by setting return_direct = True\n", - "-----\n", - "\n", - "[ai]: \n", - "Tools: \n", - "- search({\"query\":\"weather in San Francisco\",\"return_direct\":true})\n", - "-----\n", - "\n", - "[tool]: It's sunny in San Francisco, but you better look out if you're a Gemini 😈.\n", - "-----\n", - "\n" - ] + "cell_type": "markdown", + "id": "f3c02963", + "metadata": {}, + "source": [ + "## Set up the tools\n", + "\n", + "We will first define the tools we want to use. For this simple example, we will\n", + "use a simple placeholder \"search engine\". However, it is really easy to create\n", + "your own tools - see documentation\n", + "[here](https://js.langchain.com/docs/modules/agents/tools/dynamic) on how to do\n", + "that.\n", + "\n", + "To add a 'return_direct' option, we will create a custom zod schema to use\n", + "**instead of** the schema that would be automatically inferred by the tool.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "c6e93e06", + "metadata": {}, + "outputs": [], + "source": [ + "import { DynamicStructuredTool } from \"@langchain/core/tools\";\n", + "import { z } from \"zod\";\n", + "\n", + "const SearchTool = z.object({\n", + " query: z.string().describe(\"query to look up online\"),\n", + " // **IMPORTANT** We are adding an **extra** field here\n", + " // that isn't used directly by the tool - it's used by our\n", + " // graph instead to determine whether or not to return the\n", + " // result directly to the user\n", + " return_direct: z.boolean()\n", + " .describe(\n", + " \"Whether or not the result of this should be returned directly to the user without you seeing what it is\",\n", + " )\n", + " .default(false),\n", + "});\n", + "\n", + "const searchTool = new DynamicStructuredTool({\n", + " name: \"search\",\n", + " description: \"Call to surf the web.\",\n", + " // We are overriding the default schema here to\n", + " // add an extra field\n", + " schema: SearchTool,\n", + " func: async ({}: { query: string }) => {\n", + " // This is a placeholder for the actual implementation\n", + " // Don't let the LLM know this though 😊\n", + " return \"It's sunny in San Francisco, but you better look out if you're a Gemini 😈.\";\n", + " },\n", + "});\n", + "\n", + "const tools = [searchTool];" + ] + }, + { + "cell_type": "markdown", + "id": "f443c375", + "metadata": {}, + "source": [ + "We can now wrap these tools in a simple ToolExecutor.\\\n", + "This is a real simple class that takes in a ToolInvocation and calls that tool,\n", + "returning the output. A ToolInvocation is any type with `tool` and `toolInput`\n", + "attribute.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "82f3a772", + "metadata": { + "lines_to_next_cell": 2 + }, + "outputs": [], + "source": [ + "import { ToolNode } from \"@langchain/langgraph/prebuilt\";\n", + "import { BaseMessage } from \"@langchain/core/messages\";\n", + "\n", + "const toolNode = new ToolNode<{ messages: BaseMessage[] }>(tools);" + ] + }, + { + "cell_type": "markdown", + "id": "e07a9312", + "metadata": {}, + "source": [ + "## Set up the model\n", + "\n", + "Now we need to load the chat model we want to use.\\\n", + "Importantly, this should satisfy two criteria:\n", + "\n", + "1. It should work with messages. We will represent all agent state in the form\n", + " of messages, so it needs to be able to work well with them.\n", + "2. It should support\n", + " [tool calling](https://js.langchain.com/v0.2/docs/concepts/#functiontool-calling).\n", + "\n", + "Note: these model requirements are not requirements for using LangGraph - they\n", + "are just requirements for this one example.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "f9263d46", + "metadata": { + "lines_to_next_cell": 2 + }, + "outputs": [], + "source": [ + "import { ChatOpenAI } from \"@langchain/openai\";\n", + "\n", + "const model = new ChatOpenAI({\n", + " temperature: 0,\n", + " model: \"gpt-3.5-turbo\",\n", + "});\n", + "// This formats the tools as json schema for the model API.\n", + "// The model then uses this like a system prompt.\n", + "const boundModel = model.bindTools(tools);" + ] + }, + { + "cell_type": "markdown", + "id": "4dbab039", + "metadata": {}, + "source": [ + "## Define the agent state\n", + "\n", + "The main type of graph in `langgraph` is the\n", + "[StateGraph](/langgraphjs/reference/classes/langgraph.StateGraph.html).\n", + "\n", + "This graph is parameterized by a state object that it passes around to each\n", + "node. Each node then returns operations to update that state. These operations\n", + "can either SET specific attributes on the state (e.g. overwrite the existing\n", + "values) or ADD to the existing attribute. Whether to set or add is denoted in\n", + "the state object you construct the graph with.\n", + "\n", + "For this example, the state we will track will just be a list of messages. We\n", + "want each node to just add messages to that list. Therefore, we will define the\n", + "state as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "c85e2d40", + "metadata": { + "lines_to_next_cell": 2 + }, + "outputs": [], + "source": [ + "import { Annotation } from \"@langchain/langgraph\";\n", + "import { BaseMessage } from \"@langchain/core/messages\";\n", + "\n", + "const AgentState = Annotation.Root({\n", + " messages: Annotation({\n", + " reducer: (x, y) => x.concat(y),\n", + " }),\n", + "});" + ] + }, + { + "cell_type": "markdown", + "id": "fc4b9760", + "metadata": {}, + "source": [ + "## Define the nodes\n", + "\n", + "We now need to define a few different nodes in our graph. In `langgraph`, a node\n", + "can be either a function or a\n", + "[runnable](https://js.langchain.com/docs/expression_language/). There are two\n", + "main nodes we need for this:\n", + "\n", + "1. The agent: responsible for deciding what (if any) actions to take.\n", + "2. A function to invoke tools: if the agent decides to take an action, this node\n", + " will then execute that action.\n", + "\n", + "We will also need to define some edges. Some of these edges may be conditional.\n", + "The reason they are conditional is that based on the output of a node, one of\n", + "several paths may be taken. The path that is taken is not known until that node\n", + "is run (the LLM decides).\n", + "\n", + "1. Conditional Edge: after the agent is called, we should either: a. If the\n", + " agent said to take an action, then the function to invoke tools should be\n", + " called b. If the agent said that it was finished, then it should finish\n", + "2. Normal Edge: after the tools are invoked, it should always go back to the\n", + " agent to decide what to do next\n", + "\n", + "Let's define the nodes, as well as a function to decide how what conditional\n", + "edge to take.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "c3da4bde", + "metadata": { + "lines_to_next_cell": 2 + }, + "outputs": [], + "source": [ + "import { RunnableConfig } from \"@langchain/core/runnables\";\n", + "import { END } from \"@langchain/langgraph\";\n", + "import { AIMessage } from \"@langchain/core/messages\";\n", + "\n", + "// Define the function that determines whether to continue or not\n", + "const shouldContinue = (state: typeof AgentState.State) => {\n", + " const { messages } = state;\n", + " const lastMessage = messages[messages.length - 1] as AIMessage;\n", + " // If there is no function call, then we finish\n", + " if (!lastMessage?.tool_calls?.length) {\n", + " return END;\n", + " } // Otherwise if there is, we check if it's suppose to return direct\n", + " else {\n", + " const args = lastMessage.tool_calls[0].args;\n", + " if (args?.return_direct) {\n", + " return \"final\";\n", + " } else {\n", + " return \"tools\";\n", + " }\n", + " }\n", + "};\n", + "\n", + "// Define the function that calls the model\n", + "const callModel = async (state: typeof AgentState.State, config?: RunnableConfig) => {\n", + " const messages = state.messages;\n", + " const response = await boundModel.invoke(messages, config);\n", + " // We return an object, because this will get added to the existing list\n", + " return { messages: [response] };\n", + "};" + ] + }, + { + "cell_type": "markdown", + "id": "cbd38eae", + "metadata": {}, + "source": [ + "## Define the graph\n", + "\n", + "We can now put it all together and define the graph!\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "7f830fef", + "metadata": {}, + "outputs": [], + "source": [ + "import { START, StateGraph } from \"@langchain/langgraph\";\n", + "\n", + "// Define a new graph\n", + "const workflow = new StateGraph(AgentState)\n", + " // Define the two nodes we will cycle between\n", + " .addNode(\"agent\", callModel)\n", + " // Note the \"action\" and \"final\" nodes are identical!\n", + " .addNode(\"tools\", toolNode)\n", + " .addNode(\"final\", toolNode)\n", + " // Set the entrypoint as `agent`\n", + " .addEdge(START, \"agent\")\n", + " // We now add a conditional edge\n", + " .addConditionalEdges(\n", + " // First, we define the start node. We use `agent`.\n", + " \"agent\",\n", + " // Next, we pass in the function that will determine which node is called next.\n", + " shouldContinue,\n", + " )\n", + " // We now add a normal edge from `tools` to `agent`.\n", + " .addEdge(\"tools\", \"agent\")\n", + " .addEdge(\"final\", END);\n", + "\n", + "// Finally, we compile it!\n", + "const app = workflow.compile();" + ] + }, + { + "cell_type": "markdown", + "id": "ac83bfea", + "metadata": {}, + "source": [ + "## Use it!\n", + "\n", + "We can now use it! This now exposes the\n", + "[same interface](https://js.langchain.com/docs/expression_language/) as all\n", + "other LangChain runnables.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "9ba5e47a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[human]: what is the weather in sf\n", + "-----\n", + "\n", + "[ai]: \n", + "Tools: \n", + "- search({\"query\":\"weather in San Francisco\"})\n", + "-----\n", + "\n", + "[tool]: It's sunny in San Francisco, but you better look out if you're a Gemini 😈.\n", + "-----\n", + "\n", + "[ai]: The weather in San Francisco is sunny.\n", + "-----\n", + "\n" + ] + } + ], + "source": [ + "import { HumanMessage, isAIMessage } from \"@langchain/core/messages\";\n", + "\n", + "const prettyPrint = (message: BaseMessage) => {\n", + " let txt = `[${message._getType()}]: ${message.content}`;\n", + " if (\n", + " isAIMessage(message) && (message as AIMessage)?.tool_calls?.length || 0 > 0\n", + " ) {\n", + " const tool_calls = (message as AIMessage)?.tool_calls\n", + " ?.map((tc) => `- ${tc.name}(${JSON.stringify(tc.args)})`)\n", + " .join(\"\\n\");\n", + " txt += ` \\nTools: \\n${tool_calls}`;\n", + " }\n", + " console.log(txt);\n", + "};\n", + "\n", + "const inputs = { messages: [new HumanMessage(\"what is the weather in sf\")] };\n", + "for await (const output of await app.stream(inputs, { streamMode: \"values\" })) {\n", + " const lastMessage = output.messages[output.messages.length - 1];\n", + " prettyPrint(lastMessage);\n", + " console.log(\"-----\\n\");\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "779e0d88", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[human]: what is the weather in sf? return this result directly by setting return_direct = True\n", + "-----\n", + "\n", + "[ai]: \n", + "Tools: \n", + "- search({\"query\":\"weather in San Francisco\",\"return_direct\":true})\n", + "-----\n", + "\n", + "[tool]: It's sunny in San Francisco, but you better look out if you're a Gemini 😈.\n", + "-----\n", + "\n" + ] + } + ], + "source": [ + "const inputs2 = {\n", + " messages: [\n", + " new HumanMessage(\n", + " \"what is the weather in sf? return this result directly by setting return_direct = True\",\n", + " ),\n", + " ],\n", + "};\n", + "for await (\n", + " const output of await app.stream(inputs2, { streamMode: \"values\" })\n", + ") {\n", + " const lastMessage = output.messages[output.messages.length - 1];\n", + " prettyPrint(lastMessage);\n", + " console.log(\"-----\\n\");\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "f99d8e3b", + "metadata": {}, + "source": [ + "Done! The graph **stopped** after running the `tools` node!\n", + "\n", + "```\n", + "```" + ] + } + ], + "metadata": { + "jupytext": { + "encoding": "# -*- coding: utf-8 -*-" + }, + "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" } - ], - "source": [ - "const inputs2 = {\n", - " messages: [\n", - " new HumanMessage(\n", - " \"what is the weather in sf? return this result directly by setting return_direct = True\",\n", - " ),\n", - " ],\n", - "};\n", - "for await (\n", - " const output of await app.stream(inputs2, { streamMode: \"values\" })\n", - ") {\n", - " const lastMessage = output.messages[output.messages.length - 1];\n", - " prettyPrint(lastMessage);\n", - " console.log(\"-----\\n\");\n", - "}" - ] - }, - { - "cell_type": "markdown", - "id": "f99d8e3b", - "metadata": {}, - "source": [ - "Done! The graph **stopped** after running the `tools` node!\n", - "\n", - "```\n", - "```" - ] - } - ], - "metadata": { - "jupytext": { - "encoding": "# -*- coding: utf-8 -*-" - }, - "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 -} + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file diff --git a/examples/how-tos/edit-graph-state.ipynb b/examples/how-tos/edit-graph-state.ipynb index b26d70ac..ba9fec90 100644 --- a/examples/how-tos/edit-graph-state.ipynb +++ b/examples/how-tos/edit-graph-state.ipynb @@ -1,748 +1,748 @@ { - "cells": [ - { - "attachments": { - "49539520-097a-43d5-94b4-2b56193a579f.png": { - "image/png": "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" - } - }, - "cell_type": "markdown", - "id": "51466c8d-8ce4-4b3d-be4e-18fdbeda5f53", - "metadata": {}, - "source": [ - "# How to edit graph state\n", - "\n", - "Human-in-the-loop (HIL) interactions are crucial for [agentic systems](https://langchain-ai.github.io/langgraph/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](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 and then resume from that spot to continue. \n", - "\n", - "![image.png](attachment:49539520-097a-43d5-94b4-2b56193a579f.png)" - ] - }, - { - "cell_type": "markdown", - "id": "7cbd446a-808f-4394-be92-d45ab818953c", - "metadata": {}, - "source": [ - "## Setup\n", - "\n", - "First we need to install the packages required\n", - "\n", - "```bash\n", - "npm install @langchain/langgraph @langchain/anthropic zod\n", - "```\n", - "\n", - "Next, we need to set API keys for Anthropic (the LLM we will use)\n", - "\n", - "```bash\n", - "export ANTHROPIC_API_KEY=your-api-key\n", - "```\n", - "\n", - "\n", - "Optionally, we can set API key for LangSmith tracing, which will give us best-in-class observability.\n", - "\n", - "```bash\n", - "export LANGCHAIN_TRACING_V2=\"true\"\n", - "export LANGCHAIN_CALLBACKS_BACKGROUND=\"true\"\n", - "export LANGCHAIN_API_KEY=your-api-key\n", - "```\n", - "\n", - "## Simple Usage\n", - "Let's look at very basic usage of this.\n", - "\n", - "Below, we do two things:\n", - "\n", - "1) We specify the [breakpoint](https://langchain-ai.github.io/langgraph/concepts/low_level/#breakpoints) using `interruptBefore` a specified step (node).\n", - "\n", - "2) We set up a [checkpointer](https://langchain-ai.github.io/langgraphjs/concepts/#checkpoints) to save the state of the graph up until this node.\n", - "\n", - "3) We use `.updateState` to update the state of the graph." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "85e452f8-f33a-4ead-bb4d-7386cdba8edc", - "metadata": {}, - "outputs": [], - "source": [ - "import { StateGraph, START, END, Annotation } from \"@langchain/langgraph\";\n", - "import { MemorySaver } from \"@langchain/langgraph\";\n", - "\n", - "const GraphState = Annotation.Root({\n", - " input: Annotation\n", - "});\n", - "\n", - "const step1 = (state: typeof GraphState.State) => {\n", - " console.log(\"---Step 1---\");\n", - " return state;\n", - "}\n", - "\n", - "const step2 = (state: typeof GraphState.State) => {\n", - " console.log(\"---Step 2---\");\n", - " return state;\n", - "}\n", - "\n", - "const step3 = (state: typeof GraphState.State) => {\n", - " console.log(\"---Step 3---\");\n", - " return state;\n", - "}\n", - "\n", - "\n", - "const builder = new StateGraph(GraphState)\n", - " .addNode(\"step1\", step1)\n", - " .addNode(\"step2\", step2)\n", - " .addNode(\"step3\", step3)\n", - " .addEdge(START, \"step1\")\n", - " .addEdge(\"step1\", \"step2\")\n", - " .addEdge(\"step2\", \"step3\")\n", - " .addEdge(\"step3\", END);\n", - "\n", - "\n", - "// Set up memory\n", - "const graphStateMemory = new MemorySaver()\n", - "\n", - "const graph = builder.compile({\n", - " checkpointer: graphStateMemory,\n", - " interruptBefore: [\"step2\"]\n", - "});" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "db20864a", - "metadata": {}, - "outputs": [ + "cells": [ { - "data": { - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import * as tslab from \"tslab\";\n", - "\n", - "const drawableGraphGraphState = graph.getGraph();\n", - "const graphStateImage = await drawableGraphGraphState.drawMermaidPng();\n", - "const graphStateArrayBuffer = await graphStateImage.arrayBuffer();\n", - "\n", - "await tslab.display.png(new Uint8Array(graphStateArrayBuffer));" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "1b3aa6fc-c7fb-4819-8d7f-ba6057cc4edf", - "metadata": {}, - "outputs": [ + "attachments": { + "49539520-097a-43d5-94b4-2b56193a579f.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "id": "51466c8d-8ce4-4b3d-be4e-18fdbeda5f53", + "metadata": {}, + "source": [ + "# How to edit graph state\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", + "\n", + "![image.png](attachment:49539520-097a-43d5-94b4-2b56193a579f.png)" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- hello world ---\n", - "---Step 1---\n", - "--- hello world ---\n", - "--- GRAPH INTERRUPTED ---\n" - ] - } - ], - "source": [ - "// Input\n", - "const initialInput = { input: \"hello world\" };\n", - "\n", - "// Thread\n", - "const graphStateConfig = { configurable: { thread_id: \"1\" }, streamMode: \"values\" as const };\n", - "\n", - "// Run the graph until the first interruption\n", - "for await (const event of await graph.stream(initialInput, graphStateConfig)) {\n", - " console.log(`--- ${event.input} ---`);\n", - "}\n", - "\n", - "// Will log when the graph is interrupted, after step 2.\n", - "console.log(\"--- GRAPH INTERRUPTED ---\");\n" - ] - }, - { - "cell_type": "markdown", - "id": "4ab27716-e861-4ba3-9d7d-90694013e3c4", - "metadata": {}, - "source": [ - "Now, we can just manually update our graph state - " - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "49d61230-e5dc-4272-b8ab-09b0af30f088", - "metadata": {}, - "outputs": [ + "cell_type": "markdown", + "id": "7cbd446a-808f-4394-be92-d45ab818953c", + "metadata": {}, + "source": [ + "## Setup\n", + "\n", + "First we need to install the packages required\n", + "\n", + "```bash\n", + "npm install @langchain/langgraph @langchain/anthropic zod\n", + "```\n", + "\n", + "Next, we need to set API keys for Anthropic (the LLM we will use)\n", + "\n", + "```bash\n", + "export ANTHROPIC_API_KEY=your-api-key\n", + "```\n", + "\n", + "\n", + "Optionally, we can set API key for LangSmith tracing, which will give us best-in-class observability.\n", + "\n", + "```bash\n", + "export LANGCHAIN_TRACING_V2=\"true\"\n", + "export LANGCHAIN_CALLBACKS_BACKGROUND=\"true\"\n", + "export LANGCHAIN_API_KEY=your-api-key\n", + "```\n", + "\n", + "## Simple Usage\n", + "Let's look at very basic usage of this.\n", + "\n", + "Below, we do two things:\n", + "\n", + "1) We specify the [breakpoint](/langgraphjs/concepts/low_level/#breakpoints) using `interruptBefore` a specified step (node).\n", + "\n", + "2) We set up a [checkpointer](/langgraphjs/concepts/#checkpoints) to save the state of the graph up until this node.\n", + "\n", + "3) We use `.updateState` to update the state of the graph." + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Current state!\n", - "{ input: 'hello world' }\n", - "---\n", - "---\n", - "Updated state!\n", - "{ input: 'hello universe!' }\n" - ] - } - ], - "source": [ - "console.log(\"Current state!\")\n", - "const currState = await graph.getState(graphStateConfig);\n", - "console.log(currState.values)\n", - "\n", - "await graph.updateState(graphStateConfig, { input: \"hello universe!\" })\n", - "\n", - "console.log(\"---\\n---\\nUpdated state!\")\n", - "const updatedState = await graph.getState(graphStateConfig);\n", - "console.log(updatedState.values)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "cf77f6eb-4cc0-4615-a095-eb5ae7027b7a", - "metadata": {}, - "outputs": [ + "cell_type": "code", + "execution_count": 1, + "id": "85e452f8-f33a-4ead-bb4d-7386cdba8edc", + "metadata": {}, + "outputs": [], + "source": [ + "import { StateGraph, START, END, Annotation } from \"@langchain/langgraph\";\n", + "import { MemorySaver } from \"@langchain/langgraph\";\n", + "\n", + "const GraphState = Annotation.Root({\n", + " input: Annotation\n", + "});\n", + "\n", + "const step1 = (state: typeof GraphState.State) => {\n", + " console.log(\"---Step 1---\");\n", + " return state;\n", + "}\n", + "\n", + "const step2 = (state: typeof GraphState.State) => {\n", + " console.log(\"---Step 2---\");\n", + " return state;\n", + "}\n", + "\n", + "const step3 = (state: typeof GraphState.State) => {\n", + " console.log(\"---Step 3---\");\n", + " return state;\n", + "}\n", + "\n", + "\n", + "const builder = new StateGraph(GraphState)\n", + " .addNode(\"step1\", step1)\n", + " .addNode(\"step2\", step2)\n", + " .addNode(\"step3\", step3)\n", + " .addEdge(START, \"step1\")\n", + " .addEdge(\"step1\", \"step2\")\n", + " .addEdge(\"step2\", \"step3\")\n", + " .addEdge(\"step3\", END);\n", + "\n", + "\n", + "// Set up memory\n", + "const graphStateMemory = new MemorySaver()\n", + "\n", + "const graph = builder.compile({\n", + " checkpointer: graphStateMemory,\n", + " interruptBefore: [\"step2\"]\n", + "});" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "---Step 2---\n", - "--- hello universe! ---\n", - "---Step 3---\n", - "--- hello universe! ---\n" - ] - } - ], - "source": [ - "// Continue the graph execution\n", - "for await (const event of await graph.stream(null, graphStateConfig)) {\n", - " console.log(`--- ${event.input} ---`);\n", - "}" - ] - }, - { - "cell_type": "markdown", - "id": "3333b771", - "metadata": {}, - "source": [ - "## Agent\n", - "\n", - "In the context of agents, updating state is useful for things like editing tool calls.\n", - " \n", - "To show this, we will build a relatively simple ReAct-style agent that does tool calling. \n", - "\n", - "We will use Anthropic's models and a fake tool (just for demo purposes)." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "6098e5cb", - "metadata": {}, - "outputs": [], - "source": [ - "// Set up the tool\n", - "import { ChatAnthropic } from \"@langchain/anthropic\";\n", - "import { tool } from \"@langchain/core/tools\";\n", - "import { StateGraph, START, END } from \"@langchain/langgraph\";\n", - "import { MemorySaver, messagesStateReducer } from \"@langchain/langgraph\";\n", - "import { ToolNode } from \"@langchain/langgraph/prebuilt\";\n", - "import { BaseMessage, AIMessage } from \"@langchain/core/messages\";\n", - "import { z } from \"zod\";\n", - "import { v4 as uuidv4 } from \"uuid\";\n", - "\n", - "const AgentState = 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", - " name: \"search\",\n", - " description: \"Call to surf the web.\",\n", - " schema: z.string(),\n", - "})\n", - "\n", - "const tools = [search]\n", - "const toolNode = new ToolNode(tools)\n", - "\n", - "// Set up the model\n", - "const model = new ChatAnthropic({ model: \"claude-3-5-sonnet-20240620\" })\n", - "const modelWithTools = model.bindTools(tools)\n", - "\n", - "\n", - "// Define nodes and conditional edges\n", - "\n", - "// Define the function that determines whether to continue or not\n", - "function shouldContinue(state: typeof AgentState.State): \"action\" | typeof END {\n", - " const lastMessage = state.messages[state.messages.length - 1];\n", - " // If there is no function call, then we finish\n", - " if (lastMessage && !(lastMessage as AIMessage).tool_calls?.length) {\n", - " return END;\n", - " }\n", - " // Otherwise if there is, we continue\n", - " return \"action\";\n", - "}\n", - "\n", - "// Define the function that calls the model\n", - "async function callModel(state: typeof AgentState.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", - " return { messages: [response] };\n", - "}\n", - "\n", - "// Define a new graph\n", - "const workflow = new StateGraph(AgentState)\n", - " // Define the two nodes we will cycle between\n", - " .addNode(\"agent\", callModel)\n", - " .addNode(\"action\", toolNode)\n", - " // We now add a conditional edge\n", - " .addConditionalEdges(\n", - " // First, we define the start node. We use `agent`.\n", - " // This means these are the edges taken after the `agent` node is called.\n", - " \"agent\",\n", - " // Next, we pass in the function that will determine which node is called next.\n", - " shouldContinue\n", - " )\n", - " // We now add a normal edge from `action` to `agent`.\n", - " // This means that after `action` is called, `agent` node is called next.\n", - " .addEdge(\"action\", \"agent\")\n", - " // Set the entrypoint as `agent`\n", - " // This means that this node is the first one called\n", - " .addEdge(START, \"agent\");\n", - "\n", - "// Setup memory\n", - "const memory = new MemorySaver();\n", - "\n", - "// Finally, we compile it!\n", - "// This compiles it into a LangChain Runnable,\n", - "// meaning you can use it as you would any other runnable\n", - "const app = workflow.compile({\n", - " checkpointer: memory,\n", - " interruptBefore: [\"action\"]\n", - "});" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "9b011246", - "metadata": {}, - "outputs": [ + "cell_type": "code", + "execution_count": 2, + "id": "db20864a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import * as tslab from \"tslab\";\n", + "\n", + "const drawableGraphGraphState = graph.getGraph();\n", + "const graphStateImage = await drawableGraphGraphState.drawMermaidPng();\n", + "const graphStateArrayBuffer = await graphStateImage.arrayBuffer();\n", + "\n", + "await tslab.display.png(new Uint8Array(graphStateArrayBuffer));" + ] + }, { - "data": { - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import * as tslab from \"tslab\";\n", - "\n", - "const drawableGraph = app.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": "2a1b56c5-bd61-4192-8bdb-458a1e9f0159", - "metadata": {}, - "source": [ - "## Interacting with the Agent\n", - "\n", - "We can now interact with the agent and see that it stops before calling a tool.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "cfd140f0-a5a6-4697-8115-322242f197b5", - "metadata": {}, - "outputs": [ + "cell_type": "code", + "execution_count": 3, + "id": "1b3aa6fc-c7fb-4819-8d7f-ba6057cc4edf", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- hello world ---\n", + "---Step 1---\n", + "--- hello world ---\n", + "--- GRAPH INTERRUPTED ---\n" + ] + } + ], + "source": [ + "// Input\n", + "const initialInput = { input: \"hello world\" };\n", + "\n", + "// Thread\n", + "const graphStateConfig = { configurable: { thread_id: \"1\" }, streamMode: \"values\" as const };\n", + "\n", + "// Run the graph until the first interruption\n", + "for await (const event of await graph.stream(initialInput, graphStateConfig)) {\n", + " console.log(`--- ${event.input} ---`);\n", + "}\n", + "\n", + "// Will log when the graph is interrupted, after step 2.\n", + "console.log(\"--- GRAPH INTERRUPTED ---\");\n" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "================================ human Message (1) =================================\n", - "search for the weather in sf now\n", - "================================ ai Message (1) =================================\n", - "[\n", - " {\n", - " type: 'text',\n", - " text: 'Certainly! I can help you search for the current weather in San Francisco. Let me use the search function to find that information for you.'\n", - " },\n", - " {\n", - " type: 'tool_use',\n", - " id: 'toolu_0141zTpknasyWkrjTV6eKeT6',\n", - " name: 'search',\n", - " input: { input: 'current weather in San Francisco' }\n", - " }\n", - "]\n" - ] - } - ], - "source": [ - "import { HumanMessage } from \"@langchain/core/messages\";\n", - "// Input\n", - "const inputs = new HumanMessage(\"search for the weather in sf now\");\n", - "\n", - "// Thread\n", - "const config = { configurable: { thread_id: \"3\" }, streamMode: \"values\" as const };\n", - "\n", - "for await (const event of await app.stream({\n", - " messages: [inputs]\n", - "}, config)) {\n", - " const recentMsg = event.messages[event.messages.length - 1];\n", - " console.log(`================================ ${recentMsg._getType()} Message (1) =================================`)\n", - " console.log(recentMsg.content);\n", - "}" - ] - }, - { - "cell_type": "markdown", - "id": "78e3f5b9-9700-42b1-863f-c404861f8620", - "metadata": {}, - "source": [ - "**Edit**\n", - "\n", - "We can now update the state accordingly. Let's modify the tool call to have the query `\"current weather in SF\"`." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "1aa7b1b9-9322-4815-bc0d-eb083870ac15", - "metadata": {}, - "outputs": [ + "cell_type": "markdown", + "id": "4ab27716-e861-4ba3-9d7d-90694013e3c4", + "metadata": {}, + "source": [ + "Now, we can just manually update our graph state - " + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "{\n", - " configurable: {\n", - " thread_id: '3',\n", - " checkpoint_id: '1ef5e785-4298-6b71-8002-4a6ceca964db'\n", - " }\n", - "}\n" - ] - } - ], - "source": [ - "// First, lets get the current state\n", - "const currentState = await app.getState(config);\n", - "\n", - "// Let's now get the last message in the state\n", - "// This is the one with the tool calls that we want to update\n", - "let lastMessage = currentState.values.messages[currentState.values.messages.length - 1]\n", - "\n", - "// Let's now update the args for that tool call\n", - "lastMessage.tool_calls[0].args = { query: \"current weather in SF\" }\n", - "\n", - "// Let's now call `updateState` to pass in this message in the `messages` key\n", - "// This will get treated as any other update to the state\n", - "// It will get passed to the reducer function for the `messages` key\n", - "// That reducer function will use the ID of the message to update it\n", - "// It's important that it has the right ID! Otherwise it would get appended\n", - "// as a new message\n", - "await app.updateState(config, { messages: lastMessage });" - ] - }, - { - "cell_type": "markdown", - "id": "0dcc5457-1ba1-4cba-ac41-da5c67cc67e5", - "metadata": {}, - "source": [ - "Let's now check the current state of the app to make sure it got updated accordingly" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "a3fcf2bd-f881-49fe-b20e-ad16e6819bc6", - "metadata": {}, - "outputs": [ + "cell_type": "code", + "execution_count": 4, + "id": "49d61230-e5dc-4272-b8ab-09b0af30f088", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Current state!\n", + "{ input: 'hello world' }\n", + "---\n", + "---\n", + "Updated state!\n", + "{ input: 'hello universe!' }\n" + ] + } + ], + "source": [ + "console.log(\"Current state!\")\n", + "const currState = await graph.getState(graphStateConfig);\n", + "console.log(currState.values)\n", + "\n", + "await graph.updateState(graphStateConfig, { input: \"hello universe!\" })\n", + "\n", + "console.log(\"---\\n---\\nUpdated state!\")\n", + "const updatedState = await graph.getState(graphStateConfig);\n", + "console.log(updatedState.values)" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "[\n", - " {\n", - " name: 'search',\n", - " args: { query: 'current weather in SF' },\n", - " id: 'toolu_0141zTpknasyWkrjTV6eKeT6',\n", - " type: 'tool_call'\n", - " }\n", - "]\n" - ] - } - ], - "source": [ - "const newState = await app.getState(config);\n", - "const updatedStateToolCalls = newState.values.messages[newState.values.messages.length -1 ].tool_calls\n", - "console.log(updatedStateToolCalls)" - ] - }, - { - "cell_type": "markdown", - "id": "1bca3814-db08-4b0b-8c0c-95b6c5440c81", - "metadata": {}, - "source": [ - "**Resume**\n", - "\n", - "We can now call the agent again with no inputs to continue, ie. run the tool as requested. We can see from the logs that it passes in the update args to the tool." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "51923913-20f7-4ee1-b9ba-d01f5fb2869b", - "metadata": {}, - "outputs": [ + "cell_type": "code", + "execution_count": 5, + "id": "cf77f6eb-4cc0-4615-a095-eb5ae7027b7a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---Step 2---\n", + "--- hello universe! ---\n", + "---Step 3---\n", + "--- hello universe! ---\n" + ] + } + ], + "source": [ + "// Continue the graph execution\n", + "for await (const event of await graph.stream(null, graphStateConfig)) {\n", + " console.log(`--- ${event.input} ---`);\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "3333b771", + "metadata": {}, + "source": [ + "## Agent\n", + "\n", + "In the context of agents, updating state is useful for things like editing tool calls.\n", + " \n", + "To show this, we will build a relatively simple ReAct-style agent that does tool calling. \n", + "\n", + "We will use Anthropic's models and a fake tool (just for demo purposes)." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "6098e5cb", + "metadata": {}, + "outputs": [], + "source": [ + "// Set up the tool\n", + "import { ChatAnthropic } from \"@langchain/anthropic\";\n", + "import { tool } from \"@langchain/core/tools\";\n", + "import { StateGraph, START, END } from \"@langchain/langgraph\";\n", + "import { MemorySaver, messagesStateReducer } from \"@langchain/langgraph\";\n", + "import { ToolNode } from \"@langchain/langgraph/prebuilt\";\n", + "import { BaseMessage, AIMessage } from \"@langchain/core/messages\";\n", + "import { z } from \"zod\";\n", + "import { v4 as uuidv4 } from \"uuid\";\n", + "\n", + "const AgentState = 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", + " name: \"search\",\n", + " description: \"Call to surf the web.\",\n", + " schema: z.string(),\n", + "})\n", + "\n", + "const tools = [search]\n", + "const toolNode = new ToolNode(tools)\n", + "\n", + "// Set up the model\n", + "const model = new ChatAnthropic({ model: \"claude-3-5-sonnet-20240620\" })\n", + "const modelWithTools = model.bindTools(tools)\n", + "\n", + "\n", + "// Define nodes and conditional edges\n", + "\n", + "// Define the function that determines whether to continue or not\n", + "function shouldContinue(state: typeof AgentState.State): \"action\" | typeof END {\n", + " const lastMessage = state.messages[state.messages.length - 1];\n", + " // If there is no function call, then we finish\n", + " if (lastMessage && !(lastMessage as AIMessage).tool_calls?.length) {\n", + " return END;\n", + " }\n", + " // Otherwise if there is, we continue\n", + " return \"action\";\n", + "}\n", + "\n", + "// Define the function that calls the model\n", + "async function callModel(state: typeof AgentState.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", + " return { messages: [response] };\n", + "}\n", + "\n", + "// Define a new graph\n", + "const workflow = new StateGraph(AgentState)\n", + " // Define the two nodes we will cycle between\n", + " .addNode(\"agent\", callModel)\n", + " .addNode(\"action\", toolNode)\n", + " // We now add a conditional edge\n", + " .addConditionalEdges(\n", + " // First, we define the start node. We use `agent`.\n", + " // This means these are the edges taken after the `agent` node is called.\n", + " \"agent\",\n", + " // Next, we pass in the function that will determine which node is called next.\n", + " shouldContinue\n", + " )\n", + " // We now add a normal edge from `action` to `agent`.\n", + " // This means that after `action` is called, `agent` node is called next.\n", + " .addEdge(\"action\", \"agent\")\n", + " // Set the entrypoint as `agent`\n", + " // This means that this node is the first one called\n", + " .addEdge(START, \"agent\");\n", + "\n", + "// Setup memory\n", + "const memory = new MemorySaver();\n", + "\n", + "// Finally, we compile it!\n", + "// This compiles it into a LangChain Runnable,\n", + "// meaning you can use it as you would any other runnable\n", + "const app = workflow.compile({\n", + " checkpointer: memory,\n", + " interruptBefore: [\"action\"]\n", + "});" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "{\n", - " messages: [\n", - " HumanMessage {\n", - " \"id\": \"7c69c1f3-914b-4236-b2ca-ef250e72cb7a\",\n", - " \"content\": \"search for the weather in sf now\",\n", - " \"additional_kwargs\": {},\n", - " \"response_metadata\": {}\n", - " },\n", - " AIMessage {\n", - " \"id\": \"msg_0152mx7AweoRWa67HFsfyaif\",\n", - " \"content\": [\n", - " {\n", - " \"type\": \"text\",\n", - " \"text\": \"Certainly! I can help you search for the current weather in San Francisco. Let me use the search function to find that information for you.\"\n", - " },\n", - " {\n", - " \"type\": \"tool_use\",\n", - " \"id\": \"toolu_0141zTpknasyWkrjTV6eKeT6\",\n", - " \"name\": \"search\",\n", - " \"input\": {\n", - " \"input\": \"current weather in San Francisco\"\n", - " }\n", - " }\n", - " ],\n", - " \"additional_kwargs\": {\n", - " \"id\": \"msg_0152mx7AweoRWa67HFsfyaif\",\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\": 380,\n", - " \"output_tokens\": 84\n", - " }\n", - " },\n", - " \"response_metadata\": {\n", - " \"id\": \"msg_0152mx7AweoRWa67HFsfyaif\",\n", - " \"model\": \"claude-3-5-sonnet-20240620\",\n", - " \"stop_reason\": \"tool_use\",\n", - " \"stop_sequence\": null,\n", - " \"usage\": {\n", - " \"input_tokens\": 380,\n", - " \"output_tokens\": 84\n", - " },\n", - " \"type\": \"message\",\n", - " \"role\": \"assistant\"\n", - " },\n", - " \"tool_calls\": [\n", - " {\n", - " \"name\": \"search\",\n", - " \"args\": {\n", - " \"query\": \"current weather in SF\"\n", - " },\n", - " \"id\": \"toolu_0141zTpknasyWkrjTV6eKeT6\",\n", - " \"type\": \"tool_call\"\n", - " }\n", - " ],\n", - " \"invalid_tool_calls\": []\n", - " },\n", - " ToolMessage {\n", - " \"id\": \"ccf0d56f-477f-408a-b809-6900a48379e0\",\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_0141zTpknasyWkrjTV6eKeT6\"\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", - " messages: [\n", - " HumanMessage {\n", - " \"id\": \"7c69c1f3-914b-4236-b2ca-ef250e72cb7a\",\n", - " \"content\": \"search for the weather in sf now\",\n", - " \"additional_kwargs\": {},\n", - " \"response_metadata\": {}\n", - " },\n", - " AIMessage {\n", - " \"id\": \"msg_0152mx7AweoRWa67HFsfyaif\",\n", - " \"content\": [\n", - " {\n", - " \"type\": \"text\",\n", - " \"text\": \"Certainly! I can help you search for the current weather in San Francisco. Let me use the search function to find that information for you.\"\n", - " },\n", - " {\n", - " \"type\": \"tool_use\",\n", - " \"id\": \"toolu_0141zTpknasyWkrjTV6eKeT6\",\n", - " \"name\": \"search\",\n", - " \"input\": {\n", - " \"input\": \"current weather in San Francisco\"\n", - " }\n", - " }\n", - " ],\n", - " \"additional_kwargs\": {\n", - " \"id\": \"msg_0152mx7AweoRWa67HFsfyaif\",\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\": 380,\n", - " \"output_tokens\": 84\n", - " }\n", - " },\n", - " \"response_metadata\": {\n", - " \"id\": \"msg_0152mx7AweoRWa67HFsfyaif\",\n", - " \"model\": \"claude-3-5-sonnet-20240620\",\n", - " \"stop_reason\": \"tool_use\",\n", - " \"stop_sequence\": null,\n", - " \"usage\": {\n", - " \"input_tokens\": 380,\n", - " \"output_tokens\": 84\n", - " },\n", - " \"type\": \"message\",\n", - " \"role\": \"assistant\"\n", - " },\n", - " \"tool_calls\": [\n", - " {\n", - " \"name\": \"search\",\n", - " \"args\": {\n", - " \"query\": \"current weather in SF\"\n", - " },\n", - " \"id\": \"toolu_0141zTpknasyWkrjTV6eKeT6\",\n", - " \"type\": \"tool_call\"\n", - " }\n", - " ],\n", - " \"invalid_tool_calls\": []\n", - " },\n", - " ToolMessage {\n", - " \"id\": \"ccf0d56f-477f-408a-b809-6900a48379e0\",\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_0141zTpknasyWkrjTV6eKeT6\"\n", - " },\n", - " AIMessage {\n", - " \"id\": \"msg_01YJXesUpaB5PfhgmRBCwnnb\",\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. This means it's a clear day with plenty of sunshine. It's a great day to be outdoors or engage in activities that benefit from good weather.\\n\\nHowever, I should note that the search result included an unusual comment about Gemini zodiac signs. This appears to be unrelated to the weather and might be part of a joke or a reference to something else. For accurate and detailed weather information, I would recommend checking a reliable weather service or website for San Francisco.\\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_01YJXesUpaB5PfhgmRBCwnnb\",\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\": 498,\n", - " \"output_tokens\": 154\n", - " }\n", - " },\n", - " \"response_metadata\": {\n", - " \"id\": \"msg_01YJXesUpaB5PfhgmRBCwnnb\",\n", - " \"model\": \"claude-3-5-sonnet-20240620\",\n", - " \"stop_reason\": \"end_turn\",\n", - " \"stop_sequence\": null,\n", - " \"usage\": {\n", - " \"input_tokens\": 498,\n", - " \"output_tokens\": 154\n", - " },\n", - " \"type\": \"message\",\n", - " \"role\": \"assistant\"\n", - " },\n", - " \"tool_calls\": [],\n", - " \"invalid_tool_calls\": [],\n", - " \"usage_metadata\": {\n", - " \"input_tokens\": 498,\n", - " \"output_tokens\": 154,\n", - " \"total_tokens\": 652\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. This means it's a clear day with plenty of sunshine. It's a great day to be outdoors or engage in activities that benefit from good weather.\n", - "\n", - "However, I should note that the search result included an unusual comment about Gemini zodiac signs. This appears to be unrelated to the weather and might be part of a joke or a reference to something else. For accurate and detailed weather information, I would recommend checking a reliable weather service or website for San Francisco.\n", - "\n", - "Is there anything else you'd like to know about the weather in San Francisco or any other information you need?\n" - ] + "cell_type": "code", + "execution_count": 7, + "id": "9b011246", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import * as tslab from \"tslab\";\n", + "\n", + "const drawableGraph = app.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": "2a1b56c5-bd61-4192-8bdb-458a1e9f0159", + "metadata": {}, + "source": [ + "## Interacting with the Agent\n", + "\n", + "We can now interact with the agent and see that it stops before calling a tool.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "cfd140f0-a5a6-4697-8115-322242f197b5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "================================ human Message (1) =================================\n", + "search for the weather in sf now\n", + "================================ ai Message (1) =================================\n", + "[\n", + " {\n", + " type: 'text',\n", + " text: 'Certainly! I can help you search for the current weather in San Francisco. Let me use the search function to find that information for you.'\n", + " },\n", + " {\n", + " type: 'tool_use',\n", + " id: 'toolu_0141zTpknasyWkrjTV6eKeT6',\n", + " name: 'search',\n", + " input: { input: 'current weather in San Francisco' }\n", + " }\n", + "]\n" + ] + } + ], + "source": [ + "import { HumanMessage } from \"@langchain/core/messages\";\n", + "// Input\n", + "const inputs = new HumanMessage(\"search for the weather in sf now\");\n", + "\n", + "// Thread\n", + "const config = { configurable: { thread_id: \"3\" }, streamMode: \"values\" as const };\n", + "\n", + "for await (const event of await app.stream({\n", + " messages: [inputs]\n", + "}, config)) {\n", + " const recentMsg = event.messages[event.messages.length - 1];\n", + " console.log(`================================ ${recentMsg._getType()} Message (1) =================================`)\n", + " console.log(recentMsg.content);\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "78e3f5b9-9700-42b1-863f-c404861f8620", + "metadata": {}, + "source": [ + "**Edit**\n", + "\n", + "We can now update the state accordingly. Let's modify the tool call to have the query `\"current weather in SF\"`." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "1aa7b1b9-9322-4815-bc0d-eb083870ac15", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{\n", + " configurable: {\n", + " thread_id: '3',\n", + " checkpoint_id: '1ef5e785-4298-6b71-8002-4a6ceca964db'\n", + " }\n", + "}\n" + ] + } + ], + "source": [ + "// First, lets get the current state\n", + "const currentState = await app.getState(config);\n", + "\n", + "// Let's now get the last message in the state\n", + "// This is the one with the tool calls that we want to update\n", + "let lastMessage = currentState.values.messages[currentState.values.messages.length - 1]\n", + "\n", + "// Let's now update the args for that tool call\n", + "lastMessage.tool_calls[0].args = { query: \"current weather in SF\" }\n", + "\n", + "// Let's now call `updateState` to pass in this message in the `messages` key\n", + "// This will get treated as any other update to the state\n", + "// It will get passed to the reducer function for the `messages` key\n", + "// That reducer function will use the ID of the message to update it\n", + "// It's important that it has the right ID! Otherwise it would get appended\n", + "// as a new message\n", + "await app.updateState(config, { messages: lastMessage });" + ] + }, + { + "cell_type": "markdown", + "id": "0dcc5457-1ba1-4cba-ac41-da5c67cc67e5", + "metadata": {}, + "source": [ + "Let's now check the current state of the app to make sure it got updated accordingly" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "a3fcf2bd-f881-49fe-b20e-ad16e6819bc6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[\n", + " {\n", + " name: 'search',\n", + " args: { query: 'current weather in SF' },\n", + " id: 'toolu_0141zTpknasyWkrjTV6eKeT6',\n", + " type: 'tool_call'\n", + " }\n", + "]\n" + ] + } + ], + "source": [ + "const newState = await app.getState(config);\n", + "const updatedStateToolCalls = newState.values.messages[newState.values.messages.length -1 ].tool_calls\n", + "console.log(updatedStateToolCalls)" + ] + }, + { + "cell_type": "markdown", + "id": "1bca3814-db08-4b0b-8c0c-95b6c5440c81", + "metadata": {}, + "source": [ + "**Resume**\n", + "\n", + "We can now call the agent again with no inputs to continue, ie. run the tool as requested. We can see from the logs that it passes in the update args to the tool." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "51923913-20f7-4ee1-b9ba-d01f5fb2869b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{\n", + " messages: [\n", + " HumanMessage {\n", + " \"id\": \"7c69c1f3-914b-4236-b2ca-ef250e72cb7a\",\n", + " \"content\": \"search for the weather in sf now\",\n", + " \"additional_kwargs\": {},\n", + " \"response_metadata\": {}\n", + " },\n", + " AIMessage {\n", + " \"id\": \"msg_0152mx7AweoRWa67HFsfyaif\",\n", + " \"content\": [\n", + " {\n", + " \"type\": \"text\",\n", + " \"text\": \"Certainly! I can help you search for the current weather in San Francisco. Let me use the search function to find that information for you.\"\n", + " },\n", + " {\n", + " \"type\": \"tool_use\",\n", + " \"id\": \"toolu_0141zTpknasyWkrjTV6eKeT6\",\n", + " \"name\": \"search\",\n", + " \"input\": {\n", + " \"input\": \"current weather in San Francisco\"\n", + " }\n", + " }\n", + " ],\n", + " \"additional_kwargs\": {\n", + " \"id\": \"msg_0152mx7AweoRWa67HFsfyaif\",\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\": 380,\n", + " \"output_tokens\": 84\n", + " }\n", + " },\n", + " \"response_metadata\": {\n", + " \"id\": \"msg_0152mx7AweoRWa67HFsfyaif\",\n", + " \"model\": \"claude-3-5-sonnet-20240620\",\n", + " \"stop_reason\": \"tool_use\",\n", + " \"stop_sequence\": null,\n", + " \"usage\": {\n", + " \"input_tokens\": 380,\n", + " \"output_tokens\": 84\n", + " },\n", + " \"type\": \"message\",\n", + " \"role\": \"assistant\"\n", + " },\n", + " \"tool_calls\": [\n", + " {\n", + " \"name\": \"search\",\n", + " \"args\": {\n", + " \"query\": \"current weather in SF\"\n", + " },\n", + " \"id\": \"toolu_0141zTpknasyWkrjTV6eKeT6\",\n", + " \"type\": \"tool_call\"\n", + " }\n", + " ],\n", + " \"invalid_tool_calls\": []\n", + " },\n", + " ToolMessage {\n", + " \"id\": \"ccf0d56f-477f-408a-b809-6900a48379e0\",\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_0141zTpknasyWkrjTV6eKeT6\"\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", + " messages: [\n", + " HumanMessage {\n", + " \"id\": \"7c69c1f3-914b-4236-b2ca-ef250e72cb7a\",\n", + " \"content\": \"search for the weather in sf now\",\n", + " \"additional_kwargs\": {},\n", + " \"response_metadata\": {}\n", + " },\n", + " AIMessage {\n", + " \"id\": \"msg_0152mx7AweoRWa67HFsfyaif\",\n", + " \"content\": [\n", + " {\n", + " \"type\": \"text\",\n", + " \"text\": \"Certainly! I can help you search for the current weather in San Francisco. Let me use the search function to find that information for you.\"\n", + " },\n", + " {\n", + " \"type\": \"tool_use\",\n", + " \"id\": \"toolu_0141zTpknasyWkrjTV6eKeT6\",\n", + " \"name\": \"search\",\n", + " \"input\": {\n", + " \"input\": \"current weather in San Francisco\"\n", + " }\n", + " }\n", + " ],\n", + " \"additional_kwargs\": {\n", + " \"id\": \"msg_0152mx7AweoRWa67HFsfyaif\",\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\": 380,\n", + " \"output_tokens\": 84\n", + " }\n", + " },\n", + " \"response_metadata\": {\n", + " \"id\": \"msg_0152mx7AweoRWa67HFsfyaif\",\n", + " \"model\": \"claude-3-5-sonnet-20240620\",\n", + " \"stop_reason\": \"tool_use\",\n", + " \"stop_sequence\": null,\n", + " \"usage\": {\n", + " \"input_tokens\": 380,\n", + " \"output_tokens\": 84\n", + " },\n", + " \"type\": \"message\",\n", + " \"role\": \"assistant\"\n", + " },\n", + " \"tool_calls\": [\n", + " {\n", + " \"name\": \"search\",\n", + " \"args\": {\n", + " \"query\": \"current weather in SF\"\n", + " },\n", + " \"id\": \"toolu_0141zTpknasyWkrjTV6eKeT6\",\n", + " \"type\": \"tool_call\"\n", + " }\n", + " ],\n", + " \"invalid_tool_calls\": []\n", + " },\n", + " ToolMessage {\n", + " \"id\": \"ccf0d56f-477f-408a-b809-6900a48379e0\",\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_0141zTpknasyWkrjTV6eKeT6\"\n", + " },\n", + " AIMessage {\n", + " \"id\": \"msg_01YJXesUpaB5PfhgmRBCwnnb\",\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. This means it's a clear day with plenty of sunshine. It's a great day to be outdoors or engage in activities that benefit from good weather.\\n\\nHowever, I should note that the search result included an unusual comment about Gemini zodiac signs. This appears to be unrelated to the weather and might be part of a joke or a reference to something else. For accurate and detailed weather information, I would recommend checking a reliable weather service or website for San Francisco.\\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_01YJXesUpaB5PfhgmRBCwnnb\",\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\": 498,\n", + " \"output_tokens\": 154\n", + " }\n", + " },\n", + " \"response_metadata\": {\n", + " \"id\": \"msg_01YJXesUpaB5PfhgmRBCwnnb\",\n", + " \"model\": \"claude-3-5-sonnet-20240620\",\n", + " \"stop_reason\": \"end_turn\",\n", + " \"stop_sequence\": null,\n", + " \"usage\": {\n", + " \"input_tokens\": 498,\n", + " \"output_tokens\": 154\n", + " },\n", + " \"type\": \"message\",\n", + " \"role\": \"assistant\"\n", + " },\n", + " \"tool_calls\": [],\n", + " \"invalid_tool_calls\": [],\n", + " \"usage_metadata\": {\n", + " \"input_tokens\": 498,\n", + " \"output_tokens\": 154,\n", + " \"total_tokens\": 652\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. This means it's a clear day with plenty of sunshine. It's a great day to be outdoors or engage in activities that benefit from good weather.\n", + "\n", + "However, I should note that the search result included an unusual comment about Gemini zodiac signs. This appears to be unrelated to the weather and might be part of a joke or a reference to something else. For accurate and detailed weather information, I would recommend checking a reliable weather service or website for San Francisco.\n", + "\n", + "Is there anything else you'd like to know about the weather in San Francisco or any other information you need?\n" + ] + } + ], + "source": [ + "for await (const event of await app.stream(null, config)) {\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", + "}" + ] + } + ], + "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" } - ], - "source": [ - "for await (const event of await app.stream(null, config)) {\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", - "}" - ] - } - ], - "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 -} + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file diff --git a/examples/how-tos/human-in-the-loop.ipynb b/examples/how-tos/human-in-the-loop.ipynb index 8b382abc..d2299301 100644 --- a/examples/how-tos/human-in-the-loop.ipynb +++ b/examples/how-tos/human-in-the-loop.ipynb @@ -1,473 +1,473 @@ { - "cells": [ - { - "cell_type": "markdown", - "id": "7388763d", - "metadata": {}, - "source": [ - "# How to add human-in-the-loop\n", - "\n", - "When creating LangGraph agents, it is often nice to add a human in the loop\n", - "component. This can be helpful when giving them access to tools. Often in these\n", - "situations you may want to manually approve an action before taking.\n", - "\n", - "This can be in several ways, but the primary supported way is to add an\n", - "\"interrupt\" before a node is executed. This interrupts execution at that node.\n", - "You can then resume from that spot to continue.\n", - "\n", - "
\n", - "

Note

\n", - "

\n", - " In this how-to, we will create our agent from scratch to be transparent (but verbose). You can accomplish similar functionality using either `interruptBefore` or `interruptAfter` in the createReactAgent(model, tools=tool, interruptBefore=[\"tools\" | \"agent\"], interruptAfter=[\"tools\" | \"agent\"]) API doc constructor. This may be more appropriate if you are used to LangChain's AgentExecutor class.\n", - "

\n", - "
\n", - "\n", - "## Setup\n", - "\n", - "First we need to install the packages required\n", - "\n", - "```bash\n", - "yarn add @langchain/langgraph\n", - "```\n", - "\n", - "Next, we need to set API keys for OpenAI (the LLM we will use). Optionally, we\n", - "can set API key for [LangSmith tracing](https://smith.langchain.com/), which\n", - "will give us best-in-class observability." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "74b6bfe1", - "metadata": { - "lines_to_next_cell": 2 - }, - "outputs": [ + "cells": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "Human-in-the-loop: 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 = \"Human-in-the-loop: LangGraphJS\";" - ] - }, - { - "cell_type": "markdown", - "id": "a7b247cf", - "metadata": {}, - "source": [ - "## Set up the State\n", - "\n", - "The state is the interface for all the nodes.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "50c5189d", - "metadata": { - "lines_to_next_cell": 2 - }, - "outputs": [], - "source": [ - "import { Annotation } from \"@langchain/langgraph\";\n", - "import { BaseMessage } from \"@langchain/core/messages\";\n", - "\n", - "const AgentState = Annotation.Root({\n", - " messages: Annotation({\n", - " reducer: (x, y) => x.concat(y),\n", - " }),\n", - "});" - ] - }, - { - "cell_type": "markdown", - "id": "b1607663", - "metadata": {}, - "source": [ - "## Set up the tools\n", - "\n", - "We will first define the tools we want to use. For this simple example, we will\n", - "create a placeholder \"search engine\". However, it is really easy to create your\n", - "own tools - see the\n", - "[LangChain documentation](https://js.langchain.com/docs/modules/agents/tools/)\n", - "on how to do that." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "b24f1e9e", - "metadata": { - "lines_to_next_cell": 2 - }, - "outputs": [], - "source": [ - "import { DynamicStructuredTool } from \"@langchain/core/tools\";\n", - "import { z } from \"zod\";\n", - "\n", - "const searchTool = new DynamicStructuredTool({\n", - " name: \"search\",\n", - " description: \"Call to surf the web.\",\n", - " schema: z.object({\n", - " query: z.string().describe(\"The query to use in your search.\"),\n", - " }),\n", - " func: async ({}: { query: string }) => {\n", - " // This is a placeholder for the actual implementation\n", - " // Don't let the LLM know this though 😊\n", - " return \"It's sunny in San Francisco, but you better look out if you're a Gemini 😈.\";\n", - " },\n", - "});\n", - "\n", - "const tools = [searchTool];" - ] - }, - { - "cell_type": "markdown", - "id": "1cfcf345", - "metadata": {}, - "source": [ - "We can now wrap these tools in a simple\n", - "[ToolNode](https://langchain-ai.github.io/langgraphjs/reference/classes/langgraph_prebuilt.ToolNode.html).\n", - "\n", - "This is a simple class that takes in a list of messages containing an\n", - "[AIMessage with tool_calls](https://v02.api.js.langchain.com/classes/langchain_core_messages.AIMessage.html),\n", - "runs the tools, and returns the output as\\\n", - "[ToolMessage](https://v02.api.js.langchain.com/classes/langchain_core_messages_tool.ToolMessage.html)s." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "528a8e10", - "metadata": { - "lines_to_next_cell": 2 - }, - "outputs": [], - "source": [ - "import { ToolNode } from \"@langchain/langgraph/prebuilt\";\n", - "\n", - "const toolNode = new ToolNode(tools);" - ] - }, - { - "cell_type": "markdown", - "id": "b3bed0ce", - "metadata": {}, - "source": [ - "## Set up the model\n", - "\n", - "Now we need to load the chat model we want to use. Since we are creating a\n", - "tool-using ReAct agent, we want to make sure the model supports\n", - "[Tool Calling](https://js.langchain.com/docs/modules/model_io/models/chat/function-calling/)\n", - "and works with chat messages.\n", - "\n", - "Note: these model requirements are not requirements for using LangGraph - they\n", - "are just requirements for this one example." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "b12434ff", - "metadata": { - "lines_to_next_cell": 2 - }, - "outputs": [], - "source": [ - "import { ChatOpenAI } from \"@langchain/openai\";\n", - "\n", - "const model = new ChatOpenAI({ temperature: 0 });\n", - "\n", - "// After we've done this, we should make sure the model knows that it has these tools available to call.\n", - "// We can do this by binding the tools to the model class.\n", - "const boundModel = model.bindTools(tools);" - ] - }, - { - "cell_type": "markdown", - "id": "97312191", - "metadata": {}, - "source": [ - "## Define the nodes\n", - "\n", - "We now need to define a few different nodes in our graph. In `langgraph`, a node\n", - "can be either a function or a\\\n", - "[runnable](https://js.langchain.com/docs/modules/runnables/). There are two main\n", - "nodes we need for this:\n", - "\n", - "1. The agent: responsible for deciding what (if any) actions to take.\n", - "2. A function to invoke tools: if the agent decides to take an action, this\n", - " node\\\n", - " will then execute that action.\n", - "\n", - "We will also need to define some edges. Some of these edges may be conditional.\n", - "The reason they are conditional is that based on the output of a node, one of\n", - "several paths may be taken. The path that is taken is not known until that node\n", - "is run (the LLM decides).\n", - "\n", - "1. Conditional Edge: after the agent is called, we should either: a. If the\n", - " agent said to take an action, then the function to invoke tools should be\n", - " called\\\n", - " b. If the agent said that it was finished, then it should finish\n", - "2. Normal Edge: after the tools are invoked, it should always go back to the\n", - " agent to decide what to do next\n", - "\n", - "Let's define the nodes, as well as a function to decide how what conditional\n", - "edge to take." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "b52bef4a", - "metadata": {}, - "outputs": [], - "source": [ - "import { RunnableConfig } from \"@langchain/core/runnables\";\n", - "import { AIMessage } from \"@langchain/core/messages\";\n", - "import { END } from \"@langchain/langgraph\";\n", - "\n", - "const routeMessage = (state: typeof AgentState.State) => {\n", - " const { messages } = state;\n", - " const lastMessage = messages[messages.length - 1] as AIMessage;\n", - " // If no tools are called, we can finish (respond to the user)\n", - " if (!lastMessage?.tool_calls?.length) {\n", - " return END;\n", - " }\n", - " // Otherwise if there is, we continue and call the tools\n", - " return \"tools\";\n", - "};\n", - "\n", - "const callModel = async (\n", - " state: typeof AgentState.State,\n", - " config?: RunnableConfig,\n", - ") => {\n", - " const { messages } = state;\n", - " const response = await boundModel.invoke(messages, config);\n", - " return { messages: [response] };\n", - "};" - ] - }, - { - "cell_type": "markdown", - "id": "22360833", - "metadata": {}, - "source": [ - "## Define the graph\n", - "\n", - "We can now put it all together and define the graph!\n" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "a8b8dace", - "metadata": {}, - "outputs": [], - "source": [ - "import { START, StateGraph } from \"@langchain/langgraph\";\n", - "import { MemorySaver } from \"@langchain/langgraph\";\n", - "\n", - "const workflow = new StateGraph(AgentState)\n", - " .addNode(\"agent\", callModel)\n", - " .addNode(\"tools\", toolNode)\n", - " .addEdge(START, \"agent\")\n", - " .addConditionalEdges(\"agent\", routeMessage)\n", - " .addEdge(\"tools\", \"agent\");\n", - "\n", - "// **Persistence**\n", - "// Human-in-the-loop workflows require a checkpointer to ensure\n", - "// nothing is lost between interactions\n", - "const checkpointer = new MemorySaver();\n", - "\n", - "// **Interrupt**\n", - "// To always interrupt before a particular node, pass the name of the node to `interruptBefore` when compiling.\n", - "const graph = workflow.compile({ checkpointer, interruptBefore: [\"tools\"] });" - ] - }, - { - "cell_type": "markdown", - "id": "325d45c5", - "metadata": {}, - "source": [ - "## Interacting with the Agent\n", - "\n", - "We can now interact with the agent and see that it stops before calling a tool.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "17d79c6b", - "metadata": {}, - "outputs": [ + "cell_type": "markdown", + "id": "7388763d", + "metadata": {}, + "source": [ + "# How to add human-in-the-loop\n", + "\n", + "When creating LangGraph agents, it is often nice to add a human in the loop\n", + "component. This can be helpful when giving them access to tools. Often in these\n", + "situations you may want to manually approve an action before taking.\n", + "\n", + "This can be in several ways, but the primary supported way is to add an\n", + "\"interrupt\" before a node is executed. This interrupts execution at that node.\n", + "You can then resume from that spot to continue.\n", + "\n", + "
\n", + "

Note

\n", + "

\n", + " In this how-to, we will create our agent from scratch to be transparent (but verbose). You can accomplish similar functionality using either `interruptBefore` or `interruptAfter` in the createReactAgent(model, tools=tool, interruptBefore=[\"tools\" | \"agent\"], interruptAfter=[\"tools\" | \"agent\"]) API doc constructor. This may be more appropriate if you are used to LangChain's AgentExecutor class.\n", + "

\n", + "
\n", + "\n", + "## Setup\n", + "\n", + "First we need to install the packages required\n", + "\n", + "```bash\n", + "yarn add @langchain/langgraph\n", + "```\n", + "\n", + "Next, we need to set API keys for OpenAI (the LLM we will use). Optionally, we\n", + "can set API key for [LangSmith tracing](https://smith.langchain.com/), which\n", + "will give us best-in-class observability." + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "[human]: hi! I'm bob\n", - "[ai]: Hello Bob! How can I assist you today?\n" - ] - } - ], - "source": [ - "import { HumanMessage, isAIMessage } from \"@langchain/core/messages\";\n", - "\n", - "const prettyPrint = (message: BaseMessage) => {\n", - " let txt = `[${message._getType()}]: ${message.content}`;\n", - " if (\n", - " isAIMessage(message) && (message as AIMessage)?.tool_calls?.length || 0 > 0\n", - " ) {\n", - " const tool_calls = (message as AIMessage)?.tool_calls\n", - " ?.map((tc) => `- ${tc.name}(${JSON.stringify(tc.args)})`)\n", - " .join(\"\\n\");\n", - " txt += ` \\nTools: \\n${tool_calls}`;\n", - " }\n", - " console.log(txt);\n", - "};\n", - "\n", - "const config = { configurable: { thread_id: \"example-thread-1\" } };\n", - "\n", - "let inputs = { messages: [new HumanMessage(\"hi! I'm bob\")] };\n", - "for await (\n", - " const { messages } of await graph.stream(inputs, {\n", - " ...config,\n", - " streamMode: \"values\",\n", - " })\n", - ") {\n", - " prettyPrint(messages[messages.length - 1]);\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "2166619d", - "metadata": {}, - "outputs": [ + "cell_type": "code", + "execution_count": 1, + "id": "74b6bfe1", + "metadata": { + "lines_to_next_cell": 2 + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Human-in-the-loop: 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 = \"Human-in-the-loop: LangGraphJS\";" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "[human]: What did I tell you my name was?\n", - "[ai]: You mentioned that your name is Bob. How can I assist you, Bob?\n" - ] - } - ], - "source": [ - "inputs = { messages: [new HumanMessage(\"What did I tell you my name was?\")] };\n", - "for await (\n", - " const { messages } of await graph.stream(inputs, {\n", - " ...config,\n", - " streamMode: \"values\",\n", - " })\n", - ") {\n", - " prettyPrint(messages[messages.length - 1]);\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "f523a658", - "metadata": {}, - "outputs": [ + "cell_type": "markdown", + "id": "a7b247cf", + "metadata": {}, + "source": [ + "## Set up the State\n", + "\n", + "The state is the interface for all the nodes.\n" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "[human]: what's the weather in sf now?\n", - "[ai]: \n", - "Tools: \n", - "- search({\"query\":\"weather in San Francisco\"})\n" - ] - } - ], - "source": [ - "inputs = { messages: [new HumanMessage(\"what's the weather in sf now?\")] };\n", - "for await (\n", - " const { messages } of await graph.stream(inputs, {\n", - " ...config,\n", - " streamMode: \"values\",\n", - " })\n", - ") {\n", - " prettyPrint(messages[messages.length - 1]);\n", - "}" - ] - }, - { - "cell_type": "markdown", - "id": "13d79e78", - "metadata": {}, - "source": [ - "**Resume**\n", - "\n", - "We can now call the agent again with no inputs to continue, ie. run the tool as\n", - "requested.\n", - "\n", - "Running an interrupted graph with `null` as the input means to \"proceed as if\n", - "the interruption didn't occur.\"" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "a0dc047e", - "metadata": {}, - "outputs": [ + "cell_type": "code", + "execution_count": 2, + "id": "50c5189d", + "metadata": { + "lines_to_next_cell": 2 + }, + "outputs": [], + "source": [ + "import { Annotation } from \"@langchain/langgraph\";\n", + "import { BaseMessage } from \"@langchain/core/messages\";\n", + "\n", + "const AgentState = Annotation.Root({\n", + " messages: Annotation({\n", + " reducer: (x, y) => x.concat(y),\n", + " }),\n", + "});" + ] + }, + { + "cell_type": "markdown", + "id": "b1607663", + "metadata": {}, + "source": [ + "## Set up the tools\n", + "\n", + "We will first define the tools we want to use. For this simple example, we will\n", + "create a placeholder \"search engine\". However, it is really easy to create your\n", + "own tools - see the\n", + "[LangChain documentation](https://js.langchain.com/docs/modules/agents/tools/)\n", + "on how to do that." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "b24f1e9e", + "metadata": { + "lines_to_next_cell": 2 + }, + "outputs": [], + "source": [ + "import { DynamicStructuredTool } from \"@langchain/core/tools\";\n", + "import { z } from \"zod\";\n", + "\n", + "const searchTool = new DynamicStructuredTool({\n", + " name: \"search\",\n", + " description: \"Call to surf the web.\",\n", + " schema: z.object({\n", + " query: z.string().describe(\"The query to use in your search.\"),\n", + " }),\n", + " func: async ({}: { query: string }) => {\n", + " // This is a placeholder for the actual implementation\n", + " // Don't let the LLM know this though 😊\n", + " return \"It's sunny in San Francisco, but you better look out if you're a Gemini 😈.\";\n", + " },\n", + "});\n", + "\n", + "const tools = [searchTool];" + ] + }, + { + "cell_type": "markdown", + "id": "1cfcf345", + "metadata": {}, + "source": [ + "We can now wrap these tools in a simple\n", + "[ToolNode](/langgraphjs/reference/classes/langgraph_prebuilt.ToolNode.html).\n", + "\n", + "This is a simple class that takes in a list of messages containing an\n", + "[AIMessage with tool_calls](https://v02.api.js.langchain.com/classes/langchain_core_messages.AIMessage.html),\n", + "runs the tools, and returns the output as\\\n", + "[ToolMessage](https://v02.api.js.langchain.com/classes/langchain_core_messages_tool.ToolMessage.html)s." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "528a8e10", + "metadata": { + "lines_to_next_cell": 2 + }, + "outputs": [], + "source": [ + "import { ToolNode } from \"@langchain/langgraph/prebuilt\";\n", + "\n", + "const toolNode = new ToolNode(tools);" + ] + }, + { + "cell_type": "markdown", + "id": "b3bed0ce", + "metadata": {}, + "source": [ + "## Set up the model\n", + "\n", + "Now we need to load the chat model we want to use. Since we are creating a\n", + "tool-using ReAct agent, we want to make sure the model supports\n", + "[Tool Calling](https://js.langchain.com/docs/modules/model_io/models/chat/function-calling/)\n", + "and works with chat messages.\n", + "\n", + "Note: these model requirements are not requirements for using LangGraph - they\n", + "are just requirements for this one example." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "b12434ff", + "metadata": { + "lines_to_next_cell": 2 + }, + "outputs": [], + "source": [ + "import { ChatOpenAI } from \"@langchain/openai\";\n", + "\n", + "const model = new ChatOpenAI({ temperature: 0 });\n", + "\n", + "// After we've done this, we should make sure the model knows that it has these tools available to call.\n", + "// We can do this by binding the tools to the model class.\n", + "const boundModel = model.bindTools(tools);" + ] + }, + { + "cell_type": "markdown", + "id": "97312191", + "metadata": {}, + "source": [ + "## Define the nodes\n", + "\n", + "We now need to define a few different nodes in our graph. In `langgraph`, a node\n", + "can be either a function or a\\\n", + "[runnable](https://js.langchain.com/docs/modules/runnables/). There are two main\n", + "nodes we need for this:\n", + "\n", + "1. The agent: responsible for deciding what (if any) actions to take.\n", + "2. A function to invoke tools: if the agent decides to take an action, this\n", + " node\\\n", + " will then execute that action.\n", + "\n", + "We will also need to define some edges. Some of these edges may be conditional.\n", + "The reason they are conditional is that based on the output of a node, one of\n", + "several paths may be taken. The path that is taken is not known until that node\n", + "is run (the LLM decides).\n", + "\n", + "1. Conditional Edge: after the agent is called, we should either: a. If the\n", + " agent said to take an action, then the function to invoke tools should be\n", + " called\\\n", + " b. If the agent said that it was finished, then it should finish\n", + "2. Normal Edge: after the tools are invoked, it should always go back to the\n", + " agent to decide what to do next\n", + "\n", + "Let's define the nodes, as well as a function to decide how what conditional\n", + "edge to take." + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "[tool]: It's sunny in San Francisco, but you better look out if you're a Gemini 😈.\n", - "[ai]: It seems like it's sunny in San Francisco at the moment. If you need more detailed weather information, feel free to ask!\n" - ] + "cell_type": "code", + "execution_count": 6, + "id": "b52bef4a", + "metadata": {}, + "outputs": [], + "source": [ + "import { RunnableConfig } from \"@langchain/core/runnables\";\n", + "import { AIMessage } from \"@langchain/core/messages\";\n", + "import { END } from \"@langchain/langgraph\";\n", + "\n", + "const routeMessage = (state: typeof AgentState.State) => {\n", + " const { messages } = state;\n", + " const lastMessage = messages[messages.length - 1] as AIMessage;\n", + " // If no tools are called, we can finish (respond to the user)\n", + " if (!lastMessage?.tool_calls?.length) {\n", + " return END;\n", + " }\n", + " // Otherwise if there is, we continue and call the tools\n", + " return \"tools\";\n", + "};\n", + "\n", + "const callModel = async (\n", + " state: typeof AgentState.State,\n", + " config?: RunnableConfig,\n", + ") => {\n", + " const { messages } = state;\n", + " const response = await boundModel.invoke(messages, config);\n", + " return { messages: [response] };\n", + "};" + ] + }, + { + "cell_type": "markdown", + "id": "22360833", + "metadata": {}, + "source": [ + "## Define the graph\n", + "\n", + "We can now put it all together and define the graph!\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "a8b8dace", + "metadata": {}, + "outputs": [], + "source": [ + "import { START, StateGraph } from \"@langchain/langgraph\";\n", + "import { MemorySaver } from \"@langchain/langgraph\";\n", + "\n", + "const workflow = new StateGraph(AgentState)\n", + " .addNode(\"agent\", callModel)\n", + " .addNode(\"tools\", toolNode)\n", + " .addEdge(START, \"agent\")\n", + " .addConditionalEdges(\"agent\", routeMessage)\n", + " .addEdge(\"tools\", \"agent\");\n", + "\n", + "// **Persistence**\n", + "// Human-in-the-loop workflows require a checkpointer to ensure\n", + "// nothing is lost between interactions\n", + "const checkpointer = new MemorySaver();\n", + "\n", + "// **Interrupt**\n", + "// To always interrupt before a particular node, pass the name of the node to `interruptBefore` when compiling.\n", + "const graph = workflow.compile({ checkpointer, interruptBefore: [\"tools\"] });" + ] + }, + { + "cell_type": "markdown", + "id": "325d45c5", + "metadata": {}, + "source": [ + "## Interacting with the Agent\n", + "\n", + "We can now interact with the agent and see that it stops before calling a tool.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "17d79c6b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[human]: hi! I'm bob\n", + "[ai]: Hello Bob! How can I assist you today?\n" + ] + } + ], + "source": [ + "import { HumanMessage, isAIMessage } from \"@langchain/core/messages\";\n", + "\n", + "const prettyPrint = (message: BaseMessage) => {\n", + " let txt = `[${message._getType()}]: ${message.content}`;\n", + " if (\n", + " isAIMessage(message) && (message as AIMessage)?.tool_calls?.length || 0 > 0\n", + " ) {\n", + " const tool_calls = (message as AIMessage)?.tool_calls\n", + " ?.map((tc) => `- ${tc.name}(${JSON.stringify(tc.args)})`)\n", + " .join(\"\\n\");\n", + " txt += ` \\nTools: \\n${tool_calls}`;\n", + " }\n", + " console.log(txt);\n", + "};\n", + "\n", + "const config = { configurable: { thread_id: \"example-thread-1\" } };\n", + "\n", + "let inputs = { messages: [new HumanMessage(\"hi! I'm bob\")] };\n", + "for await (\n", + " const { messages } of await graph.stream(inputs, {\n", + " ...config,\n", + " streamMode: \"values\",\n", + " })\n", + ") {\n", + " prettyPrint(messages[messages.length - 1]);\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "2166619d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[human]: What did I tell you my name was?\n", + "[ai]: You mentioned that your name is Bob. How can I assist you, Bob?\n" + ] + } + ], + "source": [ + "inputs = { messages: [new HumanMessage(\"What did I tell you my name was?\")] };\n", + "for await (\n", + " const { messages } of await graph.stream(inputs, {\n", + " ...config,\n", + " streamMode: \"values\",\n", + " })\n", + ") {\n", + " prettyPrint(messages[messages.length - 1]);\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "f523a658", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[human]: what's the weather in sf now?\n", + "[ai]: \n", + "Tools: \n", + "- search({\"query\":\"weather in San Francisco\"})\n" + ] + } + ], + "source": [ + "inputs = { messages: [new HumanMessage(\"what's the weather in sf now?\")] };\n", + "for await (\n", + " const { messages } of await graph.stream(inputs, {\n", + " ...config,\n", + " streamMode: \"values\",\n", + " })\n", + ") {\n", + " prettyPrint(messages[messages.length - 1]);\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "13d79e78", + "metadata": {}, + "source": [ + "**Resume**\n", + "\n", + "We can now call the agent again with no inputs to continue, ie. run the tool as\n", + "requested.\n", + "\n", + "Running an interrupted graph with `null` as the input means to \"proceed as if\n", + "the interruption didn't occur.\"" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "a0dc047e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[tool]: It's sunny in San Francisco, but you better look out if you're a Gemini 😈.\n", + "[ai]: It seems like it's sunny in San Francisco at the moment. If you need more detailed weather information, feel free to ask!\n" + ] + } + ], + "source": [ + "for await (\n", + " const { messages } of await graph.stream(null, {\n", + " ...config,\n", + " streamMode: \"values\",\n", + " })\n", + ") {\n", + " prettyPrint(messages[messages.length - 1]);\n", + "}" + ] + } + ], + "metadata": { + "jupytext": { + "encoding": "# -*- coding: utf-8 -*-" + }, + "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" } - ], - "source": [ - "for await (\n", - " const { messages } of await graph.stream(null, {\n", - " ...config,\n", - " streamMode: \"values\",\n", - " })\n", - ") {\n", - " prettyPrint(messages[messages.length - 1]);\n", - "}" - ] - } - ], - "metadata": { - "jupytext": { - "encoding": "# -*- coding: utf-8 -*-" - }, - "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 + "nbformat": 4, + "nbformat_minor": 5 } diff --git a/examples/how-tos/manage-ecosystem-dependencies.ipynb b/examples/how-tos/manage-ecosystem-dependencies.ipynb index 3990ebe5..4e75d4e6 100644 --- a/examples/how-tos/manage-ecosystem-dependencies.ipynb +++ b/examples/how-tos/manage-ecosystem-dependencies.ipynb @@ -1,124 +1,124 @@ { - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# How to install and manage dependencies\n", - "\n", - "LangGraph.js is part of the [LangChain](https://js.langchain.com/) ecosystem,\n", - "which includes the primary\n", - "[`langchain`](https://www.npmjs.com/package/langchain) package as well as\n", - "packages that contain integrations with individual third-party providers. They\n", - "can be as specific as\n", - "[`@langchain/anthropic`](https://www.npmjs.com/package/@langchain/anthropic),\n", - "which contains integrations just for Anthropic chat models, or as broad as\n", - "[`@langchain/community`](https://www.npmjs.com/package/@langchain/community),\n", - "which contains broader variety of community contributed integrations.\n", - "\n", - "These packages, as well as LangGraph.js itself, all depend on\n", - "[`@langchain/core`](https://www.npmjs.com/package/@langchain/core), which\n", - "contains the base abstractions that these packages extend.\n", - "\n", - "To ensure that all integrations and their types interact with each other\n", - "properly, it is important that they all use the same version of\n", - "`@langchain/core`. The best way to guarantee this is to add a `\"resolutions\"` or\n", - "`\"overrides\"` field like the following in your project's `package.json`. The\n", - "specific field name will depend on your package manager. Here are a few\n", - "examples:\n", - "\n", - "
\n", - "

Tip

\n", - "

\n", - " The resolutions or pnpm.overrides fields for yarn or pnpm must be set in the root package.json file.\n", - "

\n", - "
\n", - "\n", - "If you are using `yarn`, you should set\n", - "[`\"resolutions\"`](https://yarnpkg.com/cli/set/resolution):\n", - "\n", - "```json\n", - "{\n", - " \"name\": \"your-project\",\n", - " \"version\": \"0.0.0\",\n", - " \"private\": true,\n", - " \"engines\": {\n", - " \"node\": \">=18\"\n", - " },\n", - " \"dependencies\": {\n", - " \"@langchain/anthropic\": \"^0.2.1\",\n", - " \"@langchain/langgraph\": \"0.0.23\"\n", - " },\n", - " \"resolutions\": {\n", - " \"@langchain/core\": \"0.2.6\"\n", - " }\n", - "}\n", - "```\n", - "\n", - "For `npm`, use\n", - "[`\"overrides\"`](https://docs.npmjs.com/cli/v10/configuring-npm/package-json#overrides):\n", - "\n", - "```json\n", - "{\n", - " \"name\": \"your-project\",\n", - " \"version\": \"0.0.0\",\n", - " \"private\": true,\n", - " \"engines\": {\n", - " \"node\": \">=18\"\n", - " },\n", - " \"dependencies\": {\n", - " \"@langchain/anthropic\": \"^0.2.1\",\n", - " \"@langchain/langgraph\": \"0.0.23\"\n", - " },\n", - " \"overrides\": {\n", - " \"@langchain/core\": \"0.2.6\"\n", - " }\n", - "}\n", - "```\n", - "\n", - "For `pnpm`, use the nested\n", - "[`\"pnpm.overrides\"`](https://pnpm.io/package_json#pnpmoverrides) field:\n", - "\n", - "```json\n", - "{\n", - " \"name\": \"your-project\",\n", - " \"version\": \"0.0.0\",\n", - " \"private\": true,\n", - " \"engines\": {\n", - " \"node\": \">=18\"\n", - " },\n", - " \"dependencies\": {\n", - " \"@langchain/anthropic\": \"^0.2.1\",\n", - " \"@langchain/langgraph\": \"0.0.23\"\n", - " },\n", - " \"pnpm\": {\n", - " \"overrides\": {\n", - " \"@langchain/core\": \"0.2.6\"\n", - " }\n", - " }\n", - "}\n", - "```\n", - "\n", - "## Next steps\n", - "\n", - "You've now learned about some special considerations around using LangGraph.js\n", - "with other LangChain ecosystem packages.\n", - "\n", - "Next, check out\n", - "[some how-to guides on core functionality](https://langchain-ai.github.io/langgraphjs/how-tos/#core)." - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Deno", - "language": "typescript", - "name": "deno" + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# How to install and manage dependencies\n", + "\n", + "LangGraph.js is part of the [LangChain](https://js.langchain.com/) ecosystem,\n", + "which includes the primary\n", + "[`langchain`](https://www.npmjs.com/package/langchain) package as well as\n", + "packages that contain integrations with individual third-party providers. They\n", + "can be as specific as\n", + "[`@langchain/anthropic`](https://www.npmjs.com/package/@langchain/anthropic),\n", + "which contains integrations just for Anthropic chat models, or as broad as\n", + "[`@langchain/community`](https://www.npmjs.com/package/@langchain/community),\n", + "which contains broader variety of community contributed integrations.\n", + "\n", + "These packages, as well as LangGraph.js itself, all depend on\n", + "[`@langchain/core`](https://www.npmjs.com/package/@langchain/core), which\n", + "contains the base abstractions that these packages extend.\n", + "\n", + "To ensure that all integrations and their types interact with each other\n", + "properly, it is important that they all use the same version of\n", + "`@langchain/core`. The best way to guarantee this is to add a `\"resolutions\"` or\n", + "`\"overrides\"` field like the following in your project's `package.json`. The\n", + "specific field name will depend on your package manager. Here are a few\n", + "examples:\n", + "\n", + "
\n", + "

Tip

\n", + "

\n", + " The resolutions or pnpm.overrides fields for yarn or pnpm must be set in the root package.json file.\n", + "

\n", + "
\n", + "\n", + "If you are using `yarn`, you should set\n", + "[`\"resolutions\"`](https://yarnpkg.com/cli/set/resolution):\n", + "\n", + "```json\n", + "{\n", + " \"name\": \"your-project\",\n", + " \"version\": \"0.0.0\",\n", + " \"private\": true,\n", + " \"engines\": {\n", + " \"node\": \">=18\"\n", + " },\n", + " \"dependencies\": {\n", + " \"@langchain/anthropic\": \"^0.2.1\",\n", + " \"@langchain/langgraph\": \"0.0.23\"\n", + " },\n", + " \"resolutions\": {\n", + " \"@langchain/core\": \"0.2.6\"\n", + " }\n", + "}\n", + "```\n", + "\n", + "For `npm`, use\n", + "[`\"overrides\"`](https://docs.npmjs.com/cli/v10/configuring-npm/package-json#overrides):\n", + "\n", + "```json\n", + "{\n", + " \"name\": \"your-project\",\n", + " \"version\": \"0.0.0\",\n", + " \"private\": true,\n", + " \"engines\": {\n", + " \"node\": \">=18\"\n", + " },\n", + " \"dependencies\": {\n", + " \"@langchain/anthropic\": \"^0.2.1\",\n", + " \"@langchain/langgraph\": \"0.0.23\"\n", + " },\n", + " \"overrides\": {\n", + " \"@langchain/core\": \"0.2.6\"\n", + " }\n", + "}\n", + "```\n", + "\n", + "For `pnpm`, use the nested\n", + "[`\"pnpm.overrides\"`](https://pnpm.io/package_json#pnpmoverrides) field:\n", + "\n", + "```json\n", + "{\n", + " \"name\": \"your-project\",\n", + " \"version\": \"0.0.0\",\n", + " \"private\": true,\n", + " \"engines\": {\n", + " \"node\": \">=18\"\n", + " },\n", + " \"dependencies\": {\n", + " \"@langchain/anthropic\": \"^0.2.1\",\n", + " \"@langchain/langgraph\": \"0.0.23\"\n", + " },\n", + " \"pnpm\": {\n", + " \"overrides\": {\n", + " \"@langchain/core\": \"0.2.6\"\n", + " }\n", + " }\n", + "}\n", + "```\n", + "\n", + "## Next steps\n", + "\n", + "You've now learned about some special considerations around using LangGraph.js\n", + "with other LangChain ecosystem packages.\n", + "\n", + "Next, check out\n", + "[some how-to guides on core functionality](/langgraphjs/how-tos/#core)." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Deno", + "language": "typescript", + "name": "deno" + }, + "language_info": { + "name": "typescript" + } }, - "language_info": { - "name": "typescript" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} + "nbformat": 4, + "nbformat_minor": 2 +} \ No newline at end of file diff --git a/examples/how-tos/managing-agent-steps.ipynb b/examples/how-tos/managing-agent-steps.ipynb index 53131e3c..30149d38 100644 --- a/examples/how-tos/managing-agent-steps.ipynb +++ b/examples/how-tos/managing-agent-steps.ipynb @@ -76,7 +76,7 @@ "## Set up the State\n", "\n", "The main type of graph in `langgraph` is the\n", - "[StateGraph](https://langchain-ai.github.io/langgraphjs/reference/classes/langgraph.StateGraph.html).\n", + "[StateGraph](/langgraphjs/reference/classes/langgraph.StateGraph.html).\n", "This graph is parameterized by a state object that it passes around to each\n", "node. Each node then returns operations to update that state. These operations\n", "can either SET specific attributes on the state (e.g. overwrite the existing\n", @@ -150,7 +150,7 @@ "metadata": {}, "source": [ "We can now wrap these tools in a simple\n", - "[ToolNode](https://langchain-ai.github.io/langgraphjs/reference/classes/langgraph_prebuilt.ToolNode.html).\\\n", + "[ToolNode](/langgraphjs/reference/classes/langgraph_prebuilt.ToolNode.html).\\\n", "This is a simple class that takes in a list of messages containing an\n", "[AIMessages with tool_calls](https://v02.api.js.langchain.com/classes/langchain_core_messages_ai.AIMessage.html),\n", "runs the tools, and returns the output as\n", @@ -182,7 +182,7 @@ "1. It should work with messages, since our state is primarily a list of messages\n", " (chat history).\n", "2. It should work with tool calling, since we are using a prebuilt\n", - " [ToolNode](https://langchain-ai.github.io/langgraphjs/reference/classes/langgraph_prebuilt.ToolNode.html)\n", + " [ToolNode](/langgraphjs/reference/classes/langgraph_prebuilt.ToolNode.html)\n", "\n", "**Note:** these model requirements are not requirements for using LangGraph -\n", "they are just requirements for this particular example." diff --git a/examples/how-tos/map-reduce.ipynb b/examples/how-tos/map-reduce.ipynb index ef28511f..0fcd7a5d 100644 --- a/examples/how-tos/map-reduce.ipynb +++ b/examples/how-tos/map-reduce.ipynb @@ -1,254 +1,254 @@ { - "cells": [ - { - "attachments": { - "a108ffc8-6136-4cd7-a6f9-579e41a5a786.png": { - "image/png": "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" - } - }, - "cell_type": "markdown", - "id": "95a87145-34d0-4f97-b45f-5c9fd8532c8a", - "metadata": {}, - "source": [ - "# How to create map-reduce branches for parallel execution\n", - "\n", - "[Map-reduce](https://en.wikipedia.org/wiki/MapReduce) operations are essential for efficient task decomposition and parallel processing. This approach involves breaking a task into smaller sub-tasks, processing each sub-task in parallel, and aggregating the results across all of the completed sub-tasks. \n", - "\n", - "Consider this example: given a general topic from the user, generate a list of related subjects, generate a joke for each subject, and select the best joke from the resulting list. In this design pattern, a first node may generate a list of objects (e.g., related subjects) and we want to apply some other node (e.g., generate a joke) to all those objects (e.g., subjects). However, two main challenges arise.\n", - " \n", - "(1) the number of objects (e.g., subjects) may be unknown ahead of time (meaning the number of edges may not be known) when we lay out the graph and (2) the input State to the downstream Node should be different (one for each generated object).\n", - " \n", - "LangGraph addresses these challenges [through its `Send` API](https://langchain-ai.github.io/langgraphjs/concepts/low_level/#send). By utilizing conditional edges, `Send` can distribute different states (e.g., subjects) to multiple instances of a node (e.g., joke generation). Importantly, the sent state can differ from the core graph's state, allowing for flexible and dynamic workflow management. \n", - "\n", - "![Screenshot 2024-07-12 at 9.45.40 AM.png](attachment:a108ffc8-6136-4cd7-a6f9-579e41a5a786.png)\n", - "\n", - "## Setup\n", - "\n", - "This example will require a few dependencies. First, install the LangGraph library, along with the `@langchain/anthropic` package as we'll be using Anthropic LLMs in this example:\n", - "\n", - "```bash\n", - "npm install @langchain/langgraph @langchain/anthropic\n", - "```\n", - "\n", - "Next, set your Anthropic API key:\n", - "\n", - "```typescript\n", - "process.env.ANTHROPIC_API_KEY = 'YOUR_API_KEY'\n", - "```" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "d8a5a681", - "metadata": {}, - "outputs": [], - "source": [ - "import { z } from \"zod\";\n", - "import { ChatAnthropic } from \"@langchain/anthropic\";\n", - "import { StateGraph, END, START, Annotation, Send } from \"@langchain/langgraph\";\n", - "\n", - "/* Model and prompts */\n", - "\n", - "// Define model and prompts we will use\n", - "const subjectsPrompt = \"Generate a comma separated list of between 2 and 5 examples related to: {topic}.\"\n", - "const jokePrompt = \"Generate a joke about {subject}\"\n", - "const bestJokePrompt = `Below are a bunch of jokes about {topic}. Select the best one! Return the ID (index) of the best one.\n", - "\n", - "{jokes}`\n", - "\n", - "// Zod schemas for getting structured output from the LLM\n", - "const Subjects = z.object({\n", - " subjects: z.array(z.string()),\n", - "});\n", - "const Joke = z.object({\n", - " joke: z.string(),\n", - "});\n", - "const BestJoke = z.object({\n", - " id: z.number(),\n", - "});\n", - "\n", - "const model = new ChatAnthropic({\n", - " model: \"claude-3-5-sonnet-20240620\",\n", - "});\n", - "\n", - "/* Graph components: define the components that will make up the graph */\n", - "\n", - "// This will be the overall state of the main graph.\n", - "// It will contain a topic (which we expect the user to provide)\n", - "// and then will generate a list of subjects, and then a joke for\n", - "// each subject\n", - "const OverallState = Annotation.Root({\n", - " topic: Annotation,\n", - " subjects: Annotation,\n", - " // Notice here we pass a reducer function.\n", - " // This is because we want combine all the jokes we generate\n", - " // from individual nodes back into one list.\n", - " jokes: Annotation({\n", - " reducer: (state, update) => state.concat(update),\n", - " }),\n", - " bestSelectedJoke: Annotation,\n", - "});\n", - "\n", - "// This will be the state of the node that we will \"map\" all\n", - "// subjects to in order to generate a joke\n", - "interface JokeState {\n", - " subject: string;\n", - "}\n", - "\n", - "// This is the function we will use to generate the subjects of the jokes\n", - "const generateTopics = async (\n", - " state: typeof OverallState.State\n", - "): Promise> => {\n", - " const prompt = subjectsPrompt.replace(\"topic\", state.topic);\n", - " const response = await model\n", - " .withStructuredOutput(Subjects, { name: \"subjects\" })\n", - " .invoke(prompt);\n", - " return { subjects: response.subjects };\n", - "};\n", - "\n", - "// Function to generate a joke\n", - "const generateJoke = async (state: JokeState): Promise<{ jokes: string[] }> => {\n", - " const prompt = jokePrompt.replace(\"subject\", state.subject);\n", - " const response = await model\n", - " .withStructuredOutput(Joke, { name: \"joke\" })\n", - " .invoke(prompt);\n", - " return { jokes: [response.joke] };\n", - "};\n", - "\n", - "// Here we define the logic to map out over the generated subjects\n", - "// We will use this an edge in the graph\n", - "const continueToJokes = (state: typeof OverallState.State) => {\n", - " // We will return a list of `Send` objects\n", - " // Each `Send` object consists of the name of a node in the graph\n", - " // as well as the state to send to that node\n", - " return state.subjects.map((subject) => new Send(\"generateJoke\", { subject }));\n", - "};\n", - "\n", - "// Here we will judge the best joke\n", - "const bestJoke = async (\n", - " state: typeof OverallState.State\n", - "): Promise> => {\n", - " const jokes = state.jokes.join(\"\\n\\n\");\n", - " const prompt = bestJokePrompt\n", - " .replace(\"jokes\", jokes)\n", - " .replace(\"topic\", state.topic);\n", - " const response = await model\n", - " .withStructuredOutput(BestJoke, { name: \"best_joke\" })\n", - " .invoke(prompt);\n", - " return { bestSelectedJoke: state.jokes[response.id] };\n", - "};\n", - "\n", - "// Construct the graph: here we put everything together to construct our graph\n", - "const graph = new StateGraph(OverallState)\n", - " .addNode(\"generateTopics\", generateTopics)\n", - " .addNode(\"generateJoke\", generateJoke)\n", - " .addNode(\"bestJoke\", bestJoke)\n", - " .addEdge(START, \"generateTopics\")\n", - " .addConditionalEdges(\"generateTopics\", continueToJokes)\n", - " .addEdge(\"generateJoke\", \"bestJoke\")\n", - " .addEdge(\"bestJoke\", END);\n", - "\n", - "const app = graph.compile();" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "37ed1f71-63db-416f-b715-4617b33d4b7f", - "metadata": {}, - "outputs": [ + "cells": [ { - "data": { - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import * as tslab from \"tslab\";\n", - "\n", - "const graph = app.getGraph();\n", - "const image = await graph.drawMermaidPng();\n", - "const arrayBuffer = await image.arrayBuffer();\n", - "\n", - "tslab.display.png(new Uint8Array(arrayBuffer));" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "fd90cace", - "metadata": {}, - "outputs": [ + "attachments": { + "a108ffc8-6136-4cd7-a6f9-579e41a5a786.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "id": "95a87145-34d0-4f97-b45f-5c9fd8532c8a", + "metadata": {}, + "source": [ + "# How to create map-reduce branches for parallel execution\n", + "\n", + "[Map-reduce](https://en.wikipedia.org/wiki/MapReduce) operations are essential for efficient task decomposition and parallel processing. This approach involves breaking a task into smaller sub-tasks, processing each sub-task in parallel, and aggregating the results across all of the completed sub-tasks. \n", + "\n", + "Consider this example: given a general topic from the user, generate a list of related subjects, generate a joke for each subject, and select the best joke from the resulting list. In this design pattern, a first node may generate a list of objects (e.g., related subjects) and we want to apply some other node (e.g., generate a joke) to all those objects (e.g., subjects). However, two main challenges arise.\n", + " \n", + "(1) the number of objects (e.g., subjects) may be unknown ahead of time (meaning the number of edges may not be known) when we lay out the graph and (2) the input State to the downstream Node should be different (one for each generated object).\n", + " \n", + "LangGraph addresses these challenges [through its `Send` API](/langgraphjs/concepts/low_level/#send). By utilizing conditional edges, `Send` can distribute different states (e.g., subjects) to multiple instances of a node (e.g., joke generation). Importantly, the sent state can differ from the core graph's state, allowing for flexible and dynamic workflow management. \n", + "\n", + "![Screenshot 2024-07-12 at 9.45.40 AM.png](attachment:a108ffc8-6136-4cd7-a6f9-579e41a5a786.png)\n", + "\n", + "## Setup\n", + "\n", + "This example will require a few dependencies. First, install the LangGraph library, along with the `@langchain/anthropic` package as we'll be using Anthropic LLMs in this example:\n", + "\n", + "```bash\n", + "npm install @langchain/langgraph @langchain/anthropic\n", + "```\n", + "\n", + "Next, set your Anthropic API key:\n", + "\n", + "```typescript\n", + "process.env.ANTHROPIC_API_KEY = 'YOUR_API_KEY'\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "d8a5a681", + "metadata": {}, + "outputs": [], + "source": [ + "import { z } from \"zod\";\n", + "import { ChatAnthropic } from \"@langchain/anthropic\";\n", + "import { StateGraph, END, START, Annotation, Send } from \"@langchain/langgraph\";\n", + "\n", + "/* Model and prompts */\n", + "\n", + "// Define model and prompts we will use\n", + "const subjectsPrompt = \"Generate a comma separated list of between 2 and 5 examples related to: {topic}.\"\n", + "const jokePrompt = \"Generate a joke about {subject}\"\n", + "const bestJokePrompt = `Below are a bunch of jokes about {topic}. Select the best one! Return the ID (index) of the best one.\n", + "\n", + "{jokes}`\n", + "\n", + "// Zod schemas for getting structured output from the LLM\n", + "const Subjects = z.object({\n", + " subjects: z.array(z.string()),\n", + "});\n", + "const Joke = z.object({\n", + " joke: z.string(),\n", + "});\n", + "const BestJoke = z.object({\n", + " id: z.number(),\n", + "});\n", + "\n", + "const model = new ChatAnthropic({\n", + " model: \"claude-3-5-sonnet-20240620\",\n", + "});\n", + "\n", + "/* Graph components: define the components that will make up the graph */\n", + "\n", + "// This will be the overall state of the main graph.\n", + "// It will contain a topic (which we expect the user to provide)\n", + "// and then will generate a list of subjects, and then a joke for\n", + "// each subject\n", + "const OverallState = Annotation.Root({\n", + " topic: Annotation,\n", + " subjects: Annotation,\n", + " // Notice here we pass a reducer function.\n", + " // This is because we want combine all the jokes we generate\n", + " // from individual nodes back into one list.\n", + " jokes: Annotation({\n", + " reducer: (state, update) => state.concat(update),\n", + " }),\n", + " bestSelectedJoke: Annotation,\n", + "});\n", + "\n", + "// This will be the state of the node that we will \"map\" all\n", + "// subjects to in order to generate a joke\n", + "interface JokeState {\n", + " subject: string;\n", + "}\n", + "\n", + "// This is the function we will use to generate the subjects of the jokes\n", + "const generateTopics = async (\n", + " state: typeof OverallState.State\n", + "): Promise> => {\n", + " const prompt = subjectsPrompt.replace(\"topic\", state.topic);\n", + " const response = await model\n", + " .withStructuredOutput(Subjects, { name: \"subjects\" })\n", + " .invoke(prompt);\n", + " return { subjects: response.subjects };\n", + "};\n", + "\n", + "// Function to generate a joke\n", + "const generateJoke = async (state: JokeState): Promise<{ jokes: string[] }> => {\n", + " const prompt = jokePrompt.replace(\"subject\", state.subject);\n", + " const response = await model\n", + " .withStructuredOutput(Joke, { name: \"joke\" })\n", + " .invoke(prompt);\n", + " return { jokes: [response.joke] };\n", + "};\n", + "\n", + "// Here we define the logic to map out over the generated subjects\n", + "// We will use this an edge in the graph\n", + "const continueToJokes = (state: typeof OverallState.State) => {\n", + " // We will return a list of `Send` objects\n", + " // Each `Send` object consists of the name of a node in the graph\n", + " // as well as the state to send to that node\n", + " return state.subjects.map((subject) => new Send(\"generateJoke\", { subject }));\n", + "};\n", + "\n", + "// Here we will judge the best joke\n", + "const bestJoke = async (\n", + " state: typeof OverallState.State\n", + "): Promise> => {\n", + " const jokes = state.jokes.join(\"\\n\\n\");\n", + " const prompt = bestJokePrompt\n", + " .replace(\"jokes\", jokes)\n", + " .replace(\"topic\", state.topic);\n", + " const response = await model\n", + " .withStructuredOutput(BestJoke, { name: \"best_joke\" })\n", + " .invoke(prompt);\n", + " return { bestSelectedJoke: state.jokes[response.id] };\n", + "};\n", + "\n", + "// Construct the graph: here we put everything together to construct our graph\n", + "const graph = new StateGraph(OverallState)\n", + " .addNode(\"generateTopics\", generateTopics)\n", + " .addNode(\"generateJoke\", generateJoke)\n", + " .addNode(\"bestJoke\", bestJoke)\n", + " .addEdge(START, \"generateTopics\")\n", + " .addConditionalEdges(\"generateTopics\", continueToJokes)\n", + " .addEdge(\"generateJoke\", \"bestJoke\")\n", + " .addEdge(\"bestJoke\", END);\n", + "\n", + "const app = graph.compile();" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "{\n", - " generateTopics: { subjects: [ 'lion', 'elephant', 'penguin', 'dolphin' ] }\n", - "}\n", - "{\n", - " generateJoke: {\n", - " jokes: [ \"Why don't lions like fast food? Because they can't catch it!\" ]\n", - " }\n", - "}\n", - "{\n", - " generateJoke: {\n", - " jokes: [\n", - " \"Why don't elephants use computers? Because they're afraid of the mouse!\"\n", - " ]\n", - " }\n", - "}\n", - "{\n", - " generateJoke: {\n", - " jokes: [\n", - " \"Why don't dolphins use smartphones? They're afraid of phishing!\"\n", - " ]\n", - " }\n", - "}\n", - "{\n", - " generateJoke: {\n", - " jokes: [\n", - " \"Why don't you see penguins in Britain? Because they're afraid of Wales!\"\n", - " ]\n", - " }\n", - "}\n", - "{\n", - " bestJoke: {\n", - " bestSelectedJoke: \"Why don't elephants use computers? Because they're afraid of the mouse!\"\n", - " }\n", - "}\n" - ] + "cell_type": "code", + "execution_count": 2, + "id": "37ed1f71-63db-416f-b715-4617b33d4b7f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import * as tslab from \"tslab\";\n", + "\n", + "const graph = app.getGraph();\n", + "const image = await graph.drawMermaidPng();\n", + "const arrayBuffer = await image.arrayBuffer();\n", + "\n", + "tslab.display.png(new Uint8Array(arrayBuffer));" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "fd90cace", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{\n", + " generateTopics: { subjects: [ 'lion', 'elephant', 'penguin', 'dolphin' ] }\n", + "}\n", + "{\n", + " generateJoke: {\n", + " jokes: [ \"Why don't lions like fast food? Because they can't catch it!\" ]\n", + " }\n", + "}\n", + "{\n", + " generateJoke: {\n", + " jokes: [\n", + " \"Why don't elephants use computers? Because they're afraid of the mouse!\"\n", + " ]\n", + " }\n", + "}\n", + "{\n", + " generateJoke: {\n", + " jokes: [\n", + " \"Why don't dolphins use smartphones? They're afraid of phishing!\"\n", + " ]\n", + " }\n", + "}\n", + "{\n", + " generateJoke: {\n", + " jokes: [\n", + " \"Why don't you see penguins in Britain? Because they're afraid of Wales!\"\n", + " ]\n", + " }\n", + "}\n", + "{\n", + " bestJoke: {\n", + " bestSelectedJoke: \"Why don't elephants use computers? Because they're afraid of the mouse!\"\n", + " }\n", + "}\n" + ] + } + ], + "source": [ + "// Call the graph: here we call it to generate a list of jokes\n", + "for await (const s of await app.stream({ topic: \"animals\" })) {\n", + " console.log(s);\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" } - ], - "source": [ - "// Call the graph: here we call it to generate a list of jokes\n", - "for await (const s of await app.stream({ topic: \"animals\" })) {\n", - " console.log(s);\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 -} + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file diff --git a/examples/how-tos/persistence-postgres.ipynb b/examples/how-tos/persistence-postgres.ipynb index 4766fd48..feaca03e 100644 --- a/examples/how-tos/persistence-postgres.ipynb +++ b/examples/how-tos/persistence-postgres.ipynb @@ -1,985 +1,985 @@ { - "cells": [ - { - "cell_type": "markdown", - "id": "87d7b116-0f42-4ce4-90bc-43873db19cff", - "metadata": {}, - "source": [ - "# How to create a custom checkpointer using Postgres\n", - "\n", - "When creating LangGraph.js agents, you can also set them up so that they persist\n", - "their state. This allows you to do things like interact with an agent multiple\n", - "times and have it remember previous interactions.\n", - "\n", - "This example shows how to use `Postgres` as the backend for persisting\n", - "checkpoint state.\n", - "\n", - "NOTE: this is just an example implementation. You can implement your own\n", - "checkpointer using a different database or modify this one as long as it\n", - "conforms to the `BaseCheckpointSaver` interface." - ] - }, - { - "cell_type": "markdown", - "id": "7721e4e2-fd00-4fc9-bd1b-a3155bfec0b5", - "metadata": {}, - "source": [ - "### Checkpointer implementation" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "8ef31e39-3761-4740-b5d4-35d1a9d2c29e", - "metadata": {}, - "outputs": [], - "source": [ - "import {\n", - " BaseCheckpointSaver,\n", - " Checkpoint,\n", - " CheckpointMetadata,\n", - " CheckpointTuple,\n", - " SerializerProtocol,\n", - "} from \"@langchain/langgraph\";\n", - "import { load } from \"@langchain/core/load\";" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "e615d6a1-6f32-43a4-8fb4-4f1926cbd80e", - "metadata": {}, - "outputs": [], - "source": [ - "// define custom serializer, since we'll be using bytea Postgres type for `checkpoint` and `metadata` values\n", - "const CustomSerializer = {\n", - " stringify(obj) {\n", - " return Buffer.from(JSON.stringify(obj));\n", - " },\n", - "\n", - " async parse(data) {\n", - " return await load(data.toString());\n", - " },\n", - "};" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "da53e336-c017-43d0-99c4-9a44caa3b824", - "metadata": {}, - "outputs": [], - "source": [ - "import { Pool } from \"pg\";\n", - "import { RunnableConfig } from \"@langchain/core/runnables\";\n", - "\n", - "// snake_case is used to match Python implementation\n", - "interface Row {\n", - " checkpoint: string;\n", - " metadata: string;\n", - " parent_id?: string;\n", - " thread_id: string;\n", - " checkpoint_id: string;\n", - "}\n", - "\n", - "// define Postgres checkpointer\n", - "class PostgresSaver extends BaseCheckpointSaver {\n", - " private pool: Pool;\n", - " private isSetup: boolean;\n", - "\n", - " constructor(pool: Pool) {\n", - " // @ts-ignore\n", - " super(CustomSerializer);\n", - " this.pool = pool;\n", - " this.isSetup = false;\n", - " }\n", - "\n", - " static fromConnString(connString: string): PostgresSaver {\n", - " return new PostgresSaver(new Pool({ connectionString: connString }));\n", - " }\n", - "\n", - " private async setup(): Promise {\n", - " if (this.isSetup) return;\n", - "\n", - " const client = await this.pool.connect();\n", - " try {\n", - " await client.query(`\n", - "CREATE TABLE IF NOT EXISTS checkpoints (\n", - " thread_id TEXT NOT NULL,\n", - " checkpoint_id TEXT NOT NULL,\n", - " parent_id TEXT,\n", - " checkpoint BYTEA NOT NULL,\n", - " metadata BYTEA NOT NULL,\n", - " PRIMARY KEY (thread_id, checkpoint_id)\n", - ");\n", - " `);\n", - " this.isSetup = true;\n", - " } catch (error) {\n", - " console.error(\"Error creating checkpoints table\", error);\n", - " throw error;\n", - " } finally {\n", - " client.release();\n", - " }\n", - " }\n", - "\n", - " // below 3 methods are necessary for any checkpointer implementation: getTuple, list and put\n", - " async getTuple(config: RunnableConfig): Promise {\n", - " await this.setup();\n", - " const { thread_id, checkpoint_id } = config.configurable || {};\n", - "\n", - " const client = await this.pool.connect();\n", - " try {\n", - " if (checkpoint_id) {\n", - " const res = await client.query(\n", - " `SELECT checkpoint, parent_id, metadata FROM checkpoints WHERE thread_id = $1 AND checkpoint_id = $2`,\n", - " [thread_id, checkpoint_id],\n", - " );\n", - " const row = res.rows[0];\n", - " if (row) {\n", - " return {\n", - " config,\n", - " checkpoint: (await this.serde.parse(row.checkpoint)) as Checkpoint,\n", - " metadata: (await this.serde.parse(\n", - " row.metadata,\n", - " )) as CheckpointMetadata,\n", - " parentConfig: row.parent_id\n", - " ? {\n", - " configurable: {\n", - " thread_id,\n", - " checkpoint_id: row.parent_id,\n", - " },\n", - " }\n", - " : undefined,\n", - " };\n", - " }\n", - " } else {\n", - " const res = await client.query(\n", - " `SELECT thread_id, checkpoint_id, parent_id, checkpoint, metadata FROM checkpoints WHERE thread_id = $1 ORDER BY checkpoint_id DESC LIMIT 1`,\n", - " [thread_id],\n", - " );\n", - " const row = res.rows[0];\n", - " if (row) {\n", - " return {\n", - " config: {\n", - " configurable: {\n", - " thread_id: row.thread_id,\n", - " checkpoint_id: row.checkpoint_id,\n", - " },\n", - " },\n", - " checkpoint: (await this.serde.parse(row.checkpoint)) as Checkpoint,\n", - " metadata: (await this.serde.parse(\n", - " row.metadata,\n", - " )) as CheckpointMetadata,\n", - " parentConfig: row.parent_id\n", - " ? {\n", - " configurable: {\n", - " thread_id: row.thread_id,\n", - " checkpoint_id: row.parent_id,\n", - " },\n", - " }\n", - " : undefined,\n", - " };\n", - " }\n", - " }\n", - " } catch (error) {\n", - " console.error(\"Error retrieving checkpoint\", error);\n", - " throw error;\n", - " } finally {\n", - " client.release();\n", - " }\n", - "\n", - " return undefined;\n", - " }\n", - "\n", - " async *list(\n", - " config: RunnableConfig,\n", - " limit?: number,\n", - " before?: RunnableConfig,\n", - " ): AsyncGenerator {\n", - " await this.setup();\n", - " const { thread_id } = config.configurable || {};\n", - " let query =\n", - " `SELECT thread_id, checkpoint_id, parent_id, checkpoint, metadata FROM checkpoints WHERE thread_id = $1`;\n", - " const params: (string | number)[] = [thread_id];\n", - " if (before?.configurable?.checkpoint_id) {\n", - " query += \" AND checkpoint_id < $2\";\n", - " params.push(before.configurable.checkpoint_id);\n", - " }\n", - " query += \" ORDER BY checkpoint_id DESC\";\n", - " if (limit) {\n", - " query += \" LIMIT $\" + (params.length + 1);\n", - " params.push(limit);\n", - " }\n", - "\n", - " const client = await this.pool.connect();\n", - " try {\n", - " const res = await client.query(query, params);\n", - " for (const row of res.rows) {\n", - " yield {\n", - " config: {\n", - " configurable: {\n", - " thread_id: row.thread_id,\n", - " checkpoint_id: row.checkpoint_id,\n", - " },\n", - " },\n", - " checkpoint: (await this.serde.parse(row.checkpoint)) as Checkpoint,\n", - " metadata: (await this.serde.parse(\n", - " row.metadata,\n", - " )) as CheckpointMetadata,\n", - " parentConfig: row.parent_id\n", - " ? {\n", - " configurable: {\n", - " thread_id: row.thread_id,\n", - " checkpoint_id: row.parent_id,\n", - " },\n", - " }\n", - " : undefined,\n", - " };\n", - " }\n", - " } catch (error) {\n", - " console.error(\"Error listing checkpoints\", error);\n", - " throw error;\n", - " } finally {\n", - " client.release();\n", - " }\n", - " }\n", - "\n", - " async put(\n", - " config: RunnableConfig,\n", - " checkpoint: Checkpoint,\n", - " metadata: CheckpointMetadata,\n", - " ): Promise {\n", - " await this.setup();\n", - " const client = await this.pool.connect();\n", - " try {\n", - " await client.query(\n", - " `INSERT INTO checkpoints (thread_id, checkpoint_id, parent_id, checkpoint, metadata) VALUES ($1, $2, $3, $4, $5)\n", - " ON CONFLICT (thread_id, checkpoint_id) DO UPDATE SET checkpoint = EXCLUDED.checkpoint, metadata = EXCLUDED.metadata`,\n", - " [\n", - " config.configurable?.thread_id,\n", - " checkpoint.id,\n", - " config.configurable?.checkpoint_id,\n", - " this.serde.stringify(checkpoint),\n", - " this.serde.stringify(metadata),\n", - " ],\n", - " );\n", - " } catch (error) {\n", - " console.error(\"Error saving checkpoint\", error);\n", - " throw error;\n", - " } finally {\n", - " client.release();\n", - " }\n", - "\n", - " return {\n", - " configurable: {\n", - " thread_id: config.configurable?.thread_id,\n", - " checkpoint_id: checkpoint.id,\n", - " },\n", - " };\n", - " }\n", - "}" - ] - }, - { - "cell_type": "markdown", - "id": "0aba1e76-75b4-453f-b0fb-c2131d013602", - "metadata": {}, - "source": [ - "---" - ] - }, - { - "cell_type": "markdown", - "id": "0391f5fd-d3f1-4e35-a68e-bcde597b5f26", - "metadata": {}, - "source": [ - "Now we're ready to test the Postgres checkpointer with a graph. Let's define a\n", - "simple ReAct agent in LangGraph." - ] - }, - { - "cell_type": "markdown", - "id": "15e494c8-c9a5-4a66-af7a-c4e55d9946f4", - "metadata": {}, - "source": [ - "## Setup environment" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "f64404ce-1c4b-4f5e-bebe-ec04fc016708", - "metadata": { - "lines_to_next_cell": 2 - }, - "outputs": [], - "source": [ - "// process.env.OPENAI_API_KEY = \"sk-...\";" - ] - }, - { - "cell_type": "markdown", - "id": "7cba7a79-361c-4e72-b7a2-b6e65908da4b", - "metadata": {}, - "source": [ - "## Define the state\n", - "\n", - "The state is the interface for all of the nodes in our graph.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "87e996ae-5f71-42e3-bd6d-f84f8224ec5e", - "metadata": { - "lines_to_next_cell": 2 - }, - "outputs": [], - "source": [ - "import { Annotation } from \"@langchain/langgraph\";\n", - "import { BaseMessage } from \"@langchain/core/messages\";\n", - "\n", - "const AgentState = Annotation.Root({\n", - " messages: Annotation({\n", - " reducer: (x, y) => x.concat(y),\n", - " }),\n", - "});" - ] - }, - { - "cell_type": "markdown", - "id": "da96349a-2f52-45f7-a51c-bd6ead78ec9a", - "metadata": {}, - "source": [ - "## Set up the tools\n", - "\n", - "We will first define the tools we want to use. For this simple example, we will\n", - "use create a placeholder search engine. However, it is really easy to create\n", - "your own tools - see documentation\n", - "[here](https://js.langchain.com/v0.2/docs/how_to/custom_tools) on how to do\n", - "that.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "4a07a7b6-07b0-4dcf-a2dd-633dab31fc51", - "metadata": { - "lines_to_next_cell": 2 - }, - "outputs": [], - "source": [ - "import { DynamicStructuredTool } from \"@langchain/core/tools\";\n", - "import { z } from \"zod\";\n", - "\n", - "const searchTool = new DynamicStructuredTool({\n", - " name: \"search\",\n", - " description:\n", - " \"Use to surf the web, fetch current information, check the weather, and retrieve other information.\",\n", - " schema: z.object({\n", - " query: z.string().describe(\"The query to use in your search.\"),\n", - " }),\n", - " func: async ({ query: _query }: { query: string }) => {\n", - " // This is a placeholder for the actual implementation\n", - " return \"Cold, with a low of 3℃\";\n", - " },\n", - "});\n", - "\n", - "await searchTool.invoke({ query: \"What's the weather like?\" });\n", - "\n", - "const tools = [searchTool];" - ] - }, - { - "cell_type": "markdown", - "id": "0fdc21b8-5745-46c1-83ab-f85a2828224d", - "metadata": {}, - "source": [ - "We can now wrap these tools in a simple\n", - "[ToolNode](https://langchain-ai.github.io/langgraphjs/reference/classes/langgraph_prebuilt.ToolNode.html).\n", - "This object will actually run the tools (functions) whenever they are invoked by\n", - "our LLM.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "a1aeefd0-f378-4331-8d95-edf2227656a2", - "metadata": { - "lines_to_next_cell": 2 - }, - "outputs": [], - "source": [ - "import { ToolNode } from \"@langchain/langgraph/prebuilt\";\n", - "\n", - "const toolNode = new ToolNode(tools);" - ] - }, - { - "cell_type": "markdown", - "id": "c519abcb-2ca0-472e-9f7f-80d9e9aad143", - "metadata": {}, - "source": [ - "## Set up the model\n", - "\n", - "Now we will load the\n", - "[chat model](https://js.langchain.com/v0.2/docs/concepts/#chat-models).\n", - "\n", - "1. It should work with messages. We will represent all agent state in the form\n", - " of messages, so it needs to be able to work well with them.\n", - "2. It should work with\n", - " [tool calling](https://js.langchain.com/v0.2/docs/how_to/tool_calling/#passing-tools-to-llms),\n", - " meaning it can return function arguments in its response.\n", - "\n", - "
\n", - "

Note

\n", - "

\n", - " These model requirements are not general requirements for using LangGraph - they are just requirements for this one example.\n", - "

\n", - "
" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "18aef017-e4f5-47db-9f01-b6bf62e246b2", - "metadata": { - "lines_to_next_cell": 2 - }, - "outputs": [], - "source": [ - "import { ChatOpenAI } from \"@langchain/openai\";\n", - "const model = new ChatOpenAI({ model: \"gpt-4o\" });" - ] - }, - { - "cell_type": "markdown", - "id": "890fe6b7-9acd-4d11-bd50-9ca0ae2e31c3", - "metadata": {}, - "source": [ - "After we've done this, we should make sure the model knows that it has these\n", - "tools available to call. We can do this by calling\n", - "[bindTools](https://v01.api.js.langchain.com/classes/langchain_core_language_models_chat_models.BaseChatModel.html#bindTools)." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "86535395-239d-485f-a928-e54e4f8d3038", - "metadata": { - "lines_to_next_cell": 2 - }, - "outputs": [], - "source": [ - "const boundModel = model.bindTools(tools);" - ] - }, - { - "cell_type": "markdown", - "id": "93837661-26e4-4c34-9711-34269b454ec3", - "metadata": {}, - "source": [ - "## Define the graph\n", - "\n", - "We can now put it all together." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "916d2bbc-c1b4-4dd0-97ab-372f5cf7a40a", - "metadata": {}, - "outputs": [], - "source": [ - "import { END, START, StateGraph } from \"@langchain/langgraph\";\n", - "import { AIMessage } from \"@langchain/core/messages\";\n", - "import { RunnableConfig } from \"@langchain/core/runnables\";\n", - "\n", - "const routeMessage = (state: typeof AgentState.State) => {\n", - " const { messages } = state;\n", - " const lastMessage = messages[messages.length - 1] as AIMessage;\n", - " // If no tools are called, we can finish (respond to the user)\n", - " if (!lastMessage?.tool_calls?.length) {\n", - " return END;\n", - " }\n", - " // Otherwise if there is, we continue and call the tools\n", - " return \"tools\";\n", - "};\n", - "\n", - "const callModel = async (\n", - " state: typeof AgentState.State,\n", - " config?: RunnableConfig,\n", - ") => {\n", - " // For versions of @langchain/core < 0.2.3, you must call `.stream()`\n", - " // and aggregate the message from chunks instead of calling `.invoke()`.\n", - " const { messages } = state;\n", - " const responseMessage = await boundModel.invoke(messages, config);\n", - " return { messages: [responseMessage] };\n", - "};\n", - "\n", - "const workflow = new StateGraph(AgentState)\n", - " .addNode(\"agent\", callModel)\n", - " .addNode(\"tools\", toolNode)\n", - " .addEdge(START, \"agent\")\n", - " .addConditionalEdges(\"agent\", routeMessage)\n", - " .addEdge(\"tools\", \"agent\");" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "f0b69301-4726-4f62-87cc-b097e4fb451a", - "metadata": {}, - "outputs": [], - "source": [ - "// Initialize our Postgres connection pool & checkpointer\n", - "const pool = new Pool({\n", - " connectionString:\n", - " \"postgresql://postgres:postgres@localhost:5432/postgres?sslmode=disable\",\n", - "});\n", - "const checkpointer = new PostgresSaver(pool);" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "f357d9ae-8bb7-4624-b932-28e7d2b46441", - "metadata": {}, - "outputs": [], - "source": [ - "// Compile the graph with Postgres checkpointer\n", - "const graph = workflow.compile({ checkpointer: checkpointer });" - ] - }, - { - "cell_type": "markdown", - "id": "d1770321-5181-4365-8957-465009ec64e7", - "metadata": {}, - "source": [ - "## Run the graph with checkpointer" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "b5c08487-57b6-4eff-bd14-f97e7e8b69eb", - "metadata": {}, - "outputs": [], - "source": [ - "// note: we're invoking the graph with a config that contains thread ID\n", - "const config = { configurable: { thread_id: 42 } };\n", - "const res = await graph.invoke(\n", - " { \"messages\": [[\"user\", \"what's the weather in sf\"]] },\n", - " config,\n", - ");" - ] - }, - { - "cell_type": "markdown", - "id": "c922d223", - "metadata": {}, - "source": [ - "### Load checkpoint" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "d88f3851-bb66-45b7-b9e8-38cf5b97abdf", - "metadata": {}, - "outputs": [], - "source": [ - "const checkpointTuple = await checkpointer.getTuple(config);" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "49b0f317-c876-4d7e-887a-dec604b1c06a", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{\n", - " config: {\n", - " configurable: {\n", - " thread_id: \u001b[32m'42'\u001b[39m,\n", - " checkpoint_id: \u001b[32m'1ef3fb9c-599d-6ef1-8003-88ab826dad68'\u001b[39m\n", - " }\n", - " },\n", - " checkpoint: {\n", - " v: \u001b[33m1\u001b[39m,\n", - " id: \u001b[32m'1ef3fb9c-599d-6ef1-8003-88ab826dad68'\u001b[39m,\n", - " ts: \u001b[32m'2024-07-11T19:14:18.847Z'\u001b[39m,\n", - " channel_values: { messages: \u001b[36m[Array]\u001b[39m, agent: \u001b[32m'agent'\u001b[39m },\n", - " channel_versions: {\n", - " __start__: \u001b[33m1\u001b[39m,\n", - " messages: \u001b[33m5\u001b[39m,\n", - " \u001b[32m'start:agent'\u001b[39m: \u001b[33m2\u001b[39m,\n", - " agent: \u001b[33m5\u001b[39m,\n", - " \u001b[32m'branch:agent:routeMessage:tools'\u001b[39m: \u001b[33m3\u001b[39m,\n", - " tools: \u001b[33m4\u001b[39m\n", - " },\n", - " versions_seen: { __start__: \u001b[36m[Object]\u001b[39m, agent: \u001b[36m[Object]\u001b[39m, tools: \u001b[36m[Object]\u001b[39m }\n", - " },\n", - " metadata: { source: \u001b[32m'loop'\u001b[39m, step: \u001b[33m3\u001b[39m, writes: { agent: \u001b[36m[Object]\u001b[39m } },\n", - " parentConfig: {\n", - " configurable: {\n", - " thread_id: \u001b[32m'42'\u001b[39m,\n", - " checkpoint_id: \u001b[32m'1ef3fb9c-50a9-6740-8002-d0dcfbbf0749'\u001b[39m\n", - " }\n", - " }\n", - "}\n" - ] - } - ], - "source": [ - "checkpointTuple;" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "c1d20f09-0f12-4b39-a80a-7a4a073fb879", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[\n", - " \u001b[32m\"what's the weather in sf\"\u001b[39m,\n", - " AIMessage {\n", - " lc_serializable: \u001b[33mtrue\u001b[39m,\n", - " lc_kwargs: {\n", - " content: \u001b[32m''\u001b[39m,\n", - " tool_calls: \u001b[36m[Array]\u001b[39m,\n", - " invalid_tool_calls: [],\n", - " additional_kwargs: \u001b[36m[Object]\u001b[39m,\n", - " response_metadata: \u001b[36m[Object]\u001b[39m\n", - " },\n", - " lc_namespace: [ \u001b[32m'langchain_core'\u001b[39m, \u001b[32m'messages'\u001b[39m ],\n", - " content: \u001b[32m''\u001b[39m,\n", - " name: \u001b[90mundefined\u001b[39m,\n", - " additional_kwargs: { tool_calls: \u001b[36m[Array]\u001b[39m },\n", - " response_metadata: { tokenUsage: \u001b[36m[Object]\u001b[39m, finish_reason: \u001b[32m'tool_calls'\u001b[39m },\n", - " id: \u001b[90mundefined\u001b[39m,\n", - " tool_calls: [ \u001b[36m[Object]\u001b[39m ],\n", - " invalid_tool_calls: [],\n", - " usage_metadata: \u001b[90mundefined\u001b[39m\n", - " },\n", - " ToolMessage {\n", - " lc_serializable: \u001b[33mtrue\u001b[39m,\n", - " lc_kwargs: {\n", - " name: \u001b[32m'search'\u001b[39m,\n", - " content: \u001b[32m'Cold, with a low of 3℃'\u001b[39m,\n", - " tool_call_id: \u001b[32m'call_9lZWCPGg6SUP5dg4eTge2xNU'\u001b[39m,\n", - " additional_kwargs: {},\n", - " response_metadata: {}\n", - " },\n", - " lc_namespace: [ \u001b[32m'langchain_core'\u001b[39m, \u001b[32m'messages'\u001b[39m ],\n", - " content: \u001b[32m'Cold, with a low of 3℃'\u001b[39m,\n", - " name: \u001b[32m'search'\u001b[39m,\n", - " additional_kwargs: {},\n", - " response_metadata: {},\n", - " id: \u001b[90mundefined\u001b[39m,\n", - " tool_call_id: \u001b[32m'call_9lZWCPGg6SUP5dg4eTge2xNU'\u001b[39m\n", - " },\n", - " AIMessage {\n", - " lc_serializable: \u001b[33mtrue\u001b[39m,\n", - " lc_kwargs: {\n", - " content: \u001b[32m'The current weather in San Francisco is cold, with a low of 3°C.'\u001b[39m,\n", - " tool_calls: [],\n", - " invalid_tool_calls: [],\n", - " additional_kwargs: {},\n", - " response_metadata: \u001b[36m[Object]\u001b[39m\n", - " },\n", - " lc_namespace: [ \u001b[32m'langchain_core'\u001b[39m, \u001b[32m'messages'\u001b[39m ],\n", - " content: \u001b[32m'The current weather in San Francisco is cold, with a low of 3°C.'\u001b[39m,\n", - " name: \u001b[90mundefined\u001b[39m,\n", - " additional_kwargs: {},\n", - " response_metadata: { tokenUsage: \u001b[36m[Object]\u001b[39m, finish_reason: \u001b[32m'stop'\u001b[39m },\n", - " id: \u001b[90mundefined\u001b[39m,\n", - " tool_calls: [],\n", - " invalid_tool_calls: [],\n", - " usage_metadata: \u001b[90mundefined\u001b[39m\n", - " }\n", - "]\n" - ] - } - ], - "source": [ - "checkpointTuple.checkpoint.channel_values[\"messages\"];" - ] - }, - { - "cell_type": "markdown", - "id": "8b0c1f54", - "metadata": {}, - "source": [ - "### Run on the same conversation thread" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "003c34f2-f628-4536-b6d1-cc095da15fdf", - "metadata": {}, - "outputs": [], - "source": [ - "const newRes = await graph.invoke(\n", - " { \"messages\": [[\"user\", \"what about ny?\"]] },\n", - " config,\n", - ");" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "e0e43b63-8b48-4b01-a80f-e28d78b10e0e", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[\n", - " \u001b[32m\"what's the weather in sf\"\u001b[39m,\n", - " AIMessage {\n", - " lc_serializable: \u001b[33mtrue\u001b[39m,\n", - " lc_kwargs: {\n", - " content: \u001b[32m''\u001b[39m,\n", - " tool_calls: \u001b[36m[Array]\u001b[39m,\n", - " invalid_tool_calls: [],\n", - " additional_kwargs: \u001b[36m[Object]\u001b[39m,\n", - " response_metadata: \u001b[36m[Object]\u001b[39m\n", - " },\n", - " lc_namespace: [ \u001b[32m'langchain_core'\u001b[39m, \u001b[32m'messages'\u001b[39m ],\n", - " content: \u001b[32m''\u001b[39m,\n", - " name: \u001b[90mundefined\u001b[39m,\n", - " additional_kwargs: { tool_calls: \u001b[36m[Array]\u001b[39m },\n", - " response_metadata: { tokenUsage: \u001b[36m[Object]\u001b[39m, finish_reason: \u001b[32m'tool_calls'\u001b[39m },\n", - " id: \u001b[90mundefined\u001b[39m,\n", - " tool_calls: [ \u001b[36m[Object]\u001b[39m ],\n", - " invalid_tool_calls: [],\n", - " usage_metadata: \u001b[90mundefined\u001b[39m\n", - " },\n", - " ToolMessage {\n", - " lc_serializable: \u001b[33mtrue\u001b[39m,\n", - " lc_kwargs: {\n", - " name: \u001b[32m'search'\u001b[39m,\n", - " content: \u001b[32m'Cold, with a low of 3℃'\u001b[39m,\n", - " tool_call_id: \u001b[32m'call_9lZWCPGg6SUP5dg4eTge2xNU'\u001b[39m,\n", - " additional_kwargs: {},\n", - " response_metadata: {}\n", - " },\n", - " lc_namespace: [ \u001b[32m'langchain_core'\u001b[39m, \u001b[32m'messages'\u001b[39m ],\n", - " content: \u001b[32m'Cold, with a low of 3℃'\u001b[39m,\n", - " name: \u001b[32m'search'\u001b[39m,\n", - " additional_kwargs: {},\n", - " response_metadata: {},\n", - " id: \u001b[90mundefined\u001b[39m,\n", - " tool_call_id: \u001b[32m'call_9lZWCPGg6SUP5dg4eTge2xNU'\u001b[39m\n", - " },\n", - " AIMessage {\n", - " lc_serializable: \u001b[33mtrue\u001b[39m,\n", - " lc_kwargs: {\n", - " content: \u001b[32m'The current weather in San Francisco is cold, with a low of 3°C.'\u001b[39m,\n", - " tool_calls: [],\n", - " invalid_tool_calls: [],\n", - " additional_kwargs: {},\n", - " response_metadata: \u001b[36m[Object]\u001b[39m\n", - " },\n", - " lc_namespace: [ \u001b[32m'langchain_core'\u001b[39m, \u001b[32m'messages'\u001b[39m ],\n", - " content: \u001b[32m'The current weather in San Francisco is cold, with a low of 3°C.'\u001b[39m,\n", - " name: \u001b[90mundefined\u001b[39m,\n", - " additional_kwargs: {},\n", - " response_metadata: { tokenUsage: \u001b[36m[Object]\u001b[39m, finish_reason: \u001b[32m'stop'\u001b[39m },\n", - " id: \u001b[90mundefined\u001b[39m,\n", - " tool_calls: [],\n", - " invalid_tool_calls: [],\n", - " usage_metadata: \u001b[90mundefined\u001b[39m\n", - " },\n", - " \u001b[32m'what about ny?'\u001b[39m,\n", - " AIMessage {\n", - " lc_serializable: \u001b[33mtrue\u001b[39m,\n", - " lc_kwargs: {\n", - " content: \u001b[32m''\u001b[39m,\n", - " tool_calls: \u001b[36m[Array]\u001b[39m,\n", - " invalid_tool_calls: [],\n", - " additional_kwargs: \u001b[36m[Object]\u001b[39m,\n", - " response_metadata: \u001b[36m[Object]\u001b[39m\n", - " },\n", - " lc_namespace: [ \u001b[32m'langchain_core'\u001b[39m, \u001b[32m'messages'\u001b[39m ],\n", - " content: \u001b[32m''\u001b[39m,\n", - " name: \u001b[90mundefined\u001b[39m,\n", - " additional_kwargs: { tool_calls: \u001b[36m[Array]\u001b[39m },\n", - " response_metadata: { tokenUsage: \u001b[36m[Object]\u001b[39m, finish_reason: \u001b[32m'tool_calls'\u001b[39m },\n", - " id: \u001b[90mundefined\u001b[39m,\n", - " tool_calls: [ \u001b[36m[Object]\u001b[39m ],\n", - " invalid_tool_calls: [],\n", - " usage_metadata: \u001b[90mundefined\u001b[39m\n", - " },\n", - " ToolMessage {\n", - " lc_serializable: \u001b[33mtrue\u001b[39m,\n", - " lc_kwargs: {\n", - " name: \u001b[32m'search'\u001b[39m,\n", - " content: \u001b[32m'Cold, with a low of 3℃'\u001b[39m,\n", - " tool_call_id: \u001b[32m'call_7es5lLJH5bW7zVXqwH7id6tq'\u001b[39m,\n", - " additional_kwargs: {},\n", - " response_metadata: {}\n", - " },\n", - " lc_namespace: [ \u001b[32m'langchain_core'\u001b[39m, \u001b[32m'messages'\u001b[39m ],\n", - " content: \u001b[32m'Cold, with a low of 3℃'\u001b[39m,\n", - " name: \u001b[32m'search'\u001b[39m,\n", - " additional_kwargs: {},\n", - " response_metadata: {},\n", - " id: \u001b[90mundefined\u001b[39m,\n", - " tool_call_id: \u001b[32m'call_7es5lLJH5bW7zVXqwH7id6tq'\u001b[39m\n", - " },\n", - " AIMessage {\n", - " lc_serializable: \u001b[33mtrue\u001b[39m,\n", - " lc_kwargs: {\n", - " content: \u001b[32m'The current weather in New York City is also cold, with a low of 3°C.'\u001b[39m,\n", - " tool_calls: [],\n", - " invalid_tool_calls: [],\n", - " additional_kwargs: {},\n", - " response_metadata: \u001b[36m[Object]\u001b[39m\n", - " },\n", - " lc_namespace: [ \u001b[32m'langchain_core'\u001b[39m, \u001b[32m'messages'\u001b[39m ],\n", - " content: \u001b[32m'The current weather in New York City is also cold, with a low of 3°C.'\u001b[39m,\n", - " name: \u001b[90mundefined\u001b[39m,\n", - " additional_kwargs: {},\n", - " response_metadata: { tokenUsage: \u001b[36m[Object]\u001b[39m, finish_reason: \u001b[32m'stop'\u001b[39m },\n", - " id: \u001b[90mundefined\u001b[39m,\n", - " tool_calls: [],\n", - " invalid_tool_calls: [],\n", - " usage_metadata: \u001b[90mundefined\u001b[39m\n", - " }\n", - "]\n" - ] + "cells": [ + { + "cell_type": "markdown", + "id": "87d7b116-0f42-4ce4-90bc-43873db19cff", + "metadata": {}, + "source": [ + "# How to create a custom checkpointer using Postgres\n", + "\n", + "When creating LangGraph.js agents, you can also set them up so that they persist\n", + "their state. This allows you to do things like interact with an agent multiple\n", + "times and have it remember previous interactions.\n", + "\n", + "This example shows how to use `Postgres` as the backend for persisting\n", + "checkpoint state.\n", + "\n", + "NOTE: this is just an example implementation. You can implement your own\n", + "checkpointer using a different database or modify this one as long as it\n", + "conforms to the `BaseCheckpointSaver` interface." + ] + }, + { + "cell_type": "markdown", + "id": "7721e4e2-fd00-4fc9-bd1b-a3155bfec0b5", + "metadata": {}, + "source": [ + "### Checkpointer implementation" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "8ef31e39-3761-4740-b5d4-35d1a9d2c29e", + "metadata": {}, + "outputs": [], + "source": [ + "import {\n", + " BaseCheckpointSaver,\n", + " Checkpoint,\n", + " CheckpointMetadata,\n", + " CheckpointTuple,\n", + " SerializerProtocol,\n", + "} from \"@langchain/langgraph\";\n", + "import { load } from \"@langchain/core/load\";" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "e615d6a1-6f32-43a4-8fb4-4f1926cbd80e", + "metadata": {}, + "outputs": [], + "source": [ + "// define custom serializer, since we'll be using bytea Postgres type for `checkpoint` and `metadata` values\n", + "const CustomSerializer = {\n", + " stringify(obj) {\n", + " return Buffer.from(JSON.stringify(obj));\n", + " },\n", + "\n", + " async parse(data) {\n", + " return await load(data.toString());\n", + " },\n", + "};" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "da53e336-c017-43d0-99c4-9a44caa3b824", + "metadata": {}, + "outputs": [], + "source": [ + "import { Pool } from \"pg\";\n", + "import { RunnableConfig } from \"@langchain/core/runnables\";\n", + "\n", + "// snake_case is used to match Python implementation\n", + "interface Row {\n", + " checkpoint: string;\n", + " metadata: string;\n", + " parent_id?: string;\n", + " thread_id: string;\n", + " checkpoint_id: string;\n", + "}\n", + "\n", + "// define Postgres checkpointer\n", + "class PostgresSaver extends BaseCheckpointSaver {\n", + " private pool: Pool;\n", + " private isSetup: boolean;\n", + "\n", + " constructor(pool: Pool) {\n", + " // @ts-ignore\n", + " super(CustomSerializer);\n", + " this.pool = pool;\n", + " this.isSetup = false;\n", + " }\n", + "\n", + " static fromConnString(connString: string): PostgresSaver {\n", + " return new PostgresSaver(new Pool({ connectionString: connString }));\n", + " }\n", + "\n", + " private async setup(): Promise {\n", + " if (this.isSetup) return;\n", + "\n", + " const client = await this.pool.connect();\n", + " try {\n", + " await client.query(`\n", + "CREATE TABLE IF NOT EXISTS checkpoints (\n", + " thread_id TEXT NOT NULL,\n", + " checkpoint_id TEXT NOT NULL,\n", + " parent_id TEXT,\n", + " checkpoint BYTEA NOT NULL,\n", + " metadata BYTEA NOT NULL,\n", + " PRIMARY KEY (thread_id, checkpoint_id)\n", + ");\n", + " `);\n", + " this.isSetup = true;\n", + " } catch (error) {\n", + " console.error(\"Error creating checkpoints table\", error);\n", + " throw error;\n", + " } finally {\n", + " client.release();\n", + " }\n", + " }\n", + "\n", + " // below 3 methods are necessary for any checkpointer implementation: getTuple, list and put\n", + " async getTuple(config: RunnableConfig): Promise {\n", + " await this.setup();\n", + " const { thread_id, checkpoint_id } = config.configurable || {};\n", + "\n", + " const client = await this.pool.connect();\n", + " try {\n", + " if (checkpoint_id) {\n", + " const res = await client.query(\n", + " `SELECT checkpoint, parent_id, metadata FROM checkpoints WHERE thread_id = $1 AND checkpoint_id = $2`,\n", + " [thread_id, checkpoint_id],\n", + " );\n", + " const row = res.rows[0];\n", + " if (row) {\n", + " return {\n", + " config,\n", + " checkpoint: (await this.serde.parse(row.checkpoint)) as Checkpoint,\n", + " metadata: (await this.serde.parse(\n", + " row.metadata,\n", + " )) as CheckpointMetadata,\n", + " parentConfig: row.parent_id\n", + " ? {\n", + " configurable: {\n", + " thread_id,\n", + " checkpoint_id: row.parent_id,\n", + " },\n", + " }\n", + " : undefined,\n", + " };\n", + " }\n", + " } else {\n", + " const res = await client.query(\n", + " `SELECT thread_id, checkpoint_id, parent_id, checkpoint, metadata FROM checkpoints WHERE thread_id = $1 ORDER BY checkpoint_id DESC LIMIT 1`,\n", + " [thread_id],\n", + " );\n", + " const row = res.rows[0];\n", + " if (row) {\n", + " return {\n", + " config: {\n", + " configurable: {\n", + " thread_id: row.thread_id,\n", + " checkpoint_id: row.checkpoint_id,\n", + " },\n", + " },\n", + " checkpoint: (await this.serde.parse(row.checkpoint)) as Checkpoint,\n", + " metadata: (await this.serde.parse(\n", + " row.metadata,\n", + " )) as CheckpointMetadata,\n", + " parentConfig: row.parent_id\n", + " ? {\n", + " configurable: {\n", + " thread_id: row.thread_id,\n", + " checkpoint_id: row.parent_id,\n", + " },\n", + " }\n", + " : undefined,\n", + " };\n", + " }\n", + " }\n", + " } catch (error) {\n", + " console.error(\"Error retrieving checkpoint\", error);\n", + " throw error;\n", + " } finally {\n", + " client.release();\n", + " }\n", + "\n", + " return undefined;\n", + " }\n", + "\n", + " async *list(\n", + " config: RunnableConfig,\n", + " limit?: number,\n", + " before?: RunnableConfig,\n", + " ): AsyncGenerator {\n", + " await this.setup();\n", + " const { thread_id } = config.configurable || {};\n", + " let query =\n", + " `SELECT thread_id, checkpoint_id, parent_id, checkpoint, metadata FROM checkpoints WHERE thread_id = $1`;\n", + " const params: (string | number)[] = [thread_id];\n", + " if (before?.configurable?.checkpoint_id) {\n", + " query += \" AND checkpoint_id < $2\";\n", + " params.push(before.configurable.checkpoint_id);\n", + " }\n", + " query += \" ORDER BY checkpoint_id DESC\";\n", + " if (limit) {\n", + " query += \" LIMIT $\" + (params.length + 1);\n", + " params.push(limit);\n", + " }\n", + "\n", + " const client = await this.pool.connect();\n", + " try {\n", + " const res = await client.query(query, params);\n", + " for (const row of res.rows) {\n", + " yield {\n", + " config: {\n", + " configurable: {\n", + " thread_id: row.thread_id,\n", + " checkpoint_id: row.checkpoint_id,\n", + " },\n", + " },\n", + " checkpoint: (await this.serde.parse(row.checkpoint)) as Checkpoint,\n", + " metadata: (await this.serde.parse(\n", + " row.metadata,\n", + " )) as CheckpointMetadata,\n", + " parentConfig: row.parent_id\n", + " ? {\n", + " configurable: {\n", + " thread_id: row.thread_id,\n", + " checkpoint_id: row.parent_id,\n", + " },\n", + " }\n", + " : undefined,\n", + " };\n", + " }\n", + " } catch (error) {\n", + " console.error(\"Error listing checkpoints\", error);\n", + " throw error;\n", + " } finally {\n", + " client.release();\n", + " }\n", + " }\n", + "\n", + " async put(\n", + " config: RunnableConfig,\n", + " checkpoint: Checkpoint,\n", + " metadata: CheckpointMetadata,\n", + " ): Promise {\n", + " await this.setup();\n", + " const client = await this.pool.connect();\n", + " try {\n", + " await client.query(\n", + " `INSERT INTO checkpoints (thread_id, checkpoint_id, parent_id, checkpoint, metadata) VALUES ($1, $2, $3, $4, $5)\n", + " ON CONFLICT (thread_id, checkpoint_id) DO UPDATE SET checkpoint = EXCLUDED.checkpoint, metadata = EXCLUDED.metadata`,\n", + " [\n", + " config.configurable?.thread_id,\n", + " checkpoint.id,\n", + " config.configurable?.checkpoint_id,\n", + " this.serde.stringify(checkpoint),\n", + " this.serde.stringify(metadata),\n", + " ],\n", + " );\n", + " } catch (error) {\n", + " console.error(\"Error saving checkpoint\", error);\n", + " throw error;\n", + " } finally {\n", + " client.release();\n", + " }\n", + "\n", + " return {\n", + " configurable: {\n", + " thread_id: config.configurable?.thread_id,\n", + " checkpoint_id: checkpoint.id,\n", + " },\n", + " };\n", + " }\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "0aba1e76-75b4-453f-b0fb-c2131d013602", + "metadata": {}, + "source": [ + "---" + ] + }, + { + "cell_type": "markdown", + "id": "0391f5fd-d3f1-4e35-a68e-bcde597b5f26", + "metadata": {}, + "source": [ + "Now we're ready to test the Postgres checkpointer with a graph. Let's define a\n", + "simple ReAct agent in LangGraph." + ] + }, + { + "cell_type": "markdown", + "id": "15e494c8-c9a5-4a66-af7a-c4e55d9946f4", + "metadata": {}, + "source": [ + "## Setup environment" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f64404ce-1c4b-4f5e-bebe-ec04fc016708", + "metadata": { + "lines_to_next_cell": 2 + }, + "outputs": [], + "source": [ + "// process.env.OPENAI_API_KEY = \"sk-...\";" + ] + }, + { + "cell_type": "markdown", + "id": "7cba7a79-361c-4e72-b7a2-b6e65908da4b", + "metadata": {}, + "source": [ + "## Define the state\n", + "\n", + "The state is the interface for all of the nodes in our graph.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "87e996ae-5f71-42e3-bd6d-f84f8224ec5e", + "metadata": { + "lines_to_next_cell": 2 + }, + "outputs": [], + "source": [ + "import { Annotation } from \"@langchain/langgraph\";\n", + "import { BaseMessage } from \"@langchain/core/messages\";\n", + "\n", + "const AgentState = Annotation.Root({\n", + " messages: Annotation({\n", + " reducer: (x, y) => x.concat(y),\n", + " }),\n", + "});" + ] + }, + { + "cell_type": "markdown", + "id": "da96349a-2f52-45f7-a51c-bd6ead78ec9a", + "metadata": {}, + "source": [ + "## Set up the tools\n", + "\n", + "We will first define the tools we want to use. For this simple example, we will\n", + "use create a placeholder search engine. However, it is really easy to create\n", + "your own tools - see documentation\n", + "[here](https://js.langchain.com/v0.2/docs/how_to/custom_tools) on how to do\n", + "that.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "4a07a7b6-07b0-4dcf-a2dd-633dab31fc51", + "metadata": { + "lines_to_next_cell": 2 + }, + "outputs": [], + "source": [ + "import { DynamicStructuredTool } from \"@langchain/core/tools\";\n", + "import { z } from \"zod\";\n", + "\n", + "const searchTool = new DynamicStructuredTool({\n", + " name: \"search\",\n", + " description:\n", + " \"Use to surf the web, fetch current information, check the weather, and retrieve other information.\",\n", + " schema: z.object({\n", + " query: z.string().describe(\"The query to use in your search.\"),\n", + " }),\n", + " func: async ({ query: _query }: { query: string }) => {\n", + " // This is a placeholder for the actual implementation\n", + " return \"Cold, with a low of 3℃\";\n", + " },\n", + "});\n", + "\n", + "await searchTool.invoke({ query: \"What's the weather like?\" });\n", + "\n", + "const tools = [searchTool];" + ] + }, + { + "cell_type": "markdown", + "id": "0fdc21b8-5745-46c1-83ab-f85a2828224d", + "metadata": {}, + "source": [ + "We can now wrap these tools in a simple\n", + "[ToolNode](/langgraphjs/reference/classes/langgraph_prebuilt.ToolNode.html).\n", + "This object will actually run the tools (functions) whenever they are invoked by\n", + "our LLM.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "a1aeefd0-f378-4331-8d95-edf2227656a2", + "metadata": { + "lines_to_next_cell": 2 + }, + "outputs": [], + "source": [ + "import { ToolNode } from \"@langchain/langgraph/prebuilt\";\n", + "\n", + "const toolNode = new ToolNode(tools);" + ] + }, + { + "cell_type": "markdown", + "id": "c519abcb-2ca0-472e-9f7f-80d9e9aad143", + "metadata": {}, + "source": [ + "## Set up the model\n", + "\n", + "Now we will load the\n", + "[chat model](https://js.langchain.com/v0.2/docs/concepts/#chat-models).\n", + "\n", + "1. It should work with messages. We will represent all agent state in the form\n", + " of messages, so it needs to be able to work well with them.\n", + "2. It should work with\n", + " [tool calling](https://js.langchain.com/v0.2/docs/how_to/tool_calling/#passing-tools-to-llms),\n", + " meaning it can return function arguments in its response.\n", + "\n", + "
\n", + "

Note

\n", + "

\n", + " These model requirements are not general requirements for using LangGraph - they are just requirements for this one example.\n", + "

\n", + "
" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "18aef017-e4f5-47db-9f01-b6bf62e246b2", + "metadata": { + "lines_to_next_cell": 2 + }, + "outputs": [], + "source": [ + "import { ChatOpenAI } from \"@langchain/openai\";\n", + "const model = new ChatOpenAI({ model: \"gpt-4o\" });" + ] + }, + { + "cell_type": "markdown", + "id": "890fe6b7-9acd-4d11-bd50-9ca0ae2e31c3", + "metadata": {}, + "source": [ + "After we've done this, we should make sure the model knows that it has these\n", + "tools available to call. We can do this by calling\n", + "[bindTools](https://v01.api.js.langchain.com/classes/langchain_core_language_models_chat_models.BaseChatModel.html#bindTools)." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "86535395-239d-485f-a928-e54e4f8d3038", + "metadata": { + "lines_to_next_cell": 2 + }, + "outputs": [], + "source": [ + "const boundModel = model.bindTools(tools);" + ] + }, + { + "cell_type": "markdown", + "id": "93837661-26e4-4c34-9711-34269b454ec3", + "metadata": {}, + "source": [ + "## Define the graph\n", + "\n", + "We can now put it all together." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "916d2bbc-c1b4-4dd0-97ab-372f5cf7a40a", + "metadata": {}, + "outputs": [], + "source": [ + "import { END, START, StateGraph } from \"@langchain/langgraph\";\n", + "import { AIMessage } from \"@langchain/core/messages\";\n", + "import { RunnableConfig } from \"@langchain/core/runnables\";\n", + "\n", + "const routeMessage = (state: typeof AgentState.State) => {\n", + " const { messages } = state;\n", + " const lastMessage = messages[messages.length - 1] as AIMessage;\n", + " // If no tools are called, we can finish (respond to the user)\n", + " if (!lastMessage?.tool_calls?.length) {\n", + " return END;\n", + " }\n", + " // Otherwise if there is, we continue and call the tools\n", + " return \"tools\";\n", + "};\n", + "\n", + "const callModel = async (\n", + " state: typeof AgentState.State,\n", + " config?: RunnableConfig,\n", + ") => {\n", + " // For versions of @langchain/core < 0.2.3, you must call `.stream()`\n", + " // and aggregate the message from chunks instead of calling `.invoke()`.\n", + " const { messages } = state;\n", + " const responseMessage = await boundModel.invoke(messages, config);\n", + " return { messages: [responseMessage] };\n", + "};\n", + "\n", + "const workflow = new StateGraph(AgentState)\n", + " .addNode(\"agent\", callModel)\n", + " .addNode(\"tools\", toolNode)\n", + " .addEdge(START, \"agent\")\n", + " .addConditionalEdges(\"agent\", routeMessage)\n", + " .addEdge(\"tools\", \"agent\");" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "f0b69301-4726-4f62-87cc-b097e4fb451a", + "metadata": {}, + "outputs": [], + "source": [ + "// Initialize our Postgres connection pool & checkpointer\n", + "const pool = new Pool({\n", + " connectionString:\n", + " \"postgresql://postgres:postgres@localhost:5432/postgres?sslmode=disable\",\n", + "});\n", + "const checkpointer = new PostgresSaver(pool);" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "f357d9ae-8bb7-4624-b932-28e7d2b46441", + "metadata": {}, + "outputs": [], + "source": [ + "// Compile the graph with Postgres checkpointer\n", + "const graph = workflow.compile({ checkpointer: checkpointer });" + ] + }, + { + "cell_type": "markdown", + "id": "d1770321-5181-4365-8957-465009ec64e7", + "metadata": {}, + "source": [ + "## Run the graph with checkpointer" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "b5c08487-57b6-4eff-bd14-f97e7e8b69eb", + "metadata": {}, + "outputs": [], + "source": [ + "// note: we're invoking the graph with a config that contains thread ID\n", + "const config = { configurable: { thread_id: 42 } };\n", + "const res = await graph.invoke(\n", + " { \"messages\": [[\"user\", \"what's the weather in sf\"]] },\n", + " config,\n", + ");" + ] + }, + { + "cell_type": "markdown", + "id": "c922d223", + "metadata": {}, + "source": [ + "### Load checkpoint" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "d88f3851-bb66-45b7-b9e8-38cf5b97abdf", + "metadata": {}, + "outputs": [], + "source": [ + "const checkpointTuple = await checkpointer.getTuple(config);" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "49b0f317-c876-4d7e-887a-dec604b1c06a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{\n", + " config: {\n", + " configurable: {\n", + " thread_id: \u001b[32m'42'\u001b[39m,\n", + " checkpoint_id: \u001b[32m'1ef3fb9c-599d-6ef1-8003-88ab826dad68'\u001b[39m\n", + " }\n", + " },\n", + " checkpoint: {\n", + " v: \u001b[33m1\u001b[39m,\n", + " id: \u001b[32m'1ef3fb9c-599d-6ef1-8003-88ab826dad68'\u001b[39m,\n", + " ts: \u001b[32m'2024-07-11T19:14:18.847Z'\u001b[39m,\n", + " channel_values: { messages: \u001b[36m[Array]\u001b[39m, agent: \u001b[32m'agent'\u001b[39m },\n", + " channel_versions: {\n", + " __start__: \u001b[33m1\u001b[39m,\n", + " messages: \u001b[33m5\u001b[39m,\n", + " \u001b[32m'start:agent'\u001b[39m: \u001b[33m2\u001b[39m,\n", + " agent: \u001b[33m5\u001b[39m,\n", + " \u001b[32m'branch:agent:routeMessage:tools'\u001b[39m: \u001b[33m3\u001b[39m,\n", + " tools: \u001b[33m4\u001b[39m\n", + " },\n", + " versions_seen: { __start__: \u001b[36m[Object]\u001b[39m, agent: \u001b[36m[Object]\u001b[39m, tools: \u001b[36m[Object]\u001b[39m }\n", + " },\n", + " metadata: { source: \u001b[32m'loop'\u001b[39m, step: \u001b[33m3\u001b[39m, writes: { agent: \u001b[36m[Object]\u001b[39m } },\n", + " parentConfig: {\n", + " configurable: {\n", + " thread_id: \u001b[32m'42'\u001b[39m,\n", + " checkpoint_id: \u001b[32m'1ef3fb9c-50a9-6740-8002-d0dcfbbf0749'\u001b[39m\n", + " }\n", + " }\n", + "}\n" + ] + } + ], + "source": [ + "checkpointTuple;" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "c1d20f09-0f12-4b39-a80a-7a4a073fb879", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[\n", + " \u001b[32m\"what's the weather in sf\"\u001b[39m,\n", + " AIMessage {\n", + " lc_serializable: \u001b[33mtrue\u001b[39m,\n", + " lc_kwargs: {\n", + " content: \u001b[32m''\u001b[39m,\n", + " tool_calls: \u001b[36m[Array]\u001b[39m,\n", + " invalid_tool_calls: [],\n", + " additional_kwargs: \u001b[36m[Object]\u001b[39m,\n", + " response_metadata: \u001b[36m[Object]\u001b[39m\n", + " },\n", + " lc_namespace: [ \u001b[32m'langchain_core'\u001b[39m, \u001b[32m'messages'\u001b[39m ],\n", + " content: \u001b[32m''\u001b[39m,\n", + " name: \u001b[90mundefined\u001b[39m,\n", + " additional_kwargs: { tool_calls: \u001b[36m[Array]\u001b[39m },\n", + " response_metadata: { tokenUsage: \u001b[36m[Object]\u001b[39m, finish_reason: \u001b[32m'tool_calls'\u001b[39m },\n", + " id: \u001b[90mundefined\u001b[39m,\n", + " tool_calls: [ \u001b[36m[Object]\u001b[39m ],\n", + " invalid_tool_calls: [],\n", + " usage_metadata: \u001b[90mundefined\u001b[39m\n", + " },\n", + " ToolMessage {\n", + " lc_serializable: \u001b[33mtrue\u001b[39m,\n", + " lc_kwargs: {\n", + " name: \u001b[32m'search'\u001b[39m,\n", + " content: \u001b[32m'Cold, with a low of 3℃'\u001b[39m,\n", + " tool_call_id: \u001b[32m'call_9lZWCPGg6SUP5dg4eTge2xNU'\u001b[39m,\n", + " additional_kwargs: {},\n", + " response_metadata: {}\n", + " },\n", + " lc_namespace: [ \u001b[32m'langchain_core'\u001b[39m, \u001b[32m'messages'\u001b[39m ],\n", + " content: \u001b[32m'Cold, with a low of 3℃'\u001b[39m,\n", + " name: \u001b[32m'search'\u001b[39m,\n", + " additional_kwargs: {},\n", + " response_metadata: {},\n", + " id: \u001b[90mundefined\u001b[39m,\n", + " tool_call_id: \u001b[32m'call_9lZWCPGg6SUP5dg4eTge2xNU'\u001b[39m\n", + " },\n", + " AIMessage {\n", + " lc_serializable: \u001b[33mtrue\u001b[39m,\n", + " lc_kwargs: {\n", + " content: \u001b[32m'The current weather in San Francisco is cold, with a low of 3°C.'\u001b[39m,\n", + " tool_calls: [],\n", + " invalid_tool_calls: [],\n", + " additional_kwargs: {},\n", + " response_metadata: \u001b[36m[Object]\u001b[39m\n", + " },\n", + " lc_namespace: [ \u001b[32m'langchain_core'\u001b[39m, \u001b[32m'messages'\u001b[39m ],\n", + " content: \u001b[32m'The current weather in San Francisco is cold, with a low of 3°C.'\u001b[39m,\n", + " name: \u001b[90mundefined\u001b[39m,\n", + " additional_kwargs: {},\n", + " response_metadata: { tokenUsage: \u001b[36m[Object]\u001b[39m, finish_reason: \u001b[32m'stop'\u001b[39m },\n", + " id: \u001b[90mundefined\u001b[39m,\n", + " tool_calls: [],\n", + " invalid_tool_calls: [],\n", + " usage_metadata: \u001b[90mundefined\u001b[39m\n", + " }\n", + "]\n" + ] + } + ], + "source": [ + "checkpointTuple.checkpoint.channel_values[\"messages\"];" + ] + }, + { + "cell_type": "markdown", + "id": "8b0c1f54", + "metadata": {}, + "source": [ + "### Run on the same conversation thread" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "003c34f2-f628-4536-b6d1-cc095da15fdf", + "metadata": {}, + "outputs": [], + "source": [ + "const newRes = await graph.invoke(\n", + " { \"messages\": [[\"user\", \"what about ny?\"]] },\n", + " config,\n", + ");" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "e0e43b63-8b48-4b01-a80f-e28d78b10e0e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[\n", + " \u001b[32m\"what's the weather in sf\"\u001b[39m,\n", + " AIMessage {\n", + " lc_serializable: \u001b[33mtrue\u001b[39m,\n", + " lc_kwargs: {\n", + " content: \u001b[32m''\u001b[39m,\n", + " tool_calls: \u001b[36m[Array]\u001b[39m,\n", + " invalid_tool_calls: [],\n", + " additional_kwargs: \u001b[36m[Object]\u001b[39m,\n", + " response_metadata: \u001b[36m[Object]\u001b[39m\n", + " },\n", + " lc_namespace: [ \u001b[32m'langchain_core'\u001b[39m, \u001b[32m'messages'\u001b[39m ],\n", + " content: \u001b[32m''\u001b[39m,\n", + " name: \u001b[90mundefined\u001b[39m,\n", + " additional_kwargs: { tool_calls: \u001b[36m[Array]\u001b[39m },\n", + " response_metadata: { tokenUsage: \u001b[36m[Object]\u001b[39m, finish_reason: \u001b[32m'tool_calls'\u001b[39m },\n", + " id: \u001b[90mundefined\u001b[39m,\n", + " tool_calls: [ \u001b[36m[Object]\u001b[39m ],\n", + " invalid_tool_calls: [],\n", + " usage_metadata: \u001b[90mundefined\u001b[39m\n", + " },\n", + " ToolMessage {\n", + " lc_serializable: \u001b[33mtrue\u001b[39m,\n", + " lc_kwargs: {\n", + " name: \u001b[32m'search'\u001b[39m,\n", + " content: \u001b[32m'Cold, with a low of 3℃'\u001b[39m,\n", + " tool_call_id: \u001b[32m'call_9lZWCPGg6SUP5dg4eTge2xNU'\u001b[39m,\n", + " additional_kwargs: {},\n", + " response_metadata: {}\n", + " },\n", + " lc_namespace: [ \u001b[32m'langchain_core'\u001b[39m, \u001b[32m'messages'\u001b[39m ],\n", + " content: \u001b[32m'Cold, with a low of 3℃'\u001b[39m,\n", + " name: \u001b[32m'search'\u001b[39m,\n", + " additional_kwargs: {},\n", + " response_metadata: {},\n", + " id: \u001b[90mundefined\u001b[39m,\n", + " tool_call_id: \u001b[32m'call_9lZWCPGg6SUP5dg4eTge2xNU'\u001b[39m\n", + " },\n", + " AIMessage {\n", + " lc_serializable: \u001b[33mtrue\u001b[39m,\n", + " lc_kwargs: {\n", + " content: \u001b[32m'The current weather in San Francisco is cold, with a low of 3°C.'\u001b[39m,\n", + " tool_calls: [],\n", + " invalid_tool_calls: [],\n", + " additional_kwargs: {},\n", + " response_metadata: \u001b[36m[Object]\u001b[39m\n", + " },\n", + " lc_namespace: [ \u001b[32m'langchain_core'\u001b[39m, \u001b[32m'messages'\u001b[39m ],\n", + " content: \u001b[32m'The current weather in San Francisco is cold, with a low of 3°C.'\u001b[39m,\n", + " name: \u001b[90mundefined\u001b[39m,\n", + " additional_kwargs: {},\n", + " response_metadata: { tokenUsage: \u001b[36m[Object]\u001b[39m, finish_reason: \u001b[32m'stop'\u001b[39m },\n", + " id: \u001b[90mundefined\u001b[39m,\n", + " tool_calls: [],\n", + " invalid_tool_calls: [],\n", + " usage_metadata: \u001b[90mundefined\u001b[39m\n", + " },\n", + " \u001b[32m'what about ny?'\u001b[39m,\n", + " AIMessage {\n", + " lc_serializable: \u001b[33mtrue\u001b[39m,\n", + " lc_kwargs: {\n", + " content: \u001b[32m''\u001b[39m,\n", + " tool_calls: \u001b[36m[Array]\u001b[39m,\n", + " invalid_tool_calls: [],\n", + " additional_kwargs: \u001b[36m[Object]\u001b[39m,\n", + " response_metadata: \u001b[36m[Object]\u001b[39m\n", + " },\n", + " lc_namespace: [ \u001b[32m'langchain_core'\u001b[39m, \u001b[32m'messages'\u001b[39m ],\n", + " content: \u001b[32m''\u001b[39m,\n", + " name: \u001b[90mundefined\u001b[39m,\n", + " additional_kwargs: { tool_calls: \u001b[36m[Array]\u001b[39m },\n", + " response_metadata: { tokenUsage: \u001b[36m[Object]\u001b[39m, finish_reason: \u001b[32m'tool_calls'\u001b[39m },\n", + " id: \u001b[90mundefined\u001b[39m,\n", + " tool_calls: [ \u001b[36m[Object]\u001b[39m ],\n", + " invalid_tool_calls: [],\n", + " usage_metadata: \u001b[90mundefined\u001b[39m\n", + " },\n", + " ToolMessage {\n", + " lc_serializable: \u001b[33mtrue\u001b[39m,\n", + " lc_kwargs: {\n", + " name: \u001b[32m'search'\u001b[39m,\n", + " content: \u001b[32m'Cold, with a low of 3℃'\u001b[39m,\n", + " tool_call_id: \u001b[32m'call_7es5lLJH5bW7zVXqwH7id6tq'\u001b[39m,\n", + " additional_kwargs: {},\n", + " response_metadata: {}\n", + " },\n", + " lc_namespace: [ \u001b[32m'langchain_core'\u001b[39m, \u001b[32m'messages'\u001b[39m ],\n", + " content: \u001b[32m'Cold, with a low of 3℃'\u001b[39m,\n", + " name: \u001b[32m'search'\u001b[39m,\n", + " additional_kwargs: {},\n", + " response_metadata: {},\n", + " id: \u001b[90mundefined\u001b[39m,\n", + " tool_call_id: \u001b[32m'call_7es5lLJH5bW7zVXqwH7id6tq'\u001b[39m\n", + " },\n", + " AIMessage {\n", + " lc_serializable: \u001b[33mtrue\u001b[39m,\n", + " lc_kwargs: {\n", + " content: \u001b[32m'The current weather in New York City is also cold, with a low of 3°C.'\u001b[39m,\n", + " tool_calls: [],\n", + " invalid_tool_calls: [],\n", + " additional_kwargs: {},\n", + " response_metadata: \u001b[36m[Object]\u001b[39m\n", + " },\n", + " lc_namespace: [ \u001b[32m'langchain_core'\u001b[39m, \u001b[32m'messages'\u001b[39m ],\n", + " content: \u001b[32m'The current weather in New York City is also cold, with a low of 3°C.'\u001b[39m,\n", + " name: \u001b[90mundefined\u001b[39m,\n", + " additional_kwargs: {},\n", + " response_metadata: { tokenUsage: \u001b[36m[Object]\u001b[39m, finish_reason: \u001b[32m'stop'\u001b[39m },\n", + " id: \u001b[90mundefined\u001b[39m,\n", + " tool_calls: [],\n", + " invalid_tool_calls: [],\n", + " usage_metadata: \u001b[90mundefined\u001b[39m\n", + " }\n", + "]\n" + ] + } + ], + "source": [ + "// verify that we have the new messages added to the latest checkpoint for the thread\n", + "(await checkpointer.getTuple(config)).checkpoint.channel_values[\"messages\"];" + ] + }, + { + "cell_type": "markdown", + "id": "d37e6fa0-0080-4209-826a-f860eba3c101", + "metadata": {}, + "source": [ + "### List checkpoints" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "1b8a7859-91ec-4383-b637-21423273a947", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{\n", + " config: {\n", + " configurable: {\n", + " thread_id: \u001b[32m'1'\u001b[39m,\n", + " checkpoint_id: \u001b[32m'1ef3fb99-f829-66d0-8012-e62c07718de3'\u001b[39m\n", + " }\n", + " },\n", + " checkpoint: {\n", + " v: \u001b[33m1\u001b[39m,\n", + " id: \u001b[32m'1ef3fb99-f829-66d0-8012-e62c07718de3'\u001b[39m,\n", + " ts: \u001b[32m'2024-07-11T19:13:14.941Z'\u001b[39m,\n", + " channel_values: { messages: \u001b[36m[Array]\u001b[39m, agent: \u001b[32m'agent'\u001b[39m },\n", + " channel_versions: {\n", + " __start__: \u001b[33m16\u001b[39m,\n", + " messages: \u001b[33m20\u001b[39m,\n", + " \u001b[32m'start:agent'\u001b[39m: \u001b[33m17\u001b[39m,\n", + " agent: \u001b[33m20\u001b[39m,\n", + " \u001b[32m'branch:agent:routeMessage:tools'\u001b[39m: \u001b[33m18\u001b[39m,\n", + " tools: \u001b[33m19\u001b[39m\n", + " },\n", + " versions_seen: { __start__: \u001b[36m[Object]\u001b[39m, agent: \u001b[36m[Object]\u001b[39m, tools: \u001b[36m[Object]\u001b[39m }\n", + " },\n", + " metadata: { source: \u001b[32m'loop'\u001b[39m, step: \u001b[33m18\u001b[39m, writes: { agent: \u001b[36m[Object]\u001b[39m } },\n", + " parentConfig: {\n", + " configurable: {\n", + " thread_id: \u001b[32m'1'\u001b[39m,\n", + " checkpoint_id: \u001b[32m'1ef3fb99-f1b2-6270-8011-7ecc1fda99cf'\u001b[39m\n", + " }\n", + " }\n", + "}\n", + "{\n", + " config: {\n", + " configurable: {\n", + " thread_id: \u001b[32m'1'\u001b[39m,\n", + " checkpoint_id: \u001b[32m'1ef3fb99-f1b2-6270-8011-7ecc1fda99cf'\u001b[39m\n", + " }\n", + " },\n", + " checkpoint: {\n", + " v: \u001b[33m1\u001b[39m,\n", + " id: \u001b[32m'1ef3fb99-f1b2-6270-8011-7ecc1fda99cf'\u001b[39m,\n", + " ts: \u001b[32m'2024-07-11T19:13:14.263Z'\u001b[39m,\n", + " channel_values: { messages: \u001b[36m[Array]\u001b[39m, tools: \u001b[32m'tools'\u001b[39m },\n", + " channel_versions: {\n", + " __start__: \u001b[33m16\u001b[39m,\n", + " messages: \u001b[33m19\u001b[39m,\n", + " \u001b[32m'start:agent'\u001b[39m: \u001b[33m17\u001b[39m,\n", + " agent: \u001b[33m18\u001b[39m,\n", + " \u001b[32m'branch:agent:routeMessage:tools'\u001b[39m: \u001b[33m18\u001b[39m,\n", + " tools: \u001b[33m19\u001b[39m\n", + " },\n", + " versions_seen: { __start__: \u001b[36m[Object]\u001b[39m, agent: \u001b[36m[Object]\u001b[39m, tools: \u001b[36m[Object]\u001b[39m }\n", + " },\n", + " metadata: { source: \u001b[32m'loop'\u001b[39m, step: \u001b[33m17\u001b[39m, writes: { tools: \u001b[36m[Object]\u001b[39m } },\n", + " parentConfig: {\n", + " configurable: {\n", + " thread_id: \u001b[32m'1'\u001b[39m,\n", + " checkpoint_id: \u001b[32m'1ef3fb99-f1af-6b60-8010-b3c0f6939ab2'\u001b[39m\n", + " }\n", + " }\n", + "}\n" + ] + } + ], + "source": [ + "// list last 2 checkpoints\n", + "const limit = 2;\n", + "for await (\n", + " const chunk of await checkpointer.list(\n", + " { configurable: { thread_id: 1 } },\n", + " limit,\n", + " )\n", + ") {\n", + " console.log(chunk);\n", + "}" + ] } - ], - "source": [ - "// verify that we have the new messages added to the latest checkpoint for the thread\n", - "(await checkpointer.getTuple(config)).checkpoint.channel_values[\"messages\"];" - ] - }, - { - "cell_type": "markdown", - "id": "d37e6fa0-0080-4209-826a-f860eba3c101", - "metadata": {}, - "source": [ - "### List checkpoints" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "1b8a7859-91ec-4383-b637-21423273a947", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{\n", - " config: {\n", - " configurable: {\n", - " thread_id: \u001b[32m'1'\u001b[39m,\n", - " checkpoint_id: \u001b[32m'1ef3fb99-f829-66d0-8012-e62c07718de3'\u001b[39m\n", - " }\n", - " },\n", - " checkpoint: {\n", - " v: \u001b[33m1\u001b[39m,\n", - " id: \u001b[32m'1ef3fb99-f829-66d0-8012-e62c07718de3'\u001b[39m,\n", - " ts: \u001b[32m'2024-07-11T19:13:14.941Z'\u001b[39m,\n", - " channel_values: { messages: \u001b[36m[Array]\u001b[39m, agent: \u001b[32m'agent'\u001b[39m },\n", - " channel_versions: {\n", - " __start__: \u001b[33m16\u001b[39m,\n", - " messages: \u001b[33m20\u001b[39m,\n", - " \u001b[32m'start:agent'\u001b[39m: \u001b[33m17\u001b[39m,\n", - " agent: \u001b[33m20\u001b[39m,\n", - " \u001b[32m'branch:agent:routeMessage:tools'\u001b[39m: \u001b[33m18\u001b[39m,\n", - " tools: \u001b[33m19\u001b[39m\n", - " },\n", - " versions_seen: { __start__: \u001b[36m[Object]\u001b[39m, agent: \u001b[36m[Object]\u001b[39m, tools: \u001b[36m[Object]\u001b[39m }\n", - " },\n", - " metadata: { source: \u001b[32m'loop'\u001b[39m, step: \u001b[33m18\u001b[39m, writes: { agent: \u001b[36m[Object]\u001b[39m } },\n", - " parentConfig: {\n", - " configurable: {\n", - " thread_id: \u001b[32m'1'\u001b[39m,\n", - " checkpoint_id: \u001b[32m'1ef3fb99-f1b2-6270-8011-7ecc1fda99cf'\u001b[39m\n", - " }\n", - " }\n", - "}\n", - "{\n", - " config: {\n", - " configurable: {\n", - " thread_id: \u001b[32m'1'\u001b[39m,\n", - " checkpoint_id: \u001b[32m'1ef3fb99-f1b2-6270-8011-7ecc1fda99cf'\u001b[39m\n", - " }\n", - " },\n", - " checkpoint: {\n", - " v: \u001b[33m1\u001b[39m,\n", - " id: \u001b[32m'1ef3fb99-f1b2-6270-8011-7ecc1fda99cf'\u001b[39m,\n", - " ts: \u001b[32m'2024-07-11T19:13:14.263Z'\u001b[39m,\n", - " channel_values: { messages: \u001b[36m[Array]\u001b[39m, tools: \u001b[32m'tools'\u001b[39m },\n", - " channel_versions: {\n", - " __start__: \u001b[33m16\u001b[39m,\n", - " messages: \u001b[33m19\u001b[39m,\n", - " \u001b[32m'start:agent'\u001b[39m: \u001b[33m17\u001b[39m,\n", - " agent: \u001b[33m18\u001b[39m,\n", - " \u001b[32m'branch:agent:routeMessage:tools'\u001b[39m: \u001b[33m18\u001b[39m,\n", - " tools: \u001b[33m19\u001b[39m\n", - " },\n", - " versions_seen: { __start__: \u001b[36m[Object]\u001b[39m, agent: \u001b[36m[Object]\u001b[39m, tools: \u001b[36m[Object]\u001b[39m }\n", - " },\n", - " metadata: { source: \u001b[32m'loop'\u001b[39m, step: \u001b[33m17\u001b[39m, writes: { tools: \u001b[36m[Object]\u001b[39m } },\n", - " parentConfig: {\n", - " configurable: {\n", - " thread_id: \u001b[32m'1'\u001b[39m,\n", - " checkpoint_id: \u001b[32m'1ef3fb99-f1af-6b60-8010-b3c0f6939ab2'\u001b[39m\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" } - ], - "source": [ - "// list last 2 checkpoints\n", - "const limit = 2;\n", - "for await (\n", - " const chunk of await checkpointer.list(\n", - " { configurable: { thread_id: 1 } },\n", - " limit,\n", - " )\n", - ") {\n", - " console.log(chunk);\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 -} + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file diff --git a/examples/how-tos/persistence.ipynb b/examples/how-tos/persistence.ipynb index 13602fda..7a5a54bc 100644 --- a/examples/how-tos/persistence.ipynb +++ b/examples/how-tos/persistence.ipynb @@ -1,580 +1,580 @@ { - "cells": [ - { - "cell_type": "markdown", - "id": "aad4e28d", - "metadata": {}, - "source": [ - "# How to add persistence (\"memory\") to your graph\n", - "\n", - "Many AI applications need memory to share context across multiple interactions.\n", - "In LangGraph, memory is provided for any\n", - "[StateGraph](https://langchain-ai.github.io/langgraphjs/reference/classes/langgraph.StateGraph.html)\n", - "through\n", - "[Checkpointers](https://langchain-ai.github.io/langgraphjs/reference/modules/checkpoint.html).\n", - "\n", - "When creating any LangGraph workflow, you can set them up to persist their state\n", - "by doing using the following:\n", - "\n", - "1. A\n", - " [Checkpointer](https://langchain-ai.github.io/langgraphjs/reference/classes/checkpoint.BaseCheckpointSaver.html),\n", - " such as the\n", - " [MemorySaver](https://langchain-ai.github.io/langgraphjs/reference/classes/checkpoint.MemorySaver.html)\n", - "2. Call `compile(checkpointer=myCheckpointer)` when compiling the graph.\n", - "\n", - "Example:\n", - "\n", - "```javascript\n", - "import { MemorySaver, Annotation } from \"@langchain/langgraph\";\n", - "\n", - "const GraphState = Annotation.Root({ ... });\n", - "\n", - "const workflow = new StateGraph(GraphState);\n", - "\n", - "/// ... Add nodes and edges\n", - "// Initialize any compatible CheckPointSaver\n", - "const memory = new MemorySaver();\n", - "const persistentGraph = workflow.compile({ checkpointer: memory });\n", - "```\n", - "\n", - "This works for\n", - "[StateGraph](https://langchain-ai.github.io/langgraphjs/reference/classes/langgraph.StateGraph.html)\n", - "and all its subclasses, such as\n", - "[MessageGraph](https://langchain-ai.github.io/langgraphjs/reference/classes/langgraph.MessageGraph.html).\n", - "\n", - "Below is an example.\n", - "\n", - "
\n", - "

Note

\n", - "

\n", - " In this how-to, we will create our agent from scratch to be transparent (but verbose). You can accomplish similar functionality using the createReactAgent(model, tools=tool, checkpointer=checkpointer) (API doc) constructor. This may be more appropriate if you are used to LangChain's AgentExecutor class.\n", - "

\n", - "
\n", - "\n", - "## Setup\n", - "\n", - "This guide will use OpenAI's GPT-4o model. We will optionally set our API key\n", - "for [LangSmith tracing](https://smith.langchain.com/), which will give us\n", - "best-in-class observability." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "10021b8c", - "metadata": { - "lines_to_next_cell": 2 - }, - "outputs": [ + "cells": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "Persistence: 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 = \"Persistence: LangGraphJS\";" - ] - }, - { - "cell_type": "markdown", - "id": "5b9e252c", - "metadata": {}, - "source": [ - "## Define the state\n", - "\n", - "The state is the interface for all of the nodes in our graph.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "9fc47087", - "metadata": { - "lines_to_next_cell": 2 - }, - "outputs": [], - "source": [ - "import { Annotation } from \"@langchain/langgraph\";\n", - "import { BaseMessage } from \"@langchain/core/messages\";\n", - "\n", - "const GraphState = Annotation.Root({\n", - " messages: Annotation({\n", - " reducer: (x, y) => x.concat(y),\n", - " }),\n", - "});" - ] - }, - { - "cell_type": "markdown", - "id": "8bdba79f", - "metadata": {}, - "source": [ - "## Set up the tools\n", - "\n", - "We will first define the tools we want to use. For this simple example, we will\n", - "use create a placeholder search engine. However, it is really easy to create\n", - "your own tools - see documentation\n", - "[here](https://js.langchain.com/v0.2/docs/how_to/custom_tools) on how to do\n", - "that." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "5f1e5deb", - "metadata": { - "lines_to_next_cell": 2 - }, - "outputs": [], - "source": [ - "import { DynamicStructuredTool } from \"@langchain/core/tools\";\n", - "import { z } from \"zod\";\n", - "\n", - "const searchTool = new DynamicStructuredTool({\n", - " name: \"search\",\n", - " description:\n", - " \"Use to surf the web, fetch current information, check the weather, and retrieve other information.\",\n", - " schema: z.object({\n", - " query: z.string().describe(\"The query to use in your search.\"),\n", - " }),\n", - " func: async ({}: { query: string }) => {\n", - " // This is a placeholder for the actual implementation\n", - " return \"Cold, with a low of 13 ℃\";\n", - " },\n", - "});\n", - "\n", - "await searchTool.invoke({ query: \"What's the weather like?\" });\n", - "\n", - "const tools = [searchTool];" - ] - }, - { - "cell_type": "markdown", - "id": "a5615fd8", - "metadata": {}, - "source": [ - "We can now wrap these tools in a simple\n", - "[ToolNode](https://langchain-ai.github.io/langgraphjs/reference/classes/prebuilt.ToolNode.html).\n", - "This object will actually run the tools (functions) whenever they are invoked by\n", - "our LLM." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "1852d2a4", - "metadata": { - "lines_to_next_cell": 2 - }, - "outputs": [], - "source": [ - "import { ToolNode } from \"@langchain/langgraph/prebuilt\";\n", - "\n", - "const toolNode = new ToolNode(tools);" - ] - }, - { - "cell_type": "markdown", - "id": "a593cc20", - "metadata": {}, - "source": [ - "## Set up the model\n", - "\n", - "Now we will load the\n", - "[chat model](https://js.langchain.com/v0.2/docs/concepts/#chat-models).\n", - "\n", - "1. It should work with messages. We will represent all agent state in the form\n", - " of messages, so it needs to be able to work well with them.\n", - "2. It should work with\n", - " [tool calling](https://js.langchain.com/v0.2/docs/how_to/tool_calling/#passing-tools-to-llms),\n", - " meaning it can return function arguments in its response.\n", - "\n", - "
\n", - "

Note

\n", - "

\n", - " These model requirements are not general requirements for using LangGraph - they are just requirements for this one example.\n", - "

\n", - "
" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "77c9701b", - "metadata": { - "lines_to_next_cell": 2 - }, - "outputs": [], - "source": [ - "import { ChatOpenAI } from \"@langchain/openai\";\n", - "\n", - "const model = new ChatOpenAI({ model: \"gpt-4o\" });" - ] - }, - { - "cell_type": "markdown", - "id": "4177b143", - "metadata": {}, - "source": [ - "After we've done this, we should make sure the model knows that it has these\n", - "tools available to call. We can do this by calling\n", - "[bindTools](https://v01.api.js.langchain.com/classes/langchain_core_language_models_chat_models.BaseChatModel.html#bindTools)." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "b35d9bd2", - "metadata": { - "lines_to_next_cell": 2 - }, - "outputs": [], - "source": [ - "const boundModel = model.bindTools(tools);" - ] - }, - { - "cell_type": "markdown", - "id": "bbb0ae12", - "metadata": {}, - "source": [ - "## Define the graph\n", - "\n", - "We can now put it all together. We will run it first without a checkpointer:\n" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "5f85457b", - "metadata": {}, - "outputs": [], - "source": [ - "import { END, START, StateGraph } from \"@langchain/langgraph\";\n", - "import { AIMessage } from \"@langchain/core/messages\";\n", - "import { RunnableConfig } from \"@langchain/core/runnables\";\n", - "\n", - "const routeMessage = (state: typeof GraphState.State) => {\n", - " const { messages } = state;\n", - " const lastMessage = messages[messages.length - 1] as AIMessage;\n", - " // If no tools are called, we can finish (respond to the user)\n", - " if (!lastMessage.tool_calls?.length) {\n", - " return END;\n", - " }\n", - " // Otherwise if there is, we continue and call the tools\n", - " return \"tools\";\n", - "};\n", - "\n", - "const callModel = async (\n", - " state: typeof GraphState.State,\n", - " config?: RunnableConfig,\n", - ") => {\n", - " const { messages } = state;\n", - " const response = await boundModel.invoke(messages, config);\n", - " return { messages: [response] };\n", - "};\n", - "\n", - "const workflow = new StateGraph(GraphState)\n", - " .addNode(\"agent\", callModel)\n", - " .addNode(\"tools\", toolNode)\n", - " .addEdge(START, \"agent\")\n", - " .addConditionalEdges(\"agent\", routeMessage)\n", - " .addEdge(\"tools\", \"agent\");\n", - "\n", - "const graph = workflow.compile();" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "41364864", - "metadata": {}, - "outputs": [ + "cell_type": "markdown", + "id": "aad4e28d", + "metadata": {}, + "source": [ + "# How to add persistence (\"memory\") to your graph\n", + "\n", + "Many AI applications need memory to share context across multiple interactions.\n", + "In LangGraph, memory is provided for any\n", + "[StateGraph](/langgraphjs/reference/classes/langgraph.StateGraph.html)\n", + "through\n", + "[Checkpointers](/langgraphjs/reference/modules/checkpoint.html).\n", + "\n", + "When creating any LangGraph workflow, you can set them up to persist their state\n", + "by doing using the following:\n", + "\n", + "1. A\n", + " [Checkpointer](/langgraphjs/reference/classes/checkpoint.BaseCheckpointSaver.html),\n", + " such as the\n", + " [MemorySaver](/langgraphjs/reference/classes/checkpoint.MemorySaver.html)\n", + "2. Call `compile(checkpointer=myCheckpointer)` when compiling the graph.\n", + "\n", + "Example:\n", + "\n", + "```javascript\n", + "import { MemorySaver, Annotation } from \"@langchain/langgraph\";\n", + "\n", + "const GraphState = Annotation.Root({ ... });\n", + "\n", + "const workflow = new StateGraph(GraphState);\n", + "\n", + "/// ... Add nodes and edges\n", + "// Initialize any compatible CheckPointSaver\n", + "const memory = new MemorySaver();\n", + "const persistentGraph = workflow.compile({ checkpointer: memory });\n", + "```\n", + "\n", + "This works for\n", + "[StateGraph](/langgraphjs/reference/classes/langgraph.StateGraph.html)\n", + "and all its subclasses, such as\n", + "[MessageGraph](/langgraphjs/reference/classes/langgraph.MessageGraph.html).\n", + "\n", + "Below is an example.\n", + "\n", + "
\n", + "

Note

\n", + "

\n", + " In this how-to, we will create our agent from scratch to be transparent (but verbose). You can accomplish similar functionality using the createReactAgent(model, tools=tool, checkpointer=checkpointer) (API doc) constructor. This may be more appropriate if you are used to LangChain's AgentExecutor class.\n", + "

\n", + "
\n", + "\n", + "## Setup\n", + "\n", + "This guide will use OpenAI's GPT-4o model. We will optionally set our API key\n", + "for [LangSmith tracing](https://smith.langchain.com/), which will give us\n", + "best-in-class observability." + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "[ 'user', \"Hi I'm Yu, niced to meet you.\" ]\n", - "-----\n", - "\n", - "Hi Yu, nice to meet you too! How can I assist you today?\n", - "-----\n", - "\n" - ] - } - ], - "source": [ - "let inputs = { messages: [[\"user\", \"Hi I'm Yu, niced to meet you.\"]] };\n", - "for await (\n", - " const { messages } of await graph.stream(inputs, {\n", - " streamMode: \"values\",\n", - " })\n", - ") {\n", - " let msg = messages[messages?.length - 1];\n", - " if (msg?.content) {\n", - " console.log(msg.content);\n", - " } else if (msg?.tool_calls?.length > 0) {\n", - " console.log(msg.tool_calls);\n", - " } else {\n", - " console.log(msg);\n", - " }\n", - " console.log(\"-----\\n\");\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "ccddfd4a", - "metadata": {}, - "outputs": [ + "cell_type": "code", + "execution_count": 1, + "id": "10021b8c", + "metadata": { + "lines_to_next_cell": 2 + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Persistence: 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 = \"Persistence: LangGraphJS\";" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "[ 'user', 'Remember my name?' ]\n", - "-----\n", - "\n", - "I don't have memory of previous interactions, so I don't remember your name. Can you please tell me again?\n", - "-----\n", - "\n" - ] - } - ], - "source": [ - "inputs = { messages: [[\"user\", \"Remember my name?\"]] };\n", - "for await (\n", - " const { messages } of await graph.stream(inputs, {\n", - " streamMode: \"values\",\n", - " })\n", - ") {\n", - " let msg = messages[messages?.length - 1];\n", - " if (msg?.content) {\n", - " console.log(msg.content);\n", - " } else if (msg?.tool_calls?.length > 0) {\n", - " console.log(msg.tool_calls);\n", - " } else {\n", - " console.log(msg);\n", - " }\n", - " console.log(\"-----\\n\");\n", - "}" - ] - }, - { - "cell_type": "markdown", - "id": "3bece060", - "metadata": {}, - "source": [ - "## Add Memory\n", - "\n", - "Let's try it again with a checkpointer. We will use the\n", - "[MemorySaver](https://langchain-ai.github.io/langgraphjs/reference/classes/index.MemorySaver.html),\n", - "which will \"save\" checkpoints in-memory." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "217ac741", - "metadata": { - "lines_to_next_cell": 2 - }, - "outputs": [], - "source": [ - "import { MemorySaver } from \"@langchain/langgraph\";\n", - "\n", - "// Here we only save in-memory\n", - "const memory = new MemorySaver();\n", - "const persistentGraph = workflow.compile({ checkpointer: memory });" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "173c17f9", - "metadata": {}, - "outputs": [ + "cell_type": "markdown", + "id": "5b9e252c", + "metadata": {}, + "source": [ + "## Define the state\n", + "\n", + "The state is the interface for all of the nodes in our graph.\n" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "[ 'user', \"Hi I'm Jo, niced to meet you.\" ]\n", - "-----\n", - "\n", - "Hi Jo, nice to meet you too! How can I assist you today?\n", - "-----\n", - "\n" - ] - } - ], - "source": [ - "let config = { configurable: { thread_id: \"conversation-num-1\" } };\n", - "inputs = { messages: [[\"user\", \"Hi I'm Jo, niced to meet you.\"]] };\n", - "for await (\n", - " const { messages } of await persistentGraph.stream(inputs, {\n", - " ...config,\n", - " streamMode: \"values\",\n", - " })\n", - ") {\n", - " let msg = messages[messages?.length - 1];\n", - " if (msg?.content) {\n", - " console.log(msg.content);\n", - " } else if (msg?.tool_calls?.length > 0) {\n", - " console.log(msg.tool_calls);\n", - " } else {\n", - " console.log(msg);\n", - " }\n", - " console.log(\"-----\\n\");\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "1162eb84", - "metadata": {}, - "outputs": [ + "cell_type": "code", + "execution_count": 2, + "id": "9fc47087", + "metadata": { + "lines_to_next_cell": 2 + }, + "outputs": [], + "source": [ + "import { Annotation } from \"@langchain/langgraph\";\n", + "import { BaseMessage } from \"@langchain/core/messages\";\n", + "\n", + "const GraphState = Annotation.Root({\n", + " messages: Annotation({\n", + " reducer: (x, y) => x.concat(y),\n", + " }),\n", + "});" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "[ 'user', 'Remember my name?' ]\n", - "-----\n", - "\n", - "Of course, Jo! How can I help you today?\n", - "-----\n", - "\n" - ] - } - ], - "source": [ - "inputs = { messages: [[\"user\", \"Remember my name?\"]] };\n", - "for await (\n", - " const { messages } of await persistentGraph.stream(inputs, {\n", - " ...config,\n", - " streamMode: \"values\",\n", - " })\n", - ") {\n", - " let msg = messages[messages?.length - 1];\n", - " if (msg?.content) {\n", - " console.log(msg.content);\n", - " } else if (msg?.tool_calls?.length > 0) {\n", - " console.log(msg.tool_calls);\n", - " } else {\n", - " console.log(msg);\n", - " }\n", - " console.log(\"-----\\n\");\n", - "}" - ] - }, - { - "cell_type": "markdown", - "id": "73902faf", - "metadata": {}, - "source": [ - "## New Conversational Thread\n", - "\n", - "If we want to start a new conversation, we can pass in a different\n", - "**`thread_id`**. Poof! All the memories are gone (just kidding, they'll always\n", - "live in that other thread)!\n" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "58cc0612", - "metadata": { - "lines_to_next_cell": 2 - }, - "outputs": [ + "cell_type": "markdown", + "id": "8bdba79f", + "metadata": {}, + "source": [ + "## Set up the tools\n", + "\n", + "We will first define the tools we want to use. For this simple example, we will\n", + "use create a placeholder search engine. However, it is really easy to create\n", + "your own tools - see documentation\n", + "[here](https://js.langchain.com/v0.2/docs/how_to/custom_tools) on how to do\n", + "that." + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "{ configurable: { thread_id: 'conversation-2' } }\n" - ] - } - ], - "source": [ - "config = { configurable: { thread_id: \"conversation-2\" } };" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "25aea87b", - "metadata": {}, - "outputs": [ + "cell_type": "code", + "execution_count": 3, + "id": "5f1e5deb", + "metadata": { + "lines_to_next_cell": 2 + }, + "outputs": [], + "source": [ + "import { DynamicStructuredTool } from \"@langchain/core/tools\";\n", + "import { z } from \"zod\";\n", + "\n", + "const searchTool = new DynamicStructuredTool({\n", + " name: \"search\",\n", + " description:\n", + " \"Use to surf the web, fetch current information, check the weather, and retrieve other information.\",\n", + " schema: z.object({\n", + " query: z.string().describe(\"The query to use in your search.\"),\n", + " }),\n", + " func: async ({}: { query: string }) => {\n", + " // This is a placeholder for the actual implementation\n", + " return \"Cold, with a low of 13 ℃\";\n", + " },\n", + "});\n", + "\n", + "await searchTool.invoke({ query: \"What's the weather like?\" });\n", + "\n", + "const tools = [searchTool];" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "[ 'user', 'you forgot?' ]\n", - "-----\n", - "\n" - ] + "cell_type": "markdown", + "id": "a5615fd8", + "metadata": {}, + "source": [ + "We can now wrap these tools in a simple\n", + "[ToolNode](/langgraphjs/reference/classes/prebuilt.ToolNode.html).\n", + "This object will actually run the tools (functions) whenever they are invoked by\n", + "our LLM." + ] }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "I'm sorry, it seems like I missed something. Could you remind me what you're referring to?\n", - "-----\n", - "\n" - ] + "cell_type": "code", + "execution_count": 4, + "id": "1852d2a4", + "metadata": { + "lines_to_next_cell": 2 + }, + "outputs": [], + "source": [ + "import { ToolNode } from \"@langchain/langgraph/prebuilt\";\n", + "\n", + "const toolNode = new ToolNode(tools);" + ] + }, + { + "cell_type": "markdown", + "id": "a593cc20", + "metadata": {}, + "source": [ + "## Set up the model\n", + "\n", + "Now we will load the\n", + "[chat model](https://js.langchain.com/v0.2/docs/concepts/#chat-models).\n", + "\n", + "1. It should work with messages. We will represent all agent state in the form\n", + " of messages, so it needs to be able to work well with them.\n", + "2. It should work with\n", + " [tool calling](https://js.langchain.com/v0.2/docs/how_to/tool_calling/#passing-tools-to-llms),\n", + " meaning it can return function arguments in its response.\n", + "\n", + "
\n", + "

Note

\n", + "

\n", + " These model requirements are not general requirements for using LangGraph - they are just requirements for this one example.\n", + "

\n", + "
" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "77c9701b", + "metadata": { + "lines_to_next_cell": 2 + }, + "outputs": [], + "source": [ + "import { ChatOpenAI } from \"@langchain/openai\";\n", + "\n", + "const model = new ChatOpenAI({ model: \"gpt-4o\" });" + ] + }, + { + "cell_type": "markdown", + "id": "4177b143", + "metadata": {}, + "source": [ + "After we've done this, we should make sure the model knows that it has these\n", + "tools available to call. We can do this by calling\n", + "[bindTools](https://v01.api.js.langchain.com/classes/langchain_core_language_models_chat_models.BaseChatModel.html#bindTools)." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "b35d9bd2", + "metadata": { + "lines_to_next_cell": 2 + }, + "outputs": [], + "source": [ + "const boundModel = model.bindTools(tools);" + ] + }, + { + "cell_type": "markdown", + "id": "bbb0ae12", + "metadata": {}, + "source": [ + "## Define the graph\n", + "\n", + "We can now put it all together. We will run it first without a checkpointer:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "5f85457b", + "metadata": {}, + "outputs": [], + "source": [ + "import { END, START, StateGraph } from \"@langchain/langgraph\";\n", + "import { AIMessage } from \"@langchain/core/messages\";\n", + "import { RunnableConfig } from \"@langchain/core/runnables\";\n", + "\n", + "const routeMessage = (state: typeof GraphState.State) => {\n", + " const { messages } = state;\n", + " const lastMessage = messages[messages.length - 1] as AIMessage;\n", + " // If no tools are called, we can finish (respond to the user)\n", + " if (!lastMessage.tool_calls?.length) {\n", + " return END;\n", + " }\n", + " // Otherwise if there is, we continue and call the tools\n", + " return \"tools\";\n", + "};\n", + "\n", + "const callModel = async (\n", + " state: typeof GraphState.State,\n", + " config?: RunnableConfig,\n", + ") => {\n", + " const { messages } = state;\n", + " const response = await boundModel.invoke(messages, config);\n", + " return { messages: [response] };\n", + "};\n", + "\n", + "const workflow = new StateGraph(GraphState)\n", + " .addNode(\"agent\", callModel)\n", + " .addNode(\"tools\", toolNode)\n", + " .addEdge(START, \"agent\")\n", + " .addConditionalEdges(\"agent\", routeMessage)\n", + " .addEdge(\"tools\", \"agent\");\n", + "\n", + "const graph = workflow.compile();" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "41364864", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 'user', \"Hi I'm Yu, niced to meet you.\" ]\n", + "-----\n", + "\n", + "Hi Yu, nice to meet you too! How can I assist you today?\n", + "-----\n", + "\n" + ] + } + ], + "source": [ + "let inputs = { messages: [[\"user\", \"Hi I'm Yu, niced to meet you.\"]] };\n", + "for await (\n", + " const { messages } of await graph.stream(inputs, {\n", + " streamMode: \"values\",\n", + " })\n", + ") {\n", + " let msg = messages[messages?.length - 1];\n", + " if (msg?.content) {\n", + " console.log(msg.content);\n", + " } else if (msg?.tool_calls?.length > 0) {\n", + " console.log(msg.tool_calls);\n", + " } else {\n", + " console.log(msg);\n", + " }\n", + " console.log(\"-----\\n\");\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "ccddfd4a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 'user', 'Remember my name?' ]\n", + "-----\n", + "\n", + "I don't have memory of previous interactions, so I don't remember your name. Can you please tell me again?\n", + "-----\n", + "\n" + ] + } + ], + "source": [ + "inputs = { messages: [[\"user\", \"Remember my name?\"]] };\n", + "for await (\n", + " const { messages } of await graph.stream(inputs, {\n", + " streamMode: \"values\",\n", + " })\n", + ") {\n", + " let msg = messages[messages?.length - 1];\n", + " if (msg?.content) {\n", + " console.log(msg.content);\n", + " } else if (msg?.tool_calls?.length > 0) {\n", + " console.log(msg.tool_calls);\n", + " } else {\n", + " console.log(msg);\n", + " }\n", + " console.log(\"-----\\n\");\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "3bece060", + "metadata": {}, + "source": [ + "## Add Memory\n", + "\n", + "Let's try it again with a checkpointer. We will use the\n", + "[MemorySaver](/langgraphjs/reference/classes/index.MemorySaver.html),\n", + "which will \"save\" checkpoints in-memory." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "217ac741", + "metadata": { + "lines_to_next_cell": 2 + }, + "outputs": [], + "source": [ + "import { MemorySaver } from \"@langchain/langgraph\";\n", + "\n", + "// Here we only save in-memory\n", + "const memory = new MemorySaver();\n", + "const persistentGraph = workflow.compile({ checkpointer: memory });" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "173c17f9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 'user', \"Hi I'm Jo, niced to meet you.\" ]\n", + "-----\n", + "\n", + "Hi Jo, nice to meet you too! How can I assist you today?\n", + "-----\n", + "\n" + ] + } + ], + "source": [ + "let config = { configurable: { thread_id: \"conversation-num-1\" } };\n", + "inputs = { messages: [[\"user\", \"Hi I'm Jo, niced to meet you.\"]] };\n", + "for await (\n", + " const { messages } of await persistentGraph.stream(inputs, {\n", + " ...config,\n", + " streamMode: \"values\",\n", + " })\n", + ") {\n", + " let msg = messages[messages?.length - 1];\n", + " if (msg?.content) {\n", + " console.log(msg.content);\n", + " } else if (msg?.tool_calls?.length > 0) {\n", + " console.log(msg.tool_calls);\n", + " } else {\n", + " console.log(msg);\n", + " }\n", + " console.log(\"-----\\n\");\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "1162eb84", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 'user', 'Remember my name?' ]\n", + "-----\n", + "\n", + "Of course, Jo! How can I help you today?\n", + "-----\n", + "\n" + ] + } + ], + "source": [ + "inputs = { messages: [[\"user\", \"Remember my name?\"]] };\n", + "for await (\n", + " const { messages } of await persistentGraph.stream(inputs, {\n", + " ...config,\n", + " streamMode: \"values\",\n", + " })\n", + ") {\n", + " let msg = messages[messages?.length - 1];\n", + " if (msg?.content) {\n", + " console.log(msg.content);\n", + " } else if (msg?.tool_calls?.length > 0) {\n", + " console.log(msg.tool_calls);\n", + " } else {\n", + " console.log(msg);\n", + " }\n", + " console.log(\"-----\\n\");\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "73902faf", + "metadata": {}, + "source": [ + "## New Conversational Thread\n", + "\n", + "If we want to start a new conversation, we can pass in a different\n", + "**`thread_id`**. Poof! All the memories are gone (just kidding, they'll always\n", + "live in that other thread)!\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "58cc0612", + "metadata": { + "lines_to_next_cell": 2 + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{ configurable: { thread_id: 'conversation-2' } }\n" + ] + } + ], + "source": [ + "config = { configurable: { thread_id: \"conversation-2\" } };" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "25aea87b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 'user', 'you forgot?' ]\n", + "-----\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "I'm sorry, it seems like I missed something. Could you remind me what you're referring to?\n", + "-----\n", + "\n" + ] + } + ], + "source": [ + "inputs = { messages: [[\"user\", \"you forgot?\"]] };\n", + "for await (\n", + " const { messages } of await persistentGraph.stream(inputs, {\n", + " ...config,\n", + " streamMode: \"values\",\n", + " })\n", + ") {\n", + " let msg = messages[messages?.length - 1];\n", + " if (msg?.content) {\n", + " console.log(msg.content);\n", + " } else if (msg?.tool_calls?.length > 0) {\n", + " console.log(msg.tool_calls);\n", + " } else {\n", + " console.log(msg);\n", + " }\n", + " console.log(\"-----\\n\");\n", + "}" + ] + } + ], + "metadata": { + "jupytext": { + "encoding": "# -*- coding: utf-8 -*-" + }, + "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" } - ], - "source": [ - "inputs = { messages: [[\"user\", \"you forgot?\"]] };\n", - "for await (\n", - " const { messages } of await persistentGraph.stream(inputs, {\n", - " ...config,\n", - " streamMode: \"values\",\n", - " })\n", - ") {\n", - " let msg = messages[messages?.length - 1];\n", - " if (msg?.content) {\n", - " console.log(msg.content);\n", - " } else if (msg?.tool_calls?.length > 0) {\n", - " console.log(msg.tool_calls);\n", - " } else {\n", - " console.log(msg);\n", - " }\n", - " console.log(\"-----\\n\");\n", - "}" - ] - } - ], - "metadata": { - "jupytext": { - "encoding": "# -*- coding: utf-8 -*-" - }, - "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 -} + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file diff --git a/examples/how-tos/respond-in-format.ipynb b/examples/how-tos/respond-in-format.ipynb index aa0851fd..30765e5d 100644 --- a/examples/how-tos/respond-in-format.ipynb +++ b/examples/how-tos/respond-in-format.ipynb @@ -158,7 +158,7 @@ "metadata": {}, "source": [ "We can now wrap these tools in a\n", - "[ToolNode](https://langchain-ai.github.io/langgraphjs/reference/classes/langgraph_prebuilt.ToolNode.html).\n" + "[ToolNode](/langgraphjs/reference/classes/langgraph_prebuilt.ToolNode.html).\n" ] }, { diff --git a/examples/how-tos/stream-tokens.ipynb b/examples/how-tos/stream-tokens.ipynb index ff9391cd..5de975de 100644 --- a/examples/how-tos/stream-tokens.ipynb +++ b/examples/how-tos/stream-tokens.ipynb @@ -26,9 +26,9 @@ "incorporate the functionality into a prototypical agent in LangGraph.\n", "\n", "This works for\n", - "[StateGraph](https://langchain-ai.github.io/langgraphjs/reference/classes/langgraph.StateGraph.html)\n", + "[StateGraph](/langgraphjs/reference/classes/langgraph.StateGraph.html)\n", "and all its subclasses, such as\n", - "[MessageGraph](https://langchain-ai.github.io/langgraphjs/reference/classes/langgraph.MessageGraph.html).\n", + "[MessageGraph](/langgraphjs/reference/classes/langgraph.MessageGraph.html).\n", "\n", "
\n", "

Streaming Support

\n", @@ -40,7 +40,7 @@ "
\n", "

Note

\n", "

\n", - " In this how-to, we will create our agent from scratch to be transparent (but verbose). You can accomplish similar functionality using the createReactAgent({ llm, tools }) (API doc) constructor. This may be more appropriate if you are used to LangChain's AgentExecutor class.\n", + " In this how-to, we will create our agent from scratch to be transparent (but verbose). You can accomplish similar functionality using the createReactAgent({ llm, tools }) (API doc) constructor. This may be more appropriate if you are used to LangChain's AgentExecutor class.\n", "

\n", "
\n", "\n", @@ -145,7 +145,7 @@ "metadata": {}, "source": [ "We can now wrap these tools in a prebuilt\n", - "[ToolNode](https://langchain-ai.github.io/langgraphjs/reference/classes/langgraph_prebuilt.ToolNode.html).\n", + "[ToolNode](/langgraphjs/reference/classes/langgraph_prebuilt.ToolNode.html).\n", "This object will actually run the tools (functions) whenever they are invoked by\n", "our LLM." ] @@ -610,7 +610,7 @@ "\n", "## Next steps\n", "\n", - "You've now seen some ways to stream LLM tokens from within your graph. Next, check out some of the other how-tos around streaming by going [to this page](https://langchain-ai.github.io/langgraphjs/how-tos/#streaming)." + "You've now seen some ways to stream LLM tokens from within your graph. Next, check out some of the other how-tos around streaming by going [to this page](/langgraphjs/how-tos/#streaming)." ] } ], @@ -634,4 +634,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} +} \ No newline at end of file diff --git a/examples/how-tos/stream-updates.ipynb b/examples/how-tos/stream-updates.ipynb index 71ae564d..2e704c9a 100644 --- a/examples/how-tos/stream-updates.ipynb +++ b/examples/how-tos/stream-updates.ipynb @@ -108,7 +108,7 @@ "metadata": {}, "source": [ "We can now wrap these tools in a simple\n", - "[ToolNode](https://langchain-ai.github.io/langgraphjs/reference/classes/langgraph_prebuilt.ToolNode.html).\n", + "[ToolNode](/langgraphjs/reference/classes/langgraph_prebuilt.ToolNode.html).\n", "This object will actually run the tools (functions) whenever they are invoked by\n", "our LLM.\n" ] diff --git a/examples/how-tos/stream-values.ipynb b/examples/how-tos/stream-values.ipynb index c1ec2c08..64bb68f2 100644 --- a/examples/how-tos/stream-values.ipynb +++ b/examples/how-tos/stream-values.ipynb @@ -108,7 +108,7 @@ "metadata": {}, "source": [ "We can now wrap these tools in a simple\n", - "[ToolNode](https://langchain-ai.github.io/langgraphjs/reference/classes/langgraph_prebuilt.ToolNode.html).\n", + "[ToolNode](/langgraphjs/reference/classes/langgraph_prebuilt.ToolNode.html).\n", "This object will actually run the tools (functions) whenever they are invoked by\n", "our LLM.\n" ] diff --git a/examples/how-tos/streaming-tokens-without-langchain.ipynb b/examples/how-tos/streaming-tokens-without-langchain.ipynb index 93955eb5..66d29e6e 100644 --- a/examples/how-tos/streaming-tokens-without-langchain.ipynb +++ b/examples/how-tos/streaming-tokens-without-langchain.ipynb @@ -1,358 +1,358 @@ { - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# How to stream LLM tokens (without LangChain models)\n", - "\n", - "In this guide, we will stream tokens from the language model powering an agent without using LangChain chat models. We'll be using the OpenAI client library directly in a ReAct agent as an example.\n", - "\n", - "## Setup\n", - "\n", - "To get started, install the `openai` and `langgraph` packages separately:\n", - "\n", - "```bash\n", - "$ npm install openai @langchain/langgraph\n", - "```\n", - "\n", - "
\n", - "

Compatibility

\n", - "

\n", - " This guide requires @langchain/core>=0.2.19, and if you are using LangSmith, langsmith>=0.1.39. For help upgrading, see this guide.\n", - "

\n", - "
\n", - "\n", - "You'll also need to make sure you have your OpenAI key set as `process.env.OPENAI_API_KEY`.\n", - "\n", - "## Defining a model and a tool schema\n", - "\n", - "First, initialize the OpenAI SDK and define a tool schema for the model to populate using [OpenAI's format](https://platform.openai.com/docs/api-reference/chat/create#chat-create-tools):" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import OpenAI from \"openai\";\n", - "\n", - "const openaiClient = new OpenAI({});\n", - "\n", - "const toolSchema: OpenAI.ChatCompletionTool = {\n", - " type: \"function\",\n", - " function: {\n", - " name: \"get_items\",\n", - " description: \"Use this tool to look up which items are in the given place.\",\n", - " parameters: {\n", - " type: \"object\",\n", - " properties: {\n", - " place: {\n", - " type: \"string\",\n", - " },\n", - " },\n", - " required: [\"place\"],\n", - " }\n", - " }\n", - "};" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Calling the model\n", - "\n", - "Now, define a method for a LangGraph node that will call the model. It will handle formatting tool calls to and from the model, as well as streaming via [custom callback events](https://js.langchain.com/v0.2/docs/how_to/callbacks_custom_events).\n", - "\n", - "If you are using [LangSmith](https://docs.smith.langchain.com/), you can also wrap the OpenAI client for the same nice tracing you'd get with a LangChain chat model.\n", - "\n", - "Here's what that looks like:" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "import { dispatchCustomEvent } from \"@langchain/core/callbacks/dispatch\";\n", - "import { wrapOpenAI } from \"langsmith/wrappers/openai\";\n", - "import { Annotation } from \"@langchain/langgraph\";\n", - "\n", - "const GraphState = Annotation.Root({\n", - " messages: Annotation({\n", - " reducer: (x, y) => x.concat(y),\n", - " }),\n", - "});\n", - "\n", - "// If using LangSmith, use \"wrapOpenAI\" on the whole client or\n", - "// \"traceable\" to wrap a single method for nicer tracing:\n", - "// https://docs.smith.langchain.com/how_to_guides/tracing/annotate_code\n", - "const wrappedClient = wrapOpenAI(openaiClient);\n", - "\n", - "const callModel = async (state: typeof GraphState.State): Promise> => {\n", - " const { messages } = state;\n", - " const stream = await wrappedClient.chat.completions.create({\n", - " messages,\n", - " model: \"gpt-4o-mini\",\n", - " tools: [toolSchema],\n", - " stream: true,\n", - " });\n", - " let responseContent = \"\";\n", - " let role: string = \"assistant\";\n", - " let toolCallId: string | undefined;\n", - " let toolCallName: string | undefined;\n", - " let toolCallArgs = \"\";\n", - " for await (const chunk of stream) {\n", - " const delta = chunk.choices[0].delta;\n", - " if (delta.role !== undefined) {\n", - " role = delta.role;\n", - " }\n", - " if (delta.content) {\n", - " responseContent += delta.content;\n", - " await dispatchCustomEvent(\"streamed_token\", {\n", - " content: delta.content,\n", - " });\n", - " }\n", - " if (delta.tool_calls !== undefined && delta.tool_calls.length > 0) {\n", - " // note: for simplicity we're only handling a single tool call here\n", - " const toolCall = delta.tool_calls[0];\n", - " if (toolCall.function?.name !== undefined) {\n", - " toolCallName = toolCall.function.name;\n", - " }\n", - " if (toolCall.id !== undefined) {\n", - " toolCallId = toolCall.id;\n", - " }\n", - " await dispatchCustomEvent(\"streamed_tool_call_chunk\", toolCall);\n", - " toolCallArgs += toolCall.function?.arguments ?? \"\";\n", - " }\n", - " }\n", - " let finalToolCalls;\n", - " if (toolCallName !== undefined && toolCallId !== undefined) {\n", - " finalToolCalls = [{\n", - " id: toolCallId,\n", - " function: {\n", - " name: toolCallName,\n", - " arguments: toolCallArgs\n", - " },\n", - " type: \"function\" as const,\n", - " }];\n", - " }\n", - "\n", - " const responseMessage = {\n", - " role: role as any,\n", - " content: responseContent,\n", - " tool_calls: finalToolCalls,\n", - " };\n", - " return { messages: [responseMessage] };\n", - "}" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note that you can't call this method outside of a LangGraph node since `dispatchCustomEvent` will fail if it is called outside the proper context.\n", - "\n", - "## Define tools and a tool-calling node\n", - "\n", - "Next, set up the actual tool function and the node that will call it when the model populates a tool call:" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "const getItems = async ({ place }: { place: string }) => {\n", - " if (place.toLowerCase().includes(\"bed\")) { // For under the bed\n", - " return \"socks, shoes and dust bunnies\";\n", - " } else if (place.toLowerCase().includes(\"shelf\")) { // For 'shelf'\n", - " return \"books, pencils and pictures\";\n", - " } else { // if the agent decides to ask about a different place\n", - " return \"cat snacks\";\n", - " }\n", - "};\n", - "\n", - "const callTools = async (state: typeof GraphState.State): Promise> => {\n", - " const { messages } = state;\n", - " const mostRecentMessage = messages[messages.length - 1];\n", - " const toolCalls = (mostRecentMessage as OpenAI.ChatCompletionAssistantMessageParam).tool_calls;\n", - " if (toolCalls === undefined || toolCalls.length === 0) {\n", - " throw new Error(\"No tool calls passed to node.\");\n", - " }\n", - " const toolNameMap = {\n", - " get_items: getItems,\n", - " };\n", - " const functionName = toolCalls[0].function.name;\n", - " const functionArguments = JSON.parse(toolCalls[0].function.arguments);\n", - " const response = await toolNameMap[functionName](functionArguments);\n", - " const toolMessage = {\n", - " tool_call_id: toolCalls[0].id,\n", - " role: \"tool\" as const,\n", - " name: functionName,\n", - " content: response,\n", - " }\n", - " return { messages: [toolMessage] };\n", - "}" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Build the graph\n", - "\n", - "Finally, it's time to build your graph:" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "import { StateGraph } from \"@langchain/langgraph\";\n", - "import OpenAI from \"openai\";\n", - "\n", - "// We can reuse the same `GraphState` from above as it has not changed.\n", - "const shouldContinue = (state: typeof GraphState.State) => {\n", - " const { messages } = state;\n", - " const lastMessage =\n", - " messages[messages.length - 1] as OpenAI.ChatCompletionAssistantMessageParam;\n", - " if (lastMessage?.tool_calls !== undefined && lastMessage?.tool_calls.length > 0) {\n", - " return \"tools\";\n", - " }\n", - " return \"__end__\";\n", - "}\n", - "\n", - "const graph = new StateGraph(GraphState)\n", - " .addNode(\"model\", callModel)\n", - " .addNode(\"tools\", callTools)\n", - " .addEdge(\"__start__\", \"model\")\n", - " .addConditionalEdges(\"model\", shouldContinue, {\n", - " tools: \"tools\",\n", - " __end__: \"__end__\",\n", - " })\n", - " .addEdge(\"tools\", \"model\")\n", - " .compile();\n", - " " - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ + "cells": [ { - "data": { - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import * as tslab from \"tslab\";\n", - "\n", - "const representation = graph.getGraph();\n", - "const image = await representation.drawMermaidPng();\n", - "const arrayBuffer = await image.arrayBuffer();\n", - "\n", - "await tslab.display.png(new Uint8Array(arrayBuffer));" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Streaming tokens\n", - "\n", - "And now we can use the [`.streamEvents`](https://js.langchain.com/v0.2/docs/how_to/streaming#using-stream-events) method to get the streamed tokens and tool calls from the OpenAI model:" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# How to stream LLM tokens (without LangChain models)\n", + "\n", + "In this guide, we will stream tokens from the language model powering an agent without using LangChain chat models. We'll be using the OpenAI client library directly in a ReAct agent as an example.\n", + "\n", + "## Setup\n", + "\n", + "To get started, install the `openai` and `langgraph` packages separately:\n", + "\n", + "```bash\n", + "$ npm install openai @langchain/langgraph\n", + "```\n", + "\n", + "
\n", + "

Compatibility

\n", + "

\n", + " This guide requires @langchain/core>=0.2.19, and if you are using LangSmith, langsmith>=0.1.39. For help upgrading, see this guide.\n", + "

\n", + "
\n", + "\n", + "You'll also need to make sure you have your OpenAI key set as `process.env.OPENAI_API_KEY`.\n", + "\n", + "## Defining a model and a tool schema\n", + "\n", + "First, initialize the OpenAI SDK and define a tool schema for the model to populate using [OpenAI's format](https://platform.openai.com/docs/api-reference/chat/create#chat-create-tools):" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import OpenAI from \"openai\";\n", + "\n", + "const openaiClient = new OpenAI({});\n", + "\n", + "const toolSchema: OpenAI.ChatCompletionTool = {\n", + " type: \"function\",\n", + " function: {\n", + " name: \"get_items\",\n", + " description: \"Use this tool to look up which items are in the given place.\",\n", + " parameters: {\n", + " type: \"object\",\n", + " properties: {\n", + " place: {\n", + " type: \"string\",\n", + " },\n", + " },\n", + " required: [\"place\"],\n", + " }\n", + " }\n", + "};" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "streamed_tool_call_chunk {\n", - " index: 0,\n", - " id: 'call_v99reml4gZvvUypPgOpLgxM2',\n", - " type: 'function',\n", - " function: { name: 'get_items', arguments: '' }\n", - "}\n", - "streamed_tool_call_chunk { index: 0, function: { arguments: '{\"' } }\n", - "streamed_tool_call_chunk { index: 0, function: { arguments: 'place' } }\n", - "streamed_tool_call_chunk { index: 0, function: { arguments: '\":\"' } }\n", - "streamed_tool_call_chunk { index: 0, function: { arguments: 'bed' } }\n", - "streamed_tool_call_chunk { index: 0, function: { arguments: 'room' } }\n", - "streamed_tool_call_chunk { index: 0, function: { arguments: '\"}' } }\n", - "streamed_token { content: 'In' }\n", - "streamed_token { content: ' the' }\n", - "streamed_token { content: ' bedroom' }\n", - "streamed_token { content: ',' }\n", - "streamed_token { content: ' you' }\n", - "streamed_token { content: ' can' }\n", - "streamed_token { content: ' find' }\n", - "streamed_token { content: ' socks' }\n", - "streamed_token { content: ',' }\n", - "streamed_token { content: ' shoes' }\n", - "streamed_token { content: ',' }\n", - "streamed_token { content: ' and' }\n", - "streamed_token { content: ' dust' }\n", - "streamed_token { content: ' b' }\n", - "streamed_token { content: 'unnies' }\n", - "streamed_token { content: '.' }\n" - ] + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Calling the model\n", + "\n", + "Now, define a method for a LangGraph node that will call the model. It will handle formatting tool calls to and from the model, as well as streaming via [custom callback events](https://js.langchain.com/v0.2/docs/how_to/callbacks_custom_events).\n", + "\n", + "If you are using [LangSmith](https://docs.smith.langchain.com/), you can also wrap the OpenAI client for the same nice tracing you'd get with a LangChain chat model.\n", + "\n", + "Here's what that looks like:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import { dispatchCustomEvent } from \"@langchain/core/callbacks/dispatch\";\n", + "import { wrapOpenAI } from \"langsmith/wrappers/openai\";\n", + "import { Annotation } from \"@langchain/langgraph\";\n", + "\n", + "const GraphState = Annotation.Root({\n", + " messages: Annotation({\n", + " reducer: (x, y) => x.concat(y),\n", + " }),\n", + "});\n", + "\n", + "// If using LangSmith, use \"wrapOpenAI\" on the whole client or\n", + "// \"traceable\" to wrap a single method for nicer tracing:\n", + "// https://docs.smith.langchain.com/how_to_guides/tracing/annotate_code\n", + "const wrappedClient = wrapOpenAI(openaiClient);\n", + "\n", + "const callModel = async (state: typeof GraphState.State): Promise> => {\n", + " const { messages } = state;\n", + " const stream = await wrappedClient.chat.completions.create({\n", + " messages,\n", + " model: \"gpt-4o-mini\",\n", + " tools: [toolSchema],\n", + " stream: true,\n", + " });\n", + " let responseContent = \"\";\n", + " let role: string = \"assistant\";\n", + " let toolCallId: string | undefined;\n", + " let toolCallName: string | undefined;\n", + " let toolCallArgs = \"\";\n", + " for await (const chunk of stream) {\n", + " const delta = chunk.choices[0].delta;\n", + " if (delta.role !== undefined) {\n", + " role = delta.role;\n", + " }\n", + " if (delta.content) {\n", + " responseContent += delta.content;\n", + " await dispatchCustomEvent(\"streamed_token\", {\n", + " content: delta.content,\n", + " });\n", + " }\n", + " if (delta.tool_calls !== undefined && delta.tool_calls.length > 0) {\n", + " // note: for simplicity we're only handling a single tool call here\n", + " const toolCall = delta.tool_calls[0];\n", + " if (toolCall.function?.name !== undefined) {\n", + " toolCallName = toolCall.function.name;\n", + " }\n", + " if (toolCall.id !== undefined) {\n", + " toolCallId = toolCall.id;\n", + " }\n", + " await dispatchCustomEvent(\"streamed_tool_call_chunk\", toolCall);\n", + " toolCallArgs += toolCall.function?.arguments ?? \"\";\n", + " }\n", + " }\n", + " let finalToolCalls;\n", + " if (toolCallName !== undefined && toolCallId !== undefined) {\n", + " finalToolCalls = [{\n", + " id: toolCallId,\n", + " function: {\n", + " name: toolCallName,\n", + " arguments: toolCallArgs\n", + " },\n", + " type: \"function\" as const,\n", + " }];\n", + " }\n", + "\n", + " const responseMessage = {\n", + " role: role as any,\n", + " content: responseContent,\n", + " tool_calls: finalToolCalls,\n", + " };\n", + " return { messages: [responseMessage] };\n", + "}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that you can't call this method outside of a LangGraph node since `dispatchCustomEvent` will fail if it is called outside the proper context.\n", + "\n", + "## Define tools and a tool-calling node\n", + "\n", + "Next, set up the actual tool function and the node that will call it when the model populates a tool call:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "const getItems = async ({ place }: { place: string }) => {\n", + " if (place.toLowerCase().includes(\"bed\")) { // For under the bed\n", + " return \"socks, shoes and dust bunnies\";\n", + " } else if (place.toLowerCase().includes(\"shelf\")) { // For 'shelf'\n", + " return \"books, pencils and pictures\";\n", + " } else { // if the agent decides to ask about a different place\n", + " return \"cat snacks\";\n", + " }\n", + "};\n", + "\n", + "const callTools = async (state: typeof GraphState.State): Promise> => {\n", + " const { messages } = state;\n", + " const mostRecentMessage = messages[messages.length - 1];\n", + " const toolCalls = (mostRecentMessage as OpenAI.ChatCompletionAssistantMessageParam).tool_calls;\n", + " if (toolCalls === undefined || toolCalls.length === 0) {\n", + " throw new Error(\"No tool calls passed to node.\");\n", + " }\n", + " const toolNameMap = {\n", + " get_items: getItems,\n", + " };\n", + " const functionName = toolCalls[0].function.name;\n", + " const functionArguments = JSON.parse(toolCalls[0].function.arguments);\n", + " const response = await toolNameMap[functionName](functionArguments);\n", + " const toolMessage = {\n", + " tool_call_id: toolCalls[0].id,\n", + " role: \"tool\" as const,\n", + " name: functionName,\n", + " content: response,\n", + " }\n", + " return { messages: [toolMessage] };\n", + "}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Build the graph\n", + "\n", + "Finally, it's time to build your graph:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "import { StateGraph } from \"@langchain/langgraph\";\n", + "import OpenAI from \"openai\";\n", + "\n", + "// We can reuse the same `GraphState` from above as it has not changed.\n", + "const shouldContinue = (state: typeof GraphState.State) => {\n", + " const { messages } = state;\n", + " const lastMessage =\n", + " messages[messages.length - 1] as OpenAI.ChatCompletionAssistantMessageParam;\n", + " if (lastMessage?.tool_calls !== undefined && lastMessage?.tool_calls.length > 0) {\n", + " return \"tools\";\n", + " }\n", + " return \"__end__\";\n", + "}\n", + "\n", + "const graph = new StateGraph(GraphState)\n", + " .addNode(\"model\", callModel)\n", + " .addNode(\"tools\", callTools)\n", + " .addEdge(\"__start__\", \"model\")\n", + " .addConditionalEdges(\"model\", shouldContinue, {\n", + " tools: \"tools\",\n", + " __end__: \"__end__\",\n", + " })\n", + " .addEdge(\"tools\", \"model\")\n", + " .compile();\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import * as tslab from \"tslab\";\n", + "\n", + "const representation = graph.getGraph();\n", + "const image = await representation.drawMermaidPng();\n", + "const arrayBuffer = await image.arrayBuffer();\n", + "\n", + "await tslab.display.png(new Uint8Array(arrayBuffer));" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Streaming tokens\n", + "\n", + "And now we can use the [`.streamEvents`](https://js.langchain.com/v0.2/docs/how_to/streaming#using-stream-events) method to get the streamed tokens and tool calls from the OpenAI model:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "streamed_tool_call_chunk {\n", + " index: 0,\n", + " id: 'call_v99reml4gZvvUypPgOpLgxM2',\n", + " type: 'function',\n", + " function: { name: 'get_items', arguments: '' }\n", + "}\n", + "streamed_tool_call_chunk { index: 0, function: { arguments: '{\"' } }\n", + "streamed_tool_call_chunk { index: 0, function: { arguments: 'place' } }\n", + "streamed_tool_call_chunk { index: 0, function: { arguments: '\":\"' } }\n", + "streamed_tool_call_chunk { index: 0, function: { arguments: 'bed' } }\n", + "streamed_tool_call_chunk { index: 0, function: { arguments: 'room' } }\n", + "streamed_tool_call_chunk { index: 0, function: { arguments: '\"}' } }\n", + "streamed_token { content: 'In' }\n", + "streamed_token { content: ' the' }\n", + "streamed_token { content: ' bedroom' }\n", + "streamed_token { content: ',' }\n", + "streamed_token { content: ' you' }\n", + "streamed_token { content: ' can' }\n", + "streamed_token { content: ' find' }\n", + "streamed_token { content: ' socks' }\n", + "streamed_token { content: ',' }\n", + "streamed_token { content: ' shoes' }\n", + "streamed_token { content: ',' }\n", + "streamed_token { content: ' and' }\n", + "streamed_token { content: ' dust' }\n", + "streamed_token { content: ' b' }\n", + "streamed_token { content: 'unnies' }\n", + "streamed_token { content: '.' }\n" + ] + } + ], + "source": [ + "const eventStream = await graph.streamEvents(\n", + " { messages: [{ role: \"user\", content: \"what's in the bedroom?\" }] },\n", + " { version: \"v2\" },\n", + ");\n", + "\n", + "for await (const { event, name, data } of eventStream) {\n", + " if (event === \"on_custom_event\") {\n", + " console.log(name, data);\n", + " }\n", + "}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And if you've set up LangSmith tracing, you'll also see [a trace like this one](https://smith.langchain.com/public/ddb1af36-ebe5-4ba6-9a57-87a296dc801f/r)." + ] + } + ], + "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" } - ], - "source": [ - "const eventStream = await graph.streamEvents(\n", - " { messages: [{ role: \"user\", content: \"what's in the bedroom?\" }] },\n", - " { version: \"v2\" },\n", - ");\n", - "\n", - "for await (const { event, name, data } of eventStream) {\n", - " if (event === \"on_custom_event\") {\n", - " console.log(name, data);\n", - " }\n", - "}" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "And if you've set up LangSmith tracing, you'll also see [a trace like this one](https://smith.langchain.com/public/ddb1af36-ebe5-4ba6-9a57-87a296dc801f/r)." - ] - } - ], - "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": 2 -} + "nbformat": 4, + "nbformat_minor": 2 +} \ No newline at end of file diff --git a/examples/how-tos/subgraph.ipynb b/examples/how-tos/subgraph.ipynb index dd2aeea3..9f78317e 100644 --- a/examples/how-tos/subgraph.ipynb +++ b/examples/how-tos/subgraph.ipynb @@ -8,13 +8,13 @@ "# How to create subgraphs\n", "\n", "Graphs such as\n", - "[StateGraph](https://langchain-ai.github.io/langgraphjs/reference/classes/langgraph.StateGraph.html)'s\n", + "[StateGraph](/langgraphjs/reference/classes/langgraph.StateGraph.html)'s\n", "naturally can be composed. Creating subgraphs lets you build things like\n", "[multi-agent teams](./multi_agent/hierarchical_agent_teams.ipynb), where each\n", "team can track its own separate state.\n", "\n", "You can add a `StateGraph` instance as a node by first\n", - "[compiling](https://langchain-ai.github.io/langgraphjs/reference/classes/langgraph.StateGraph.html#compile)\n", + "[compiling](/langgraphjs/reference/classes/langgraph.StateGraph.html#compile)\n", "it to translate it to its lower-level Pregel operations.\n", "\n", "The main thing you should note is ensuring the \"handoff\" from the calling graph\n", diff --git a/examples/how-tos/time-travel.ipynb b/examples/how-tos/time-travel.ipynb index 6de9a7d4..b2853e01 100644 --- a/examples/how-tos/time-travel.ipynb +++ b/examples/how-tos/time-travel.ipynb @@ -19,9 +19,9 @@ "\n", "The key methods used for this functionality are:\n", "\n", - "- [getState](https://langchain-ai.github.io/langgraphjs/reference/classes/langgraph_pregel.Pregel.html#getState):\n", + "- [getState](/langgraphjs/reference/classes/langgraph_pregel.Pregel.html#getState):\n", " fetch the values from the target config\n", - "- [updateState](https://langchain-ai.github.io/langgraphjs/reference/classes/langgraph_pregel.Pregel.html#updateState):\n", + "- [updateState](/langgraphjs/reference/classes/langgraph_pregel.Pregel.html#updateState):\n", " apply the given values to the target state\n", "\n", "**Note:** this requires passing in a checkpointer.\n", @@ -33,16 +33,16 @@ "``` -->\n", "\n", "This works for\n", - "[StateGraph](https://langchain-ai.github.io/langgraphjs/reference/classes/langgraph.StateGraph.html)\n", + "[StateGraph](/langgraphjs/reference/classes/langgraph.StateGraph.html)\n", "and all its subclasses, such as\n", - "[MessageGraph](https://langchain-ai.github.io/langgraphjs/reference/classes/langgraph.MessageGraph.html).\n", + "[MessageGraph](/langgraphjs/reference/classes/langgraph.MessageGraph.html).\n", "\n", "Below is an example.\n", "\n", "
\n", "

Note

\n", "

\n", - " In this how-to, we will create our agent from scratch to be transparent (but verbose). You can accomplish similar functionality using the createReactAgent(model, tools=tool, checkpointer=checkpointer) (API doc) constructor. This may be more appropriate if you are used to LangChain's AgentExecutor class.\n", + " In this how-to, we will create our agent from scratch to be transparent (but verbose). You can accomplish similar functionality using the createReactAgent(model, tools=tool, checkpointer=checkpointer) (API doc) constructor. This may be more appropriate if you are used to LangChain's AgentExecutor class.\n", "

\n", "
\n", "\n", @@ -158,7 +158,7 @@ "metadata": {}, "source": [ "We can now wrap these tools in a simple\n", - "[ToolNode](https://langchain-ai.github.io/langgraphjs/reference/classes/prebuilt.ToolNode.html).\n", + "[ToolNode](/langgraphjs/reference/classes/prebuilt.ToolNode.html).\n", "This object will actually run the tools (functions) whenever they are invoked by\n", "our LLM.\n" ] @@ -247,7 +247,7 @@ "We can now put it all together. Time travel requires a checkpointer to save the\n", "state - otherwise you wouldn't have anything go `get` or `update`. We will use\n", "the\n", - "[MemorySaver](https://langchain-ai.github.io/langgraphjs/reference/classes/index.MemorySaver.html),\n", + "[MemorySaver](/langgraphjs/reference/classes/index.MemorySaver.html),\n", "which \"saves\" checkpoints in-memory." ] }, @@ -583,7 +583,7 @@ "## Get State\n", "\n", "You can fetch the latest graph checkpoint using\n", - "[`getState(config)`](https://langchain-ai.github.io/langgraphjs/reference/classes/pregel.Pregel.html#getState)." + "[`getState(config)`](/langgraphjs/reference/classes/pregel.Pregel.html#getState)." ] }, { @@ -1124,4 +1124,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} +} \ No newline at end of file diff --git a/examples/how-tos/tool-calling-errors.ipynb b/examples/how-tos/tool-calling-errors.ipynb index abf9eefd..110f9535 100644 --- a/examples/how-tos/tool-calling-errors.ipynb +++ b/examples/how-tos/tool-calling-errors.ipynb @@ -13,7 +13,7 @@ "
\n", "

Compatibility

\n", "

\n", - " This guide requires @langchain/langgraph>=0.0.28, @langchain/anthropic>=0.2.6, and @langchain/core>=0.2.17. For help upgrading, see this guide.\n", + " This guide requires @langchain/langgraph>=0.0.28, @langchain/anthropic>=0.2.6, and @langchain/core>=0.2.17. For help upgrading, see this guide.\n", "

\n", "
\n", "\n", @@ -56,7 +56,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Next, set up a graph implementation of the [ReAct agent](https://langchain-ai.github.io/langgraphjs/concepts/). This agent takes some query as input, then repeatedly call tools until it has enough information to resolve the query. We'll use the prebuilt [`ToolNode`](https://langchain-ai.github.io/langgraphjs/reference/classes/langgraph_prebuilt.ToolNode.html) to execute called tools, and a small, fast model powered by Anthropic:" + "Next, set up a graph implementation of the [ReAct agent](/langgraphjs/concepts/). This agent takes some query as input, then repeatedly call tools until it has enough information to resolve the query. We'll use the prebuilt [`ToolNode`](/langgraphjs/reference/classes/langgraph_prebuilt.ToolNode.html) to execute called tools, and a small, fast model powered by Anthropic:" ] }, { @@ -778,7 +778,7 @@ "\n", "You've now seen how to implement some strategies to handle tool calling errors.\n", "\n", - "Next, check out some of the [other LangGraph how-to guides here](https://langchain-ai.github.io/langgraphjs/how-tos/)." + "Next, check out some of the [other LangGraph how-to guides here](/langgraphjs/how-tos/)." ] } ], diff --git a/examples/how-tos/tool-calling.ipynb b/examples/how-tos/tool-calling.ipynb index 272d95b4..7d953d34 100644 --- a/examples/how-tos/tool-calling.ipynb +++ b/examples/how-tos/tool-calling.ipynb @@ -6,7 +6,7 @@ "source": [ "# How to call tools using ToolNode\n", "\n", - "This guide covers how to use LangGraph's prebuilt [`ToolNode`](https://langchain-ai.github.io/langgraphjs/reference/classes/langgraph_prebuilt.ToolNode.html) for tool calling.\n", + "This guide covers how to use LangGraph's prebuilt [`ToolNode`](/langgraphjs/reference/classes/langgraph_prebuilt.ToolNode.html) for tool calling.\n", "\n", "`ToolNode` is a LangChain Runnable that takes graph state (with a list of messages) as input and outputs state update with the result of tool calls. It is designed to work well out-of-box with LangGraph's prebuilt ReAct agent, but can also work with any `StateGraph` as long as its state has a `messages` key with an appropriate reducer (see [`MessagesState`](https://github.com/langchain-ai/langgraphjs/blob/bcefdd0cfa1727104012993326462b5ebca46f79/langgraph/src/graph/message.ts#L79))." ] @@ -297,7 +297,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Next, let's see how to use `ToolNode` inside a LangGraph graph. Let's set up a graph implementation of the [ReAct agent](https://langchain-ai.github.io/langgraph/concepts/agentic_concepts/#react-agent). This agent takes some query as input, then repeatedly call tools until it has enough information to resolve the query. We'll be using `ToolNode` and the Anthropic model with tools we just defined" + "Next, let's see how to use `ToolNode` inside a LangGraph graph. Let's set up a graph implementation of the [ReAct agent](/langgraphjs/concepts/agentic_concepts/#react-agent). This agent takes some query as input, then repeatedly call tools until it has enough information to resolve the query. We'll be using `ToolNode` and the Anthropic model with tools we just defined" ] }, { @@ -578,7 +578,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "`ToolNode` can also handle errors during tool execution. See our guide on handling errors in `ToolNode` [here](https://langchain-ai.github.io/langgraphjs/how-tos/tool-calling-errors/)" + "`ToolNode` can also handle errors during tool execution. See our guide on handling errors in `ToolNode` [here](/langgraphjs/how-tos/tool-calling-errors/)" ] } ], diff --git a/examples/how-tos/use-in-web-environments.ipynb b/examples/how-tos/use-in-web-environments.ipynb index 4541af5b..df7ba263 100644 --- a/examples/how-tos/use-in-web-environments.ipynb +++ b/examples/how-tos/use-in-web-environments.ipynb @@ -1,320 +1,320 @@ { - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# How to use LangGraph.js in web environments\n", - "\n", - "LangGraph.js uses the [`async_hooks`](https://nodejs.org/api/async_hooks.html)\n", - "API to more conveniently allow for tracing and callback propagation within\n", - "nodes. This API is supported in many environments, such as\n", - "[Node.js](https://nodejs.org/api/async_hooks.html),\n", - "[Deno](https://deno.land/std@0.177.0/node/internal/async_hooks.ts),\n", - "[Cloudflare Workers](https://developers.cloudflare.com/workers/runtime-apis/nodejs/asynclocalstorage/),\n", - "and the\n", - "[Edge runtime](https://vercel.com/docs/functions/runtimes/edge-runtime#compatible-node.js-modules),\n", - "but not all, such as within web browsers.\n", - "\n", - "To allow usage of LangGraph.js in environments that do not have the\n", - "`async_hooks` API available, we've added a separate `@langchain/langgraph/web`\n", - "entrypoint. This entrypoint exports everything that the primary\n", - "`@langchain/langgraph` exports, but will not initialize or even import\n", - "`async_hooks`. Here's a simple example:" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ + "cells": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "Hello from the browser!\n" - ] - } - ], - "source": [ - "// Import from \"@langchain/langgraph/web\"\n", - "import {\n", - " END,\n", - " START,\n", - " StateGraph,\n", - " Annotation,\n", - "} from \"@langchain/langgraph/web\";\n", - "import { BaseMessage, HumanMessage } from \"@langchain/core/messages\";\n", - "\n", - "const GraphState = Annotation.Root({\n", - " messages: Annotation({\n", - " reducer: (x, y) => x.concat(y),\n", - " }),\n", - "});\n", - "\n", - "const nodeFn = async (_state: typeof GraphState.State) => {\n", - " return { messages: [new HumanMessage(\"Hello from the browser!\")] };\n", - "};\n", - "\n", - "// Define a new graph\n", - "const workflow = new StateGraph(GraphState)\n", - " .addNode(\"node\", nodeFn)\n", - " .addEdge(START, \"node\")\n", - " .addEdge(\"node\", END);\n", - "\n", - "const app = workflow.compile({});\n", - "\n", - "// Use the Runnable\n", - "const finalState = await app.invoke(\n", - " { messages: [] },\n", - ");\n", - "\n", - "console.log(finalState.messages[finalState.messages.length - 1].content);" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Other entrypoints, such as `@langchain/langgraph/prebuilt`, can be used in\n", - "either environment.\n", - "\n", - "
\n", - "

Caution

\n", - "

\n", - " If you are using LangGraph.js on the frontend, make sure you are not exposing any private keys!\n", - " For chat models, this means you need to use something like WebLLM\n", - " that can run client-side without authentication.\n", - "

\n", - "
\n", - "\n", - "## Passing config\n", - "\n", - "The lack of `async_hooks` support in web browsers means that if you are calling\n", - "a [`Runnable`](https://js.langchain.com/v0.2/docs/concepts#interface) within a\n", - "node (for example, when calling a chat model), you need to manually pass a\n", - "`config` object through to properly support tracing,\n", - "[`.streamEvents()`](https://js.langchain.com/v0.2/docs/how_to/streaming#using-stream-events)\n", - "to stream intermediate steps, and other callback related functionality. This\n", - "config object will passed in as the second argument of each node, and should be\n", - "used as the second parameter of any `Runnable` method.\n", - "\n", - "To illustrate this, let's set up our graph again as before, but with a\n", - "`Runnable` within our node. First, we'll avoid passing `config` through into the\n", - "nested function, then try to use `.streamEvents()` to see the intermediate\n", - "results of the nested function:" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# How to use LangGraph.js in web environments\n", + "\n", + "LangGraph.js uses the [`async_hooks`](https://nodejs.org/api/async_hooks.html)\n", + "API to more conveniently allow for tracing and callback propagation within\n", + "nodes. This API is supported in many environments, such as\n", + "[Node.js](https://nodejs.org/api/async_hooks.html),\n", + "[Deno](https://deno.land/std@0.177.0/node/internal/async_hooks.ts),\n", + "[Cloudflare Workers](https://developers.cloudflare.com/workers/runtime-apis/nodejs/asynclocalstorage/),\n", + "and the\n", + "[Edge runtime](https://vercel.com/docs/functions/runtimes/edge-runtime#compatible-node.js-modules),\n", + "but not all, such as within web browsers.\n", + "\n", + "To allow usage of LangGraph.js in environments that do not have the\n", + "`async_hooks` API available, we've added a separate `@langchain/langgraph/web`\n", + "entrypoint. This entrypoint exports everything that the primary\n", + "`@langchain/langgraph` exports, but will not initialize or even import\n", + "`async_hooks`. Here's a simple example:" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Received 0 events from the nested function\n" - ] - } - ], - "source": [ - "// Import from \"@langchain/langgraph/web\"\n", - "import {\n", - " END,\n", - " START,\n", - " StateGraph,\n", - " Annotation,\n", - "} from \"@langchain/langgraph/web\";\n", - "import { BaseMessage } from \"@langchain/core/messages\";\n", - "import { RunnableLambda } from \"@langchain/core/runnables\";\n", - "import { type StreamEvent } from \"@langchain/core/tracers/log_stream\";\n", - "\n", - "const GraphState2 = Annotation.Root({\n", - " messages: Annotation({\n", - " reducer: (x, y) => x.concat(y),\n", - " }),\n", - "});\n", - "\n", - "const nodeFn2 = async (_state: typeof GraphState2.State) => {\n", - " // Note that we do not pass any `config` through here\n", - " const nestedFn = RunnableLambda.from(async (input: string) => {\n", - " return new HumanMessage(`Hello from ${input}!`);\n", - " }).withConfig({ runName: \"nested\" });\n", - " const responseMessage = await nestedFn.invoke(\"a nested function\");\n", - " return { messages: [responseMessage] };\n", - "};\n", - "\n", - "// Define a new graph\n", - "const workflow2 = new StateGraph(GraphState2)\n", - " .addNode(\"node\", nodeFn2)\n", - " .addEdge(START, \"node\")\n", - " .addEdge(\"node\", END);\n", - "\n", - "const app2 = workflow2.compile({});\n", - "\n", - "// Stream intermediate steps from the graph\n", - "const eventStream2 = app2.streamEvents(\n", - " { messages: [] },\n", - " { version: \"v2\" },\n", - " { includeNames: [\"nested\"] },\n", - ");\n", - "\n", - "const events2: StreamEvent[] = [];\n", - "for await (const event of eventStream2) {\n", - " console.log(event);\n", - " events2.push(event);\n", - "}\n", - "\n", - "console.log(`Received ${events2.length} events from the nested function`);" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We can see that we get no events.\n", - "\n", - "Next, let's try redeclaring the graph with a node that passes config through\n", - "correctly:" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hello from the browser!\n" + ] + } + ], + "source": [ + "// Import from \"@langchain/langgraph/web\"\n", + "import {\n", + " END,\n", + " START,\n", + " StateGraph,\n", + " Annotation,\n", + "} from \"@langchain/langgraph/web\";\n", + "import { BaseMessage, HumanMessage } from \"@langchain/core/messages\";\n", + "\n", + "const GraphState = Annotation.Root({\n", + " messages: Annotation({\n", + " reducer: (x, y) => x.concat(y),\n", + " }),\n", + "});\n", + "\n", + "const nodeFn = async (_state: typeof GraphState.State) => {\n", + " return { messages: [new HumanMessage(\"Hello from the browser!\")] };\n", + "};\n", + "\n", + "// Define a new graph\n", + "const workflow = new StateGraph(GraphState)\n", + " .addNode(\"node\", nodeFn)\n", + " .addEdge(START, \"node\")\n", + " .addEdge(\"node\", END);\n", + "\n", + "const app = workflow.compile({});\n", + "\n", + "// Use the Runnable\n", + "const finalState = await app.invoke(\n", + " { messages: [] },\n", + ");\n", + "\n", + "console.log(finalState.messages[finalState.messages.length - 1].content);" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "{\n", - " event: \"on_chain_start\",\n", - " data: { input: { messages: [] } },\n", - " name: \"nested\",\n", - " tags: [],\n", - " run_id: \"22747451-a2fa-447b-b62f-9da19a539b2f\",\n", - " metadata: {\n", - " langgraph_step: 1,\n", - " langgraph_node: \"node\",\n", - " langgraph_triggers: [ \"start:node\" ],\n", - " langgraph_task_idx: 0,\n", - " __pregel_resuming: false,\n", - " checkpoint_id: \"1ef62793-f065-6840-fffe-cdfb4cbb1248\",\n", - " checkpoint_ns: \"node\"\n", - " }\n", - "}\n", - "{\n", - " event: \"on_chain_end\",\n", - " data: {\n", - " output: HumanMessage {\n", - " \"content\": \"Hello from a nested function!\",\n", - " \"additional_kwargs\": {},\n", - " \"response_metadata\": {}\n", - " }\n", - " },\n", - " run_id: \"22747451-a2fa-447b-b62f-9da19a539b2f\",\n", - " name: \"nested\",\n", - " tags: [],\n", - " metadata: {\n", - " langgraph_step: 1,\n", - " langgraph_node: \"node\",\n", - " langgraph_triggers: [ \"start:node\" ],\n", - " langgraph_task_idx: 0,\n", - " __pregel_resuming: false,\n", - " checkpoint_id: \"1ef62793-f065-6840-fffe-cdfb4cbb1248\",\n", - " checkpoint_ns: \"node\"\n", - " }\n", - "}\n", - "Received 2 events from the nested function\n" - ] + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Other entrypoints, such as `@langchain/langgraph/prebuilt`, can be used in\n", + "either environment.\n", + "\n", + "
\n", + "

Caution

\n", + "

\n", + " If you are using LangGraph.js on the frontend, make sure you are not exposing any private keys!\n", + " For chat models, this means you need to use something like WebLLM\n", + " that can run client-side without authentication.\n", + "

\n", + "
\n", + "\n", + "## Passing config\n", + "\n", + "The lack of `async_hooks` support in web browsers means that if you are calling\n", + "a [`Runnable`](https://js.langchain.com/v0.2/docs/concepts#interface) within a\n", + "node (for example, when calling a chat model), you need to manually pass a\n", + "`config` object through to properly support tracing,\n", + "[`.streamEvents()`](https://js.langchain.com/v0.2/docs/how_to/streaming#using-stream-events)\n", + "to stream intermediate steps, and other callback related functionality. This\n", + "config object will passed in as the second argument of each node, and should be\n", + "used as the second parameter of any `Runnable` method.\n", + "\n", + "To illustrate this, let's set up our graph again as before, but with a\n", + "`Runnable` within our node. First, we'll avoid passing `config` through into the\n", + "nested function, then try to use `.streamEvents()` to see the intermediate\n", + "results of the nested function:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Received 0 events from the nested function\n" + ] + } + ], + "source": [ + "// Import from \"@langchain/langgraph/web\"\n", + "import {\n", + " END,\n", + " START,\n", + " StateGraph,\n", + " Annotation,\n", + "} from \"@langchain/langgraph/web\";\n", + "import { BaseMessage } from \"@langchain/core/messages\";\n", + "import { RunnableLambda } from \"@langchain/core/runnables\";\n", + "import { type StreamEvent } from \"@langchain/core/tracers/log_stream\";\n", + "\n", + "const GraphState2 = Annotation.Root({\n", + " messages: Annotation({\n", + " reducer: (x, y) => x.concat(y),\n", + " }),\n", + "});\n", + "\n", + "const nodeFn2 = async (_state: typeof GraphState2.State) => {\n", + " // Note that we do not pass any `config` through here\n", + " const nestedFn = RunnableLambda.from(async (input: string) => {\n", + " return new HumanMessage(`Hello from ${input}!`);\n", + " }).withConfig({ runName: \"nested\" });\n", + " const responseMessage = await nestedFn.invoke(\"a nested function\");\n", + " return { messages: [responseMessage] };\n", + "};\n", + "\n", + "// Define a new graph\n", + "const workflow2 = new StateGraph(GraphState2)\n", + " .addNode(\"node\", nodeFn2)\n", + " .addEdge(START, \"node\")\n", + " .addEdge(\"node\", END);\n", + "\n", + "const app2 = workflow2.compile({});\n", + "\n", + "// Stream intermediate steps from the graph\n", + "const eventStream2 = app2.streamEvents(\n", + " { messages: [] },\n", + " { version: \"v2\" },\n", + " { includeNames: [\"nested\"] },\n", + ");\n", + "\n", + "const events2: StreamEvent[] = [];\n", + "for await (const event of eventStream2) {\n", + " console.log(event);\n", + " events2.push(event);\n", + "}\n", + "\n", + "console.log(`Received ${events2.length} events from the nested function`);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can see that we get no events.\n", + "\n", + "Next, let's try redeclaring the graph with a node that passes config through\n", + "correctly:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{\n", + " event: \"on_chain_start\",\n", + " data: { input: { messages: [] } },\n", + " name: \"nested\",\n", + " tags: [],\n", + " run_id: \"22747451-a2fa-447b-b62f-9da19a539b2f\",\n", + " metadata: {\n", + " langgraph_step: 1,\n", + " langgraph_node: \"node\",\n", + " langgraph_triggers: [ \"start:node\" ],\n", + " langgraph_task_idx: 0,\n", + " __pregel_resuming: false,\n", + " checkpoint_id: \"1ef62793-f065-6840-fffe-cdfb4cbb1248\",\n", + " checkpoint_ns: \"node\"\n", + " }\n", + "}\n", + "{\n", + " event: \"on_chain_end\",\n", + " data: {\n", + " output: HumanMessage {\n", + " \"content\": \"Hello from a nested function!\",\n", + " \"additional_kwargs\": {},\n", + " \"response_metadata\": {}\n", + " }\n", + " },\n", + " run_id: \"22747451-a2fa-447b-b62f-9da19a539b2f\",\n", + " name: \"nested\",\n", + " tags: [],\n", + " metadata: {\n", + " langgraph_step: 1,\n", + " langgraph_node: \"node\",\n", + " langgraph_triggers: [ \"start:node\" ],\n", + " langgraph_task_idx: 0,\n", + " __pregel_resuming: false,\n", + " checkpoint_id: \"1ef62793-f065-6840-fffe-cdfb4cbb1248\",\n", + " checkpoint_ns: \"node\"\n", + " }\n", + "}\n", + "Received 2 events from the nested function\n" + ] + } + ], + "source": [ + "// Import from \"@langchain/langgraph/web\"\n", + "import {\n", + " END,\n", + " START,\n", + " StateGraph,\n", + " Annotation,\n", + "} from \"@langchain/langgraph/web\";\n", + "import { BaseMessage } from \"@langchain/core/messages\";\n", + "import { type RunnableConfig, RunnableLambda } from \"@langchain/core/runnables\";\n", + "import { type StreamEvent } from \"@langchain/core/tracers/log_stream\";\n", + "\n", + "const GraphState3 = Annotation.Root({\n", + " messages: Annotation({\n", + " reducer: (x, y) => x.concat(y),\n", + " }),\n", + "});\n", + "\n", + "// Note the second argument here.\n", + "const nodeFn3 = async (_state: typeof GraphState3.State, config?: RunnableConfig) => {\n", + " // If you need to nest deeper, remember to pass `_config` when invoking\n", + " const nestedFn = RunnableLambda.from(\n", + " async (input: string, _config?: RunnableConfig) => {\n", + " return new HumanMessage(`Hello from ${input}!`);\n", + " },\n", + " ).withConfig({ runName: \"nested\" });\n", + " const responseMessage = await nestedFn.invoke(\"a nested function\", config);\n", + " return { messages: [responseMessage] };\n", + "};\n", + "\n", + "// Define a new graph\n", + "const workflow3 = new StateGraph(GraphState3)\n", + " .addNode(\"node\", nodeFn3)\n", + " .addEdge(START, \"node\")\n", + " .addEdge(\"node\", END);\n", + "\n", + "const app3 = workflow3.compile({});\n", + "\n", + "// Stream intermediate steps from the graph\n", + "const eventStream3 = app3.streamEvents(\n", + " { messages: [] },\n", + " { version: \"v2\" },\n", + " { includeNames: [\"nested\"] },\n", + ");\n", + "\n", + "const events3: StreamEvent[] = [];\n", + "for await (const event of eventStream3) {\n", + " console.log(event);\n", + " events3.push(event);\n", + "}\n", + "\n", + "console.log(`Received ${events3.length} events from the nested function`);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can see that we get events from the nested function as expected.\n", + "\n", + "## Next steps\n", + "\n", + "You've now learned about some special considerations around using LangGraph.js\n", + "in web environments.\n", + "\n", + "Next, check out\n", + "[some how-to guides on core functionality](/langgraphjs/how-tos/#core)." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Deno", + "language": "typescript", + "name": "deno" + }, + "language_info": { + "file_extension": ".ts", + "mimetype": "text/x.typescript", + "name": "typescript", + "nb_converter": "script", + "pygments_lexer": "typescript", + "version": "5.3.3" } - ], - "source": [ - "// Import from \"@langchain/langgraph/web\"\n", - "import {\n", - " END,\n", - " START,\n", - " StateGraph,\n", - " Annotation,\n", - "} from \"@langchain/langgraph/web\";\n", - "import { BaseMessage } from \"@langchain/core/messages\";\n", - "import { type RunnableConfig, RunnableLambda } from \"@langchain/core/runnables\";\n", - "import { type StreamEvent } from \"@langchain/core/tracers/log_stream\";\n", - "\n", - "const GraphState3 = Annotation.Root({\n", - " messages: Annotation({\n", - " reducer: (x, y) => x.concat(y),\n", - " }),\n", - "});\n", - "\n", - "// Note the second argument here.\n", - "const nodeFn3 = async (_state: typeof GraphState3.State, config?: RunnableConfig) => {\n", - " // If you need to nest deeper, remember to pass `_config` when invoking\n", - " const nestedFn = RunnableLambda.from(\n", - " async (input: string, _config?: RunnableConfig) => {\n", - " return new HumanMessage(`Hello from ${input}!`);\n", - " },\n", - " ).withConfig({ runName: \"nested\" });\n", - " const responseMessage = await nestedFn.invoke(\"a nested function\", config);\n", - " return { messages: [responseMessage] };\n", - "};\n", - "\n", - "// Define a new graph\n", - "const workflow3 = new StateGraph(GraphState3)\n", - " .addNode(\"node\", nodeFn3)\n", - " .addEdge(START, \"node\")\n", - " .addEdge(\"node\", END);\n", - "\n", - "const app3 = workflow3.compile({});\n", - "\n", - "// Stream intermediate steps from the graph\n", - "const eventStream3 = app3.streamEvents(\n", - " { messages: [] },\n", - " { version: \"v2\" },\n", - " { includeNames: [\"nested\"] },\n", - ");\n", - "\n", - "const events3: StreamEvent[] = [];\n", - "for await (const event of eventStream3) {\n", - " console.log(event);\n", - " events3.push(event);\n", - "}\n", - "\n", - "console.log(`Received ${events3.length} events from the nested function`);" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "You can see that we get events from the nested function as expected.\n", - "\n", - "## Next steps\n", - "\n", - "You've now learned about some special considerations around using LangGraph.js\n", - "in web environments.\n", - "\n", - "Next, check out\n", - "[some how-to guides on core functionality](https://langchain-ai.github.io/langgraphjs/how-tos/#core)." - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Deno", - "language": "typescript", - "name": "deno" }, - "language_info": { - "file_extension": ".ts", - "mimetype": "text/x.typescript", - "name": "typescript", - "nb_converter": "script", - "pygments_lexer": "typescript", - "version": "5.3.3" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} + "nbformat": 4, + "nbformat_minor": 2 +} \ No newline at end of file diff --git a/examples/how-tos/wait-user-input.ipynb b/examples/how-tos/wait-user-input.ipynb index 09270d47..0b059660 100644 --- a/examples/how-tos/wait-user-input.ipynb +++ b/examples/how-tos/wait-user-input.ipynb @@ -1,1080 +1,1080 @@ { - "cells": [ - { - "attachments": { - "02ae42da-d1a4-4849-984a-6ab0bbf759bd.png": { - "image/png": "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" - } - }, - "cell_type": "markdown", - "id": "51466c8d-8ce4-4b3d-be4e-18fdbeda5f53", - "metadata": {}, - "source": [ - "# How to wait for user input\n", - "\n", - "Human-in-the-loop (HIL) interactions are crucial for [agentic systems](https://langchain-ai.github.io/langgraph/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](https://langchain-ai.github.io/langgraph/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", - "\n", - "![Screenshot 2024-07-08 at 5.26.26 PM.png](attachment:02ae42da-d1a4-4849-984a-6ab0bbf759bd.png)" - ] - }, - { - "cell_type": "markdown", - "id": "7cbd446a-808f-4394-be92-d45ab818953c", - "metadata": {}, - "source": [ - "## Setup\n", - "First we need to install the packages required\n", - "\n", - "```bash\n", - "npm install @langchain/langgraph @langchain/anthropic zod\n", - "```\n", - "\n", - "Next, we need to set API keys for Anthropic (the LLM we will use)\n", - "\n", - "```bash\n", - "export ANTHROPIC_API_KEY=your-api-key\n", - "```\n", - "\n", - "Optionally, we can set API key for [LangSmith tracing](https://smith.langchain.com/), which will give us best-in-class observability.\n", - "\n", - "```bash\n", - "export LANGCHAIN_TRACING_V2=\"true\"\n", - "export LANGCHAIN_CALLBACKS_BACKGROUND=\"true\"\n", - "export LANGCHAIN_API_KEY=your-api-key\n", - "```" - ] - }, - { - "cell_type": "markdown", - "id": "e6cf1fad-5ab6-49c5-b0c8-15a1b6e8cf21", - "metadata": {}, - "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](https://langchain-ai.github.io/langgraph/concepts/low_level/#breakpoints) using `interruptBefore` our `humanFeedback` node.\n", - "\n", - "2) We set up a [checkpointer](https://langchain-ai.github.io/langgraph/concepts/low_level/#checkpointer) to save the state of the graph up until this node.\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](https://langchain-ai.github.io/langgraph/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." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "58eae42d-be32-48da-8d0a-ab64471657d9", - "metadata": {}, - "outputs": [], - "source": [ - "import { StateGraph, Annotation, START, END } from \"@langchain/langgraph\";\n", - "import { MemorySaver } from \"@langchain/langgraph\";\n", - "\n", - "const GraphState = Annotation.Root({\n", - " input: Annotation,\n", - " userFeedback: Annotation\n", - "});\n", - "\n", - "const step1 = (state: typeof GraphState.State) => {\n", - " console.log(\"---Step 1---\");\n", - " return state;\n", - "}\n", - "\n", - "const humanFeedback = (state: typeof GraphState.State) => {\n", - " console.log(\"--- humanFeedback ---\");\n", - " return state;\n", - "}\n", - "\n", - "const step3 = (state: typeof GraphState.State) => {\n", - " console.log(\"---Step 3---\");\n", - " return state;\n", - "}\n", - "\n", - "const builder = new StateGraph(GraphState)\n", - " .addNode(\"step1\", step1)\n", - " .addNode(\"humanFeedback\", humanFeedback)\n", - " .addNode(\"step3\", step3)\n", - " .addEdge(START, \"step1\")\n", - " .addEdge(\"step1\", \"humanFeedback\")\n", - " .addEdge(\"humanFeedback\", \"step3\")\n", - " .addEdge(\"step3\", END);\n", - "\n", - "\n", - "// Set up memory\n", - "const memory = new MemorySaver()\n", - "\n", - "// Add \n", - "const graph = builder.compile({\n", - " checkpointer: memory,\n", - " interruptBefore: [\"humanFeedback\"]\n", - "});" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "9e990a56", - "metadata": {}, - "outputs": [ + "cells": [ { - "data": { - "image/png": "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" - }, - "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": "ce0fe2bc-86fc-465f-956c-729805d50404", - "metadata": {}, - "source": [ - "Run until our breakpoint at `step2`" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "eb8e7d47-e7c9-4217-b72c-08394a2c4d3e", - "metadata": {}, - "outputs": [ + "attachments": { + "02ae42da-d1a4-4849-984a-6ab0bbf759bd.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "id": "51466c8d-8ce4-4b3d-be4e-18fdbeda5f53", + "metadata": {}, + "source": [ + "# How to wait for user input\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", + "\n", + "![Screenshot 2024-07-08 at 5.26.26 PM.png](attachment:02ae42da-d1a4-4849-984a-6ab0bbf759bd.png)" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- hello world ---\n", - "---Step 1---\n", - "--- hello world ---\n", - "--- GRAPH INTERRUPTED ---\n" - ] - } - ], - "source": [ - "// Input\n", - "const initialInput = { input: \"hello world\" };\n", - "\n", - "// Thread\n", - "const config = { configurable: { thread_id: \"1\" }, streamMode: \"values\" as const };\n", - "\n", - "// Run the graph until the first interruption\n", - "for await (const event of await graph.stream(initialInput, config)) {\n", - " console.log(`--- ${event.input} ---`);\n", - "}\n", - "\n", - "// Will log when the graph is interrupted, after step 2.\n", - "console.log(\"--- GRAPH INTERRUPTED ---\");" - ] - }, - { - "cell_type": "markdown", - "id": "28a7d545-ab19-4800-985b-62837d060809", - "metadata": {}, - "source": [ - "Now, we can just manually update our graph state with with the user input - " - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "2165a1bc-1c5b-411f-9e9c-a2b9627e5d56", - "metadata": {}, - "outputs": [ + "cell_type": "markdown", + "id": "7cbd446a-808f-4394-be92-d45ab818953c", + "metadata": {}, + "source": [ + "## Setup\n", + "First we need to install the packages required\n", + "\n", + "```bash\n", + "npm install @langchain/langgraph @langchain/anthropic zod\n", + "```\n", + "\n", + "Next, we need to set API keys for Anthropic (the LLM we will use)\n", + "\n", + "```bash\n", + "export ANTHROPIC_API_KEY=your-api-key\n", + "```\n", + "\n", + "Optionally, we can set API key for [LangSmith tracing](https://smith.langchain.com/), which will give us best-in-class observability.\n", + "\n", + "```bash\n", + "export LANGCHAIN_TRACING_V2=\"true\"\n", + "export LANGCHAIN_CALLBACKS_BACKGROUND=\"true\"\n", + "export LANGCHAIN_API_KEY=your-api-key\n", + "```" + ] + }, { - "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": [ + "cell_type": "markdown", + "id": "e6cf1fad-5ab6-49c5-b0c8-15a1b6e8cf21", + "metadata": {}, + "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", + "\n", + "2) We set up a [checkpointer](/langgraphjs/concepts/low_level/#checkpointer) to save the state of the graph up until this node.\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." + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- humanFeedback ---\n", - "--- hello world ---\n", - "---Step 3---\n", - "--- hello world ---\n" - ] - } - ], - "source": [ - "// Continue the graph execution\n", - "for await (const event of await graph.stream(null, config)) {\n", - " console.log(`--- ${event.input} ---`);\n", - "}" - ] - }, - { - "cell_type": "markdown", - "id": "a75a1060-47aa-4cc6-8c41-e6ba2e9d7923", - "metadata": {}, - "source": [ - "We can see our feedback was added to state - " - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "2b83e5ca-8497-43ca-bff7-7203e654c4d3", - "metadata": {}, - "outputs": [ + "cell_type": "code", + "execution_count": 1, + "id": "58eae42d-be32-48da-8d0a-ab64471657d9", + "metadata": {}, + "outputs": [], + "source": [ + "import { StateGraph, Annotation, START, END } from \"@langchain/langgraph\";\n", + "import { MemorySaver } from \"@langchain/langgraph\";\n", + "\n", + "const GraphState = Annotation.Root({\n", + " input: Annotation,\n", + " userFeedback: Annotation\n", + "});\n", + "\n", + "const step1 = (state: typeof GraphState.State) => {\n", + " console.log(\"---Step 1---\");\n", + " return state;\n", + "}\n", + "\n", + "const humanFeedback = (state: typeof GraphState.State) => {\n", + " console.log(\"--- humanFeedback ---\");\n", + " return state;\n", + "}\n", + "\n", + "const step3 = (state: typeof GraphState.State) => {\n", + " console.log(\"---Step 3---\");\n", + " return state;\n", + "}\n", + "\n", + "const builder = new StateGraph(GraphState)\n", + " .addNode(\"step1\", step1)\n", + " .addNode(\"humanFeedback\", humanFeedback)\n", + " .addNode(\"step3\", step3)\n", + " .addEdge(START, \"step1\")\n", + " .addEdge(\"step1\", \"humanFeedback\")\n", + " .addEdge(\"humanFeedback\", \"step3\")\n", + " .addEdge(\"step3\", END);\n", + "\n", + "\n", + "// Set up memory\n", + "const memory = new MemorySaver()\n", + "\n", + "// Add \n", + "const graph = builder.compile({\n", + " checkpointer: memory,\n", + " interruptBefore: [\"humanFeedback\"]\n", + "});" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "{ input: 'hello world', userFeedback: 'Go to step 3!!' }\n" - ] - } - ], - "source": [ - "(await graph.getState(config)).values" - ] - }, - { - "cell_type": "markdown", - "id": "e36f89e5", - "metadata": {}, - "source": [ - "## Agent\n", - "\n", - "In the context of agents, waiting for user feedback is useful to ask clarifying questions.\n", - " \n", - "To show this, we will build a relatively simple ReAct-style agent that does tool calling. \n", - "\n", - "We will use OpenAI and / or Anthropic's models and a fake tool (just for demo purposes)." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "f5319e01", - "metadata": {}, - "outputs": [], - "source": [ - "// 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 { ToolNode } from \"@langchain/langgraph/prebuilt\";\n", - "import { BaseMessage, AIMessage } from \"@langchain/core/messages\";\n", - "import { z } from \"zod\";\n", - "\n", - "const GraphMessagesState = 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", - " name: \"search\",\n", - " description: \"Call to surf the web.\",\n", - " schema: z.string(),\n", - "})\n", - "\n", - "const tools = [search]\n", - "const toolNode = new ToolNode(tools)\n", - "\n", - "// Set up the model\n", - "const model = new ChatAnthropic({ model: \"claude-3-5-sonnet-20240620\" })\n", - "\n", - "const askHumanTool = tool((_) => {\n", - " return \"The human said XYZ\";\n", - "}, {\n", - " name: \"askHuman\",\n", - " description: \"Ask the human for input.\",\n", - " schema: z.string(),\n", - "});\n", - "\n", - "\n", - "const modelWithTools = model.bindTools([...tools, askHumanTool])\n", - "\n", - "// Define nodes and conditional edges\n", - "\n", - "// Define the function that determines whether to continue or not\n", - "function shouldContinue(state: typeof GraphMessagesState.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", - " if (castLastMessage && !castLastMessage.tool_calls?.length) {\n", - " return END;\n", - " }\n", - " // If tool call is askHuman, we return that node\n", - " // You could also add logic here to let some system know that there's something that requires Human input\n", - " // For example, send a slack message, etc\n", - " if (castLastMessage.tool_calls?.[0]?.name === \"askHuman\") {\n", - " console.log(\"--- ASKING HUMAN ---\")\n", - " return \"askHuman\";\n", - " }\n", - " // Otherwise if it isn't, we continue with the action node\n", - " return \"action\";\n", - "}\n", - "\n", - "\n", - "// Define the function that calls the model\n", - "async function callModel(state: typeof GraphMessagesState.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", - " return { messages: [response] };\n", - "}\n", - "\n", - "\n", - "// We define a fake node to ask the human\n", - "function askHuman(state: typeof GraphMessagesState.State): Partial {\n", - " return state;\n", - "}\n", - "\n", - "// Define a new graph\n", - "const messagesWorkflow = new StateGraph(GraphMessagesState)\n", - " // Define the two nodes we will cycle between\n", - " .addNode(\"agent\", callModel)\n", - " .addNode(\"action\", toolNode)\n", - " .addNode(\"askHuman\", askHuman)\n", - " // We now add a conditional edge\n", - " .addConditionalEdges(\n", - " // First, we define the start node. We use `agent`.\n", - " // This means these are the edges taken after the `agent` node is called.\n", - " \"agent\",\n", - " // Next, we pass in the function that will determine which node is called next.\n", - " shouldContinue\n", - " )\n", - " // We now add a normal edge from `action` to `agent`.\n", - " // This means that after `action` is called, `agent` node is called next.\n", - " .addEdge(\"action\", \"agent\")\n", - " // After we get back the human response, we go back to the agent\n", - " .addEdge(\"askHuman\", \"agent\")\n", - " // Set the entrypoint as `agent`\n", - " // This means that this node is the first one called\n", - " .addEdge(START, \"agent\");\n", - "\n", - "\n", - "// Setup memory\n", - "const messagesMemory = new MemorySaver();\n", - "\n", - "// Finally, we compile it!\n", - "// This compiles it into a LangChain Runnable,\n", - "// 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, - "id": "4b816850", - "metadata": {}, - "outputs": [ + "cell_type": "code", + "execution_count": 2, + "id": "9e990a56", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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" + }, + "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));" + ] + }, { - "data": { - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import * as tslab from \"tslab\";\n", - "\n", - "const drawableGraph2 = messagesApp.getGraph();\n", - "const image2 = await drawableGraph2.drawMermaidPng();\n", - "const arrayBuffer2 = await image2.arrayBuffer();\n", - "\n", - "await tslab.display.png(new Uint8Array(arrayBuffer2));" - ] - }, - { - "cell_type": "markdown", - "id": "2a1b56c5-bd61-4192-8bdb-458a1e9f0159", - "metadata": {}, - "source": [ - "## Interacting with the Agent\n", - "\n", - "We can now interact with the agent. Let's ask it to ask the user where they are, then tell them the weather. \n", - "\n", - "This should make it use the `askHuman` tool first, then use the normal tool." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "cfd140f0-a5a6-4697-8115-322242f197b5", - "metadata": {}, - "outputs": [ + "cell_type": "markdown", + "id": "ce0fe2bc-86fc-465f-956c-729805d50404", + "metadata": {}, + "source": [ + "Run until our breakpoint at `step2`" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "================================ human Message (1) =================================\n", - "Use the search tool to ask the user where they are, then look up the weather there\n", - "--- ASKING HUMAN ---\n", - "================================ ai Message (1) =================================\n", - "[\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", - " },\n", - " {\n", - " type: 'tool_use',\n", - " id: 'toolu_01RN181HAAL5BcnMXkexbA1r',\n", - " name: 'askHuman',\n", - " input: {\n", - " input: 'Where are you located? Please provide your city and country.'\n", - " }\n", - " }\n", - "]\n", - "next: [ 'askHuman' ]\n" - ] - } - ], - "source": [ - "import { HumanMessage } from \"@langchain/core/messages\";\n", - "// Input\n", - "const inputs = new HumanMessage(\"Use the search tool to ask the user where they are, then look up the weather there\");\n", - "\n", - "// Thread\n", - "const config2 = { configurable: { thread_id: \"3\" }, streamMode: \"values\" as const };\n", - "\n", - "for await (const event of await messagesApp.stream({\n", - " messages: [inputs]\n", - "}, config2)) {\n", - " const recentMsg = event.messages[event.messages.length - 1];\n", - " console.log(`================================ ${recentMsg._getType()} Message (1) =================================`)\n", - " console.log(recentMsg.content);\n", - "}\n", - "\n", - "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", - "metadata": {}, - "outputs": [ + "cell_type": "code", + "execution_count": 3, + "id": "eb8e7d47-e7c9-4217-b72c-08394a2c4d3e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- hello world ---\n", + "---Step 1---\n", + "--- hello world ---\n", + "--- GRAPH INTERRUPTED ---\n" + ] + } + ], + "source": [ + "// Input\n", + "const initialInput = { input: \"hello world\" };\n", + "\n", + "// Thread\n", + "const config = { configurable: { thread_id: \"1\" }, streamMode: \"values\" as const };\n", + "\n", + "// Run the graph until the first interruption\n", + "for await (const event of await graph.stream(initialInput, config)) {\n", + " console.log(`--- ${event.input} ---`);\n", + "}\n", + "\n", + "// Will log when the graph is interrupted, after step 2.\n", + "console.log(\"--- GRAPH INTERRUPTED ---\");" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "next before update state: [ 'askHuman' ]\n", - "next AFTER update state: [ 'agent' ]\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)" - ] - }, - { - "cell_type": "markdown", - "id": "6a30c9fb-2a40-45cc-87ba-406c11c9f0cf", - "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" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "a9f599b5-1a55-406b-a76b-f52b3ca06975", - "metadata": {}, - "outputs": [ + "cell_type": "markdown", + "id": "28a7d545-ab19-4800-985b-62837d060809", + "metadata": {}, + "source": [ + "Now, we can just manually update our graph state with with the user input - " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "2165a1bc-1c5b-411f-9e9c-a2b9627e5d56", + "metadata": {}, + "outputs": [ + { + "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": [ + "--- humanFeedback ---\n", + "--- hello world ---\n", + "---Step 3---\n", + "--- hello world ---\n" + ] + } + ], + "source": [ + "// Continue the graph execution\n", + "for await (const event of await graph.stream(null, config)) {\n", + " console.log(`--- ${event.input} ---`);\n", + "}" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "{\n", - " messages: [\n", - " HumanMessage {\n", - " \"id\": \"a80d5763-0f27-4a00-9e54-8a239b499ea1\",\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", - " \"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", - " },\n", - " {\n", - " \"type\": \"tool_use\",\n", - " \"id\": \"toolu_01RN181HAAL5BcnMXkexbA1r\",\n", - " \"name\": \"askHuman\",\n", - " \"input\": {\n", - " \"input\": \"Where are you located? Please provide your city and country.\"\n", - " }\n", - " }\n", - " ],\n", - " \"additional_kwargs\": {\n", - " \"id\": \"msg_01CsrDn46VqNXrdkpVHbcMKA\",\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\": 108\n", - " }\n", - " },\n", - " \"response_metadata\": {\n", - " \"id\": \"msg_01CsrDn46VqNXrdkpVHbcMKA\",\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", - " },\n", - " \"type\": \"message\",\n", - " \"role\": \"assistant\"\n", - " },\n", - " \"tool_calls\": [\n", - " {\n", - " \"name\": \"askHuman\",\n", - " \"args\": {\n", - " \"input\": \"Where are you located? Please provide your city and country.\"\n", - " },\n", - " \"id\": \"toolu_01RN181HAAL5BcnMXkexbA1r\",\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", - " \"additional_kwargs\": {},\n", - " \"response_metadata\": {},\n", - " \"tool_call_id\": \"toolu_01RN181HAAL5BcnMXkexbA1r\"\n", - " },\n", - " AIMessage {\n", - " \"id\": \"msg_017hfZ8kdhX5nKD97THKWpPx\",\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", - " },\n", - " {\n", - " \"type\": \"tool_use\",\n", - " \"id\": \"toolu_01QCcxzRjojWW5JqQp7WTN82\",\n", - " \"name\": \"search\",\n", - " \"input\": {\n", - " \"input\": \"current weather in San Francisco\"\n", - " }\n", - " }\n", - " ],\n", - " \"additional_kwargs\": {\n", - " \"id\": \"msg_017hfZ8kdhX5nKD97THKWpPx\",\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", - " }\n", - " },\n", - " \"response_metadata\": {\n", - " \"id\": \"msg_017hfZ8kdhX5nKD97THKWpPx\",\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", - " },\n", - " \"type\": \"message\",\n", - " \"role\": \"assistant\"\n", - " },\n", - " \"tool_calls\": [\n", - " {\n", - " \"name\": \"search\",\n", - " \"args\": {\n", - " \"input\": \"current weather in San Francisco\"\n", - " },\n", - " \"id\": \"toolu_01QCcxzRjojWW5JqQp7WTN82\",\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", - " }\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", - " messages: [\n", - " HumanMessage {\n", - " \"id\": \"a80d5763-0f27-4a00-9e54-8a239b499ea1\",\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", - " \"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", - " },\n", - " {\n", - " \"type\": \"tool_use\",\n", - " \"id\": \"toolu_01RN181HAAL5BcnMXkexbA1r\",\n", - " \"name\": \"askHuman\",\n", - " \"input\": {\n", - " \"input\": \"Where are you located? Please provide your city and country.\"\n", - " }\n", - " }\n", - " ],\n", - " \"additional_kwargs\": {\n", - " \"id\": \"msg_01CsrDn46VqNXrdkpVHbcMKA\",\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\": 108\n", - " }\n", - " },\n", - " \"response_metadata\": {\n", - " \"id\": \"msg_01CsrDn46VqNXrdkpVHbcMKA\",\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", - " },\n", - " \"type\": \"message\",\n", - " \"role\": \"assistant\"\n", - " },\n", - " \"tool_calls\": [\n", - " {\n", - " \"name\": \"askHuman\",\n", - " \"args\": {\n", - " \"input\": \"Where are you located? Please provide your city and country.\"\n", - " },\n", - " \"id\": \"toolu_01RN181HAAL5BcnMXkexbA1r\",\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", - " \"additional_kwargs\": {},\n", - " \"response_metadata\": {},\n", - " \"tool_call_id\": \"toolu_01RN181HAAL5BcnMXkexbA1r\"\n", - " },\n", - " AIMessage {\n", - " \"id\": \"msg_017hfZ8kdhX5nKD97THKWpPx\",\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", - " },\n", - " {\n", - " \"type\": \"tool_use\",\n", - " \"id\": \"toolu_01QCcxzRjojWW5JqQp7WTN82\",\n", - " \"name\": \"search\",\n", - " \"input\": {\n", - " \"input\": \"current weather in San Francisco\"\n", - " }\n", - " }\n", - " ],\n", - " \"additional_kwargs\": {\n", - " \"id\": \"msg_017hfZ8kdhX5nKD97THKWpPx\",\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", - " }\n", - " },\n", - " \"response_metadata\": {\n", - " \"id\": \"msg_017hfZ8kdhX5nKD97THKWpPx\",\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", - " },\n", - " \"type\": \"message\",\n", - " \"role\": \"assistant\"\n", - " },\n", - " \"tool_calls\": [\n", - " {\n", - " \"name\": \"search\",\n", - " \"args\": {\n", - " \"input\": \"current weather in San Francisco\"\n", - " },\n", - " \"id\": \"toolu_01QCcxzRjojWW5JqQp7WTN82\",\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", - " }\n", - " },\n", - " ToolMessage {\n", - " \"id\": \"0bf52bcd-ffbd-4f82-9ee1-7ba2108f0d27\",\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", - " }\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", - " messages: [\n", - " HumanMessage {\n", - " \"id\": \"a80d5763-0f27-4a00-9e54-8a239b499ea1\",\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", - " \"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", - " },\n", - " {\n", - " \"type\": \"tool_use\",\n", - " \"id\": \"toolu_01RN181HAAL5BcnMXkexbA1r\",\n", - " \"name\": \"askHuman\",\n", - " \"input\": {\n", - " \"input\": \"Where are you located? Please provide your city and country.\"\n", - " }\n", - " }\n", - " ],\n", - " \"additional_kwargs\": {\n", - " \"id\": \"msg_01CsrDn46VqNXrdkpVHbcMKA\",\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\": 108\n", - " }\n", - " },\n", - " \"response_metadata\": {\n", - " \"id\": \"msg_01CsrDn46VqNXrdkpVHbcMKA\",\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", - " },\n", - " \"type\": \"message\",\n", - " \"role\": \"assistant\"\n", - " },\n", - " \"tool_calls\": [\n", - " {\n", - " \"name\": \"askHuman\",\n", - " \"args\": {\n", - " \"input\": \"Where are you located? Please provide your city and country.\"\n", - " },\n", - " \"id\": \"toolu_01RN181HAAL5BcnMXkexbA1r\",\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", - " \"additional_kwargs\": {},\n", - " \"response_metadata\": {},\n", - " \"tool_call_id\": \"toolu_01RN181HAAL5BcnMXkexbA1r\"\n", - " },\n", - " AIMessage {\n", - " \"id\": \"msg_017hfZ8kdhX5nKD97THKWpPx\",\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", - " },\n", - " {\n", - " \"type\": \"tool_use\",\n", - " \"id\": \"toolu_01QCcxzRjojWW5JqQp7WTN82\",\n", - " \"name\": \"search\",\n", - " \"input\": {\n", - " \"input\": \"current weather in San Francisco\"\n", - " }\n", - " }\n", - " ],\n", - " \"additional_kwargs\": {\n", - " \"id\": \"msg_017hfZ8kdhX5nKD97THKWpPx\",\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", - " }\n", - " },\n", - " \"response_metadata\": {\n", - " \"id\": \"msg_017hfZ8kdhX5nKD97THKWpPx\",\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", - " },\n", - " \"type\": \"message\",\n", - " \"role\": \"assistant\"\n", - " },\n", - " \"tool_calls\": [\n", - " {\n", - " \"name\": \"search\",\n", - " \"args\": {\n", - " \"input\": \"current weather in San Francisco\"\n", - " },\n", - " \"id\": \"toolu_01QCcxzRjojWW5JqQp7WTN82\",\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", - " }\n", - " },\n", - " ToolMessage {\n", - " \"id\": \"0bf52bcd-ffbd-4f82-9ee1-7ba2108f0d27\",\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", - " },\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", - " \"additional_kwargs\": {\n", - " \"id\": \"msg_01NuhYbiu36DSgW7brfoKMr8\",\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", - " }\n", - " },\n", - " \"response_metadata\": {\n", - " \"id\": \"msg_01NuhYbiu36DSgW7brfoKMr8\",\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", - " },\n", - " \"type\": \"message\",\n", - " \"role\": \"assistant\"\n", - " },\n", - " \"tool_calls\": [],\n", - " \"invalid_tool_calls\": [],\n", - " \"usage_metadata\": {\n", - " \"input_tokens\": 701,\n", - " \"output_tokens\": 121,\n", - " \"total_tokens\": 822\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" - ] + "cell_type": "markdown", + "id": "a75a1060-47aa-4cc6-8c41-e6ba2e9d7923", + "metadata": {}, + "source": [ + "We can see our feedback was added to state - " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "2b83e5ca-8497-43ca-bff7-7203e654c4d3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{ input: 'hello world', userFeedback: 'Go to step 3!!' }\n" + ] + } + ], + "source": [ + "(await graph.getState(config)).values" + ] + }, + { + "cell_type": "markdown", + "id": "e36f89e5", + "metadata": {}, + "source": [ + "## Agent\n", + "\n", + "In the context of agents, waiting for user feedback is useful to ask clarifying questions.\n", + " \n", + "To show this, we will build a relatively simple ReAct-style agent that does tool calling. \n", + "\n", + "We will use OpenAI and / or Anthropic's models and a fake tool (just for demo purposes)." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "f5319e01", + "metadata": {}, + "outputs": [], + "source": [ + "// 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 { ToolNode } from \"@langchain/langgraph/prebuilt\";\n", + "import { BaseMessage, AIMessage } from \"@langchain/core/messages\";\n", + "import { z } from \"zod\";\n", + "\n", + "const GraphMessagesState = 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", + " name: \"search\",\n", + " description: \"Call to surf the web.\",\n", + " schema: z.string(),\n", + "})\n", + "\n", + "const tools = [search]\n", + "const toolNode = new ToolNode(tools)\n", + "\n", + "// Set up the model\n", + "const model = new ChatAnthropic({ model: \"claude-3-5-sonnet-20240620\" })\n", + "\n", + "const askHumanTool = tool((_) => {\n", + " return \"The human said XYZ\";\n", + "}, {\n", + " name: \"askHuman\",\n", + " description: \"Ask the human for input.\",\n", + " schema: z.string(),\n", + "});\n", + "\n", + "\n", + "const modelWithTools = model.bindTools([...tools, askHumanTool])\n", + "\n", + "// Define nodes and conditional edges\n", + "\n", + "// Define the function that determines whether to continue or not\n", + "function shouldContinue(state: typeof GraphMessagesState.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", + " if (castLastMessage && !castLastMessage.tool_calls?.length) {\n", + " return END;\n", + " }\n", + " // If tool call is askHuman, we return that node\n", + " // You could also add logic here to let some system know that there's something that requires Human input\n", + " // For example, send a slack message, etc\n", + " if (castLastMessage.tool_calls?.[0]?.name === \"askHuman\") {\n", + " console.log(\"--- ASKING HUMAN ---\")\n", + " return \"askHuman\";\n", + " }\n", + " // Otherwise if it isn't, we continue with the action node\n", + " return \"action\";\n", + "}\n", + "\n", + "\n", + "// Define the function that calls the model\n", + "async function callModel(state: typeof GraphMessagesState.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", + " return { messages: [response] };\n", + "}\n", + "\n", + "\n", + "// We define a fake node to ask the human\n", + "function askHuman(state: typeof GraphMessagesState.State): Partial {\n", + " return state;\n", + "}\n", + "\n", + "// Define a new graph\n", + "const messagesWorkflow = new StateGraph(GraphMessagesState)\n", + " // Define the two nodes we will cycle between\n", + " .addNode(\"agent\", callModel)\n", + " .addNode(\"action\", toolNode)\n", + " .addNode(\"askHuman\", askHuman)\n", + " // We now add a conditional edge\n", + " .addConditionalEdges(\n", + " // First, we define the start node. We use `agent`.\n", + " // This means these are the edges taken after the `agent` node is called.\n", + " \"agent\",\n", + " // Next, we pass in the function that will determine which node is called next.\n", + " shouldContinue\n", + " )\n", + " // We now add a normal edge from `action` to `agent`.\n", + " // This means that after `action` is called, `agent` node is called next.\n", + " .addEdge(\"action\", \"agent\")\n", + " // After we get back the human response, we go back to the agent\n", + " .addEdge(\"askHuman\", \"agent\")\n", + " // Set the entrypoint as `agent`\n", + " // This means that this node is the first one called\n", + " .addEdge(START, \"agent\");\n", + "\n", + "\n", + "// Setup memory\n", + "const messagesMemory = new MemorySaver();\n", + "\n", + "// Finally, we compile it!\n", + "// This compiles it into a LangChain Runnable,\n", + "// 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, + "id": "4b816850", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import * as tslab from \"tslab\";\n", + "\n", + "const drawableGraph2 = messagesApp.getGraph();\n", + "const image2 = await drawableGraph2.drawMermaidPng();\n", + "const arrayBuffer2 = await image2.arrayBuffer();\n", + "\n", + "await tslab.display.png(new Uint8Array(arrayBuffer2));" + ] + }, + { + "cell_type": "markdown", + "id": "2a1b56c5-bd61-4192-8bdb-458a1e9f0159", + "metadata": {}, + "source": [ + "## Interacting with the Agent\n", + "\n", + "We can now interact with the agent. Let's ask it to ask the user where they are, then tell them the weather. \n", + "\n", + "This should make it use the `askHuman` tool first, then use the normal tool." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "cfd140f0-a5a6-4697-8115-322242f197b5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "================================ human Message (1) =================================\n", + "Use the search tool to ask the user where they are, then look up the weather there\n", + "--- ASKING HUMAN ---\n", + "================================ ai Message (1) =================================\n", + "[\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", + " },\n", + " {\n", + " type: 'tool_use',\n", + " id: 'toolu_01RN181HAAL5BcnMXkexbA1r',\n", + " name: 'askHuman',\n", + " input: {\n", + " input: 'Where are you located? Please provide your city and country.'\n", + " }\n", + " }\n", + "]\n", + "next: [ 'askHuman' ]\n" + ] + } + ], + "source": [ + "import { HumanMessage } from \"@langchain/core/messages\";\n", + "// Input\n", + "const inputs = new HumanMessage(\"Use the search tool to ask the user where they are, then look up the weather there\");\n", + "\n", + "// Thread\n", + "const config2 = { configurable: { thread_id: \"3\" }, streamMode: \"values\" as const };\n", + "\n", + "for await (const event of await messagesApp.stream({\n", + " messages: [inputs]\n", + "}, config2)) {\n", + " const recentMsg = event.messages[event.messages.length - 1];\n", + " console.log(`================================ ${recentMsg._getType()} Message (1) =================================`)\n", + " console.log(recentMsg.content);\n", + "}\n", + "\n", + "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", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "next before update state: [ 'askHuman' ]\n", + "next AFTER update state: [ 'agent' ]\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)" + ] + }, + { + "cell_type": "markdown", + "id": "6a30c9fb-2a40-45cc-87ba-406c11c9f0cf", + "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" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "a9f599b5-1a55-406b-a76b-f52b3ca06975", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{\n", + " messages: [\n", + " HumanMessage {\n", + " \"id\": \"a80d5763-0f27-4a00-9e54-8a239b499ea1\",\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", + " \"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", + " },\n", + " {\n", + " \"type\": \"tool_use\",\n", + " \"id\": \"toolu_01RN181HAAL5BcnMXkexbA1r\",\n", + " \"name\": \"askHuman\",\n", + " \"input\": {\n", + " \"input\": \"Where are you located? Please provide your city and country.\"\n", + " }\n", + " }\n", + " ],\n", + " \"additional_kwargs\": {\n", + " \"id\": \"msg_01CsrDn46VqNXrdkpVHbcMKA\",\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\": 108\n", + " }\n", + " },\n", + " \"response_metadata\": {\n", + " \"id\": \"msg_01CsrDn46VqNXrdkpVHbcMKA\",\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", + " },\n", + " \"type\": \"message\",\n", + " \"role\": \"assistant\"\n", + " },\n", + " \"tool_calls\": [\n", + " {\n", + " \"name\": \"askHuman\",\n", + " \"args\": {\n", + " \"input\": \"Where are you located? Please provide your city and country.\"\n", + " },\n", + " \"id\": \"toolu_01RN181HAAL5BcnMXkexbA1r\",\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", + " \"additional_kwargs\": {},\n", + " \"response_metadata\": {},\n", + " \"tool_call_id\": \"toolu_01RN181HAAL5BcnMXkexbA1r\"\n", + " },\n", + " AIMessage {\n", + " \"id\": \"msg_017hfZ8kdhX5nKD97THKWpPx\",\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", + " },\n", + " {\n", + " \"type\": \"tool_use\",\n", + " \"id\": \"toolu_01QCcxzRjojWW5JqQp7WTN82\",\n", + " \"name\": \"search\",\n", + " \"input\": {\n", + " \"input\": \"current weather in San Francisco\"\n", + " }\n", + " }\n", + " ],\n", + " \"additional_kwargs\": {\n", + " \"id\": \"msg_017hfZ8kdhX5nKD97THKWpPx\",\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", + " }\n", + " },\n", + " \"response_metadata\": {\n", + " \"id\": \"msg_017hfZ8kdhX5nKD97THKWpPx\",\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", + " },\n", + " \"type\": \"message\",\n", + " \"role\": \"assistant\"\n", + " },\n", + " \"tool_calls\": [\n", + " {\n", + " \"name\": \"search\",\n", + " \"args\": {\n", + " \"input\": \"current weather in San Francisco\"\n", + " },\n", + " \"id\": \"toolu_01QCcxzRjojWW5JqQp7WTN82\",\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", + " }\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", + " messages: [\n", + " HumanMessage {\n", + " \"id\": \"a80d5763-0f27-4a00-9e54-8a239b499ea1\",\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", + " \"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", + " },\n", + " {\n", + " \"type\": \"tool_use\",\n", + " \"id\": \"toolu_01RN181HAAL5BcnMXkexbA1r\",\n", + " \"name\": \"askHuman\",\n", + " \"input\": {\n", + " \"input\": \"Where are you located? Please provide your city and country.\"\n", + " }\n", + " }\n", + " ],\n", + " \"additional_kwargs\": {\n", + " \"id\": \"msg_01CsrDn46VqNXrdkpVHbcMKA\",\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\": 108\n", + " }\n", + " },\n", + " \"response_metadata\": {\n", + " \"id\": \"msg_01CsrDn46VqNXrdkpVHbcMKA\",\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", + " },\n", + " \"type\": \"message\",\n", + " \"role\": \"assistant\"\n", + " },\n", + " \"tool_calls\": [\n", + " {\n", + " \"name\": \"askHuman\",\n", + " \"args\": {\n", + " \"input\": \"Where are you located? Please provide your city and country.\"\n", + " },\n", + " \"id\": \"toolu_01RN181HAAL5BcnMXkexbA1r\",\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", + " \"additional_kwargs\": {},\n", + " \"response_metadata\": {},\n", + " \"tool_call_id\": \"toolu_01RN181HAAL5BcnMXkexbA1r\"\n", + " },\n", + " AIMessage {\n", + " \"id\": \"msg_017hfZ8kdhX5nKD97THKWpPx\",\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", + " },\n", + " {\n", + " \"type\": \"tool_use\",\n", + " \"id\": \"toolu_01QCcxzRjojWW5JqQp7WTN82\",\n", + " \"name\": \"search\",\n", + " \"input\": {\n", + " \"input\": \"current weather in San Francisco\"\n", + " }\n", + " }\n", + " ],\n", + " \"additional_kwargs\": {\n", + " \"id\": \"msg_017hfZ8kdhX5nKD97THKWpPx\",\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", + " }\n", + " },\n", + " \"response_metadata\": {\n", + " \"id\": \"msg_017hfZ8kdhX5nKD97THKWpPx\",\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", + " },\n", + " \"type\": \"message\",\n", + " \"role\": \"assistant\"\n", + " },\n", + " \"tool_calls\": [\n", + " {\n", + " \"name\": \"search\",\n", + " \"args\": {\n", + " \"input\": \"current weather in San Francisco\"\n", + " },\n", + " \"id\": \"toolu_01QCcxzRjojWW5JqQp7WTN82\",\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", + " }\n", + " },\n", + " ToolMessage {\n", + " \"id\": \"0bf52bcd-ffbd-4f82-9ee1-7ba2108f0d27\",\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", + " }\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", + " messages: [\n", + " HumanMessage {\n", + " \"id\": \"a80d5763-0f27-4a00-9e54-8a239b499ea1\",\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", + " \"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", + " },\n", + " {\n", + " \"type\": \"tool_use\",\n", + " \"id\": \"toolu_01RN181HAAL5BcnMXkexbA1r\",\n", + " \"name\": \"askHuman\",\n", + " \"input\": {\n", + " \"input\": \"Where are you located? Please provide your city and country.\"\n", + " }\n", + " }\n", + " ],\n", + " \"additional_kwargs\": {\n", + " \"id\": \"msg_01CsrDn46VqNXrdkpVHbcMKA\",\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\": 108\n", + " }\n", + " },\n", + " \"response_metadata\": {\n", + " \"id\": \"msg_01CsrDn46VqNXrdkpVHbcMKA\",\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", + " },\n", + " \"type\": \"message\",\n", + " \"role\": \"assistant\"\n", + " },\n", + " \"tool_calls\": [\n", + " {\n", + " \"name\": \"askHuman\",\n", + " \"args\": {\n", + " \"input\": \"Where are you located? Please provide your city and country.\"\n", + " },\n", + " \"id\": \"toolu_01RN181HAAL5BcnMXkexbA1r\",\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", + " \"additional_kwargs\": {},\n", + " \"response_metadata\": {},\n", + " \"tool_call_id\": \"toolu_01RN181HAAL5BcnMXkexbA1r\"\n", + " },\n", + " AIMessage {\n", + " \"id\": \"msg_017hfZ8kdhX5nKD97THKWpPx\",\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", + " },\n", + " {\n", + " \"type\": \"tool_use\",\n", + " \"id\": \"toolu_01QCcxzRjojWW5JqQp7WTN82\",\n", + " \"name\": \"search\",\n", + " \"input\": {\n", + " \"input\": \"current weather in San Francisco\"\n", + " }\n", + " }\n", + " ],\n", + " \"additional_kwargs\": {\n", + " \"id\": \"msg_017hfZ8kdhX5nKD97THKWpPx\",\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", + " }\n", + " },\n", + " \"response_metadata\": {\n", + " \"id\": \"msg_017hfZ8kdhX5nKD97THKWpPx\",\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", + " },\n", + " \"type\": \"message\",\n", + " \"role\": \"assistant\"\n", + " },\n", + " \"tool_calls\": [\n", + " {\n", + " \"name\": \"search\",\n", + " \"args\": {\n", + " \"input\": \"current weather in San Francisco\"\n", + " },\n", + " \"id\": \"toolu_01QCcxzRjojWW5JqQp7WTN82\",\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", + " }\n", + " },\n", + " ToolMessage {\n", + " \"id\": \"0bf52bcd-ffbd-4f82-9ee1-7ba2108f0d27\",\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", + " },\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", + " \"additional_kwargs\": {\n", + " \"id\": \"msg_01NuhYbiu36DSgW7brfoKMr8\",\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", + " }\n", + " },\n", + " \"response_metadata\": {\n", + " \"id\": \"msg_01NuhYbiu36DSgW7brfoKMr8\",\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", + " },\n", + " \"type\": \"message\",\n", + " \"role\": \"assistant\"\n", + " },\n", + " \"tool_calls\": [],\n", + " \"invalid_tool_calls\": [],\n", + " \"usage_metadata\": {\n", + " \"input_tokens\": 701,\n", + " \"output_tokens\": 121,\n", + " \"total_tokens\": 822\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" + ] + } + ], + "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", + "}" + ] + } + ], + "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" } - ], - "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", - "}" - ] - } - ], - "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 -} + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file diff --git a/examples/quickstart.ipynb b/examples/quickstart.ipynb index c920ede4..c8f28d84 100644 --- a/examples/quickstart.ipynb +++ b/examples/quickstart.ipynb @@ -1,285 +1,285 @@ { - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Quickstart\n", - "\n", - "In this quickstart guide, you'll get up and running with a simple agent that can\n", - "search the web using [Tavily Search API](https://tavily.com/). The code is fully\n", - "configurable, meaning you can swap out components, customize the execution flow,\n", - "and extend to add any custom code or tooling.\n", - "\n", - "First install the required dependencies:\n", - "\n", - "```bash\n", - "npm install @langchain/langgraph @langchain/openai @langchain/community\n", - "```\n", - "\n", - "Then set the required environment variables. Optionally, set up\n", - "[LangSmith](https://docs.smith.langchain.com/) for best-in-class observability:" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "// process.env.OPENAI_API_KEY = \"sk_...\";\n", - "// process.env.TAVILY_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 = \"Quickstart: LangGraphJS\";\n" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ + "cells": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "The current weather in San Francisco is as follows:\n", - "- Temperature: 82.0°F (27.8°C)\n", - "- Condition: Sunny\n", - "- Wind: 11.9 mph from the NW\n", - "- Humidity: 41%\n", - "- Pressure: 29.98 in\n", - "- Visibility: 9.0 miles\n", - "- UV Index: 6.0\n", - "\n", - "For more details, you can visit [Weather in San Francisco](https://www.weatherapi.com/).\n", - "The current weather in New York is as follows:\n", - "- Temperature: 84.0°F (28.9°C)\n", - "- Condition: Sunny\n", - "- Wind: 2.2 mph from SSE\n", - "- Humidity: 57%\n", - "- Pressure: 29.89 in\n", - "- Precipitation: 0.01 in\n", - "- Visibility: 9.0 miles\n", - "- UV Index: 6.0\n", - "\n", - "For more details, you can visit [Weather in New York](https://www.weatherapi.com/).\n" - ] - } - ], - "source": [ - "import { TavilySearchResults } from \"@langchain/community/tools/tavily_search\";\n", - "import { ChatOpenAI } from \"@langchain/openai\";\n", - "import { MemorySaver } from \"@langchain/langgraph\";\n", - "import { HumanMessage } from \"@langchain/core/messages\";\n", - "import { createReactAgent } from \"@langchain/langgraph/prebuilt\";\n", - "\n", - "// Define the tools for the agent to use\n", - "const agentTools = [new TavilySearchResults({ maxResults: 3 })];\n", - "const agentModel = new ChatOpenAI({ temperature: 0 });\n", - "\n", - "// Initialize memory to persist state between graph runs\n", - "const agentCheckpointer = new MemorySaver();\n", - "const agent = createReactAgent({\n", - " llm: agentModel,\n", - " tools: agentTools,\n", - " checkpointSaver: agentCheckpointer,\n", - "});\n", - "\n", - "// Now it's time to use!\n", - "const agentFinalState = await agent.invoke(\n", - " { messages: [new HumanMessage(\"what is the current weather in sf\")] },\n", - " { configurable: { thread_id: \"42\" } },\n", - ");\n", - "\n", - "console.log(\n", - " agentFinalState.messages[agentFinalState.messages.length - 1].content,\n", - ");\n", - "\n", - "const agentNextState = await agent.invoke(\n", - " { messages: [new HumanMessage(\"what about ny\")] },\n", - " { configurable: { thread_id: \"42\" } },\n", - ");\n", - "\n", - "console.log(\n", - " agentNextState.messages[agentNextState.messages.length - 1].content,\n", - ");" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## How does it work?\n", - "\n", - "The\n", - "[createReactAgent](https://langchain-ai.github.io/langgraphjs/reference/functions/langgraph_prebuilt.createReactAgent.html)\n", - "constructor lets you create a simple tool-using LangGraph agent in a single line\n", - "of code. Here's a visual representation of the graph:" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Quickstart\n", + "\n", + "In this quickstart guide, you'll get up and running with a simple agent that can\n", + "search the web using [Tavily Search API](https://tavily.com/). The code is fully\n", + "configurable, meaning you can swap out components, customize the execution flow,\n", + "and extend to add any custom code or tooling.\n", + "\n", + "First install the required dependencies:\n", + "\n", + "```bash\n", + "npm install @langchain/langgraph @langchain/openai @langchain/community\n", + "```\n", + "\n", + "Then set the required environment variables. Optionally, set up\n", + "[LangSmith](https://docs.smith.langchain.com/) for best-in-class observability:" + ] + }, { - "data": { - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import * as tslab from \"tslab\";\n", - "\n", - "const graph = agent.getGraph();\n", - "const image = await graph.drawMermaidPng();\n", - "const arrayBuffer = await image.arrayBuffer();\n", - "\n", - "await tslab.display.png(new Uint8Array(arrayBuffer));" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "This can be powerful, but what makes LangGraph powerful is that you can fully\n", - "decompose the agent for finer-grained control over its behavior. The following\n", - "code creates an agent with the same behavior as the example above, but you can\n", - "clearly see the execution logic and how you could customize it." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "// process.env.OPENAI_API_KEY = \"sk_...\";\n", + "// process.env.TAVILY_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 = \"Quickstart: LangGraphJS\";\n" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "The current weather in San Francisco is partly cloudy with a temperature of 72.0°F (22.2°C). The wind speed is 31.0 km/h coming from the west. The humidity is at 64%, and the visibility is 16.0 km.\n", - "The current weather in New York is partly cloudy with a temperature of 73.9°F (23.3°C). The wind speed is 3.6 km/h coming from the west-northwest. The humidity is at 38%, and the visibility is 16.0 km.\n" - ] + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The current weather in San Francisco is as follows:\n", + "- Temperature: 82.0°F (27.8°C)\n", + "- Condition: Sunny\n", + "- Wind: 11.9 mph from the NW\n", + "- Humidity: 41%\n", + "- Pressure: 29.98 in\n", + "- Visibility: 9.0 miles\n", + "- UV Index: 6.0\n", + "\n", + "For more details, you can visit [Weather in San Francisco](https://www.weatherapi.com/).\n", + "The current weather in New York is as follows:\n", + "- Temperature: 84.0°F (28.9°C)\n", + "- Condition: Sunny\n", + "- Wind: 2.2 mph from SSE\n", + "- Humidity: 57%\n", + "- Pressure: 29.89 in\n", + "- Precipitation: 0.01 in\n", + "- Visibility: 9.0 miles\n", + "- UV Index: 6.0\n", + "\n", + "For more details, you can visit [Weather in New York](https://www.weatherapi.com/).\n" + ] + } + ], + "source": [ + "import { TavilySearchResults } from \"@langchain/community/tools/tavily_search\";\n", + "import { ChatOpenAI } from \"@langchain/openai\";\n", + "import { MemorySaver } from \"@langchain/langgraph\";\n", + "import { HumanMessage } from \"@langchain/core/messages\";\n", + "import { createReactAgent } from \"@langchain/langgraph/prebuilt\";\n", + "\n", + "// Define the tools for the agent to use\n", + "const agentTools = [new TavilySearchResults({ maxResults: 3 })];\n", + "const agentModel = new ChatOpenAI({ temperature: 0 });\n", + "\n", + "// Initialize memory to persist state between graph runs\n", + "const agentCheckpointer = new MemorySaver();\n", + "const agent = createReactAgent({\n", + " llm: agentModel,\n", + " tools: agentTools,\n", + " checkpointSaver: agentCheckpointer,\n", + "});\n", + "\n", + "// Now it's time to use!\n", + "const agentFinalState = await agent.invoke(\n", + " { messages: [new HumanMessage(\"what is the current weather in sf\")] },\n", + " { configurable: { thread_id: \"42\" } },\n", + ");\n", + "\n", + "console.log(\n", + " agentFinalState.messages[agentFinalState.messages.length - 1].content,\n", + ");\n", + "\n", + "const agentNextState = await agent.invoke(\n", + " { messages: [new HumanMessage(\"what about ny\")] },\n", + " { configurable: { thread_id: \"42\" } },\n", + ");\n", + "\n", + "console.log(\n", + " agentNextState.messages[agentNextState.messages.length - 1].content,\n", + ");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## How does it work?\n", + "\n", + "The\n", + "[createReactAgent](/langgraphjs/reference/functions/langgraph_prebuilt.createReactAgent.html)\n", + "constructor lets you create a simple tool-using LangGraph agent in a single line\n", + "of code. Here's a visual representation of the graph:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import * as tslab from \"tslab\";\n", + "\n", + "const graph = agent.getGraph();\n", + "const image = await graph.drawMermaidPng();\n", + "const arrayBuffer = await image.arrayBuffer();\n", + "\n", + "await tslab.display.png(new Uint8Array(arrayBuffer));" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This can be powerful, but what makes LangGraph powerful is that you can fully\n", + "decompose the agent for finer-grained control over its behavior. The following\n", + "code creates an agent with the same behavior as the example above, but you can\n", + "clearly see the execution logic and how you could customize it." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The current weather in San Francisco is partly cloudy with a temperature of 72.0°F (22.2°C). The wind speed is 31.0 km/h coming from the west. The humidity is at 64%, and the visibility is 16.0 km.\n", + "The current weather in New York is partly cloudy with a temperature of 73.9°F (23.3°C). The wind speed is 3.6 km/h coming from the west-northwest. The humidity is at 38%, and the visibility is 16.0 km.\n" + ] + } + ], + "source": [ + "import { TavilySearchResults } from \"@langchain/community/tools/tavily_search\";\n", + "import { ChatOpenAI } from \"@langchain/openai\";\n", + "import { MemorySaver } from \"@langchain/langgraph\";\n", + "import { HumanMessage, BaseMessage } from \"@langchain/core/messages\";\n", + "import { ToolNode } from \"@langchain/langgraph/prebuilt\";\n", + "import { END, START, StateGraph, Annotation } from \"@langchain/langgraph\";\n", + "\n", + "// Define the graph state\n", + "const GraphAnnotation = Annotation.Root({\n", + " messages: Annotation({\n", + " reducer: (state, update) => state.concat(update),\n", + " default: () => [],\n", + " })\n", + "})\n", + "\n", + "// Define the tools for the agent to use\n", + "const tools = [new TavilySearchResults({ maxResults: 3 })];\n", + "\n", + "const toolNode = new ToolNode(tools);\n", + "\n", + "const model = new ChatOpenAI({ temperature: 0 }).bindTools(tools);\n", + "\n", + "// Define the function that determines whether to continue or not\n", + "function shouldContinue(state: typeof GraphAnnotation.State): \"tools\" | typeof END {\n", + " const messages = state.messages;\n", + "\n", + " const lastMessage = messages[messages.length - 1];\n", + "\n", + " // If the LLM makes a tool call, then we route to the \"tools\" node\n", + " if (lastMessage.additional_kwargs.tool_calls) {\n", + " return \"tools\";\n", + " }\n", + " // Otherwise, we stop (reply to the user)\n", + " return END;\n", + "}\n", + "\n", + "// Define the function that calls the model\n", + "async function callModel(state: typeof GraphAnnotation.State) {\n", + " const messages = state.messages;\n", + "\n", + " const response = await model.invoke(messages);\n", + "\n", + " // We return a list, because this will get added to the existing list\n", + " return { messages: [response] };\n", + "}\n", + "\n", + "// Define a new graph\n", + "const workflow = new StateGraph(GraphAnnotation)\n", + " .addNode(\"agent\", callModel)\n", + " .addNode(\"tools\", toolNode)\n", + " .addEdge(START, \"agent\")\n", + " .addConditionalEdges(\"agent\", shouldContinue)\n", + " .addEdge(\"tools\", \"agent\");\n", + "\n", + "// Initialize memory to persist state between graph runs\n", + "const checkpointer = new MemorySaver();\n", + "\n", + "// Finally, we compile it!\n", + "// This compiles it into a LangChain Runnable.\n", + "// Note that we're (optionally) passing the memory when compiling the graph\n", + "const app = workflow.compile({ checkpointer });\n", + "\n", + "// Use the agent\n", + "const finalState = await app.invoke(\n", + " { messages: [new HumanMessage(\"what is the weather in sf\")] },\n", + " { configurable: { thread_id: \"42\" } },\n", + ");\n", + "\n", + "console.log(finalState.messages[finalState.messages.length - 1].content);\n", + "\n", + "const nextState = await app.invoke(\n", + " { messages: [new HumanMessage(\"what about ny\")] },\n", + " { configurable: { thread_id: \"42\" } },\n", + ");\n", + "\n", + "console.log(nextState.messages[nextState.messages.length - 1].content);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Next Steps\n", + "\n", + "Now that you've created a custom agent, check out the\n", + "[tutorials](/langgraphjs/tutorials/) to learn\n", + "LangGraph by implementing different types of end-to-end workflows from RAG to\n", + "multi-agent swarms, or consult the\n", + "[how-to guides](/langgraphjs/how-tos/) for more\n", + "examples of how to implement different design patterns." + ] + } + ], + "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" } - ], - "source": [ - "import { TavilySearchResults } from \"@langchain/community/tools/tavily_search\";\n", - "import { ChatOpenAI } from \"@langchain/openai\";\n", - "import { MemorySaver } from \"@langchain/langgraph\";\n", - "import { HumanMessage, BaseMessage } from \"@langchain/core/messages\";\n", - "import { ToolNode } from \"@langchain/langgraph/prebuilt\";\n", - "import { END, START, StateGraph, Annotation } from \"@langchain/langgraph\";\n", - "\n", - "// Define the graph state\n", - "const GraphAnnotation = Annotation.Root({\n", - " messages: Annotation({\n", - " reducer: (state, update) => state.concat(update),\n", - " default: () => [],\n", - " })\n", - "})\n", - "\n", - "// Define the tools for the agent to use\n", - "const tools = [new TavilySearchResults({ maxResults: 3 })];\n", - "\n", - "const toolNode = new ToolNode(tools);\n", - "\n", - "const model = new ChatOpenAI({ temperature: 0 }).bindTools(tools);\n", - "\n", - "// Define the function that determines whether to continue or not\n", - "function shouldContinue(state: typeof GraphAnnotation.State): \"tools\" | typeof END {\n", - " const messages = state.messages;\n", - "\n", - " const lastMessage = messages[messages.length - 1];\n", - "\n", - " // If the LLM makes a tool call, then we route to the \"tools\" node\n", - " if (lastMessage.additional_kwargs.tool_calls) {\n", - " return \"tools\";\n", - " }\n", - " // Otherwise, we stop (reply to the user)\n", - " return END;\n", - "}\n", - "\n", - "// Define the function that calls the model\n", - "async function callModel(state: typeof GraphAnnotation.State) {\n", - " const messages = state.messages;\n", - "\n", - " const response = await model.invoke(messages);\n", - "\n", - " // We return a list, because this will get added to the existing list\n", - " return { messages: [response] };\n", - "}\n", - "\n", - "// Define a new graph\n", - "const workflow = new StateGraph(GraphAnnotation)\n", - " .addNode(\"agent\", callModel)\n", - " .addNode(\"tools\", toolNode)\n", - " .addEdge(START, \"agent\")\n", - " .addConditionalEdges(\"agent\", shouldContinue)\n", - " .addEdge(\"tools\", \"agent\");\n", - "\n", - "// Initialize memory to persist state between graph runs\n", - "const checkpointer = new MemorySaver();\n", - "\n", - "// Finally, we compile it!\n", - "// This compiles it into a LangChain Runnable.\n", - "// Note that we're (optionally) passing the memory when compiling the graph\n", - "const app = workflow.compile({ checkpointer });\n", - "\n", - "// Use the agent\n", - "const finalState = await app.invoke(\n", - " { messages: [new HumanMessage(\"what is the weather in sf\")] },\n", - " { configurable: { thread_id: \"42\" } },\n", - ");\n", - "\n", - "console.log(finalState.messages[finalState.messages.length - 1].content);\n", - "\n", - "const nextState = await app.invoke(\n", - " { messages: [new HumanMessage(\"what about ny\")] },\n", - " { configurable: { thread_id: \"42\" } },\n", - ");\n", - "\n", - "console.log(nextState.messages[nextState.messages.length - 1].content);" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Next Steps\n", - "\n", - "Now that you've created a custom agent, check out the\n", - "[tutorials](https://langchain-ai.github.io/langgraphjs/tutorials/) to learn\n", - "LangGraph by implementing different types of end-to-end workflows from RAG to\n", - "multi-agent swarms, or consult the\n", - "[how-to guides](https://langchain-ai.github.io/langgraphjs/how-tos/) for more\n", - "examples of how to implement different design patterns." - ] - } - ], - "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": 2 -} + "nbformat": 4, + "nbformat_minor": 2 +} \ No newline at end of file