From 2d6ddd0a1d77f96342a0705d0cc68d01f4be6d64 Mon Sep 17 00:00:00 2001 From: vbarda Date: Thu, 21 Nov 2024 14:30:23 -0500 Subject: [PATCH 01/31] langgraph: fix issue w/ type annotations in tools_condition --- libs/langgraph/langgraph/prebuilt/tool_node.py | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/libs/langgraph/langgraph/prebuilt/tool_node.py b/libs/langgraph/langgraph/prebuilt/tool_node.py index cdcbdd8192..3c43bfba84 100644 --- a/libs/langgraph/langgraph/prebuilt/tool_node.py +++ b/libs/langgraph/langgraph/prebuilt/tool_node.py @@ -1,11 +1,8 @@ -from __future__ import annotations - import asyncio import inspect import json from copy import copy from typing import ( - TYPE_CHECKING, Any, Callable, Dict, @@ -35,15 +32,13 @@ from langchain_core.tools import BaseTool, InjectedToolArg from langchain_core.tools import tool as create_tool from langchain_core.tools.base import get_all_basemodel_annotations +from pydantic import BaseModel from typing_extensions import Annotated, get_args, get_origin from langgraph.errors import GraphInterrupt from langgraph.store.base import BaseStore from langgraph.utils.runnable import RunnableCallable -if TYPE_CHECKING: - from pydantic import BaseModel - INVALID_TOOL_NAME_ERROR_TEMPLATE = ( "Error: {requested_tool} is not a valid tool, try one of [{available_tools}]." ) From 416dfe95da68065b26e755c93b2bd1433c5ea9f6 Mon Sep 17 00:00:00 2001 From: Eugene Yurtsev Date: Fri, 22 Nov 2024 13:16:41 -0500 Subject: [PATCH 02/31] qxqx --- docs/docs/concepts/template_applications.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/docs/docs/concepts/template_applications.md b/docs/docs/concepts/template_applications.md index df8bc5e63a..6217559616 100644 --- a/docs/docs/concepts/template_applications.md +++ b/docs/docs/concepts/template_applications.md @@ -6,7 +6,8 @@ Templates are open source reference applications designed to help you get started quickly when building with LangGraph. They provide working examples of common agentic workflows that can be customized to your needs. -Templates can be accessed via [LangGraph Studio (macOS only)](langgraph_studio.md), or cloned directly from Github. You can download LangGraph Studio and see available templates [here](https://studio.langchain.com/). +You can create an application from a template using the LangGraph CLI. + ## Available templates From 05791f5dfc5804a5022549cf10a60d86568da2de Mon Sep 17 00:00:00 2001 From: Eugene Yurtsev Date: Fri, 22 Nov 2024 13:26:46 -0500 Subject: [PATCH 03/31] qxqx --- docs/docs/concepts/template_applications.md | 27 ++++++++++++++++++--- docs/docs/tutorials/index.md | 1 + 2 files changed, 24 insertions(+), 4 deletions(-) diff --git a/docs/docs/concepts/template_applications.md b/docs/docs/concepts/template_applications.md index 6217559616..366237e1d4 100644 --- a/docs/docs/concepts/template_applications.md +++ b/docs/docs/concepts/template_applications.md @@ -1,9 +1,5 @@ # Template Applications -!!! note Prerequisites - - - [LangGraph Studio](./langgraph_studio.md) - Templates are open source reference applications designed to help you get started quickly when building with LangGraph. They provide working examples of common agentic workflows that can be customized to your needs. You can create an application from a template using the LangGraph CLI. @@ -18,3 +14,26 @@ You can create an application from a template using the LangGraph CLI. | **Memory Agent** | A ReAct-style agent with an additional tool to store memories for use across threads. | [Repo](https://github.com/langchain-ai/memory-agent) | [Repo](https://github.com/langchain-ai/memory-agent-js) | | **Retrieval Agent** | An agent that includes a retrieval-based question-answering system. | [Repo](https://github.com/langchain-ai/retrieval-agent-template) | [Repo](https://github.com/langchain-ai/retrieval-agent-template-js) | | **Data-Enrichment Agent** | An agent that performs web searches and organizes its findings into a structured format. | [Repo](https://github.com/langchain-ai/data-enrichment) | [Repo](https://github.com/langchain-ai/data-enrichment-js) | + + + +## 🌱 Create a LangGraph App + +To create a new app from a template, use the `langgraph new` command. This command will create a new directory with the specified template. + +```shell + +This is a quick start guide to help you get a LangGraph app up and running locally. + +!!! info "Requirements" + + - [LangGraph CLI](https://langchain-ai.github.io/langgraph/cloud/reference/cli/): Requires langchain-cli[inmem] >= 0.1.58 + +## Install the LangGraph CLI + +```bash +pip install "langgraph-cli[inmem]==0.1.58" python-dot-env +``` + + + diff --git a/docs/docs/tutorials/index.md b/docs/docs/tutorials/index.md index d9593c9b8e..2605c282ec 100644 --- a/docs/docs/tutorials/index.md +++ b/docs/docs/tutorials/index.md @@ -13,6 +13,7 @@ New to LangGraph or LLM app development? Read this material to get up and runnin - [LangGraph Quickstart](introduction.ipynb): Build a chatbot that can use tools and keep track of conversation history. Add human-in-the-loop capabilities and explore how time-travel works. - [LangGraph Server Quickstart](langgraph-platform/local-server.md): Launch a LangGraph server locally and interact with it using the REST API and LangGraph Studio Web UI. - [LangGraph Cloud QuickStart](../cloud/quick_start.md): Deploy a LangGraph app using LangGraph Cloud. +- [Start from a ](../concepts/template_applications.md): Use a template to quickly create a new LangGraph application. ## Use cases 🛠️ From f122ae2eb16d2bd36b6518e1008fb48fa4f79004 Mon Sep 17 00:00:00 2001 From: Eugene Yurtsev Date: Fri, 22 Nov 2024 14:20:56 -0500 Subject: [PATCH 04/31] qxqx --- docs/docs/how-tos/deploy-self-hosted.md | 2 +- docs/docs/tutorials/langgraph-platform/local-server.md | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/docs/how-tos/deploy-self-hosted.md b/docs/docs/how-tos/deploy-self-hosted.md index 88d7c72e43..d0d3a3efe3 100644 --- a/docs/docs/how-tos/deploy-self-hosted.md +++ b/docs/docs/how-tos/deploy-self-hosted.md @@ -74,7 +74,7 @@ If you want to run this quickly without setting up a separate Redis and Postgres * You need to replace `my-image` with the name of the image you built in the previous step (from `langgraph build`). and you should provide appropriate values for `REDIS_URI`, `DATABASE_URI`, and `LANGSMITH_API_KEY`. * If your application requires additional environment variables, you can pass them in a similar way. - * If using [Self-Hosted Enterprise](../concepts/deployment_options.md#self-hosted-enterprise, you must provide `LANGGRAPH_CLOUD_LICENSE_KEY` as an additional environment variable. + * If using [Self-Hosted Enterprise](../concepts/deployment_options.md#self-hosted-enterprise), you must provide `LANGGRAPH_CLOUD_LICENSE_KEY` as an additional environment variable. ### Using Docker Compose diff --git a/docs/docs/tutorials/langgraph-platform/local-server.md b/docs/docs/tutorials/langgraph-platform/local-server.md index a413339210..22754c4715 100644 --- a/docs/docs/tutorials/langgraph-platform/local-server.md +++ b/docs/docs/tutorials/langgraph-platform/local-server.md @@ -9,7 +9,7 @@ This is a quick start guide to help you get a LangGraph app up and running local ## Install the LangGraph CLI ```bash -pip install "langgraph-cli[inmem]==0.1.58" python-dot-env +pip install "langgraph-cli[inmem]==0.1.58" python-dotenv ``` ## 🌱 Create a LangGraph App @@ -241,4 +241,4 @@ Access detailed documentation for development and API usage: - **[LangGraph Server API Reference](../../cloud/reference/api/api_ref.html)**: Explore the LangGraph Server API documentation. - **[Python SDK Reference](../../cloud/reference/sdk/python_sdk_ref.md)**: Explore the Python SDK API Reference. -- **[JS/TS SDK Reference](../../cloud/reference/sdk/js_ts_sdk_ref.md)**: Explore the Python SDK API Reference. \ No newline at end of file +- **[JS/TS SDK Reference](../../cloud/reference/sdk/js_ts_sdk_ref.md)**: Explore the Python SDK API Reference. From c1c2ce8f1be240f02b6deec1d508be550124e4f2 Mon Sep 17 00:00:00 2001 From: Eugene Yurtsev Date: Fri, 22 Nov 2024 14:42:36 -0500 Subject: [PATCH 05/31] x --- docs/docs/concepts/template_applications.md | 43 ++++++++++++++++----- docs/docs/tutorials/index.md | 2 +- 2 files changed, 34 insertions(+), 11 deletions(-) diff --git a/docs/docs/concepts/template_applications.md b/docs/docs/concepts/template_applications.md index 366237e1d4..1bed86a324 100644 --- a/docs/docs/concepts/template_applications.md +++ b/docs/docs/concepts/template_applications.md @@ -4,8 +4,18 @@ Templates are open source reference applications designed to help you get starte You can create an application from a template using the LangGraph CLI. +!!! info "Requirements" -## Available templates + - Python >= 3.11 + - [LangGraph CLI](https://langchain-ai.github.io/langgraph/cloud/reference/cli/): Requires langchain-cli[inmem] >= 0.1.58 + +## Install the LangGraph CLI + +```bash +pip install "langgraph-cli[inmem]==0.1.58" python-dotenv +``` + +## Available Templates | Template | Description | Python | JS/TS | |---------------------------|------------------------------------------------------------------------------------------|------------------------------------------------------------------|---------------------------------------------------------------------| @@ -16,24 +26,37 @@ You can create an application from a template using the LangGraph CLI. | **Data-Enrichment Agent** | An agent that performs web searches and organizes its findings into a structured format. | [Repo](https://github.com/langchain-ai/data-enrichment) | [Repo](https://github.com/langchain-ai/data-enrichment-js) | - ## 🌱 Create a LangGraph App -To create a new app from a template, use the `langgraph new` command. This command will create a new directory with the specified template. +To create a new app from a template, use the `langgraph new` command. -```shell +```bash +langgraph new +``` -This is a quick start guide to help you get a LangGraph app up and running locally. +## Next Steps -!!! info "Requirements" +Review the `README.md` file in the root of your new LangGraph app for more information about the template and how to customize it. - - [LangGraph CLI](https://langchain-ai.github.io/langgraph/cloud/reference/cli/): Requires langchain-cli[inmem] >= 0.1.58 - -## Install the LangGraph CLI +After configuring the app properly and adding your API keys, you can start the app using the LangGraph CLI: ```bash -pip install "langgraph-cli[inmem]==0.1.58" python-dot-env +langgraph dev ``` +See the following guides for more information on how to deploy your app: + +- **[Launch Local LangGraph Server](../tutorials/langgraph-platform/local-server.md)**: This quick start guide shows how to start a LangGraph Server locally for the **ReAct Agent** template. The steps are similar for other templates. +- **[Deploy to LangGraph Cloud](../cloud/quick_start.md)**: Deploy your LangGraph app using LangGraph Cloud. + +### LangGraph Framework + +- **[LangGraph Concepts](../../concepts)**: Learn the foundational concepts of LangGraph. +- **[LangGraph How-to Guides](../../how-tos)**: Guides for common tasks with LangGraph. + +### 📚 Learn More about LangGraph Platform +Expand your knowledge with these resources: +- **[LangGraph Platform Concepts](../concepts/index.md#langgraph-platform)**: Understand the foundational concepts of the LangGraph Platform. +- **[LangGraph Platform How-to Guides](../how-tos/index.md#langgraph-platform)**: Discover step-by-step guides to build and deploy applications. diff --git a/docs/docs/tutorials/index.md b/docs/docs/tutorials/index.md index 2605c282ec..286137479c 100644 --- a/docs/docs/tutorials/index.md +++ b/docs/docs/tutorials/index.md @@ -13,7 +13,7 @@ New to LangGraph or LLM app development? Read this material to get up and runnin - [LangGraph Quickstart](introduction.ipynb): Build a chatbot that can use tools and keep track of conversation history. Add human-in-the-loop capabilities and explore how time-travel works. - [LangGraph Server Quickstart](langgraph-platform/local-server.md): Launch a LangGraph server locally and interact with it using the REST API and LangGraph Studio Web UI. - [LangGraph Cloud QuickStart](../cloud/quick_start.md): Deploy a LangGraph app using LangGraph Cloud. -- [Start from a ](../concepts/template_applications.md): Use a template to quickly create a new LangGraph application. +- [LangGraph Template Quickstart](../concepts/template_applications.md): Quickly start building with LangGraph Platform using a template application. ## Use cases 🛠️ From 24b16908b712d2c1ce9cb705c731109908a401d0 Mon Sep 17 00:00:00 2001 From: Eugene Yurtsev Date: Fri, 22 Nov 2024 14:43:08 -0500 Subject: [PATCH 06/31] x --- docs/docs/concepts/template_applications.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/docs/concepts/template_applications.md b/docs/docs/concepts/template_applications.md index 1bed86a324..34809eae1c 100644 --- a/docs/docs/concepts/template_applications.md +++ b/docs/docs/concepts/template_applications.md @@ -51,8 +51,8 @@ See the following guides for more information on how to deploy your app: ### LangGraph Framework -- **[LangGraph Concepts](../../concepts)**: Learn the foundational concepts of LangGraph. -- **[LangGraph How-to Guides](../../how-tos)**: Guides for common tasks with LangGraph. +- **[LangGraph Concepts](../concepts)**: Learn the foundational concepts of LangGraph. +- **[LangGraph How-to Guides](../how-tos)**: Guides for common tasks with LangGraph. ### 📚 Learn More about LangGraph Platform From f08155d60be7a07aadddbcc76ae7c49dbb762f65 Mon Sep 17 00:00:00 2001 From: Eugene Yurtsev Date: Fri, 22 Nov 2024 14:43:28 -0500 Subject: [PATCH 07/31] x --- docs/docs/concepts/template_applications.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/docs/concepts/template_applications.md b/docs/docs/concepts/template_applications.md index 34809eae1c..32209ad470 100644 --- a/docs/docs/concepts/template_applications.md +++ b/docs/docs/concepts/template_applications.md @@ -51,8 +51,8 @@ See the following guides for more information on how to deploy your app: ### LangGraph Framework -- **[LangGraph Concepts](../concepts)**: Learn the foundational concepts of LangGraph. -- **[LangGraph How-to Guides](../how-tos)**: Guides for common tasks with LangGraph. +- **[LangGraph Concepts](../concepts/index.md)**: Learn the foundational concepts of LangGraph. +- **[LangGraph How-to Guides](../how-tos/index.md)**: Guides for common tasks with LangGraph. ### 📚 Learn More about LangGraph Platform From 90eab07deddf3eb63613a2a152df7ddc4704dca0 Mon Sep 17 00:00:00 2001 From: vbarda Date: Wed, 4 Dec 2024 12:56:39 -0500 Subject: [PATCH 08/31] docs: add Command/GraphCommand docs --- docs/docs/concepts/low_level.md | 46 +++ docs/docs/how-tos/graph-command.ipynb | 363 ++++++++++++++++++++++++ docs/docs/how-tos/index.md | 1 + docs/docs/reference/graphs.md | 1 + docs/docs/reference/types.md | 1 + docs/mkdocs.yml | 1 + libs/langgraph/langgraph/graph/state.py | 13 +- libs/langgraph/langgraph/types.py | 11 +- 8 files changed, 435 insertions(+), 2 deletions(-) create mode 100644 docs/docs/how-tos/graph-command.ipynb diff --git a/docs/docs/concepts/low_level.md b/docs/docs/concepts/low_level.md index 05ceacdea0..9c562e0931 100644 --- a/docs/docs/concepts/low_level.md +++ b/docs/docs/concepts/low_level.md @@ -322,6 +322,52 @@ def continue_to_jokes(state: OverallState): graph.add_conditional_edges("node_a", continue_to_jokes) ``` +## `GraphCommand` + +Typically, LangGraph separates control flow (edges) from state updates (nodes). However, it is often beneficial to combine the two. For example, you might want to BOTH perform state updates AND decide which node to go next in the SAME node. LangGraph provides a way to combine control flow and node state updates using [`GraphCommand`][langgraph.graph.state.GraphCommand]. To do so, you can return a `GraphCommand` object from a node instead of a state update or `Send` objects. + +`GraphCommand` has the following properties: + + - `goto`: optional, name of the node to navigate to next. + If not specified, the graph will halt after executing the current superstep. + - `graph`: optional, graph to send the command to. Supported values are: + - `None`: the current graph (default) + - `GraphCommand.PARENT`: parent graph. + - `update`: optional, state update to apply to the graph's state at the current superstep. + - `send`: optional, list of [`Send`](#send) objects to send to other nodes. + - `resume`: optional, value to resume execution with. Will be used when `interrupt()` is called. + +```python +from langgraph.graph import GraphCommand, StateGraph, START +from typing_extensions import TypedDict, Literal + +class State(TypedDict): + foo: str + +def my_node(state: State) -> GraphCommand[Literal["my_other_node"]]: + return GraphCommand(update={"foo": "bar"}, goto="my_other_node") + +def my_other_node(state: State): + return {"foo": state["foo"] + "baz"} + +builder = StateGraph(State) +builder.add_edge(START, "my_node") +builder.add_node("my_node", my_node) +builder.add_node("my_other_node", my_other_node) + +graph = builder.compile() +``` + +With `GraphCommand` you can also achieve dynamic control flow behavior (identical to [conditional edges](#conditional-edges)): + +```python +def my_node(state: State) -> GraphCommand[Literal["my_other_node", "__end__"]]: + if state["foo"] == "bar": + return GraphCommand(update={"foo": "baz"}, goto="my_other_node") + else: + return GraphCommand(goto="__end__") +``` + ## Persistence LangGraph provides built-in persistence for your agent's state using [checkpointers][langgraph.checkpoint.base.BaseCheckpointSaver]. Checkpointers save snapshots of the graph state at every superstep, allowing resumption at any time. This enables features like human-in-the-loop interactions, memory management, and fault-tolerance. You can even directly manipulate a graph's state after its execution using the diff --git a/docs/docs/how-tos/graph-command.ipynb b/docs/docs/how-tos/graph-command.ipynb new file mode 100644 index 0000000000..8df59c9f46 --- /dev/null +++ b/docs/docs/how-tos/graph-command.ipynb @@ -0,0 +1,363 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "d33ecddc-6818-41a3-9d0d-b1b1cbcd286d", + "metadata": {}, + "source": [ + "# How to combine control flow and state updates with GraphCommand" + ] + }, + { + "cell_type": "markdown", + "id": "7c0a8d03-80b4-47fd-9b17-e26aa9b081f3", + "metadata": {}, + "source": [ + "Typically, LangGraph separates control flow (edges) and state updates (nodes). However, it is often beneficial to combine the two. For example, you might want to BOTH perform state updates AND decide which node to go next in the SAME node. LangGraph provides a way to combine control flow and node state updates using `GraphCommand`. This guide shows how you can do so." + ] + }, + { + "cell_type": "markdown", + "id": "d1c3f866-8c20-40c7-a201-35f6c9f4b680", + "metadata": {}, + "source": [ + "## Setup\n", + "\n", + "First, let's install the required packages" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "6999c7fe-31bb-4c19-946a-85c2edc57da7", + "metadata": {}, + "outputs": [], + "source": [ + "%%capture --no-stderr\n", + "%pip install -U langgraph" + ] + }, + { + "cell_type": "markdown", + "id": "0f131c92-4744-431c-a89c-7c382a15b79f", + "metadata": {}, + "source": [ + "
\n", + "

Set up LangSmith for LangGraph development

\n", + "

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

\n", + "
" + ] + }, + { + "cell_type": "markdown", + "id": "f22c228f-6882-4757-8e7e-1ca51328af4a", + "metadata": {}, + "source": [ + "Let's create a simple graph with 3 nodes: A, B and C. We will first execute node A, and then decide whether to go to Node B or Node C next based on the output of node A." + ] + }, + { + "cell_type": "markdown", + "id": "71c8bc81-c1b4-46aa-835f-2c2849156594", + "metadata": {}, + "source": [ + "## Using edges" + ] + }, + { + "cell_type": "markdown", + "id": "9a81df3a-6489-44da-8a7e-615009ef9f59", + "metadata": {}, + "source": [ + "Let's first implement the graph with a traditional LangGraph primitives -- nodes and conditional edges. The conditional edge (`route_from_a`) will inspect the state last updated by node A and decide where to go next based on the value of the state key `foo`." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "de32d339-3501-4982-a34f-8d3facc53579", + "metadata": {}, + "outputs": [], + "source": [ + "import random\n", + "from typing_extensions import TypedDict, Literal\n", + "\n", + "from langgraph.graph import GraphCommand, StateGraph, START\n", + "\n", + "\n", + "# Define graph state\n", + "class State(TypedDict):\n", + " foo: str\n", + "\n", + "\n", + "# Define the nodes\n", + "def node_a(state: State):\n", + " print(\"Called A\")\n", + " return {\"foo\": random.choice([\"a\", \"b\"])}\n", + "\n", + "def node_b(state: State):\n", + " print(\"Called B\")\n", + " return {\"foo\": state[\"foo\"] + \"b\"}\n", + "\n", + "def node_c(state: State):\n", + " print(\"Called C\")\n", + " return {\"foo\": state[\"foo\"] + \"c\"}\n", + "\n", + "# Define the conditional edges\n", + "def route_from_a(state: State) -> Literal[\"node_b\", \"node_c\"]:\n", + " if state[\"foo\"] == \"a\":\n", + " return \"node_b\"\n", + " else:\n", + " return \"node_c\"" + ] + }, + { + "cell_type": "markdown", + "id": "87ef1325-d42f-4a6c-81e6-0058b9628b9e", + "metadata": {}, + "source": [ + "We can now create the StateGraph with the above nodes and conditional edges." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "b6e3044b-d817-4f7e-9e4f-1b3aff109670", + "metadata": {}, + "outputs": [], + "source": [ + "builder = StateGraph(State)\n", + "builder.add_edge(START, \"node_a\")\n", + "builder.add_node(node_a)\n", + "builder.add_node(node_b)\n", + "builder.add_node(node_c)\n", + "builder.add_conditional_edges(\"node_a\", route_from_a)\n", + "\n", + "graph = builder.compile()" + ] + }, + { + "cell_type": "markdown", + "id": "e60c8a11-ce6f-484c-ba2f-936c3d69b120", + "metadata": {}, + "source": [ + "If we run the graph multiple times, we'd see it take different paths (A -> B or A -> C) based on the random choice in node A." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "9175add8-0c08-48ee-8d70-249c5d209736", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Called A\n", + "Called C\n" + ] + }, + { + "data": { + "text/plain": [ + "{'foo': 'bc'}" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "graph.invoke({\"foo\": \"\"})" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "254eb3a1-bb47-4401-93fb-51a65b6b8e71", + "metadata": {}, + "outputs": [ + { + "data": { + "image/jpeg": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from IPython.display import display, Image\n", + "\n", + "display(Image(graph.get_graph().draw_mermaid_png()))" + ] + }, + { + "cell_type": "markdown", + "id": "0c52be14-d250-4c64-99e2-ce0a201e4523", + "metadata": {}, + "source": [ + "Now let's reimplement the same graph using `GraphCommand`!" + ] + }, + { + "cell_type": "markdown", + "id": "6a08d957-b3d2-4538-bf4a-68ef90a51b98", + "metadata": {}, + "source": [ + "## Using GraphCommand" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "37107209-34d6-4414-a54e-cd3ee38e3651", + "metadata": {}, + "outputs": [], + "source": [ + "# Define the nodes\n", + "\n", + "def node_a(state: State) -> GraphCommand[Literal[\"node_b\", \"node_c\"]]:\n", + " print(\"Called A\")\n", + " value = random.choice([\"a\", \"b\"])\n", + " # this is a replacement for the logic in route_from_a\n", + " if value == \"a\":\n", + " goto = \"node_b\"\n", + " else:\n", + " goto = \"node_c\"\n", + "\n", + " # note how GraphCommand allows you to BOTH update the graph state AND route to the next node\n", + " return GraphCommand(\n", + " # this is the state update, same as we returned from node A previously\n", + " update={\"foo\": value},\n", + " # this is a replacement for route_from_a conditional edge\n", + " goto=goto\n", + " )\n", + "\n", + "# Nodes B and C are unchanged\n", + "\n", + "def node_b(state: State):\n", + " print(\"Called B\")\n", + " # graph command can also be used \n", + " return {\"foo\": state[\"foo\"] + \"b\"}\n", + "\n", + "def node_c(state: State):\n", + " print(\"Called C\")\n", + " return {\"foo\": state[\"foo\"] + \"c\"}" + ] + }, + { + "cell_type": "markdown", + "id": "badc25eb-4876-482e-bb10-d763023cdaad", + "metadata": {}, + "source": [ + "We can now create the `StateGraph` with the above nodes. But notice that the graph no longer uses conditional edges! This is because control flow is defined inside `node_a`." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "d6711650-4380-4551-a007-2805f49ab2d8", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "builder = StateGraph(State)\n", + "builder.add_edge(START, \"node_a\")\n", + "builder.add_node(node_a)\n", + "builder.add_node(node_b)\n", + "builder.add_node(node_c)\n", + "# NOTE: there are no edges between nodes A, B and C!\n", + "\n", + "graph = builder.compile()" + ] + }, + { + "cell_type": "markdown", + "id": "0ab344c5-d634-4d7d-b3b4-edf4fa875311", + "metadata": {}, + "source": [ + "!!! important\n", + "\n", + " You might have noticed that we used `GraphCommand` as a return type annotation, e.g. `GraphCommand[Literal[\"node_b\", \"node_c\"]]`. This is necessary for the graph compilation and rendering, and tells LangGraph that `node_a` can navigate to `node_b` and `node_c`." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "eeb810e5-8822-4c09-8d53-c55cd0f5d42e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/jpeg": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "display(Image(graph.get_graph().draw_mermaid_png()))" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "d88a5d9b-ee08-4ed4-9c65-6e868210bfac", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Called A\n", + "Called C\n" + ] + }, + { + "data": { + "text/plain": [ + "{'foo': 'bc'}" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "graph.invoke({\"foo\": \"\"})" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/docs/how-tos/index.md b/docs/docs/how-tos/index.md index e579902d9e..06694822cb 100644 --- a/docs/docs/how-tos/index.md +++ b/docs/docs/how-tos/index.md @@ -20,6 +20,7 @@ These how-to guides show how to achieve that controllability. - [How to create branches for parallel execution](branching.ipynb) - [How to create map-reduce branches for parallel execution](map-reduce.ipynb) - [How to control graph recursion limit](recursion-limit.ipynb) +- [How to combine control flow and state updates with GraphCommand](graph-command.ipynb) ### Persistence diff --git a/docs/docs/reference/graphs.md b/docs/docs/reference/graphs.md index c67e2136af..fef38e1593 100644 --- a/docs/docs/reference/graphs.md +++ b/docs/docs/reference/graphs.md @@ -11,6 +11,7 @@ members: - StateGraph - CompiledStateGraph + - GraphCommand ::: langgraph.graph.message options: diff --git a/docs/docs/reference/types.md b/docs/docs/reference/types.md index 347a87d6e6..98b1ef1377 100644 --- a/docs/docs/reference/types.md +++ b/docs/docs/reference/types.md @@ -13,3 +13,4 @@ - PregelExecutableTask - StateSnapshot - Send + - Command diff --git a/docs/mkdocs.yml b/docs/mkdocs.yml index 58489b12a1..882e3cdfd7 100644 --- a/docs/mkdocs.yml +++ b/docs/mkdocs.yml @@ -151,6 +151,7 @@ nav: - how-tos/branching.ipynb - how-tos/map-reduce.ipynb - how-tos/recursion-limit.ipynb + - how-tos/graph-command.ipynb - Persistence: - Persistence: how-tos#persistence - how-tos/persistence.ipynb diff --git a/libs/langgraph/langgraph/graph/state.py b/libs/langgraph/langgraph/graph/state.py index 1a7208a2a0..c9b4199ab1 100644 --- a/libs/langgraph/langgraph/graph/state.py +++ b/libs/langgraph/langgraph/graph/state.py @@ -86,7 +86,18 @@ def _get_node_name(node: RunnableLike) -> str: @dataclasses.dataclass(**_DC_KWARGS) class GraphCommand(Generic[N], Command[N]): - """One or more commands to update a StateGraph's state and go to, or send messages to nodes.""" + """One or more commands to update a StateGraph's state and go to, or send messages to nodes. + + Args: + goto: name of the node to navigate to next. + If not specified, the graph will halt after executing the current superstep. + graph: graph to send the command to. Supported values are: + - None: the current graph (default) + - GraphCommand.PARENT: closest parent graph + update: state update to apply to the graph's state at the current superstep. + send: list of `Send` objects to send to other nodes. + resume: value to resume execution with. Will be used when `interrupt()` is called. + """ goto: Union[str, Sequence[str]] = () diff --git a/libs/langgraph/langgraph/types.py b/libs/langgraph/langgraph/types.py index 7bf9148c5d..e8407d0f18 100644 --- a/libs/langgraph/langgraph/types.py +++ b/libs/langgraph/langgraph/types.py @@ -239,7 +239,16 @@ def __eq__(self, value: object) -> bool: @dataclasses.dataclass(**_DC_KWARGS) class Command(Generic[N]): - """One or more commands to update the graph's state and send messages to nodes.""" + """One or more commands to update the graph's state and send messages to nodes. + + Args: + graph: graph to send the command to. Supported values are: + - None: the current graph (default) + - GraphCommand.PARENT: closest parent graph + update: state update to apply to the graph's state at the current superstep. + send: list of `Send` objects to send to other nodes. + resume: value to resume execution with. Will be used when `interrupt()` is called. + """ graph: Optional[str] = None update: Optional[dict[str, Any]] = None From 0fdf3c9daf0bf8b8fd66348ebb3ec212e9023ad3 Mon Sep 17 00:00:00 2001 From: vbarda Date: Wed, 4 Dec 2024 16:26:31 -0500 Subject: [PATCH 09/31] cr --- docs/docs/concepts/low_level.md | 31 ++-- docs/docs/how-tos/graph-command.ipynb | 196 ++++++------------------ libs/langgraph/langgraph/graph/state.py | 5 +- 3 files changed, 67 insertions(+), 165 deletions(-) diff --git a/docs/docs/concepts/low_level.md b/docs/docs/concepts/low_level.md index 9c562e0931..75ff6d4a37 100644 --- a/docs/docs/concepts/low_level.md +++ b/docs/docs/concepts/low_level.md @@ -324,22 +324,31 @@ graph.add_conditional_edges("node_a", continue_to_jokes) ## `GraphCommand` -Typically, LangGraph separates control flow (edges) from state updates (nodes). However, it is often beneficial to combine the two. For example, you might want to BOTH perform state updates AND decide which node to go next in the SAME node. LangGraph provides a way to combine control flow and node state updates using [`GraphCommand`][langgraph.graph.state.GraphCommand]. To do so, you can return a `GraphCommand` object from a node instead of a state update or `Send` objects. +It can be useful to combine control flow (edges) and state updates (nodes). For example, you might want to BOTH perform state updates AND decide which node to go to next in the SAME node. LangGraph provides a way to do so by returning a [`GraphCommand`][langgraph.graph.state.GraphCommand] object from node functions: + +```python +def my_node(state: State) -> GraphCommand[Literal["my_other_node"]]: + return GraphCommand( + # state update + update={"foo": "bar"}, + # control flow + goto="my_other_node" + ) +``` `GraphCommand` has the following properties: - - `goto`: optional, name of the node to navigate to next. - If not specified, the graph will halt after executing the current superstep. - - `graph`: optional, graph to send the command to. Supported values are: - - `None`: the current graph (default) - - `GraphCommand.PARENT`: parent graph. - - `update`: optional, state update to apply to the graph's state at the current superstep. - - `send`: optional, list of [`Send`](#send) objects to send to other nodes. - - `resume`: optional, value to resume execution with. Will be used when `interrupt()` is called. +| Property | Description | +| --- | --- | +| `graph` | Graph to send the command to. Supported values:
- `None`: the current graph (default)
- `GraphCommand.PARENT`: parent graph | +| `goto` | Name of the node to navigate to next. Can be any node that belongs to the specified `graph` (current or parent). If `goto` not specified, the graph will halt after executing the current superstep. | +| `update` | State update to apply to the graph's state at the current superstep | +| `send` | List of [`Send`](#send) objects to send to other nodes | +| `resume` | Value to resume execution with. Will be used when `interrupt()` is called | ```python from langgraph.graph import GraphCommand, StateGraph, START -from typing_extensions import TypedDict, Literal +from typing_extensions import Literal, TypedDict class State(TypedDict): foo: str @@ -368,6 +377,8 @@ def my_node(state: State) -> GraphCommand[Literal["my_other_node", "__end__"]]: return GraphCommand(goto="__end__") ``` +Check out this [how-to guide](../how-tos/graph-command.ipynb) for an end-to-end example of how to use `GraphCommand`. + ## Persistence LangGraph provides built-in persistence for your agent's state using [checkpointers][langgraph.checkpoint.base.BaseCheckpointSaver]. Checkpointers save snapshots of the graph state at every superstep, allowing resumption at any time. This enables features like human-in-the-loop interactions, memory management, and fault-tolerance. You can even directly manipulate a graph's state after its execution using the diff --git a/docs/docs/how-tos/graph-command.ipynb b/docs/docs/how-tos/graph-command.ipynb index 8df59c9f46..b215c9f4a3 100644 --- a/docs/docs/how-tos/graph-command.ipynb +++ b/docs/docs/how-tos/graph-command.ipynb @@ -13,7 +13,27 @@ "id": "7c0a8d03-80b4-47fd-9b17-e26aa9b081f3", "metadata": {}, "source": [ - "Typically, LangGraph separates control flow (edges) and state updates (nodes). However, it is often beneficial to combine the two. For example, you might want to BOTH perform state updates AND decide which node to go next in the SAME node. LangGraph provides a way to combine control flow and node state updates using `GraphCommand`. This guide shows how you can do so." + "!!! info \"Prerequisites\"\n", + " This guide assumes familiarity with the following:\n", + " \n", + " - [State](../../concepts/low_level/#state)\n", + " - [Nodes](../../concepts/low_level/#nodes)\n", + " - [Edges](../../concepts/low_level/#edges)\n", + " - [GraphCommand](../../concepts/low_level/#graphcommand)\n", + "\n", + "It can be useful to combine control flow (edges) and state updates (nodes). For example, you might want to BOTH perform state updates AND decide which node to go to next in the SAME node. LangGraph provides a way to do so by returning a `GraphCommand` object from node functions:\n", + "\n", + "```python\n", + "def my_node(state: State) -> GraphCommand[Literal[\"my_other_node\"]]:\n", + " return GraphCommand(\n", + " # state update\n", + " update={\"foo\": \"bar\"},\n", + " # control flow\n", + " goto=\"my_other_node\"\n", + " )\n", + "```\n", + "\n", + "This guide shows how you can do use `GraphCommand` to add dynamic control flow in your LangGraph app." ] }, { @@ -60,24 +80,16 @@ }, { "cell_type": "markdown", - "id": "71c8bc81-c1b4-46aa-835f-2c2849156594", - "metadata": {}, - "source": [ - "## Using edges" - ] - }, - { - "cell_type": "markdown", - "id": "9a81df3a-6489-44da-8a7e-615009ef9f59", + "id": "6a08d957-b3d2-4538-bf4a-68ef90a51b98", "metadata": {}, "source": [ - "Let's first implement the graph with a traditional LangGraph primitives -- nodes and conditional edges. The conditional edge (`route_from_a`) will inspect the state last updated by node A and decide where to go next based on the value of the state key `foo`." + "## Control flow with GraphCommand" ] }, { "cell_type": "code", "execution_count": 2, - "id": "de32d339-3501-4982-a34f-8d3facc53579", + "id": "4539b81b-09e9-4660-ac55-1b1775e13892", "metadata": {}, "outputs": [], "source": [ @@ -91,142 +103,12 @@ "class State(TypedDict):\n", " foo: str\n", "\n", - "\n", - "# Define the nodes\n", - "def node_a(state: State):\n", - " print(\"Called A\")\n", - " return {\"foo\": random.choice([\"a\", \"b\"])}\n", - "\n", - "def node_b(state: State):\n", - " print(\"Called B\")\n", - " return {\"foo\": state[\"foo\"] + \"b\"}\n", - "\n", - "def node_c(state: State):\n", - " print(\"Called C\")\n", - " return {\"foo\": state[\"foo\"] + \"c\"}\n", - "\n", - "# Define the conditional edges\n", - "def route_from_a(state: State) -> Literal[\"node_b\", \"node_c\"]:\n", - " if state[\"foo\"] == \"a\":\n", - " return \"node_b\"\n", - " else:\n", - " return \"node_c\"" - ] - }, - { - "cell_type": "markdown", - "id": "87ef1325-d42f-4a6c-81e6-0058b9628b9e", - "metadata": {}, - "source": [ - "We can now create the StateGraph with the above nodes and conditional edges." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "b6e3044b-d817-4f7e-9e4f-1b3aff109670", - "metadata": {}, - "outputs": [], - "source": [ - "builder = StateGraph(State)\n", - "builder.add_edge(START, \"node_a\")\n", - "builder.add_node(node_a)\n", - "builder.add_node(node_b)\n", - "builder.add_node(node_c)\n", - "builder.add_conditional_edges(\"node_a\", route_from_a)\n", - "\n", - "graph = builder.compile()" - ] - }, - { - "cell_type": "markdown", - "id": "e60c8a11-ce6f-484c-ba2f-936c3d69b120", - "metadata": {}, - "source": [ - "If we run the graph multiple times, we'd see it take different paths (A -> B or A -> C) based on the random choice in node A." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "9175add8-0c08-48ee-8d70-249c5d209736", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Called A\n", - "Called C\n" - ] - }, - { - "data": { - "text/plain": [ - "{'foo': 'bc'}" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "graph.invoke({\"foo\": \"\"})" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "254eb3a1-bb47-4401-93fb-51a65b6b8e71", - "metadata": {}, - "outputs": [ - { - "data": { - "image/jpeg": "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", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from IPython.display import display, Image\n", - "\n", - "display(Image(graph.get_graph().draw_mermaid_png()))" - ] - }, - { - "cell_type": "markdown", - "id": "0c52be14-d250-4c64-99e2-ce0a201e4523", - "metadata": {}, - "source": [ - "Now let's reimplement the same graph using `GraphCommand`!" - ] - }, - { - "cell_type": "markdown", - "id": "6a08d957-b3d2-4538-bf4a-68ef90a51b98", - "metadata": {}, - "source": [ - "## Using GraphCommand" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "37107209-34d6-4414-a54e-cd3ee38e3651", - "metadata": {}, - "outputs": [], - "source": [ "# Define the nodes\n", "\n", "def node_a(state: State) -> GraphCommand[Literal[\"node_b\", \"node_c\"]]:\n", " print(\"Called A\")\n", " value = random.choice([\"a\", \"b\"])\n", - " # this is a replacement for the logic in route_from_a\n", + " # this is a replacement for a conditional edge function\n", " if value == \"a\":\n", " goto = \"node_b\"\n", " else:\n", @@ -234,9 +116,9 @@ "\n", " # note how GraphCommand allows you to BOTH update the graph state AND route to the next node\n", " return GraphCommand(\n", - " # this is the state update, same as we returned from node A previously\n", + " # this is the state update\n", " update={\"foo\": value},\n", - " # this is a replacement for route_from_a conditional edge\n", + " # this is a replacement for an edge\n", " goto=goto\n", " )\n", "\n", @@ -257,17 +139,16 @@ "id": "badc25eb-4876-482e-bb10-d763023cdaad", "metadata": {}, "source": [ - "We can now create the `StateGraph` with the above nodes. But notice that the graph no longer uses conditional edges! This is because control flow is defined inside `node_a`." + "We can now create the `StateGraph` with the above nodes. Notice that the graph doesn't have [conditional edges](../../concepts/low_level#conditional-edges) for routing! This is because control flow is defined with `GraphCommand` inside `node_a`." ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 3, "id": "d6711650-4380-4551-a007-2805f49ab2d8", "metadata": {}, "outputs": [], "source": [ - "\n", "builder = StateGraph(State)\n", "builder.add_edge(START, \"node_a\")\n", "builder.add_node(node_a)\n", @@ -290,7 +171,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 4, "id": "eeb810e5-8822-4c09-8d53-c55cd0f5d42e", "metadata": {}, "outputs": [ @@ -306,12 +187,21 @@ } ], "source": [ + "from IPython.display import display, Image\n", "display(Image(graph.get_graph().draw_mermaid_png()))" ] }, + { + "cell_type": "markdown", + "id": "58fb6c32-e6fb-4c94-8182-e351ed52a45d", + "metadata": {}, + "source": [ + "If we run the graph multiple times, we'd see it take different paths (A -> B or A -> C) based on the random choice in node A." + ] + }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 5, "id": "d88a5d9b-ee08-4ed4-9c65-6e868210bfac", "metadata": {}, "outputs": [ @@ -320,16 +210,16 @@ "output_type": "stream", "text": [ "Called A\n", - "Called C\n" + "Called B\n" ] }, { "data": { "text/plain": [ - "{'foo': 'bc'}" + "{'foo': 'ab'}" ] }, - "execution_count": 9, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } diff --git a/libs/langgraph/langgraph/graph/state.py b/libs/langgraph/langgraph/graph/state.py index c9b4199ab1..d3f6083569 100644 --- a/libs/langgraph/langgraph/graph/state.py +++ b/libs/langgraph/langgraph/graph/state.py @@ -89,14 +89,15 @@ class GraphCommand(Generic[N], Command[N]): """One or more commands to update a StateGraph's state and go to, or send messages to nodes. Args: - goto: name of the node to navigate to next. - If not specified, the graph will halt after executing the current superstep. graph: graph to send the command to. Supported values are: - None: the current graph (default) - GraphCommand.PARENT: closest parent graph update: state update to apply to the graph's state at the current superstep. send: list of `Send` objects to send to other nodes. resume: value to resume execution with. Will be used when `interrupt()` is called. + goto: name of the node to navigate to next. + Can be any node that belongs to the specified `graph` (current or parent). + If `goto` not specified, the graph will halt after executing the current superstep. """ goto: Union[str, Sequence[str]] = () From d52bb911a4d3f78519d786c96ebd8cce84433bc0 Mon Sep 17 00:00:00 2001 From: vbarda Date: Wed, 4 Dec 2024 16:50:56 -0500 Subject: [PATCH 10/31] lint --- docs/docs/how-tos/graph-command.ipynb | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/docs/docs/how-tos/graph-command.ipynb b/docs/docs/how-tos/graph-command.ipynb index b215c9f4a3..b768e75a81 100644 --- a/docs/docs/how-tos/graph-command.ipynb +++ b/docs/docs/how-tos/graph-command.ipynb @@ -103,8 +103,10 @@ "class State(TypedDict):\n", " foo: str\n", "\n", + "\n", "# Define the nodes\n", "\n", + "\n", "def node_a(state: State) -> GraphCommand[Literal[\"node_b\", \"node_c\"]]:\n", " print(\"Called A\")\n", " value = random.choice([\"a\", \"b\"])\n", @@ -119,16 +121,19 @@ " # this is the state update\n", " update={\"foo\": value},\n", " # this is a replacement for an edge\n", - " goto=goto\n", + " goto=goto,\n", " )\n", "\n", + "\n", "# Nodes B and C are unchanged\n", "\n", + "\n", "def node_b(state: State):\n", " print(\"Called B\")\n", - " # graph command can also be used \n", + " # graph command can also be used\n", " return {\"foo\": state[\"foo\"] + \"b\"}\n", "\n", + "\n", "def node_c(state: State):\n", " print(\"Called C\")\n", " return {\"foo\": state[\"foo\"] + \"c\"}" @@ -188,6 +193,7 @@ ], "source": [ "from IPython.display import display, Image\n", + "\n", "display(Image(graph.get_graph().draw_mermaid_png()))" ] }, From b4b3ac6f57adad2b0458026622c1e0ceb07c6c9f Mon Sep 17 00:00:00 2001 From: Nuno Campos Date: Wed, 4 Dec 2024 15:12:03 -0800 Subject: [PATCH 11/31] lib: Merge GraphCommand and Command - Now we have only Command - Command(goto=) combines the previous functionality of Command(send=) and Command(goto=) --- libs/langgraph/langgraph/graph/__init__.py | 3 +- libs/langgraph/langgraph/graph/state.py | 48 ++++---------- libs/langgraph/langgraph/pregel/io.py | 9 +-- libs/langgraph/langgraph/types.py | 2 +- libs/langgraph/tests/test_pregel.py | 58 ++++++++--------- libs/langgraph/tests/test_pregel_async.py | 68 ++++++++++---------- libs/scheduler-kafka/tests/test_push.py | 18 +++--- libs/scheduler-kafka/tests/test_push_sync.py | 18 +++--- libs/sdk-py/langgraph_sdk/schema.py | 2 +- 9 files changed, 101 insertions(+), 125 deletions(-) diff --git a/libs/langgraph/langgraph/graph/__init__.py b/libs/langgraph/langgraph/graph/__init__.py index 241106a3a2..c81ad9903d 100644 --- a/libs/langgraph/langgraph/graph/__init__.py +++ b/libs/langgraph/langgraph/graph/__init__.py @@ -1,13 +1,12 @@ from langgraph.graph.graph import END, START, Graph from langgraph.graph.message import MessageGraph, MessagesState, add_messages -from langgraph.graph.state import GraphCommand, StateGraph +from langgraph.graph.state import StateGraph __all__ = [ "END", "START", "Graph", "StateGraph", - "GraphCommand", "MessageGraph", "add_messages", "MessagesState", diff --git a/libs/langgraph/langgraph/graph/state.py b/libs/langgraph/langgraph/graph/state.py index 1a7208a2a0..e63f25111f 100644 --- a/libs/langgraph/langgraph/graph/state.py +++ b/libs/langgraph/langgraph/graph/state.py @@ -1,4 +1,3 @@ -import dataclasses import inspect import logging import typing @@ -9,7 +8,6 @@ from typing import ( Any, Callable, - Generic, Literal, NamedTuple, Optional, @@ -55,7 +53,7 @@ from langgraph.pregel.read import ChannelRead, PregelNode from langgraph.pregel.write import SKIP_WRITE, ChannelWrite, ChannelWriteEntry from langgraph.store.base import BaseStore -from langgraph.types import _DC_KWARGS, All, Checkpointer, Command, N, RetryPolicy +from langgraph.types import All, Checkpointer, Command, RetryPolicy from langgraph.utils.fields import get_field_default from langgraph.utils.pydantic import create_model from langgraph.utils.runnable import RunnableCallable, coerce_to_runnable @@ -84,22 +82,6 @@ def _get_node_name(node: RunnableLike) -> str: raise TypeError(f"Unsupported node type: {type(node)}") -@dataclasses.dataclass(**_DC_KWARGS) -class GraphCommand(Generic[N], Command[N]): - """One or more commands to update a StateGraph's state and go to, or send messages to nodes.""" - - goto: Union[str, Sequence[str]] = () - - def __repr__(self) -> str: - # get all non-None values - contents = ", ".join( - f"{key}={value!r}" - for key, value in dataclasses.asdict(self).items() - if value - ) - return f"Command({contents})" - - class StateNodeSpec(NamedTuple): runnable: Runnable metadata: Optional[dict[str, Any]] @@ -392,7 +374,7 @@ def add_node( input = input_hint if ( (rtn := hints.get("return")) - and get_origin(rtn) in (Command, GraphCommand) + and get_origin(rtn) is Command and (rargs := get_args(rtn)) and get_origin(rargs[0]) is Literal and (vals := get_args(rargs[0])) @@ -834,15 +816,12 @@ def _control_branch(value: Any) -> Sequence[Union[str, Send]]: if value.graph == Command.PARENT: raise ParentCommand(value) rtn: list[Union[str, Send]] = [] - if isinstance(value, GraphCommand): - if isinstance(value.goto, str): - rtn.append(value.goto) - else: - rtn.extend(value.goto) - if isinstance(value.send, Send): - rtn.append(value.send) + if isinstance(value.goto, Send): + rtn.append(value.goto) + elif isinstance(value.goto, str): + rtn.append(value.goto) else: - rtn.extend(value.send) + rtn.extend(value.goto) return rtn @@ -854,15 +833,12 @@ async def _acontrol_branch(value: Any) -> Sequence[Union[str, Send]]: if value.graph == Command.PARENT: raise ParentCommand(value) rtn: list[Union[str, Send]] = [] - if isinstance(value, GraphCommand): - if isinstance(value.goto, str): - rtn.append(value.goto) - else: - rtn.extend(value.goto) - if isinstance(value.send, Send): - rtn.append(value.send) + if isinstance(value.goto, Send): + rtn.append(value.goto) + elif isinstance(value.goto, str): + rtn.append(value.goto) else: - rtn.extend(value.send) + rtn.extend(value.goto) return rtn diff --git a/libs/langgraph/langgraph/pregel/io.py b/libs/langgraph/langgraph/pregel/io.py index ed2c289385..c1fed349ab 100644 --- a/libs/langgraph/langgraph/pregel/io.py +++ b/libs/langgraph/langgraph/pregel/io.py @@ -72,17 +72,18 @@ def map_command( """Map input chunk to a sequence of pending writes in the form (channel, value).""" if cmd.graph == Command.PARENT: raise InvalidUpdateError("There is not parent graph") - if cmd.send: + if cmd.goto: if isinstance(cmd.send, (tuple, list)): - sends = cmd.send + sends = cmd.goto else: - sends = [cmd.send] + sends = [cmd.goto] for send in sends: if not isinstance(send, Send): raise TypeError( - f"In Command.send, expected Send, got {type(send).__name__}" + f"In Command.goto, expected Send, got {type(send).__name__}" ) yield (NULL_TASK_ID, PUSH if FF_SEND_V2 else TASKS, send) + # TODO handle goto str for state graph if cmd.resume: if isinstance(cmd.resume, dict) and all(is_task_id(k) for k in cmd.resume): for tid, resume in cmd.resume.items(): diff --git a/libs/langgraph/langgraph/types.py b/libs/langgraph/langgraph/types.py index 4047a28f7d..67c7e53f8a 100644 --- a/libs/langgraph/langgraph/types.py +++ b/libs/langgraph/langgraph/types.py @@ -249,8 +249,8 @@ class Command(Generic[N]): graph: Optional[str] = None update: Optional[dict[str, Any]] = None - send: Union[Send, Sequence[Send]] = () resume: Optional[Union[Any, dict[str, Any]]] = None + goto: Union[Send, Sequence[Union[Send, str]], str] = () def __repr__(self) -> str: # get all non-None values diff --git a/libs/langgraph/tests/test_pregel.py b/libs/langgraph/tests/test_pregel.py index 4f768badda..68071594bf 100644 --- a/libs/langgraph/tests/test_pregel.py +++ b/libs/langgraph/tests/test_pregel.py @@ -65,7 +65,7 @@ START, ) from langgraph.errors import InvalidUpdateError, MultipleSubgraphsError, NodeInterrupt -from langgraph.graph import END, Graph, GraphCommand, StateGraph +from langgraph.graph import END, Graph, StateGraph from langgraph.graph.message import MessageGraph, MessagesState, add_messages from langgraph.managed.shared_value import SharedValue from langgraph.prebuilt.chat_agent_executor import create_tool_calling_executor @@ -270,10 +270,10 @@ class State(TypedDict): bar: str def node_a(state: State): - return GraphCommand(goto="b", update={"foo": "bar"}) + return Command(goto="b", update={"foo": "bar"}) def node_b(state: State): - return GraphCommand(goto=END, update={"bar": "baz"}) + return Command(goto=END, update={"bar": "baz"}) builder = StateGraph(State) builder.add_node("a", node_a) @@ -1925,8 +1925,8 @@ def __call__(self, state): def send_for_fun(state): return [ - Send("2", Command(send=Send("2", 3))), - Send("2", GraphCommand(send=Send("2", 4))), + Send("2", Command(goto=Send("2", 3))), + Send("2", Command(goto=Send("2", 4))), "3.1", ] @@ -1947,8 +1947,8 @@ def route_to_three(state) -> Literal["3"]: == [ "0", "1", - "2|Command(send=Send(node='2', arg=3))", - "2|Command(send=Send(node='2', arg=4))", + "2|Command(goto=Send(node='2', arg=3))", + "2|Command(goto=Send(node='2', arg=4))", "2|3", "2|4", "3", @@ -1959,8 +1959,8 @@ def route_to_three(state) -> Literal["3"]: "0", "1", "3.1", - "2|Command(send=Send(node='2', arg=3))", - "2|Command(send=Send(node='2', arg=4))", + "2|Command(goto=Send(node='2', arg=3))", + "2|Command(goto=Send(node='2', arg=4))", "3", "2|3", "2|4", @@ -2000,15 +2000,15 @@ def __call__(self, state): if isinstance(state, list) else ["|".join((self.name, str(state)))] ) - if isinstance(state, GraphCommand): + if isinstance(state, Command): return replace(state, update=update) else: return update def send_for_fun(state): return [ - Send("2", GraphCommand(send=Send("2", 3))), - Send("2", GraphCommand(send=Send("flaky", 4))), + Send("2", Command(goto=Send("2", 3))), + Send("2", Command(goto=Send("flaky", 4))), "3.1", ] @@ -2030,8 +2030,8 @@ def route_to_three(state) -> Literal["3"]: assert graph.invoke(["0"], thread1, debug=1) == [ "0", "1", - "2|Command(send=Send(node='2', arg=3))", - "2|Command(send=Send(node='flaky', arg=4))", + "2|Command(goto=Send(node='2', arg=3))", + "2|Command(goto=Send(node='flaky', arg=4))", "2|3", ] assert builder.nodes["2"].runnable.func.ticks == 3 @@ -2046,8 +2046,8 @@ def route_to_three(state) -> Literal["3"]: assert graph.invoke(None, thread1, debug=1) == [ "0", "1", - "2|Command(send=Send(node='2', arg=3))", - "2|Command(send=Send(node='flaky', arg=4))", + "2|Command(goto=Send(node='2', arg=3))", + "2|Command(goto=Send(node='flaky', arg=4))", "2|3", "flaky|4", "3", @@ -2069,8 +2069,8 @@ def route_to_three(state) -> Literal["3"]: values=[ "0", "1", - "2|Command(send=Send(node='2', arg=3))", - "2|Command(send=Send(node='flaky', arg=4))", + "2|Command(goto=Send(node='2', arg=3))", + "2|Command(goto=Send(node='flaky', arg=4))", "2|3", "flaky|4", "3", @@ -2105,8 +2105,8 @@ def route_to_three(state) -> Literal["3"]: values=[ "0", "1", - "2|Command(send=Send(node='2', arg=3))", - "2|Command(send=Send(node='flaky', arg=4))", + "2|Command(goto=Send(node='2', arg=3))", + "2|Command(goto=Send(node='flaky', arg=4))", "2|3", "flaky|4", ], @@ -2123,8 +2123,8 @@ def route_to_three(state) -> Literal["3"]: "writes": { "1": ["1"], "2": [ - ["2|Command(send=Send(node='2', arg=3))"], - ["2|Command(send=Send(node='flaky', arg=4))"], + ["2|Command(goto=Send(node='2', arg=3))"], + ["2|Command(goto=Send(node='flaky', arg=4))"], ["2|3"], ], "flaky": ["flaky|4"], @@ -2209,7 +2209,7 @@ def route_to_three(state) -> Literal["3"]: error=None, interrupts=(), state=None, - result=["2|Command(send=Send(node='2', arg=3))"], + result=["2|Command(goto=Send(node='2', arg=3))"], ), PregelTask( id=AnyStr(), @@ -2223,7 +2223,7 @@ def route_to_three(state) -> Literal["3"]: error=None, interrupts=(), state=None, - result=["2|Command(send=Send(node='flaky', arg=4))"], + result=["2|Command(goto=Send(node='flaky', arg=4))"], ), PregelTask( id=AnyStr(), @@ -2786,10 +2786,10 @@ def test_send_react_interrupt_control( tool_calls=[ToolCall(name="foo", args={"hi": [1, 2, 3]}, id=AnyStr())], ) - def agent(state) -> GraphCommand[Literal["foo"]]: - return GraphCommand( + def agent(state) -> Command[Literal["foo"]]: + return Command( update={"messages": ai_message}, - send=[Send(call["name"], call) for call in ai_message.tool_calls], + goto=[Send(call["name"], call) for call in ai_message.tool_calls], ) foo_called = 0 @@ -14580,9 +14580,9 @@ def test_parent_command(request: pytest.FixtureRequest, checkpointer_name: str) from langchain_core.tools import tool @tool(return_direct=True) - def get_user_name() -> GraphCommand: + def get_user_name() -> Command: """Retrieve user name""" - return GraphCommand(update={"user_name": "Meow"}, graph=GraphCommand.PARENT) + return Command(update={"user_name": "Meow"}, graph=Command.PARENT) subgraph_builder = StateGraph(MessagesState) subgraph_builder.add_node("tool", get_user_name) diff --git a/libs/langgraph/tests/test_pregel_async.py b/libs/langgraph/tests/test_pregel_async.py index addb18b2b9..538730c78b 100644 --- a/libs/langgraph/tests/test_pregel_async.py +++ b/libs/langgraph/tests/test_pregel_async.py @@ -62,7 +62,7 @@ START, ) from langgraph.errors import InvalidUpdateError, MultipleSubgraphsError, NodeInterrupt -from langgraph.graph import END, Graph, GraphCommand, StateGraph +from langgraph.graph import END, Graph, StateGraph from langgraph.graph.message import MessageGraph, MessagesState, add_messages from langgraph.managed.shared_value import SharedValue from langgraph.prebuilt.chat_agent_executor import create_tool_calling_executor @@ -2580,8 +2580,8 @@ async def __call__(self, state): async def send_for_fun(state): return [ - Send("2", Command(send=Send("2", 3))), - Send("2", GraphCommand(send=Send("2", 4))), + Send("2", Command(goto=Send("2", 3))), + Send("2", Command(goto=Send("2", 4))), "3.1", ] @@ -2602,8 +2602,8 @@ async def route_to_three(state) -> Literal["3"]: == [ "0", "1", - "2|Command(send=Send(node='2', arg=3))", - "2|Command(send=Send(node='2', arg=4))", + "2|Command(goto=Send(node='2', arg=3))", + "2|Command(goto=Send(node='2', arg=4))", "2|3", "2|4", "3", @@ -2614,8 +2614,8 @@ async def route_to_three(state) -> Literal["3"]: "0", "1", "3.1", - "2|Command(send=Send(node='2', arg=3))", - "2|Command(send=Send(node='2', arg=4))", + "2|Command(goto=Send(node='2', arg=3))", + "2|Command(goto=Send(node='2', arg=4))", "3", "2|3", "2|4", @@ -2632,16 +2632,16 @@ async def route_to_three(state) -> Literal["3"]: assert await graph.ainvoke(["0"], thread1) == [ "0", "1", - "2|Command(send=Send(node='2', arg=3))", - "2|Command(send=Send(node='2', arg=4))", + "2|Command(goto=Send(node='2', arg=3))", + "2|Command(goto=Send(node='2', arg=4))", "2|3", "2|4", ] assert await graph.ainvoke(None, thread1) == [ "0", "1", - "2|Command(send=Send(node='2', arg=3))", - "2|Command(send=Send(node='2', arg=4))", + "2|Command(goto=Send(node='2', arg=3))", + "2|Command(goto=Send(node='2', arg=4))", "2|3", "2|4", "3", @@ -2677,15 +2677,15 @@ def __call__(self, state): if isinstance(state, list) else ["|".join((self.name, str(state)))] ) - if isinstance(state, GraphCommand): + if isinstance(state, Command): return replace(state, update=update) else: return update def send_for_fun(state): return [ - Send("2", GraphCommand(send=Send("2", 3))), - Send("2", GraphCommand(send=Send("flaky", 4))), + Send("2", Command(goto=Send("2", 3))), + Send("2", Command(goto=Send("flaky", 4))), "3.1", ] @@ -2708,8 +2708,8 @@ def route_to_three(state) -> Literal["3"]: assert await graph.ainvoke(["0"], thread1, debug=1) == [ "0", "1", - "2|Command(send=Send(node='2', arg=3))", - "2|Command(send=Send(node='flaky', arg=4))", + "2|Command(goto=Send(node='2', arg=3))", + "2|Command(goto=Send(node='flaky', arg=4))", "2|3", ] assert builder.nodes["2"].runnable.func.ticks == 3 @@ -2718,8 +2718,8 @@ def route_to_three(state) -> Literal["3"]: assert await graph.ainvoke(None, thread1, debug=1) == [ "0", "1", - "2|Command(send=Send(node='2', arg=3))", - "2|Command(send=Send(node='flaky', arg=4))", + "2|Command(goto=Send(node='2', arg=3))", + "2|Command(goto=Send(node='flaky', arg=4))", "2|3", "flaky|4", "3", @@ -2736,8 +2736,8 @@ def route_to_three(state) -> Literal["3"]: values=[ "0", "1", - "2|Command(send=Send(node='2', arg=3))", - "2|Command(send=Send(node='flaky', arg=4))", + "2|Command(goto=Send(node='2', arg=3))", + "2|Command(goto=Send(node='flaky', arg=4))", "2|3", "flaky|4", "3", @@ -2772,8 +2772,8 @@ def route_to_three(state) -> Literal["3"]: values=[ "0", "1", - "2|Command(send=Send(node='2', arg=3))", - "2|Command(send=Send(node='flaky', arg=4))", + "2|Command(goto=Send(node='2', arg=3))", + "2|Command(goto=Send(node='flaky', arg=4))", "2|3", "flaky|4", ], @@ -2790,8 +2790,8 @@ def route_to_three(state) -> Literal["3"]: "writes": { "1": ["1"], "2": [ - ["2|Command(send=Send(node='2', arg=3))"], - ["2|Command(send=Send(node='flaky', arg=4))"], + ["2|Command(goto=Send(node='2', arg=3))"], + ["2|Command(goto=Send(node='flaky', arg=4))"], ["2|3"], ], "flaky": ["flaky|4"], @@ -2876,7 +2876,7 @@ def route_to_three(state) -> Literal["3"]: error=None, interrupts=(), state=None, - result=["2|Command(send=Send(node='2', arg=3))"], + result=["2|Command(goto=Send(node='2', arg=3))"], ), PregelTask( id=AnyStr(), @@ -2890,7 +2890,7 @@ def route_to_three(state) -> Literal["3"]: error=None, interrupts=(), state=None, - result=["2|Command(send=Send(node='flaky', arg=4))"], + result=["2|Command(goto=Send(node='flaky', arg=4))"], ), PregelTask( id=AnyStr(), @@ -3448,9 +3448,9 @@ async def test_send_react_interrupt_control( ) async def agent(state) -> Command[Literal["foo"]]: - return GraphCommand( + return Command( update={"messages": ai_message}, - send=[Send(call["name"], call) for call in ai_message.tool_calls], + goto=[Send(call["name"], call) for call in ai_message.tool_calls], ) foo_called = 0 @@ -3761,13 +3761,13 @@ async def route_to_three(state) -> Literal["3"]: @pytest.mark.parametrize("checkpointer_name", ALL_CHECKPOINTERS_ASYNC) async def test_max_concurrency_control(checkpointer_name: str) -> None: - async def node1(state) -> GraphCommand[Literal["2"]]: - return GraphCommand(update=["1"], send=[Send("2", idx) for idx in range(100)]) + async def node1(state) -> Command[Literal["2"]]: + return Command(update=["1"], goto=[Send("2", idx) for idx in range(100)]) node2_currently = 0 node2_max_currently = 0 - async def node2(state) -> GraphCommand[Literal["3"]]: + async def node2(state) -> Command[Literal["3"]]: nonlocal node2_currently, node2_max_currently node2_currently += 1 if node2_currently > node2_max_currently: @@ -3775,7 +3775,7 @@ async def node2(state) -> GraphCommand[Literal["3"]]: await asyncio.sleep(0.1) node2_currently -= 1 - return GraphCommand(update=[state], goto="3") + return Command(update=[state], goto="3") async def node3(state) -> Literal["3"]: return ["3"] @@ -12788,9 +12788,9 @@ async def test_parent_command(checkpointer_name: str) -> None: from langchain_core.tools import tool @tool(return_direct=True) - def get_user_name() -> GraphCommand: + def get_user_name() -> Command: """Retrieve user name""" - return GraphCommand(update={"user_name": "Meow"}, graph=GraphCommand.PARENT) + return Command(update={"user_name": "Meow"}, graph=Command.PARENT) subgraph_builder = StateGraph(MessagesState) subgraph_builder.add_node("tool", get_user_name) diff --git a/libs/scheduler-kafka/tests/test_push.py b/libs/scheduler-kafka/tests/test_push.py index 15e9211a28..3d2e4d43d8 100644 --- a/libs/scheduler-kafka/tests/test_push.py +++ b/libs/scheduler-kafka/tests/test_push.py @@ -11,10 +11,10 @@ from langgraph.checkpoint.base import BaseCheckpointSaver from langgraph.constants import FF_SEND_V2, START from langgraph.errors import NodeInterrupt -from langgraph.graph.state import CompiledStateGraph, GraphCommand, StateGraph +from langgraph.graph.state import CompiledStateGraph, StateGraph from langgraph.scheduler.kafka import serde from langgraph.scheduler.kafka.types import MessageToOrchestrator, Topics -from langgraph.types import Send +from langgraph.types import Command, Send from tests.any import AnyDict from tests.drain import drain_topics_async @@ -48,15 +48,15 @@ def __call__(self, state): if isinstance(state, list) else ["|".join((self.name, str(state)))] ) - if isinstance(state, GraphCommand): + if isinstance(state, Command): return state.copy(update=update) else: return update def send_for_fun(state): return [ - Send("2", GraphCommand(send=Send("2", 3))), - Send("2", GraphCommand(send=Send("flaky", 4))), + Send("2", Command(goto=Send("2", 3))), + Send("2", Command(goto=Send("flaky", 4))), "3.1", ] @@ -105,8 +105,8 @@ async def test_push_graph(topics: Topics, acheckpointer: BaseCheckpointSaver) -> == [ "0", "1", - "2|Control(send=Send(node='2', arg=3))", - "2|Control(send=Send(node='flaky', arg=4))", + "2|Control(goto=Send(node='2', arg=3))", + "2|Control(goto=Send(node='flaky', arg=4))", "2|3", ] ) @@ -182,8 +182,8 @@ async def test_push_graph(topics: Topics, acheckpointer: BaseCheckpointSaver) -> == [ "0", "1", - "2|Control(send=Send(node='2', arg=3))", - "2|Control(send=Send(node='flaky', arg=4))", + "2|Control(goto=Send(node='2', arg=3))", + "2|Control(goto=Send(node='flaky', arg=4))", "2|3", "flaky|4", "3", diff --git a/libs/scheduler-kafka/tests/test_push_sync.py b/libs/scheduler-kafka/tests/test_push_sync.py index 27cd96cb70..ee33d613ee 100644 --- a/libs/scheduler-kafka/tests/test_push_sync.py +++ b/libs/scheduler-kafka/tests/test_push_sync.py @@ -10,11 +10,11 @@ from langgraph.checkpoint.base import BaseCheckpointSaver from langgraph.constants import FF_SEND_V2, START from langgraph.errors import NodeInterrupt -from langgraph.graph.state import CompiledStateGraph, GraphCommand, StateGraph +from langgraph.graph.state import CompiledStateGraph, StateGraph from langgraph.scheduler.kafka import serde from langgraph.scheduler.kafka.default_sync import DefaultProducer from langgraph.scheduler.kafka.types import MessageToOrchestrator, Topics -from langgraph.types import Send +from langgraph.types import Command, Send from tests.any import AnyDict from tests.drain import drain_topics @@ -48,15 +48,15 @@ def __call__(self, state): if isinstance(state, list) else ["|".join((self.name, str(state)))] ) - if isinstance(state, GraphCommand): + if isinstance(state, Command): return state.copy(update=update) else: return update def send_for_fun(state): return [ - Send("2", GraphCommand(send=Send("2", 3))), - Send("2", GraphCommand(send=Send("flaky", 4))), + Send("2", Command(goto=Send("2", 3))), + Send("2", Command(goto=Send("flaky", 4))), "3.1", ] @@ -106,8 +106,8 @@ def test_push_graph(topics: Topics, acheckpointer: BaseCheckpointSaver) -> None: == [ "0", "1", - "2|Control(send=Send(node='2', arg=3))", - "2|Control(send=Send(node='flaky', arg=4))", + "2|Control(goto=Send(node='2', arg=3))", + "2|Control(goto=Send(node='flaky', arg=4))", "2|3", ] ) @@ -184,8 +184,8 @@ def test_push_graph(topics: Topics, acheckpointer: BaseCheckpointSaver) -> None: == [ "0", "1", - "2|Control(send=Send(node='2', arg=3))", - "2|Control(send=Send(node='flaky', arg=4))", + "2|Control(goto=Send(node='2', arg=3))", + "2|Control(goto=Send(node='flaky', arg=4))", "2|3", "flaky|4", "3", diff --git a/libs/sdk-py/langgraph_sdk/schema.py b/libs/sdk-py/langgraph_sdk/schema.py index 1ccae3e891..6237ea5bd5 100644 --- a/libs/sdk-py/langgraph_sdk/schema.py +++ b/libs/sdk-py/langgraph_sdk/schema.py @@ -373,6 +373,6 @@ class Send(TypedDict): class Command(TypedDict, total=False): - send: Union[Send, Sequence[Send]] + goto: Union[Send, str, Sequence[Union[Send, str]]] update: dict[str, Any] resume: Any From df70e91daecac6b7d2b187b7c67a5c725e7dbe11 Mon Sep 17 00:00:00 2001 From: Nuno Campos Date: Wed, 4 Dec 2024 15:13:55 -0800 Subject: [PATCH 12/31] Lint --- libs/langgraph/langgraph/pregel/io.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libs/langgraph/langgraph/pregel/io.py b/libs/langgraph/langgraph/pregel/io.py index c1fed349ab..b2596d3ad9 100644 --- a/libs/langgraph/langgraph/pregel/io.py +++ b/libs/langgraph/langgraph/pregel/io.py @@ -73,7 +73,7 @@ def map_command( if cmd.graph == Command.PARENT: raise InvalidUpdateError("There is not parent graph") if cmd.goto: - if isinstance(cmd.send, (tuple, list)): + if isinstance(cmd.goto, (tuple, list)): sends = cmd.goto else: sends = [cmd.goto] From 771b9b28cd78a8bebae4e115c07c588d0436efd1 Mon Sep 17 00:00:00 2001 From: Nuno Campos Date: Wed, 4 Dec 2024 15:29:51 -0800 Subject: [PATCH 13/31] Speed up tests --- .github/workflows/_test_langgraph.yml | 2 +- libs/langgraph/Makefile | 6 ++++++ libs/langgraph/tests/test_pregel.py | 1 - libs/langgraph/tests/test_pregel_async.py | 3 --- 4 files changed, 7 insertions(+), 5 deletions(-) diff --git a/.github/workflows/_test_langgraph.yml b/.github/workflows/_test_langgraph.yml index 5c3f5182e3..2708d0f238 100644 --- a/.github/workflows/_test_langgraph.yml +++ b/.github/workflows/_test_langgraph.yml @@ -60,7 +60,7 @@ jobs: env: LANGGRAPH_FF_SEND_V2: ${{ matrix.ff-send-v2 }} run: | - make test + make test_parallel - name: Ensure the tests did not create any additional files shell: bash diff --git a/libs/langgraph/Makefile b/libs/langgraph/Makefile index 43d0c7afe0..8974fcd322 100644 --- a/libs/langgraph/Makefile +++ b/libs/langgraph/Makefile @@ -48,6 +48,12 @@ test: make stop-postgres; \ exit $$EXIT_CODE +test_parallel: + make start-postgres && poetry run pytest -n auto --dist worksteal $(TEST); \ + EXIT_CODE=$$?; \ + make stop-postgres; \ + exit $$EXIT_CODE + WORKERS ?= auto XDIST_ARGS := $(if $(WORKERS),-n $(WORKERS) --dist worksteal,) MAXFAIL ?= diff --git a/libs/langgraph/tests/test_pregel.py b/libs/langgraph/tests/test_pregel.py index 68071594bf..f69d36ed33 100644 --- a/libs/langgraph/tests/test_pregel.py +++ b/libs/langgraph/tests/test_pregel.py @@ -1969,7 +1969,6 @@ def route_to_three(state) -> Literal["3"]: ) -@pytest.mark.repeat(20) @pytest.mark.parametrize("checkpointer_name", ALL_CHECKPOINTERS_SYNC) def test_send_dedupe_on_resume( request: pytest.FixtureRequest, checkpointer_name: str diff --git a/libs/langgraph/tests/test_pregel_async.py b/libs/langgraph/tests/test_pregel_async.py index 538730c78b..5147037812 100644 --- a/libs/langgraph/tests/test_pregel_async.py +++ b/libs/langgraph/tests/test_pregel_async.py @@ -847,7 +847,6 @@ async def iambad(input: State) -> None: assert awhiles == 1 -@pytest.mark.repeat(10) async def test_step_timeout_on_stream_hang() -> None: inner_task_cancelled = False @@ -2559,7 +2558,6 @@ async def route_to_three(state) -> Literal["3"]: ) -@pytest.mark.repeat(10) @pytest.mark.parametrize("checkpointer_name", ALL_CHECKPOINTERS_ASYNC) async def test_send_sequences(checkpointer_name: str) -> None: class Node: @@ -2649,7 +2647,6 @@ async def route_to_three(state) -> Literal["3"]: ] -@pytest.mark.repeat(20) @pytest.mark.parametrize("checkpointer_name", ALL_CHECKPOINTERS_ASYNC) async def test_send_dedupe_on_resume(checkpointer_name: str) -> None: if not FF_SEND_V2: From 7a326ef7688ce80a3517f234a084b03dd75f8e1e Mon Sep 17 00:00:00 2001 From: Nuno Campos Date: Wed, 4 Dec 2024 15:44:24 -0800 Subject: [PATCH 14/31] lib 0.2.55 --- libs/langgraph/pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libs/langgraph/pyproject.toml b/libs/langgraph/pyproject.toml index e66600939b..cee26320e7 100644 --- a/libs/langgraph/pyproject.toml +++ b/libs/langgraph/pyproject.toml @@ -1,6 +1,6 @@ [tool.poetry] name = "langgraph" -version = "0.2.54" +version = "0.2.55" description = "Building stateful, multi-actor applications with LLMs" authors = [] license = "MIT" From dad0f39fa47ed1e77ca461c39357511bb29d930f Mon Sep 17 00:00:00 2001 From: Eugene Yurtsev Date: Wed, 4 Dec 2024 18:49:17 -0500 Subject: [PATCH 15/31] concepts: reword network architecture (#2625) --- docs/docs/concepts/multi_agent.md | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/docs/docs/concepts/multi_agent.md b/docs/docs/concepts/multi_agent.md index 46bf4eedae..d8ef0a73bd 100644 --- a/docs/docs/concepts/multi_agent.md +++ b/docs/docs/concepts/multi_agent.md @@ -28,12 +28,7 @@ There are several ways to connect agents in a multi-agent system: ### Network -In this architecture, agents are defined as graph nodes. Each agent can communicate with every other agent (many-to-many connections) and can decide which agent to call next. While very flexible, this architecture doesn't scale well as the number of agents grows: - -- hard to enforce which agent should be called next -- hard to determine how much [information](#shared-message-list) should be passed between the agents - -We recommend avoiding this architecture in production and using one of the below architectures instead. +In this architecture, agents are defined as graph nodes. Each agent can communicate with every other agent (many-to-many connections) and can decide which agent to call next. This architecture is good for problems that do not have a clear hierarchy of agents or a specific sequence in which agents should be called. ### Supervisor From 257e44ccb40b6efe943f007d93221e22aa75cb53 Mon Sep 17 00:00:00 2001 From: vbarda Date: Wed, 4 Dec 2024 18:46:29 -0500 Subject: [PATCH 16/31] update --- docs/docs/concepts/low_level.md | 32 ++++++++++++------------- docs/docs/how-tos/graph-command.ipynb | 34 +++++++++++++-------------- libs/langgraph/langgraph/types.py | 6 ++++- 3 files changed, 38 insertions(+), 34 deletions(-) diff --git a/docs/docs/concepts/low_level.md b/docs/docs/concepts/low_level.md index 75ff6d4a37..c775eae81d 100644 --- a/docs/docs/concepts/low_level.md +++ b/docs/docs/concepts/low_level.md @@ -322,13 +322,13 @@ def continue_to_jokes(state: OverallState): graph.add_conditional_edges("node_a", continue_to_jokes) ``` -## `GraphCommand` +## `Command` -It can be useful to combine control flow (edges) and state updates (nodes). For example, you might want to BOTH perform state updates AND decide which node to go to next in the SAME node. LangGraph provides a way to do so by returning a [`GraphCommand`][langgraph.graph.state.GraphCommand] object from node functions: +It can be useful to combine control flow (edges) and state updates (nodes). For example, you might want to BOTH perform state updates AND decide which node to go to next in the SAME node. LangGraph provides a way to do so by returning a [`Command`][langgraph.graph.state.GraphCommand] object from node functions: ```python -def my_node(state: State) -> GraphCommand[Literal["my_other_node"]]: - return GraphCommand( +def my_node(state: State) -> Command[Literal["my_other_node"]]: + return Command( # state update update={"foo": "bar"}, # control flow @@ -336,25 +336,25 @@ def my_node(state: State) -> GraphCommand[Literal["my_other_node"]]: ) ``` -`GraphCommand` has the following properties: +`Command` has the following properties: | Property | Description | | --- | --- | -| `graph` | Graph to send the command to. Supported values:
- `None`: the current graph (default)
- `GraphCommand.PARENT`: parent graph | -| `goto` | Name of the node to navigate to next. Can be any node that belongs to the specified `graph` (current or parent). If `goto` not specified, the graph will halt after executing the current superstep. | +| `graph` | Graph to send the command to. Supported values:
- `None`: the current graph (default)
- `GraphCommand.PARENT`: closest parent graph | | `update` | State update to apply to the graph's state at the current superstep | -| `send` | List of [`Send`](#send) objects to send to other nodes | | `resume` | Value to resume execution with. Will be used when `interrupt()` is called | +| `goto` | Can be one of the following:
- name of the node to navigate to next (any node that belongs to the specified `graph`)
- list of node names to navigate to next
- `Send` object
- sequence of `Send` objects
If `goto` is not specified and there are no other tasks left in the graph, the graph will halt after executing the current superstep. | ```python -from langgraph.graph import GraphCommand, StateGraph, START +from langgraph.graph import StateGraph, START +from langgraph.types import Command from typing_extensions import Literal, TypedDict class State(TypedDict): foo: str -def my_node(state: State) -> GraphCommand[Literal["my_other_node"]]: - return GraphCommand(update={"foo": "bar"}, goto="my_other_node") +def my_node(state: State) -> Command[Literal["my_other_node"]]: + return Command(update={"foo": "bar"}, goto="my_other_node") def my_other_node(state: State): return {"foo": state["foo"] + "baz"} @@ -367,17 +367,17 @@ builder.add_node("my_other_node", my_other_node) graph = builder.compile() ``` -With `GraphCommand` you can also achieve dynamic control flow behavior (identical to [conditional edges](#conditional-edges)): +With `Command` you can also achieve dynamic control flow behavior (identical to [conditional edges](#conditional-edges)): ```python -def my_node(state: State) -> GraphCommand[Literal["my_other_node", "__end__"]]: +def my_node(state: State) -> Command[Literal["my_other_node", "__end__"]]: if state["foo"] == "bar": - return GraphCommand(update={"foo": "baz"}, goto="my_other_node") + return Command(update={"foo": "baz"}, goto="my_other_node") else: - return GraphCommand(goto="__end__") + return Command(goto="__end__") ``` -Check out this [how-to guide](../how-tos/graph-command.ipynb) for an end-to-end example of how to use `GraphCommand`. +Check out this [how-to guide](../how-tos/graph-command.ipynb) for an end-to-end example of how to use `Command`. ## Persistence diff --git a/docs/docs/how-tos/graph-command.ipynb b/docs/docs/how-tos/graph-command.ipynb index b768e75a81..ad33e3a62a 100644 --- a/docs/docs/how-tos/graph-command.ipynb +++ b/docs/docs/how-tos/graph-command.ipynb @@ -5,7 +5,7 @@ "id": "d33ecddc-6818-41a3-9d0d-b1b1cbcd286d", "metadata": {}, "source": [ - "# How to combine control flow and state updates with GraphCommand" + "# How to combine control flow and state updates with Command" ] }, { @@ -19,12 +19,12 @@ " - [State](../../concepts/low_level/#state)\n", " - [Nodes](../../concepts/low_level/#nodes)\n", " - [Edges](../../concepts/low_level/#edges)\n", - " - [GraphCommand](../../concepts/low_level/#graphcommand)\n", + " - [Command](../../concepts/low_level/#command)\n", "\n", - "It can be useful to combine control flow (edges) and state updates (nodes). For example, you might want to BOTH perform state updates AND decide which node to go to next in the SAME node. LangGraph provides a way to do so by returning a `GraphCommand` object from node functions:\n", + "It can be useful to combine control flow (edges) and state updates (nodes). For example, you might want to BOTH perform state updates AND decide which node to go to next in the SAME node. LangGraph provides a way to do so by returning a `Command` object from node functions:\n", "\n", "```python\n", - "def my_node(state: State) -> GraphCommand[Literal[\"my_other_node\"]]:\n", + "def my_node(state: State) -> Command[Literal[\"my_other_node\"]]:\n", " return GraphCommand(\n", " # state update\n", " update={\"foo\": \"bar\"},\n", @@ -33,7 +33,7 @@ " )\n", "```\n", "\n", - "This guide shows how you can do use `GraphCommand` to add dynamic control flow in your LangGraph app." + "This guide shows how you can do use `Command` to add dynamic control flow in your LangGraph app." ] }, { @@ -83,7 +83,7 @@ "id": "6a08d957-b3d2-4538-bf4a-68ef90a51b98", "metadata": {}, "source": [ - "## Control flow with GraphCommand" + "## Control flow with Command" ] }, { @@ -96,7 +96,8 @@ "import random\n", "from typing_extensions import TypedDict, Literal\n", "\n", - "from langgraph.graph import GraphCommand, StateGraph, START\n", + "from langgraph.graph import StateGraph, START\n", + "from langgraph.types import Command\n", "\n", "\n", "# Define graph state\n", @@ -107,7 +108,7 @@ "# Define the nodes\n", "\n", "\n", - "def node_a(state: State) -> GraphCommand[Literal[\"node_b\", \"node_c\"]]:\n", + "def node_a(state: State) -> Command[Literal[\"node_b\", \"node_c\"]]:\n", " print(\"Called A\")\n", " value = random.choice([\"a\", \"b\"])\n", " # this is a replacement for a conditional edge function\n", @@ -116,8 +117,8 @@ " else:\n", " goto = \"node_c\"\n", "\n", - " # note how GraphCommand allows you to BOTH update the graph state AND route to the next node\n", - " return GraphCommand(\n", + " # note how Command allows you to BOTH update the graph state AND route to the next node\n", + " return Command(\n", " # this is the state update\n", " update={\"foo\": value},\n", " # this is a replacement for an edge\n", @@ -130,7 +131,6 @@ "\n", "def node_b(state: State):\n", " print(\"Called B\")\n", - " # graph command can also be used\n", " return {\"foo\": state[\"foo\"] + \"b\"}\n", "\n", "\n", @@ -171,7 +171,7 @@ "source": [ "!!! important\n", "\n", - " You might have noticed that we used `GraphCommand` as a return type annotation, e.g. `GraphCommand[Literal[\"node_b\", \"node_c\"]]`. This is necessary for the graph compilation and rendering, and tells LangGraph that `node_a` can navigate to `node_b` and `node_c`." + " You might have noticed that we used `Command` as a return type annotation, e.g. `Command[Literal[\"node_b\", \"node_c\"]]`. This is necessary for the graph compilation and rendering, and tells LangGraph that `node_a` can navigate to `node_b` and `node_c`." ] }, { @@ -216,13 +216,13 @@ "output_type": "stream", "text": [ "Called A\n", - "Called B\n" + "Called C\n" ] }, { "data": { "text/plain": [ - "{'foo': 'ab'}" + "{'foo': 'bc'}" ] }, "execution_count": 5, @@ -237,9 +237,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "langgraph", "language": "python", - "name": "python3" + "name": "langgraph" }, "language_info": { "codemirror_mode": { @@ -251,7 +251,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.3" + "version": "3.11.9" } }, "nbformat": 4, diff --git a/libs/langgraph/langgraph/types.py b/libs/langgraph/langgraph/types.py index 98f9e350d8..28e5a59406 100644 --- a/libs/langgraph/langgraph/types.py +++ b/libs/langgraph/langgraph/types.py @@ -252,8 +252,12 @@ class Command(Generic[N]): - None: the current graph (default) - GraphCommand.PARENT: closest parent graph update: state update to apply to the graph's state at the current superstep. - send: list of `Send` objects to send to other nodes. resume: value to resume execution with. Will be used when `interrupt()` is called. + goto: can be one of the following: + - name of the node to navigate to next (any node that belongs to the specified `graph`) + - list of node names to navigate to next + - `Send` object + - sequence of `Send` objects """ graph: Optional[str] = None From 5570121c8388d2d2c32c5f9f8204646c4657cb8c Mon Sep 17 00:00:00 2001 From: vbarda Date: Wed, 4 Dec 2024 18:56:46 -0500 Subject: [PATCH 17/31] update --- docs/docs/concepts/low_level.md | 4 ++-- docs/docs/reference/graphs.md | 1 - 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/docs/docs/concepts/low_level.md b/docs/docs/concepts/low_level.md index c775eae81d..d06dea7508 100644 --- a/docs/docs/concepts/low_level.md +++ b/docs/docs/concepts/low_level.md @@ -324,7 +324,7 @@ graph.add_conditional_edges("node_a", continue_to_jokes) ## `Command` -It can be useful to combine control flow (edges) and state updates (nodes). For example, you might want to BOTH perform state updates AND decide which node to go to next in the SAME node. LangGraph provides a way to do so by returning a [`Command`][langgraph.graph.state.GraphCommand] object from node functions: +It can be useful to combine control flow (edges) and state updates (nodes). For example, you might want to BOTH perform state updates AND decide which node to go to next in the SAME node. LangGraph provides a way to do so by returning a [`Command`][langgraph.types.Command] object from node functions: ```python def my_node(state: State) -> Command[Literal["my_other_node"]]: @@ -340,7 +340,7 @@ def my_node(state: State) -> Command[Literal["my_other_node"]]: | Property | Description | | --- | --- | -| `graph` | Graph to send the command to. Supported values:
- `None`: the current graph (default)
- `GraphCommand.PARENT`: closest parent graph | +| `graph` | Graph to send the command to. Supported values:
- `None`: the current graph (default)
- `Command.PARENT`: closest parent graph | | `update` | State update to apply to the graph's state at the current superstep | | `resume` | Value to resume execution with. Will be used when `interrupt()` is called | | `goto` | Can be one of the following:
- name of the node to navigate to next (any node that belongs to the specified `graph`)
- list of node names to navigate to next
- `Send` object
- sequence of `Send` objects
If `goto` is not specified and there are no other tasks left in the graph, the graph will halt after executing the current superstep. | diff --git a/docs/docs/reference/graphs.md b/docs/docs/reference/graphs.md index fef38e1593..c67e2136af 100644 --- a/docs/docs/reference/graphs.md +++ b/docs/docs/reference/graphs.md @@ -11,7 +11,6 @@ members: - StateGraph - CompiledStateGraph - - GraphCommand ::: langgraph.graph.message options: From 19a6e894eb8e39b2a2d085c2c2c7890dbe7f4d06 Mon Sep 17 00:00:00 2001 From: vbarda Date: Wed, 4 Dec 2024 19:02:49 -0500 Subject: [PATCH 18/31] more updates --- docs/docs/concepts/low_level.md | 3 +++ docs/docs/how-tos/graph-command.ipynb | 8 ++++---- 2 files changed, 7 insertions(+), 4 deletions(-) diff --git a/docs/docs/concepts/low_level.md b/docs/docs/concepts/low_level.md index d06dea7508..3b3806a970 100644 --- a/docs/docs/concepts/low_level.md +++ b/docs/docs/concepts/low_level.md @@ -283,6 +283,9 @@ You can optionally provide a dictionary that maps the `routing_function`'s outpu graph.add_conditional_edges("node_a", routing_function, {True: "node_b", False: "node_c"}) ``` +!!! tip + Use [`Command`](#command) instead of conditional edges if you need to combine state updates and routing. + ### Entry Point The entry point is the first node(s) that are run when the graph starts. You can use the [`add_edge`][langgraph.graph.StateGraph.add_edge] method from the virtual [`START`][langgraph.constants.START] node to the first node to execute to specify where to enter the graph. diff --git a/docs/docs/how-tos/graph-command.ipynb b/docs/docs/how-tos/graph-command.ipynb index ad33e3a62a..3f3a4c0efa 100644 --- a/docs/docs/how-tos/graph-command.ipynb +++ b/docs/docs/how-tos/graph-command.ipynb @@ -83,7 +83,7 @@ "id": "6a08d957-b3d2-4538-bf4a-68ef90a51b98", "metadata": {}, "source": [ - "## Control flow with Command" + "## Define graph" ] }, { @@ -237,9 +237,9 @@ ], "metadata": { "kernelspec": { - "display_name": "langgraph", + "display_name": "Python 3 (ipykernel)", "language": "python", - "name": "langgraph" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -251,7 +251,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.9" + "version": "3.12.3" } }, "nbformat": 4, From 085395c824b2cdbbe9449a1763e09459f48a771f Mon Sep 17 00:00:00 2001 From: vbarda Date: Wed, 4 Dec 2024 19:04:42 -0500 Subject: [PATCH 19/31] rename --- docs/docs/concepts/low_level.md | 2 +- docs/docs/how-tos/{graph-command.ipynb => command.ipynb} | 0 docs/docs/how-tos/index.md | 2 +- docs/mkdocs.yml | 2 +- 4 files changed, 3 insertions(+), 3 deletions(-) rename docs/docs/how-tos/{graph-command.ipynb => command.ipynb} (100%) diff --git a/docs/docs/concepts/low_level.md b/docs/docs/concepts/low_level.md index 3b3806a970..fab9c3e033 100644 --- a/docs/docs/concepts/low_level.md +++ b/docs/docs/concepts/low_level.md @@ -380,7 +380,7 @@ def my_node(state: State) -> Command[Literal["my_other_node", "__end__"]]: return Command(goto="__end__") ``` -Check out this [how-to guide](../how-tos/graph-command.ipynb) for an end-to-end example of how to use `Command`. +Check out this [how-to guide](../how-tos/command.ipynb) for an end-to-end example of how to use `Command`. ## Persistence diff --git a/docs/docs/how-tos/graph-command.ipynb b/docs/docs/how-tos/command.ipynb similarity index 100% rename from docs/docs/how-tos/graph-command.ipynb rename to docs/docs/how-tos/command.ipynb diff --git a/docs/docs/how-tos/index.md b/docs/docs/how-tos/index.md index 1c60818ae9..297bfd3e0c 100644 --- a/docs/docs/how-tos/index.md +++ b/docs/docs/how-tos/index.md @@ -20,7 +20,7 @@ These how-to guides show how to achieve that controllability. - [How to create branches for parallel execution](branching.ipynb) - [How to create map-reduce branches for parallel execution](map-reduce.ipynb) - [How to control graph recursion limit](recursion-limit.ipynb) -- [How to combine control flow and state updates with GraphCommand](graph-command.ipynb) +- [How to combine control flow and state updates with Command](command.ipynb) ### Persistence diff --git a/docs/mkdocs.yml b/docs/mkdocs.yml index 882e3cdfd7..bc1ff59ea0 100644 --- a/docs/mkdocs.yml +++ b/docs/mkdocs.yml @@ -151,7 +151,7 @@ nav: - how-tos/branching.ipynb - how-tos/map-reduce.ipynb - how-tos/recursion-limit.ipynb - - how-tos/graph-command.ipynb + - how-tos/command.ipynb - Persistence: - Persistence: how-tos#persistence - how-tos/persistence.ipynb From f028984b2ee3664869bf16a96796ff1b0ff0b085 Mon Sep 17 00:00:00 2001 From: Vadym Barda Date: Wed, 4 Dec 2024 19:07:50 -0500 Subject: [PATCH 20/31] langgraph: remove print (#2640) --- libs/langgraph/langgraph/types.py | 1 - 1 file changed, 1 deletion(-) diff --git a/libs/langgraph/langgraph/types.py b/libs/langgraph/langgraph/types.py index 67c7e53f8a..bd6e94d19e 100644 --- a/libs/langgraph/langgraph/types.py +++ b/libs/langgraph/langgraph/types.py @@ -350,7 +350,6 @@ def interrupt(value: Any) -> Any: if tid == NULL_TASK_ID and c == RESUME: assert len(scratchpad["resume"]) == idx, (scratchpad["resume"], idx) scratchpad["resume"].append(v) - print("saving:", scratchpad["resume"]) conf[CONFIG_KEY_SEND]([(RESUME, scratchpad["resume"])]) return v # no resume value found From 6caaa8cea7aed7e9cd3e11ff8b22ad6c795a8724 Mon Sep 17 00:00:00 2001 From: Vadym Barda Date: Wed, 4 Dec 2024 19:16:26 -0500 Subject: [PATCH 21/31] Update libs/langgraph/langgraph/types.py Co-authored-by: Nuno Campos --- libs/langgraph/langgraph/types.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libs/langgraph/langgraph/types.py b/libs/langgraph/langgraph/types.py index 28e5a59406..fcfd993181 100644 --- a/libs/langgraph/langgraph/types.py +++ b/libs/langgraph/langgraph/types.py @@ -256,7 +256,7 @@ class Command(Generic[N]): goto: can be one of the following: - name of the node to navigate to next (any node that belongs to the specified `graph`) - list of node names to navigate to next - - `Send` object + - `Send` object (to execute a node with the input provided) - sequence of `Send` objects """ From 1a492f727c12d1c1dfcd5719d82c026e67ca6f2c Mon Sep 17 00:00:00 2001 From: Vadym Barda Date: Wed, 4 Dec 2024 19:16:33 -0500 Subject: [PATCH 22/31] Update libs/langgraph/langgraph/types.py Co-authored-by: Nuno Campos --- libs/langgraph/langgraph/types.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libs/langgraph/langgraph/types.py b/libs/langgraph/langgraph/types.py index fcfd993181..6503bde3b0 100644 --- a/libs/langgraph/langgraph/types.py +++ b/libs/langgraph/langgraph/types.py @@ -251,7 +251,7 @@ class Command(Generic[N]): graph: graph to send the command to. Supported values are: - None: the current graph (default) - GraphCommand.PARENT: closest parent graph - update: state update to apply to the graph's state at the current superstep. + update: update to apply to the graph's state. resume: value to resume execution with. Will be used when `interrupt()` is called. goto: can be one of the following: - name of the node to navigate to next (any node that belongs to the specified `graph`) From 7651f1ab1cfc32ddea62271ccd0922722194b326 Mon Sep 17 00:00:00 2001 From: Vadym Barda Date: Wed, 4 Dec 2024 19:17:22 -0500 Subject: [PATCH 23/31] Update libs/langgraph/langgraph/types.py Co-authored-by: Nuno Campos --- libs/langgraph/langgraph/types.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libs/langgraph/langgraph/types.py b/libs/langgraph/langgraph/types.py index 6503bde3b0..1780c0a7f2 100644 --- a/libs/langgraph/langgraph/types.py +++ b/libs/langgraph/langgraph/types.py @@ -252,7 +252,7 @@ class Command(Generic[N]): - None: the current graph (default) - GraphCommand.PARENT: closest parent graph update: update to apply to the graph's state. - resume: value to resume execution with. Will be used when `interrupt()` is called. + resume: value to resume execution with. To be used together with `interrupt()`. goto: can be one of the following: - name of the node to navigate to next (any node that belongs to the specified `graph`) - list of node names to navigate to next From e9cd216887c3fcdfe25ec0090b51bb5c0011a655 Mon Sep 17 00:00:00 2001 From: Vadym Barda Date: Wed, 4 Dec 2024 19:18:37 -0500 Subject: [PATCH 24/31] Update docs/docs/concepts/low_level.md Co-authored-by: Nuno Campos --- docs/docs/concepts/low_level.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/docs/concepts/low_level.md b/docs/docs/concepts/low_level.md index fab9c3e033..b3df3c8826 100644 --- a/docs/docs/concepts/low_level.md +++ b/docs/docs/concepts/low_level.md @@ -284,7 +284,7 @@ graph.add_conditional_edges("node_a", routing_function, {True: "node_b", False: ``` !!! tip - Use [`Command`](#command) instead of conditional edges if you need to combine state updates and routing. + Use [`Command`](#command) instead of conditional edges if you want to combine state updates and routing in a single function. ### Entry Point From cd875291ad003d74cb0e3f685c6e2ac6227be673 Mon Sep 17 00:00:00 2001 From: William FH <13333726+hinthornw@users.noreply.github.com> Date: Wed, 4 Dec 2024 16:21:01 -0800 Subject: [PATCH 25/31] Link to conceptual doc (#2641) --- .../cassettes/semantic-search_10.msgpack.zlib | 1 + .../cassettes/semantic-search_11.msgpack.zlib | 1 - .../cassettes/semantic-search_13.msgpack.zlib | 2 +- .../cassettes/semantic-search_15.msgpack.zlib | 2 +- .../cassettes/semantic-search_17.msgpack.zlib | 2 +- .../cassettes/semantic-search_19.msgpack.zlib | 1 + docs/cassettes/semantic-search_6.msgpack.zlib | 2 +- docs/cassettes/semantic-search_8.msgpack.zlib | 2 +- docs/docs/cloud/deployment/semantic_search.md | 4 +- docs/docs/concepts/memory.md | 3 + docs/docs/how-tos/index.md | 1 + .../docs/how-tos/memory/semantic-search.ipynb | 163 +++++++++++++++--- docs/docs/tutorials/tnt-llm/tnt-llm.ipynb | 4 +- 13 files changed, 151 insertions(+), 37 deletions(-) create mode 100644 docs/cassettes/semantic-search_10.msgpack.zlib delete mode 100644 docs/cassettes/semantic-search_11.msgpack.zlib create mode 100644 docs/cassettes/semantic-search_19.msgpack.zlib diff --git a/docs/cassettes/semantic-search_10.msgpack.zlib b/docs/cassettes/semantic-search_10.msgpack.zlib new file mode 100644 index 0000000000..b55c7fcf2e --- /dev/null +++ b/docs/cassettes/semantic-search_10.msgpack.zlib @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/docs/cassettes/semantic-search_11.msgpack.zlib b/docs/cassettes/semantic-search_11.msgpack.zlib deleted file mode 100644 index efa7dbf7dd..0000000000 --- a/docs/cassettes/semantic-search_11.msgpack.zlib +++ /dev/null @@ -1 +0,0 @@ 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 \ No newline at end of file diff --git a/docs/cassettes/semantic-search_13.msgpack.zlib b/docs/cassettes/semantic-search_13.msgpack.zlib index c02706da91..b01db08460 100644 --- a/docs/cassettes/semantic-search_13.msgpack.zlib +++ b/docs/cassettes/semantic-search_13.msgpack.zlib @@ -1 +1 @@ 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 \ No newline at end of file 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 \ No newline at end of file diff --git a/docs/cassettes/semantic-search_15.msgpack.zlib b/docs/cassettes/semantic-search_15.msgpack.zlib index c453ed6747..f5810c73ac 100644 --- a/docs/cassettes/semantic-search_15.msgpack.zlib +++ b/docs/cassettes/semantic-search_15.msgpack.zlib @@ -1 +1 @@ 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 \ No newline at end of file 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 \ No newline at end of file diff --git a/docs/cassettes/semantic-search_17.msgpack.zlib b/docs/cassettes/semantic-search_17.msgpack.zlib index f0c9ab212b..23469642aa 100644 --- a/docs/cassettes/semantic-search_17.msgpack.zlib +++ b/docs/cassettes/semantic-search_17.msgpack.zlib @@ -1 +1 @@ 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 \ No newline at end of file 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 \ No newline at end of file diff --git a/docs/cassettes/semantic-search_19.msgpack.zlib b/docs/cassettes/semantic-search_19.msgpack.zlib new file mode 100644 index 0000000000..d0604b0315 --- /dev/null +++ b/docs/cassettes/semantic-search_19.msgpack.zlib @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/docs/cassettes/semantic-search_6.msgpack.zlib b/docs/cassettes/semantic-search_6.msgpack.zlib index cf72109836..9e8ecf09a6 100644 --- a/docs/cassettes/semantic-search_6.msgpack.zlib +++ b/docs/cassettes/semantic-search_6.msgpack.zlib @@ -1 +1 @@ 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 \ No newline at end of file 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 \ No newline at end of file diff --git a/docs/cassettes/semantic-search_8.msgpack.zlib b/docs/cassettes/semantic-search_8.msgpack.zlib index 786f820bca..b9b99ebd72 100644 --- a/docs/cassettes/semantic-search_8.msgpack.zlib +++ b/docs/cassettes/semantic-search_8.msgpack.zlib @@ -1 +1 @@ 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 \ No newline at end of file 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 \ No newline at end of file diff --git a/docs/docs/cloud/deployment/semantic_search.md b/docs/docs/cloud/deployment/semantic_search.md index 1ea48be139..c9dc586333 100644 --- a/docs/docs/cloud/deployment/semantic_search.md +++ b/docs/docs/cloud/deployment/semantic_search.md @@ -111,8 +111,8 @@ from langgraph_sdk import get_client async def search_store(): client = get_client() - results = await client.store.search( - namespace=("memory", "facts"), + results = await client.store.search_items( + ("memory", "facts"), query="your search query", limit=3 # number of results to return ) diff --git a/docs/docs/concepts/memory.md b/docs/docs/concepts/memory.md index 126b35993a..cdcd8ae5bf 100644 --- a/docs/docs/concepts/memory.md +++ b/docs/docs/concepts/memory.md @@ -236,6 +236,9 @@ Different applications require various types of memory. Although the analogy isn [Semantic memory](https://en.wikipedia.org/wiki/Semantic_memory), both in humans and AI agents, involves the retention of specific facts and concepts. In humans, it can include information learned in school and the understanding of concepts and their relationships. For AI agents, semantic memory is often used to personalize applications by remembering facts or concepts from past interactions. +> Note: Not to be confused with "semantic search" which is a technique for finding similar content using "meaning" (usually as embeddings). Semantic memory is a term from psychology, referring to storing facts and knowledge, while semantic search is a method for retrieving information based on meaning rather than exact matches. + + #### Profile Semantic memories can be managed in different ways. For example, memories can be a single, continuously updated "profile" of well-scoped and specific information about a user, organization, or other entity (including the agent itself). A profile is generally just a JSON document with various key-value pairs you've selected to represent your domain. diff --git a/docs/docs/how-tos/index.md b/docs/docs/how-tos/index.md index 5efbe1969c..f0c2f841d7 100644 --- a/docs/docs/how-tos/index.md +++ b/docs/docs/how-tos/index.md @@ -120,6 +120,7 @@ These guides show how to use the prebuilt ReAct agent: - [How to add a custom system prompt to a ReAct agent](create-react-agent-system-prompt.ipynb) - [How to add human-in-the-loop processes to a ReAct agent](create-react-agent-hitl.ipynb) - [How to create prebuilt ReAct agent from scratch](react-agent-from-scratch.ipynb) +- [How to add semantic search for long-term memory to a ReAct agent](memory/semantic-search.ipynb#using-in-create-react-agent) ## LangGraph Platform diff --git a/docs/docs/how-tos/memory/semantic-search.ipynb b/docs/docs/how-tos/memory/semantic-search.ipynb index 658e4bb29e..8e7a8d057b 100644 --- a/docs/docs/how-tos/memory/semantic-search.ipynb +++ b/docs/docs/how-tos/memory/semantic-search.ipynb @@ -8,12 +8,15 @@ "\n", "This guide shows how to enable semantic search in your agent's memory store. This lets search for items in the store by semantic similarity.\n", "\n", + "!!! tip Prerequisites\n", + " This guide assumes familiarity with the [memory in LangGraph](https://langchain-ai.github.io/langgraph/concepts/memory/).\n", + "\n", "First, install this guide's prerequisites." ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -23,7 +26,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -48,9 +51,18 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 2, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/gf/6rnp_mbx5914kx7qmmh7xzmw0000gn/T/ipykernel_83572/2318027494.py:5: LangChainBetaWarning: The function `init_embeddings` is in beta. It is actively being worked on, so the API may change.\n", + " embeddings = init_embeddings(\"openai:text-embedding-3-small\")\n" + ] + } + ], "source": [ "from langchain.embeddings import init_embeddings\n", "from langgraph.store.memory import InMemoryStore\n", @@ -74,7 +86,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -95,7 +107,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -122,12 +134,73 @@ "source": [ "## Using in your agent\n", "\n", - "Add semantic search to any node by injecting the store:" + "Add semantic search to any node by injecting the store." ] }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "What are you in the mood for? Since you love Italian food and pizza, would you like to order a pizza or try making one at home?" + ] + } + ], + "source": [ + "from typing import Optional\n", + "\n", + "from langchain.chat_models import init_chat_model\n", + "from langgraph.store.base import BaseStore\n", + "\n", + "from langgraph.graph import START, MessagesState, StateGraph\n", + "\n", + "llm = init_chat_model(\"openai:gpt-4o-mini\")\n", + "\n", + "\n", + "def chat(state, *, store: BaseStore):\n", + " # Search based on user's last message\n", + " items = store.search(\n", + " (\"user_123\", \"memories\"), query=state[\"messages\"][-1].content, limit=2\n", + " )\n", + " memories = \"\\n\".join(item.value[\"text\"] for item in items)\n", + " memories = f\"## Memories of user\\n{memories}\" if memories else \"\"\n", + " response = llm.invoke(\n", + " [\n", + " {\"role\": \"system\", \"content\": f\"You are a helpful assistant.\\n{memories}\"},\n", + " *state[\"messages\"],\n", + " ]\n", + " )\n", + " return {\"messages\": [response]}\n", + "\n", + "\n", + "builder = StateGraph(MessagesState)\n", + "builder.add_node(chat)\n", + "builder.add_edge(START, \"chat\")\n", + "graph = builder.compile(store=store)\n", + "\n", + "for message, metadata in graph.stream(\n", + " input={\"messages\": [{\"role\": \"user\", \"content\": \"I'm hungry\"}]},\n", + " stream_mode=\"messages\",\n", + "):\n", + " print(message.content, end=\"\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Using in `create_react_agent`\n", + "\n", + "Add semantic search to your tool calling agent by injecting the store in the `state_modifier`. You can also use the store in a tool to let your agent manually store or search for memories." + ] + }, + { + "cell_type": "code", + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -142,7 +215,7 @@ "from langgraph.prebuilt import create_react_agent\n", "\n", "\n", - "def add_memories(state, *, store: BaseStore):\n", + "def prepare_messages(state, *, store: BaseStore):\n", " # Search based on user's last message\n", " items = store.search(\n", " (\"user_123\", \"memories\"), query=state[\"messages\"][-1].content, limit=2\n", @@ -154,6 +227,7 @@ " ] + state[\"messages\"]\n", "\n", "\n", + "# You can also use the store directly within a tool!\n", "def upsert_memory(\n", " content: str,\n", " *,\n", @@ -161,6 +235,7 @@ " store: Annotated[BaseStore, InjectedToolArg],\n", "):\n", " \"\"\"Upsert a memory in the database.\"\"\"\n", + " # The LLM can use this tool to store a new memory\n", " mem_id = memory_id or uuid.uuid4()\n", " store.put(\n", " (\"user_123\", \"memories\"),\n", @@ -173,26 +248,28 @@ "agent = create_react_agent(\n", " init_chat_model(\"openai:gpt-4o-mini\"),\n", " tools=[upsert_memory],\n", - " state_modifier=add_memories,\n", + " # The state_modifier is run to prepare the messages for the LLM. It is called\n", + " # right before each LLM call\n", + " state_modifier=prepare_messages,\n", " store=store,\n", ")" ] }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "What are you in the mood for? Since you love Italian food and pizza, would you like some recommendations for a delicious pizza or a different Italian dish?" + "What are you in the mood for? Since you love Italian food and pizza, maybe something in that realm would be great! Would you like suggestions for a specific dish or restaurant?" ] } ], "source": [ - "async for message, metadata in agent.astream(\n", + "for message, metadata in agent.stream(\n", " input={\"messages\": [{\"role\": \"user\", \"content\": \"I'm hungry\"}]},\n", " stream_mode=\"messages\",\n", "):\n", @@ -212,9 +289,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Expect mem 2\n", + "Item: mem2; Score (0.5895009051396596)\n", + "Memory: Ate alone at home\n", + "Emotion: felt a bit lonely\n", + "\n", + "Expect mem1\n", + "Item: mem1; Score (0.6207546534134083)\n", + "Memory: Had pizza with friends at Mario's\n", + "Emotion: felt happy and connected\n", + "\n", + "Expect random lower score (ravioli not indexed)\n", + "Item: mem1; Score (0.2686278787315685)\n", + "Memory: Had pizza with friends at Mario's\n", + "Emotion: felt happy and connected\n", + "\n" + ] + } + ], "source": [ "# Configure store to embed both memory content and emotional context\n", "store = InMemoryStore(\n", @@ -276,7 +375,7 @@ }, { "cell_type": "code", - "execution_count": 57, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -284,12 +383,12 @@ "output_type": "stream", "text": [ "Expect mem1\n", - "Item: mem1; Score (0.3374698138722726)\n", + "Item: mem1; Score (0.3374968677940555)\n", "Memory: I love spicy food\n", "Context: At a Thai restaurant\n", "\n", "Expect mem2\n", - "Item: mem2; Score (0.3679447999059255)\n", + "Item: mem2; Score (0.36784461593247436)\n", "Memory: The restaurant was too loud\n", "Context: Dinner at an Italian place\n", "\n" @@ -353,9 +452,26 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Expect mem1\n", + "Item: mem1; Score (0.32269984224327286)\n", + "Memory: I love chocolate ice cream\n", + "Type: preference\n", + "\n", + "Expect low score (mem2 not indexed)\n", + "Item: mem1; Score (0.010241633698527089)\n", + "Memory: I love chocolate ice cream\n", + "Type: preference\n", + "\n" + ] + } + ], "source": [ "store = InMemoryStore(index={\"embed\": embeddings, \"dims\": 1536, \"fields\": [\"memory\"]})\n", "\n", @@ -390,13 +506,6 @@ " print(f\"Memory: {r.value['memory']}\")\n", " print(f\"Type: {r.value['type']}\\n\")" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { diff --git a/docs/docs/tutorials/tnt-llm/tnt-llm.ipynb b/docs/docs/tutorials/tnt-llm/tnt-llm.ipynb index c68fb81e18..d952ab592b 100644 --- a/docs/docs/tutorials/tnt-llm/tnt-llm.ipynb +++ b/docs/docs/tutorials/tnt-llm/tnt-llm.ipynb @@ -43,7 +43,7 @@ "outputs": [], "source": [ "%%capture --no-stderr\n", - "%pip install -U langgraph langchain_anthropic langsmith\n", + "%pip install -U langgraph langchain_anthropic langsmith langchain-community\n", "%pip install -U sklearn langchain_openai" ] }, @@ -632,7 +632,7 @@ "metadata": {}, "outputs": [], "source": [ - "from langchain.cache import InMemoryCache\n", + "from langchain_community.cache import InMemoryCache\n", "from langchain.globals import set_llm_cache\n", "\n", "# Optional. If you are running into errors or rate limits and want to avoid repeated computation,\n", From 1eeb90ae0d77bbe280df85c620dbbccd16323367 Mon Sep 17 00:00:00 2001 From: vbarda Date: Wed, 4 Dec 2024 19:31:46 -0500 Subject: [PATCH 26/31] cr --- docs/docs/concepts/low_level.md | 14 ++++++++------ docs/docs/reference/types.md | 1 + libs/langgraph/langgraph/types.py | 6 ++++-- 3 files changed, 13 insertions(+), 8 deletions(-) diff --git a/docs/docs/concepts/low_level.md b/docs/docs/concepts/low_level.md index b3df3c8826..1d059568bd 100644 --- a/docs/docs/concepts/low_level.md +++ b/docs/docs/concepts/low_level.md @@ -344,9 +344,9 @@ def my_node(state: State) -> Command[Literal["my_other_node"]]: | Property | Description | | --- | --- | | `graph` | Graph to send the command to. Supported values:
- `None`: the current graph (default)
- `Command.PARENT`: closest parent graph | -| `update` | State update to apply to the graph's state at the current superstep | -| `resume` | Value to resume execution with. Will be used when `interrupt()` is called | -| `goto` | Can be one of the following:
- name of the node to navigate to next (any node that belongs to the specified `graph`)
- list of node names to navigate to next
- `Send` object
- sequence of `Send` objects
If `goto` is not specified and there are no other tasks left in the graph, the graph will halt after executing the current superstep. | +| `update` | Update to apply to the graph's state. | +| `resume` | Value to resume execution with. To be used together with [`interrupt()`][langgraph.types.interrupt]. | +| `goto` | Can be one of the following:
- name of the node to navigate to next (any node that belongs to the specified `graph`)
- sequence of node names to navigate to next
- `Send` object (to execute a node with the input provided)
- sequence of `Send` objects
If `goto` is not specified and there are no other tasks left in the graph, the graph will halt after executing the current superstep. | ```python from langgraph.graph import StateGraph, START @@ -373,13 +373,15 @@ graph = builder.compile() With `Command` you can also achieve dynamic control flow behavior (identical to [conditional edges](#conditional-edges)): ```python -def my_node(state: State) -> Command[Literal["my_other_node", "__end__"]]: +def my_node(state: State) -> Command[Literal["my_other_node"]]: if state["foo"] == "bar": return Command(update={"foo": "baz"}, goto="my_other_node") - else: - return Command(goto="__end__") ``` +!!! important + + When returning `Command` in your node functions, you must add return type annotations with the list of node names the node is routing to, e.g. `Command[Literal["node_b", "node_c"]]`. This is necessary for the graph compilation and rendering, and tells LangGraph that `node_a` can navigate to `node_b` and `node_c`. + Check out this [how-to guide](../how-tos/command.ipynb) for an end-to-end example of how to use `Command`. ## Persistence diff --git a/docs/docs/reference/types.md b/docs/docs/reference/types.md index 98b1ef1377..b42b11f352 100644 --- a/docs/docs/reference/types.md +++ b/docs/docs/reference/types.md @@ -14,3 +14,4 @@ - StateSnapshot - Send - Command + - interrupt diff --git a/libs/langgraph/langgraph/types.py b/libs/langgraph/langgraph/types.py index 1780c0a7f2..d4fb5ab551 100644 --- a/libs/langgraph/langgraph/types.py +++ b/libs/langgraph/langgraph/types.py @@ -249,13 +249,15 @@ class Command(Generic[N]): Args: graph: graph to send the command to. Supported values are: + - None: the current graph (default) - GraphCommand.PARENT: closest parent graph update: update to apply to the graph's state. - resume: value to resume execution with. To be used together with `interrupt()`. + resume: value to resume execution with. To be used together with [`interrupt()`][langgraph.types.interrupt]. goto: can be one of the following: + - name of the node to navigate to next (any node that belongs to the specified `graph`) - - list of node names to navigate to next + - sequence of node names to navigate to next - `Send` object (to execute a node with the input provided) - sequence of `Send` objects """ From f40a2d71ec4fbd6b4d8cf37eab75b3f91001e751 Mon Sep 17 00:00:00 2001 From: Nuno Campos Date: Wed, 4 Dec 2024 17:15:17 -0800 Subject: [PATCH 27/31] lib 0.2.56 --- libs/langgraph/pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libs/langgraph/pyproject.toml b/libs/langgraph/pyproject.toml index cee26320e7..0a1f0b0848 100644 --- a/libs/langgraph/pyproject.toml +++ b/libs/langgraph/pyproject.toml @@ -1,6 +1,6 @@ [tool.poetry] name = "langgraph" -version = "0.2.55" +version = "0.2.56" description = "Building stateful, multi-actor applications with LLMs" authors = [] license = "MIT" From d1aaa9de8ca6d1079ee245185092661f33194fc6 Mon Sep 17 00:00:00 2001 From: Nuno Campos Date: Wed, 4 Dec 2024 17:25:51 -0800 Subject: [PATCH 28/31] sdk-py: Handle stream(params=) --- libs/sdk-py/langgraph_sdk/client.py | 22 ++++++++++++++++++---- 1 file changed, 18 insertions(+), 4 deletions(-) diff --git a/libs/sdk-py/langgraph_sdk/client.py b/libs/sdk-py/langgraph_sdk/client.py index c453eb7493..3436188c7e 100644 --- a/libs/sdk-py/langgraph_sdk/client.py +++ b/libs/sdk-py/langgraph_sdk/client.py @@ -278,7 +278,12 @@ async def delete(self, path: str, *, json: Optional[Any] = None) -> None: raise e async def stream( - self, path: str, method: str, *, json: Optional[dict] = None + self, + path: str, + method: str, + *, + json: Optional[dict] = None, + params: Optional[QueryParamTypes] = None, ) -> AsyncIterator[StreamPart]: """Stream results using SSE.""" headers, content = await aencode_json(json) @@ -286,7 +291,7 @@ async def stream( headers["Cache-Control"] = "no-store" async with self.client.stream( - method, path, headers=headers, content=content + method, path, headers=headers, content=content, params=params ) as res: # check status try: @@ -314,6 +319,8 @@ async def stream( async def aencode_json(json: Any) -> tuple[dict[str, str], bytes]: + if json is None: + return {}, None body = await asyncio.get_running_loop().run_in_executor( None, orjson.dumps, @@ -2447,11 +2454,18 @@ def delete(self, path: str, *, json: Optional[Any] = None) -> None: raise e def stream( - self, path: str, method: str, *, json: Optional[dict] = None + self, + path: str, + method: str, + *, + json: Optional[dict] = None, + params: Optional[QueryParamTypes] = None, ) -> Iterator[StreamPart]: """Stream the results of a request using SSE.""" headers, content = encode_json(json) - with self.client.stream(method, path, headers=headers, content=content) as res: + with self.client.stream( + method, path, headers=headers, content=content, params=params + ) as res: # check status try: res.raise_for_status() From 63ea71548bf4a5c8006d738f109109f49104f087 Mon Sep 17 00:00:00 2001 From: Nuno Campos Date: Wed, 4 Dec 2024 17:27:24 -0800 Subject: [PATCH 29/31] sdk-py 0.1.43 --- libs/sdk-py/pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libs/sdk-py/pyproject.toml b/libs/sdk-py/pyproject.toml index edf8a2510a..991076ea91 100644 --- a/libs/sdk-py/pyproject.toml +++ b/libs/sdk-py/pyproject.toml @@ -1,6 +1,6 @@ [tool.poetry] name = "langgraph-sdk" -version = "0.1.42" +version = "0.1.43" description = "SDK for interacting with LangGraph API" authors = [] license = "MIT" From a54587cff55d49a30ade11fa3f5448a2a01ac600 Mon Sep 17 00:00:00 2001 From: Nuno Campos Date: Wed, 4 Dec 2024 17:33:54 -0800 Subject: [PATCH 30/31] Remove unknown arg --- .github/workflows/_lint.yml | 1 - .github/workflows/_test.yml | 1 - .github/workflows/_test_release.yml | 1 - .github/workflows/release.yml | 4 ---- 4 files changed, 7 deletions(-) diff --git a/.github/workflows/_lint.yml b/.github/workflows/_lint.yml index c6616bb4b6..69b990b6ac 100644 --- a/.github/workflows/_lint.yml +++ b/.github/workflows/_lint.yml @@ -42,7 +42,6 @@ jobs: with: python-version: ${{ matrix.python-version }} poetry-version: ${{ env.POETRY_VERSION }} - working-directory: ${{ inputs.working-directory }} cache-key: lint-${{ inputs.working-directory }} - name: Check Poetry File diff --git a/.github/workflows/_test.yml b/.github/workflows/_test.yml index 29eab4cd3a..3329da546a 100644 --- a/.github/workflows/_test.yml +++ b/.github/workflows/_test.yml @@ -31,7 +31,6 @@ jobs: with: python-version: ${{ matrix.python-version }} poetry-version: ${{ env.POETRY_VERSION }} - working-directory: ${{ inputs.working-directory }} cache-key: test-${{ inputs.working-directory }} - name: Login to Docker Hub uses: docker/login-action@v3 diff --git a/.github/workflows/_test_release.yml b/.github/workflows/_test_release.yml index a4d81e1e2d..46e065d335 100644 --- a/.github/workflows/_test_release.yml +++ b/.github/workflows/_test_release.yml @@ -29,7 +29,6 @@ jobs: with: python-version: ${{ env.PYTHON_VERSION }} poetry-version: ${{ env.POETRY_VERSION }} - working-directory: ${{ inputs.working-directory }} cache-key: release # We want to keep this build stage *separate* from the release stage, diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index d3d8626aa3..d1d5b2aafe 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -31,7 +31,6 @@ jobs: with: python-version: ${{ env.PYTHON_VERSION }} poetry-version: ${{ env.POETRY_VERSION }} - working-directory: ${{ inputs.working-directory }} cache-key: release # We want to keep this build stage *separate* from the release stage, @@ -169,7 +168,6 @@ jobs: with: python-version: ${{ env.PYTHON_VERSION }} poetry-version: ${{ env.POETRY_VERSION }} - working-directory: ${{ inputs.working-directory }} - name: Import published package shell: bash @@ -256,7 +254,6 @@ jobs: with: python-version: ${{ env.PYTHON_VERSION }} poetry-version: ${{ env.POETRY_VERSION }} - working-directory: ${{ inputs.working-directory }} cache-key: release - uses: actions/download-artifact@v4 @@ -298,7 +295,6 @@ jobs: with: python-version: ${{ env.PYTHON_VERSION }} poetry-version: ${{ env.POETRY_VERSION }} - working-directory: ${{ inputs.working-directory }} cache-key: release - uses: actions/download-artifact@v4 From 8ef82f3578bc621f63e93bed45a819d8a3e428e5 Mon Sep 17 00:00:00 2001 From: Nuno Campos Date: Wed, 4 Dec 2024 17:40:27 -0800 Subject: [PATCH 31/31] Update --- libs/langgraph/langgraph/prebuilt/tool_node.py | 18 ++++++++---------- 1 file changed, 8 insertions(+), 10 deletions(-) diff --git a/libs/langgraph/langgraph/prebuilt/tool_node.py b/libs/langgraph/langgraph/prebuilt/tool_node.py index 3c43bfba84..2abd9ca5aa 100644 --- a/libs/langgraph/langgraph/prebuilt/tool_node.py +++ b/libs/langgraph/langgraph/prebuilt/tool_node.py @@ -5,8 +5,6 @@ from typing import ( Any, Callable, - Dict, - List, Literal, Optional, Sequence, @@ -45,7 +43,7 @@ TOOL_CALL_ERROR_TEMPLATE = "Error: {error}\n Please fix your mistakes." -def msg_content_output(output: Any) -> str | List[dict]: +def msg_content_output(output: Any) -> Union[str, list[dict]]: recognized_content_block_types = ("image", "image_url", "text", "json") if isinstance(output, str): return output @@ -90,7 +88,7 @@ def _handle_tool_error( return content -def _infer_handled_types(handler: Callable[..., str]) -> tuple[type[Exception]]: +def _infer_handled_types(handler: Callable[..., str]) -> tuple[type[Exception], ...]: sig = inspect.signature(handler) params = list(sig.parameters.values()) if params: @@ -189,9 +187,9 @@ def __init__( messages_key: str = "messages", ) -> None: super().__init__(self._func, self._afunc, name=name, tags=tags, trace=False) - self.tools_by_name: Dict[str, BaseTool] = {} - self.tool_to_state_args: Dict[str, Dict[str, Optional[str]]] = {} - self.tool_to_store_arg: Dict[str, Optional[str]] = {} + self.tools_by_name: dict[str, BaseTool] = {} + self.tool_to_state_args: dict[str, dict[str, Optional[str]]] = {} + self.tool_to_store_arg: dict[str, Optional[str]] = {} self.handle_tool_errors = handle_tool_errors self.messages_key = messages_key for tool_ in tools: @@ -341,7 +339,7 @@ def _parse_input( BaseModel, ], store: BaseStore, - ) -> Tuple[List[ToolCall], Literal["list", "dict"]]: + ) -> Tuple[list[ToolCall], Literal["list", "dict"]]: if isinstance(input, list): output_type = "list" message: AnyMessage = input[-1] @@ -651,9 +649,9 @@ def _is_injection( return False -def _get_state_args(tool: BaseTool) -> Dict[str, Optional[str]]: +def _get_state_args(tool: BaseTool) -> dict[str, Optional[str]]: full_schema = tool.get_input_schema() - tool_args_to_state_fields: Dict = {} + tool_args_to_state_fields: dict = {} for name, type_ in get_all_basemodel_annotations(full_schema).items(): injections = [