checkpoint: release 1.0.9 (#1628)

Split out prepare_single_task from prepare_next_tasks

.github/workflows/_test.yml

@@ -21,7 +21,11 @@ jobs:
           - "3.10"
           - "3.11"
           - "3.12"
-    name: "test #${{ matrix.python-version }}"
+        core-version:
+          - ">=0.3.0.dev1,<0.4.0"
+          - "latest"
+
+    name: "test #${{ matrix.python-version }} (langchain-core: ${{ matrix.core-version }})"
     steps:
       - uses: actions/checkout@v4
       - name: Set up Python ${{ matrix.python-version }} + Poetry ${{ env.POETRY_VERSION }}
@@ -35,7 +39,11 @@ jobs:
       - name: Install dependencies
         shell: bash
         working-directory: ${{ inputs.working-directory }}
-        run: poetry install --with dev
+        run: |
+          poetry install --with dev
+          if [ "${{ matrix.core-version }}" != "latest" ]; then
+            poetry run pip install "langchain-core${{ matrix.core-version }}"
+          fi
 
       - name: Run core tests
         shell: bash

README.md

@@ -59,7 +59,7 @@ from langchain_core.messages import HumanMessage
 from langchain_anthropic import ChatAnthropic
 from langchain_core.tools import tool
 from langgraph.checkpoint.memory import MemorySaver
-from langgraph.graph import END, StateGraph, MessagesState
+from langgraph.graph import END, START, StateGraph, MessagesState
 from langgraph.prebuilt import ToolNode
 
 
@@ -107,7 +107,7 @@ workflow.add_node("tools", tool_node)
 
 # Set the entrypoint as `agent`
 # This means that this node is the first one called
-workflow.set_entry_point("agent")
+workflow.add_edge(START, "agent")
 
 # We now add a conditional edge
 workflow.add_conditional_edges(

docs/_scripts/copy_notebooks.py

@@ -30,6 +30,8 @@ _MANUAL = {
         "input_output_schema.ipynb",
         "pass_private_state.ipynb",
         "memory/manage-conversation-history.ipynb",
+        "subgraphs-manage-state.ipynb",
+        "subgraph-transform-state.ipynb",
         "memory/delete-messages.ipynb",
         "memory/add-summary-conversation-history.ipynb",
         "persistence_postgres.ipynb",
@@ -38,6 +40,7 @@ _MANUAL = {
         "visualization.ipynb",
         "state-model.ipynb",
         "subgraph.ipynb",
+        "recursion-limit.ipynb",
         "force-calling-a-tool-first.ipynb",
         "pass-run-time-values-to-tools.ipynb",
         "tool-calling.ipynb",
@@ -56,11 +59,14 @@ _MANUAL = {
         "create-react-agent-memory.ipynb",
         "create-react-agent-hitl.ipynb",
         "human_in_the_loop/breakpoints.ipynb",
+        "human_in_the_loop/dynamic_breakpoints.ipynb",
         "human_in_the_loop/time-travel.ipynb",
         "human_in_the_loop/edit-graph-state.ipynb",
         "human_in_the_loop/wait-user-input.ipynb",
         "human_in_the_loop/review-tool-calls.ipynb",
         "node-retries.ipynb",
+        "react_diagrams.png",
+        "react-agent-structured-output.ipynb",
     ],
     "tutorials": [
         "introduction.ipynb",

docs/docs/cloud/concepts/api.md

@@ -39,7 +39,7 @@ It's often useful to run graphs on some schedule. LangGraph Cloud supports cron
 - Create a new thread with the specified assistant
 - Send the specified input to that thread
 
-Note that this sends the same input to the thread every time. See the [how-to guide](../how-tos/cloud_examples/cron_jobs.ipynb) for creating cron jobs.
+Note that this sends the same input to the thread every time. See the [how-to guide](../how-tos/cron_jobs.md) for creating cron jobs.
 
 The LangGraph Cloud API provides several endpoints for creating and managing cron jobs. See the [API reference](../reference/api/api_ref.html#tag/runscreate/POST/threads/{thread_id}/runs/crons) for more details.
 
@@ -51,16 +51,108 @@ The LangGraph Cloud API offers several features to support complex agent archite
 
 Streaming is critical for making LLM applications feel responsive to end users. When creating a streaming run, the streaming mode determines what data is streamed back to the API client. The LangGraph Cloud API supports five streaming modes.
 
-- `values`: Stream the full state of the graph after each node is executed. See the [how-to guide](../how-tos/stream_values.md) for streaming values.
+- `values`: Stream the full state of the graph after each [super-step](https://langchain-ai.github.io/langgraph/concepts/low_level/#graphs) is executed. See the [how-to guide](../how-tos/stream_values.md) for streaming values.
 - `messages`: Stream complete messages (at the end of node execution) as well as tokens for any messages generated inside a node. This mode is primarily meant for powering chat applications. This is only an option if your graph contains a `messages` key. See the [how-to guide](../how-tos/stream_messages.md) for streaming messages.
 - `updates`: Streams updates to the state of the graph after each node is executed. See the [how-to guide](../how-tos/stream_updates.md) for streaming updates.
-- `events`: Stream all events (including the state of the graph) after each node is executed. See the [how-to guide](../how-tos/stream_events.md) for streaming events. This can be used to do token-by-token streaming for LLMs.
-- `debug`: Stream debug events after each node is executed. See the [how-to guide](../how-tos/stream_debug.md) for streaming debug events.
+- `events`: Stream all events (including the state of the graph) that occur during graph execution. See the [how-to guide](../how-tos/stream_events.md) for streaming events. This can be used to do token-by-token streaming for LLMs.
+- `debug`: Stream debug events throughout graph execution. See the [how-to guide](../how-tos/stream_debug.md) for streaming debug events.
 
 You can also specify multiple streaming modes at the same time. See the [how-to guide](../how-tos/stream_multiple.md) for configuring multiple streaming modes at the same time.
 
 See the [API reference](../reference/api/api_ref.html#tag/runscreate/POST/threads/{thread_id}/runs/stream) for how to create streaming runs.
 
+Streaming modes `values`, `updates`, and `debug` are very similar to modes available in the LangGraph library - for a deeper conceptual explanation of those, you can see the LangGraph library documentation [here](../../concepts/low_level.md#streaming).
+
+Streaming mode `events` is the same as using `.astream_events` in the LangGraph library - for a deeper conceptual explanation of this, you can see the LangGraph library documentation [here](../../concepts/low_level.md#streaming).
+
+#### `mode="messages"`
+Streaming mode `messages` is a new streaming mode, currently only available in the API. What does this mode enable?
+
+This mode is focused on streaming back messages. It currently assumes that you have a `messages` key in your graph that is a list of messages. Assuming we have a simple react agent deployed, what does this stream look like?
+
+All events emitted have two attributes:
+
+- `event`: This is the name of the event
+- `data`: This is data associated with the event
+
+Let's run it on a question that should trigger a tool call:
+
+```python
+thread = await client.threads.create()
+input = {"messages": [{"role": "user", "content": "what's the weather in sf?"}]}
+
+events = []
+async for event in client.runs.stream(
+    thread["thread_id"],
+    assistant_id="agent",  # This may need to change depending on the graph you deployed
+    input=input,
+    stream_mode="messages",
+):
+    print(event.event)
+```
+```shell
+metadata
+messages/complete
+messages/metadata
+messages/partial
+...
+messages/partial
+messages/complete
+messages/complete
+messages/metadata
+messages/partial
+...
+messages/partial
+messages/complete
+end
+```
+
+We first get some `metadata` - this is metadata about the run. 
+
+```python
+StreamPart(event='metadata', data={'run_id': '1ef657cf-ae55-6f65-97d4-f4ed1dbdabc6'})
+```
+
+We then get a `messages/complete` event - this a fully formed message getting emitted. In this case,
+this was the just the input message we sent in. 
+
+```python
+StreamPart(event='messages/complete', data=[{'content': 'hi!', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '833c09a3-bb19-46c9-81d9-1e5954ec5f92', 'example': False}])
+```
+
+We then get a `messages/metadata` - this is just letting us know that a new message is starting.
+
+```python
+StreamPart(event='messages/metadata', data={'run-985c0f14-9f43-40d4-a505-4637fc58e333': {'metadata': {'created_by': 'system', 'run_id': '1ef657de-7594-66df-8eb2-31518e4a1ee2', 'graph_id': 'agent', 'thread_id': 'c178eab5-e293-423c-8e7d-1d113ffe7cd9', 'model_name': 'openai', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 1, 'langgraph_node': 'agent', 'langgraph_triggers': ['start:agent'], 'langgraph_task_idx': 0, 'ls_provider': 'openai', 'ls_model_name': 'gpt-4o', 'ls_model_type': 'chat', 'ls_temperature': 0.0}}})
+```
+
+We then get a BUNCH of `messages/partial` events - these are the individual tokens from the LLM! In the case below, we can see the START of a tool call.
+
+```python
+StreamPart(event='messages/partial', data=[{'content': '', 'additional_kwargs': {'tool_calls': [{'index': 0, 'id': 'call_w8Hr8dHGuZCPgRfd5FqRBArs', 'function': {'arguments': '', 'name': 'tavily_search_results_json'}, 'type': 'function'}]}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-985c0f14-9f43-40d4-a505-4637fc58e333', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [{'name': 'tavily_search_results_json', 'args': '', 'id': 'call_w8Hr8dHGuZCPgRfd5FqRBArs', 'error': None}], 'usage_metadata': None}])
+```
+
+After that, we get a `messages/complete` event - this is the AIMessage finishing. It's now a complete tool call:
+
+```python
+StreamPart(event='messages/complete', data=[{'content': '', 'additional_kwargs': {'tool_calls': [{'index': 0, 'id': 'call_w8Hr8dHGuZCPgRfd5FqRBArs', 'function': {'arguments': '{"query":"current weather in San Francisco"}', 'name': 'tavily_search_results_json'}, 'type': 'function'}]}, 'response_metadata': {'finish_reason': 'tool_calls', 'model_name': 'gpt-4o-2024-05-13', 'system_fingerprint': 'fp_157b3831f5'}, 'type': 'ai', 'name': None, 'id': 'run-985c0f14-9f43-40d4-a505-4637fc58e333', 'example': False, 'tool_calls': [{'name': 'tavily_search_results_json', 'args': {'query': 'current weather in San Francisco'}, 'id': 'call_w8Hr8dHGuZCPgRfd5FqRBArs'}], 'invalid_tool_calls': [], 'usage_metadata': None}])
+```
+
+After that, we get ANOTHER `messages/complete` event. This is a tool message - our agent has called a tool, gotten a response, and now inserting it into the state in the form of a tool message.
+
+```python
+StreamPart(event='messages/complete', data=[{'content': '[{"url": "https://www.weatherapi.com/", "content": "{\'location\': {\'name\': \'San Francisco\', \'region\': \'California\', \'country\': \'United States of America\', \'lat\': 37.78, \'lon\': -122.42, \'tz_id\': \'America/Los_Angeles\', \'localtime_epoch\': 1724877689, \'localtime\': \'2024-08-28 13:41\'}, \'current\': {\'last_updated_epoch\': 1724877000, \'last_updated\': \'2024-08-28 13:30\', \'temp_c\': 23.3, \'temp_f\': 73.9, \'is_day\': 1, \'condition\': {\'text\': \'Partly cloudy\', \'icon\': \'//cdn.weatherapi.com/weather/64x64/day/116.png\', \'code\': 1003}, \'wind_mph\': 15.0, \'wind_kph\': 24.1, \'wind_degree\': 310, \'wind_dir\': \'NW\', \'pressure_mb\': 1014.0, \'pressure_in\': 29.93, \'precip_mm\': 0.0, \'precip_in\': 0.0, \'humidity\': 57, \'cloud\': 25, \'feelslike_c\': 25.0, \'feelslike_f\': 77.1, \'windchill_c\': 20.9, \'windchill_f\': 69.6, \'heatindex_c\': 23.3, \'heatindex_f\': 74.0, \'dewpoint_c\': 12.9, \'dewpoint_f\': 55.2, \'vis_km\': 16.0, \'vis_miles\': 9.0, \'uv\': 6.0, \'gust_mph\': 19.5, \'gust_kph\': 31.3}}"}]', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': 'tavily_search_results_json', 'id': '0112eba5-7660-4375-9f24-c7a1d6777b97', 'tool_call_id': 'call_w8Hr8dHGuZCPgRfd5FqRBArs'}])
+```
+
+After that, we see the agent doing another LLM call and streaming back a response. We then get an `end` event:
+
+```python
+StreamPart(event='end', data=None)
+```
+
+And that's it! This is more focused streaming mode specifically focused on streaming back messages. See this [how-to guide](../how-tos/stream_messages.md) for more information.
+
+
 ### Human-in-the-Loop
 
 There are many occasions where the graph cannot run completely autonomously. For instance, the user might need to input some additional arguments to a function call, or select the next edge for the graph to continue on. In these instances, we need to insert some human in the loop interaction, which you can learn about in the [human in the loop how-tos](../how-tos/index.md#human-in-the-loop).
@@ -90,13 +182,13 @@ The only difference is in stateless background runs, if the task worker dies hal
 - whereas a stateful background run would retry from the last successful checkpoint
 - a stateless background run would retry from the beginning
 
-See the [how-to guide](../how-tos/cloud_examples/stateless_runs.ipynb) for creating stateless runs.
+See the [how-to guide](../how-tos/stateless_runs.md) for creating stateless runs.
 
 ### Webhooks
 
 For all types of runs, langgraph cloud supports completion webhooks. When you create the run you can pass a webhook URL to be called when the completes (successfully or not). This is especially useful for background runs and cron jobs, as the webhook can give you an indication the run has completed and you can perform further actions for your appilcation.
 
-See this [how-to guide](../how-tos/cloud_examples/webhooks.ipynb) to learn about how to use webhooks with LangGraph Cloud.
+See this [how-to guide](../how-tos/webhooks.md) to learn about how to use webhooks with LangGraph Cloud.
 
 ## Deployment
 

docs/docs/cloud/deployment/graph_rebuild.md

@@ -28,7 +28,7 @@ In the standard LangGraph API configuration, the server uses the compiled graph
 
 ```python
 from langchain_openai import ChatOpenAI
-from langgraph.graph import END, MessageGraph
+from langgraph.graph import END, START, MessageGraph
 
 model = ChatOpenAI(temperature=0)
 
@@ -36,7 +36,7 @@ graph_workflow = MessageGraph()
 
 graph_workflow.add_node("agent", model)
 graph_workflow.add_edge("agent", END)
-graph_workflow.set_entry_point("agent")
+graph_workflow.add_edge(START, "agent")
 
 agent = graph_workflow.compile()
 ```
@@ -60,7 +60,7 @@ To make your graph rebuild on each new run with custom configuration, you need t
 ```python
 from typing import Annotated, TypedDict
 from langchain_openai import ChatOpenAI
-from langgraph.graph import END, MessageGraph
+from langgraph.graph import END, START, MessageGraph
 from langgraph.graph.state import StateGraph
 from langgraph.graph.message import add_messages
 from langgraph.prebuilt import ToolNode
@@ -83,7 +83,7 @@ def make_default_graph():
 
     graph_workflow.add_node("agent", call_model)
     graph_workflow.add_edge("agent", END)
-    graph_workflow.set_entry_point("agent")
+    graph_workflow.add_edge(START, "agent")
 
     agent = graph_workflow.compile()
     return agent
@@ -113,7 +113,7 @@ def make_alternative_graph():
     graph_workflow.add_node("agent", call_model)
     graph_workflow.add_node("tools", tool_node)
     graph_workflow.add_edge("tools", "agent")
-    graph_workflow.set_entry_point("agent")
+    graph_workflow.add_edge(START, "agent")
     graph_workflow.add_conditional_edges("agent", should_continue)
 
     agent = graph_workflow.compile()

docs/docs/cloud/deployment/self_hosted.md

@@ -1,35 +0,0 @@
-# How to Self-Host LangGraph Cloud API
-
-!!! warning "Enterprise License Required"
-    Self-hosting LangGraph Cloud API requires a license key. Please contact sales@langchain.dev for more details.
-
-LangGraph Cloud APIs can be self-hosted with a valid LangGraph Cloud license key. Self-hosted deployments are built with Docker and deployed with Helm (on Kubernetes) or with Docker Compose. Ensure that the [Docker CLI](https://docs.docker.com/engine/reference/commandline/cli/) is installed.
-
-LangGraph Cloud license key should be passed to the service as an environment variable named LANGGRAPH_CLOUD_LICENSE_KEY.
-
-## Build Docker Image
-
-1. Follow the [How-to Guide](setup.md) for setting up a LangGraph application for deployment. Your LangGraph application will vary from the example in the How-to Guide. However, ensure that the [LangGraph API configuration file](../reference/cli.md#configuration-file) is created.
-1. Install the [LangGraph CLI](../reference/cli.md#installation).
-1. Run the following LangGraph CLI `build` command to build a Docker image. Specify the image tag (`-t`) and other desired [options](../reference/cli.md#build).
-
-        langgraph build -t tag_name
-
-!!! info "Build Platform"
-    When building the Docker image, ensure that the image is built for the platform of the target Kubernetes cluster: `langgraph build -t tag_name --platform linux/amd64,linux/arm64`
-
-## Self-Host on Kubernetes
-
-This section is for self-hosting LangGraph Cloud API on Kubernetes via Helm. A Kubernetes cluster must be provisioned before proceeding with these steps. The public Helm chart for LangGraph Cloud is available [here](https://github.com/langchain-ai/helm/tree/main/charts/langgraph-cloud).
-
-1. Publish the built Docker image to a repository that can be accessed by the target Kubernetes cluster.
-1. Ensure that the [Helm client](https://github.com/helm/helm?tab=readme-ov-file#install) is installed.
-1. Make note of all environment variables that are needed for the application. These values will need to be set in the Helm `values` YAML configuration.
-1. Follow [these instructions](https://github.com/langchain-ai/helm/tree/main/charts/langgraph-cloud#readme) to configure the Helm chart and deploy to Kubernetes.
-
-## Self-Host with Docker
-
-!!! warning "Under Construction"
-    This section of the documentation is in progress.
-
-Docker Compose can be used to deploy LangGraph Cloud to the compute infrastructure of your choice (e.g. VM).

docs/docs/cloud/deployment/setup.md

@@ -1,15 +1,14 @@
 # How to Set Up a LangGraph Application for Deployment
 
-A LangGraph application must be configured with a [LangGraph API configuration file](../reference/cli.md#configuration-file) in order to be deployed to LangGraph Cloud (or to be self-hosted). This how-to guide discusses the basic steps to setup a LangGraph application for deployment using `requirements.txt` to specify project dependencies. 
+A LangGraph application must be configured with a [LangGraph API configuration file](../reference/cli.md#configuration-file) in order to be deployed to LangGraph Cloud (or to be self-hosted). This how-to guide discusses the basic steps to setup a LangGraph application for deployment using `requirements.txt` to specify project dependencies.
 
 This walkthrough is based on [this repository](https://github.com/langchain-ai/langgraph-example), which you can play around with to learn more about how to setup your LangGraph application for deployment.
 
 !!! tip "Setup with pyproject.toml"
-    If you prefer using poetry for dependency management, check out [this how-to guide](./setup_pyproject.md) on using `pyproject.toml` for LangGraph Cloud.
+If you prefer using poetry for dependency management, check out [this how-to guide](./setup_pyproject.md) on using `pyproject.toml` for LangGraph Cloud.
 
 !!! tip "Setup with a Monorepo"
-    If you are interested in deploying a graph located inside a monorepo, take a look at [this](https://github.com/langchain-ai/langgraph-example-monorepo) repository for an example of how to do so.
-
+If you are interested in deploying a graph located inside a monorepo, take a look at [this](https://github.com/langchain-ai/langgraph-example-monorepo) repository for an example of how to do so.
 
 The final repo structure will look something like this:
 
@@ -35,23 +34,27 @@ After each step, an example file directory is provided to demonstrate how code c
 Dependencies can optionally be specified in one of the following files: `pyproject.toml`, `setup.py`, or `requirements.txt`. If none of these files is created, then dependencies can be specified later in the [LangGraph API configuration file](#create-langgraph-api-config).
 
 The dependencies below will be included in the image, you can also use them in your code, as long as with a compatible version range:
+
 ```
-langgraph>=0.2.0,<0.3.0
+langgraph>=0.2.7,<0.3.0
+langgraph-checkpoint>=1.0.4
 langchain-core>=0.2.27,<0.3.0
 langsmith>=0.1.63
-orjson>=3.10.1
-httpx>=0.27.0
-tenacity>=8.3.0
-uvicorn>=0.29.0
+orjson>=3.9.7
+httpx>=0.25.0
+tenacity>=8.0.0
+uvicorn>=0.26.0
 sse-starlette>=2.1.0
-uvloop>=0.19.0
-httptools>=0.6.1
-jsonschema-rs>=0.18.0
+uvloop>=0.18.0
+httptools>=0.5.0
+jsonschema-rs>=0.16.3
 croniter>=1.0.1
-structlog>=24.4.0
+structlog>=23.1.0
+redis>=5.0.0,<6.0.0
 ```
 
 Example `requirements.txt` file:
+
 ```
 langgraph
 langchain_anthropic
@@ -62,6 +65,7 @@ langchain_openai
 ```
 
 Example file directory:
+
 ```bash
 my-app/
 ├── my_agent # all project code lies within here
@@ -73,6 +77,7 @@ my-app/
 Environment variables can optionally be specified in a file (e.g. `.env`). See the [Environment Variables reference](../reference/env_var.md) to configure additional variables for a deployment.
 
 Example `.env` file:
+
 ```
 MY_ENV_VAR_1=foo
 MY_ENV_VAR_2=bar
@@ -94,12 +99,11 @@ Implement your graphs! Graphs can be defined in a single file or multiple files.
 
 Example `agent.py` file, which shows how to import from other modules you define (code for the modules is not shown here, please see [this repo](https://github.com/langchain-ai/langgraph-example) to see their implementation):
 
-
 ```python
 # my_agent/agent.py
 from typing import TypedDict, Literal
 
-from langgraph.graph import StateGraph, END
+from langgraph.graph import StateGraph, END, START
 from my_agent.utils.nodes import call_model, should_continue, tool_node # import nodes
 from my_agent.utils.state import AgentState # import state
 
@@ -110,7 +114,7 @@ class GraphConfig(TypedDict):
 workflow = StateGraph(AgentState, config_schema=GraphConfig)
 workflow.add_node("agent", call_model)
 workflow.add_node("action", tool_node)
-workflow.set_entry_point("agent")
+workflow.add_edge(START, "agent")
 workflow.add_conditional_edges(
     "agent",
     should_continue,
@@ -125,9 +129,10 @@ graph = workflow.compile()
 ```
 
 !!! warning "Assign `CompiledGraph` to Variable"
-    The build process for LangGraph Cloud requires that the `CompiledGraph` object be assigned to a variable at the top-level of a Python module (alternatively, you can provide [a function that creates a graph](./graph_rebuild.md)).
+The build process for LangGraph Cloud requires that the `CompiledGraph` object be assigned to a variable at the top-level of a Python module (alternatively, you can provide [a function that creates a graph](./graph_rebuild.md)).
 
 Example file directory:
+
 ```bash
 my-app/
 ├── my_agent # all project code lies within here
@@ -147,6 +152,7 @@ my-app/
 Create a [LangGraph API configuration file](../reference/cli.md#configuration-file) called `langgraph.json`. See the [LangGraph CLI reference](../reference/cli.md#configuration-file) for detailed explanations of each key in the JSON object of the configuration file.
 
 Example `langgraph.json` file:
+
 ```json
 {
   "dependencies": ["./my_agent"],
@@ -160,7 +166,7 @@ Example `langgraph.json` file:
 Note that the variable name of the `CompiledGraph` appears at the end of the value of each subkey in the top-level `graphs` key (i.e. `:<variable_name>`).
 
 !!! warning "Configuration Location"
-    The LangGraph API configuration file must be placed in a directory that is at the same level or higher than the Python files that contain compiled graphs and associated dependencies.
+The LangGraph API configuration file must be placed in a directory that is at the same level or higher than the Python files that contain compiled graphs and associated dependencies.
 
 Example file directory:
 

docs/docs/cloud/deployment/setup_javascript.md

@@ -0,0 +1,200 @@
+# How to Set Up a LangGraph.js Application for Deployment
+
+A [LangGraph.js](https://langchain-ai.github.io/langgraphjs/) application must be configured with a [LangGraph API configuration file](../reference/cli.md#configuration-file) in order to be deployed to LangGraph Cloud (or to be self-hosted). This how-to guide discusses the basic steps to setup a LangGraph.js application for deployment using `package.json` to specify project dependencies.
+
+This walkthrough is based on [this repository](https://github.com/langchain-ai/langgraphjs-studio-starter), which you can play around with to learn more about how to setup your LangGraph application for deployment.
+
+The final repo structure will look something like this:
+
+```bash
+my-app/
+├── src # all project code lies within here
+│   ├── utils # optional utilities for your graph
+│   │   ├── tools.ts # tools for your graph
+│   │   ├── nodes.ts # node functions for you graph
+│   │   └── state.ts # state definition of your graph
+│   └── agent.ts # code for constructing your graph
+├── package.json # package dependencies
+├── .env # environment variables
+└── langgraph.json # configuration file for LangGraph
+```
+
+After each step, an example file directory is provided to demonstrate how code can be organized.
+
+## Specify Dependencies
+
+Dependencies can be specified in a `package.json`. If none of these files is created, then dependencies can be specified later in the [LangGraph API configuration file](#create-langgraph-api-config).
+
+Example `package.json` file:
+
+```json
+{
+  "name": "langgraphjs-studio-starter",
+  "packageManager": "yarn@1.22.22",
+  "dependencies": {
+    "@langchain/community": "^0.2.31",
+    "@langchain/core": "^0.2.31",
+    "@langchain/langgraph": "^0.2.0",
+    "@langchain/openai": "^0.2.8"
+  }
+}
+```
+
+Example file directory:
+
+```bash
+my-app/
+└── package.json # package dependencies
+```
+
+## Specify Environment Variables
+
+Environment variables can optionally be specified in a file (e.g. `.env`). See the [Environment Variables reference](../reference/env_var.md) to configure additional variables for a deployment.
+
+Example `.env` file:
+
+```
+MY_ENV_VAR_1=foo
+MY_ENV_VAR_2=bar
+OPENAI_API_KEY=key
+TAVILY_API_KEY=key_2
+```
+
+Example file directory:
+
+```bash
+my-app/
+├── package.json
+└── .env # environment variables
+```
+
+## Define Graphs
+
+Implement your graphs! Graphs can be defined in a single file or multiple files. Make note of the variable names of each compiled graph to be included in the LangGraph application. The variable names will be used later when creating the [LangGraph API configuration file](../reference/cli.md#configuration-file).
+
+Here is an example `agent.ts`:
+
+```ts
+import type { AIMessage } from "@langchain/core/messages";
+import { TavilySearchResults } from "@langchain/community/tools/tavily_search";
+import { ChatOpenAI } from "@langchain/openai";
+
+import { MessagesAnnotation, StateGraph } from "@langchain/langgraph";
+import { ToolNode } from "@langchain/langgraph/prebuilt";
+
+const tools = [
+  new TavilySearchResults({ maxResults: 3, }),
+];
+
+// Define the function that calls the model
+async function callModel(
+  state: typeof MessagesAnnotation.State,
+) {
+  /**
+   * Call the LLM powering our agent.
+   * Feel free to customize the prompt, model, and other logic!
+   */
+  const model = new ChatOpenAI({
+    model: "gpt-4o",
+  }).bindTools(tools);
+
+  const response = await model.invoke([
+    {
+      role: "system",
+      content: `You are a helpful assistant. The current date is ${new Date().getTime()}.`
+    },
+    ...state.messages
+  ]);
+
+  // MessagesAnnotation supports returning a single message or array of messages
+  return { messages: response };
+}
+
+// Define the function that determines whether to continue or not
+function routeModelOutput(state: typeof MessagesAnnotation.State) {
+  const messages = state.messages;
+  const lastMessage: AIMessage = messages[messages.length - 1];
+  // If the LLM is invoking tools, route there.
+  if ((lastMessage?.tool_calls?.length ?? 0) > 0) {
+    return "tools";
+  }
+  // Otherwise end the graph.
+  return "__end__";
+}
+
+// Define a new graph.
+// See https://langchain-ai.github.io/langgraphjs/how-tos/define-state/#getting-started for
+// more on defining custom graph states.
+const workflow = new StateGraph(MessagesAnnotation)
+  // Define the two nodes we will cycle between
+  .addNode("callModel", callModel)
+  .addNode("tools", new ToolNode(tools))
+  // Set the entrypoint as `callModel`
+  // This means that this node is the first one called
+  .addEdge("__start__", "callModel")
+  .addConditionalEdges(
+    // First, we define the edges' source node. We use `callModel`.
+    // This means these are the edges taken after the `callModel` node is called.
+    "callModel",
+    // Next, we pass in the function that will determine the sink node(s), which
+    // will be called after the source node is called.
+    routeModelOutput,
+    // List of the possible destinations the conditional edge can route to.
+    // Required for conditional edges to properly render the graph in Studio
+    [
+      "tools",
+      "__end__"
+    ],
+  )
+  // This means that after `tools` is called, `callModel` node is called next.
+  .addEdge("tools", "callModel");
+
+// Finally, we compile it!
+// This compiles it into a graph you can invoke and deploy.
+export const graph = workflow.compile();
+```
+
+!!! info "Assign `CompiledGraph` to Variable"
+    The build process for LangGraph Cloud requires that the `CompiledGraph` object be assigned to a variable at the top-level of a JavaScript module (alternatively, you can provide [a function that creates a graph](./graph_rebuild.md)).
+
+Example file directory:
+
+```bash
+my-app/
+├── src # all project code lies within here
+│   ├── utils # optional utilities for your graph
+│   │   ├── tools.ts # tools for your graph
+│   │   ├── nodes.ts # node functions for you graph
+│   │   └── state.ts # state definition of your graph
+│   └── agent.ts # code for constructing your graph
+├── package.json # package dependencies
+├── .env # environment variables
+└── langgraph.json # configuration file for LangGraph
+```
+
+## Create LangGraph API Config
+
+Create a [LangGraph API configuration file](../reference/cli.md#configuration-file) called `langgraph.json`. See the [LangGraph CLI reference](../reference/cli.md#configuration-file) for detailed explanations of each key in the JSON object of the configuration file.
+
+Example `langgraph.json` file:
+
+```json
+{
+  "node_version": "20",
+  "dockerfile_lines": [],
+  "dependencies": ["."],
+  "graphs": {
+    "agent": "./src/agent.ts:graph"
+  },
+  "env": ".env"
+}
+```
+
+Note that the variable name of the `CompiledGraph` appears at the end of the value of each subkey in the top-level `graphs` key (i.e. `:<variable_name>`).
+
+!!! info "Configuration Location"
+    The LangGraph API configuration file must be placed in a directory that is at the same level or higher than the TypeScript files that contain compiled graphs and associated dependencies.
+
+## Next
+
+After you setup your project and place it in a github repo, it's time to [deploy your app](./cloud.md).

docs/docs/cloud/deployment/setup_pyproject.md

@@ -1,8 +1,8 @@
 # How to Set Up a LangGraph Application for Deployment
 
-A LangGraph application must be configured with a [LangGraph API configuration file](../reference/cli.md#configuration-file) in order to be deployed to LangGraph Cloud (or to be self-hosted). This how-to guide discusses the basic steps to setup a LangGraph application for deployment using `pyproject.toml` to define your package's dependencies. 
+A LangGraph application must be configured with a [LangGraph API configuration file](../reference/cli.md#configuration-file) in order to be deployed to LangGraph Cloud (or to be self-hosted). This how-to guide discusses the basic steps to setup a LangGraph application for deployment using `pyproject.toml` to define your package's dependencies.
 
-This walkthrough is based on [this repository](https://github.com/langchain-ai/langgraph-example), which you can play around with to learn more about how to setup your LangGraph application for deployment.
+This walkthrough is based on [this repository](https://github.com/langchain-ai/langgraph-example-pyproject), which you can play around with to learn more about how to setup your LangGraph application for deployment.
 
 !!! tip "Setup with requirements.txt"
   If you prefer using `requirements.txt` for dependency management, check out [this how-to guide](./setup.md).
@@ -34,20 +34,23 @@ After each step, an example file directory is provided to demonstrate how code c
 Dependencies can optionally be specified in one of the following files: `pyproject.toml`, `setup.py`, or `requirements.txt`. If none of these files is created, then dependencies can be specified later in the [LangGraph API configuration file](#create-langgraph-api-config).
 
 The dependencies below will be included in the image, you can also use them in your code, as long as with a compatible version range:
+
 ```
-langgraph>=0.2.0,<0.3.0
+langgraph>=0.2.7,<0.3.0
+langgraph-checkpoint>=1.0.4
 langchain-core>=0.2.27,<0.3.0
 langsmith>=0.1.63
-orjson>=3.10.1
-httpx>=0.27.0
-tenacity>=8.3.0
-uvicorn>=0.29.0
+orjson>=3.9.7
+httpx>=0.25.0
+tenacity>=8.0.0
+uvicorn>=0.26.0
 sse-starlette>=2.1.0
-uvloop>=0.19.0
-httptools>=0.6.1
-jsonschema-rs>=0.18.0
+uvloop>=0.18.0
+httptools>=0.5.0
+jsonschema-rs>=0.16.3
 croniter>=1.0.1
 structlog>=24.4.0
+redis>=5.0.8,<6.0.0
 ```
 
 Example `pyproject.toml` file:
@@ -109,7 +112,7 @@ Example `agent.py` file, which shows how to import from other modules you define
 # my_agent/agent.py
 from typing import TypedDict, Literal
 
-from langgraph.graph import StateGraph, END
+from langgraph.graph import StateGraph, END, START
 from my_agent.utils.nodes import call_model, should_continue, tool_node # import nodes
 from my_agent.utils.state import AgentState # import state
 
@@ -120,7 +123,7 @@ class GraphConfig(TypedDict):
 workflow = StateGraph(AgentState, config_schema=GraphConfig)
 workflow.add_node("agent", call_model)
 workflow.add_node("action", tool_node)
-workflow.set_entry_point("agent")
+workflow.add_edge(START, "agent")
 workflow.add_conditional_edges(
     "agent",
     should_continue,

docs/docs/cloud/deployment/test_locally.md

@@ -49,6 +49,7 @@ You can either initialize by passing authentication or by setting an environment
 
     # only pass the url argument to get_client() if you changed the default port when calling langgraph up
     client = get_client(url=<DEPLOYMENT_URL>,api_key=<LANGCHAIN_API_KEY>)
+    # Using the graph deployed with the name "agent"
     assistant_id = "agent"
     thread = await client.threads.create()
     ```
@@ -60,7 +61,8 @@ You can either initialize by passing authentication or by setting an environment
 
     // only set the apiUrl if you changed the default port when calling langgraph up
     const client = new Client({ apiUrl: <DEPLOYMENT_URL>, apiKey: <LANGCHAIN_API_KEY> });
-    const assistantId = "agent"
+    // Using the graph deployed with the name "agent"
+    const assistantId = "agent";
     const thread = await client.threads.create();
     ```
 
@@ -85,6 +87,7 @@ If you have a `LANGCHAIN_API_KEY` set in your environment, you do not need to ex
 
     # only pass the url argument to get_client() if you changed the default port when calling langgraph up
     client = get_client()
+    # Using the graph deployed with the name "agent"
     assistant_id = "agent"
     thread = await client.threads.create()
     ```
@@ -96,7 +99,8 @@ If you have a `LANGCHAIN_API_KEY` set in your environment, you do not need to ex
 
     // only set the apiUrl if you changed the default port when calling langgraph up
     const client = new Client();
-    const assistantId = "agent"
+    // Using the graph deployed with the name "agent"
+    const assistantId = "agent";
     const thread = await client.threads.create();
     ```
 

docs/docs/cloud/faq/studio.md

@@ -43,15 +43,23 @@ If you don't define your conditional edges carefully, you might notice extra edg
 
 ### Solution 1: Include a path map
 
-The first way to solve this is to add path maps to your conditional edges. A path map is just a dictionary that maps the possible outputs of your router function with the names of the nodes that each output corresponds to. The path map is passed as the third argument to the `add_conditional_edges` function like so:
+The first way to solve this is to add path maps to your conditional edges. A path map is just a dictionary or array that maps the possible outputs of your router function with the names of the nodes that each output corresponds to. The path map is passed as the third argument to the `add_conditional_edges` function like so:
 
-```python
-graph.add_conditional_edges("node_a", routing_function, {True: "node_b", False: "node_c"})
-```
+=== "Python"
+
+    ```python
+    graph.add_conditional_edges("node_a", routing_function, {True: "node_b", False: "node_c"})
+    ```
+
+=== "Javascript"
+
+    ```ts
+    graph.addConditionalEdges("node_a", routingFunction, ["node_b", "node_c"]);
+    ```
 
 In this case, the routing function returns either True or False, which map to `node_b` and `node_c` respectively.
 
-### Solution 2: Update the typing of the router
+### Solution 2: Update the typing of the router (Python only)
 
 Instead of passing a path map, you can also be explicit about the typing of your routing function by specifying the nodes it can map to using the `Literal` python definition. Here is an example of how to define a routing function in that way:
 

docs/docs/cloud/how-tos/background_run.md

@@ -0,0 +1,443 @@
+# How to kick off background runs
+
+This guide covers how to kick off background runs for your agent.
+This can be useful for long running jobs.
+
+First let's set up our client and thread:
+
+=== "Python"
+
+    ```python
+    from langgraph_sdk import get_client
+
+    client = get_client(url=<DEPLOYMENT_URL>)
+    # Using the graph deployed with the name "agent"
+    assistant_id = "agent"
+    # create thread
+    thread = await client.threads.create()
+    print(thread)
+    ```
+
+=== "Javascript"
+
+    ```js
+    import { Client } from "@langchain/langgraph-sdk";
+
+    const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
+    // Using the graph deployed with the name "agent"
+    const assistantID = "agent";
+    // create thread
+    const thread = await client.threads.create();
+    console.log(thread);
+    ```
+
+=== "CURL"
+
+    ```bash
+    curl --request POST \
+      --url <DEPLOYMENT_URL>/threads \
+      --header 'Content-Type: application/json'
+    ```
+
+Output:
+
+    {
+        'thread_id': '5cb1e8a1-34b3-4a61-a34e-71a9799bd00d',
+        'created_at': '2024-08-30T20:35:52.062934+00:00',
+        'updated_at': '2024-08-30T20:35:52.062934+00:00',
+        'metadata': {},
+        'status': 'idle',
+        'config': {},
+        'values': None
+    }
+
+If we list the current runs on this thread, we will see that it's empty:
+
+=== "Python"
+
+    ```python
+    runs = await client.runs.list(thread["thread_id"])
+    print(runs)
+    ```
+
+=== "Javascript"
+
+    ```js
+    let runs = await client.runs.list(thread['thread_id']);
+    console.log(runs);
+    ```
+
+=== "CURL"
+
+    ```bash
+    curl --request GET \
+        --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs
+    ```
+
+Output:
+
+    []
+
+Now let's kick off a run:
+
+=== "Python"
+
+    ```python
+    input = {"messages": [{"role": "human", "content": "what's the weather in sf"}]}
+    run = await client.runs.create(thread["thread_id"], assistant_id, input=input)
+    ```
+
+=== "Javascript"
+
+    ```js
+    let input = {"messages": [{"role": "human", "content": "what's the weather in sf"}]};
+    let run = await client.runs.create(thread["thread_id"], assistantID, { input });
+    ```
+
+=== "CURL"
+
+    ```bash
+    curl --request POST \
+        --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs \
+        --header 'Content-Type: application/json' \
+        --data '{
+            "assistant_id": <ASSISTANT_ID>
+        }'
+    ```
+
+The first time we poll it, we can see `status=pending`:
+
+=== "Python"
+
+    ```python
+    print(await client.runs.get(thread["thread_id"], run["run_id"]))
+    ```
+
+=== "Javascript"
+
+    ```js
+    console.log(await client.runs.get(thread["thread_id"], run["run_id"]));
+    ```
+
+=== "CURL"
+
+    ```bash
+    curl --request GET \
+        --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/<RUN_ID>
+    ```
+
+Output:
+
+        {
+            "run_id": "1ef6a5f8-bd86-6763-bbd6-bff042db7b1b",
+            "thread_id": "7885f0cf-94ad-4040-91d7-73f7ba007c8a",
+            "assistant_id": "fe096781-5601-53d2-b2f6-0d3403f7e9ca",
+            "created_at": "2024-09-04T01:46:47.244887+00:00",
+            "updated_at": "2024-09-04T01:46:47.244887+00:00",
+            "metadata": {},
+            "status": "pending",
+            "kwargs": {
+                "input": {
+                    "messages": [
+                        {
+                            "role": "human",
+                            "content": "what's the weather in sf"
+                        }
+                    ]
+                },
+                "config": {
+                    "metadata": {
+                        "created_by": "system"
+                    },
+                    "configurable": {
+                        "run_id": "1ef6a5f8-bd86-6763-bbd6-bff042db7b1b",
+                        "user_id": "",
+                        "graph_id": "agent",
+                        "thread_id": "7885f0cf-94ad-4040-91d7-73f7ba007c8a",
+                        "assistant_id": "fe096781-5601-53d2-b2f6-0d3403f7e9ca",
+                        "checkpoint_id": null
+                    }
+                },
+                "webhook": null,
+                "temporary": false,
+                "stream_mode": [
+                    "values"
+                ],
+                "feedback_keys": null,
+                "interrupt_after": null,
+                "interrupt_before": null
+            },
+            "multitask_strategy": "reject"
+        }
+
+
+
+Now we can join the run, wait for it to finish and check that status again:
+
+=== "Python"
+
+    ```python
+    await client.runs.join(thread["thread_id"], run["run_id"])
+    print(await client.runs.get(thread["thread_id"], run["run_id"]))
+    ```
+
+=== "Javascript"
+
+    ```js
+    await client.runs.join(thread["thread_id"], run["run_id"]);
+    console.log(await client.runs.get(thread["thread_id"], run["run_id"]));
+    ```
+
+=== "CURL"
+
+    ```bash
+    curl --request GET \
+        --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/<RUN_ID>/join &&
+    curl --request GET \
+        --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/<RUN_ID>
+    ```
+
+Output:
+
+    {
+        "run_id": "1ef6a5f8-bd86-6763-bbd6-bff042db7b1b",
+        "thread_id": "7885f0cf-94ad-4040-91d7-73f7ba007c8a",
+        "assistant_id": "fe096781-5601-53d2-b2f6-0d3403f7e9ca",
+        "created_at": "2024-09-04T01:46:47.244887+00:00",
+        "updated_at": "2024-09-04T01:46:47.244887+00:00",
+        "metadata": {},
+        "status": "success",
+        "kwargs": {
+            "input": {
+                "messages": [
+                    {
+                        "role": "human",
+                        "content": "what's the weather in sf"
+                    }
+                ]
+            },
+            "config": {
+                "metadata": {
+                    "created_by": "system"
+                },
+                "configurable": {
+                    "run_id": "1ef6a5f8-bd86-6763-bbd6-bff042db7b1b",
+                    "user_id": "",
+                    "graph_id": "agent",
+                    "thread_id": "7885f0cf-94ad-4040-91d7-73f7ba007c8a",
+                    "assistant_id": "fe096781-5601-53d2-b2f6-0d3403f7e9ca",
+                    "checkpoint_id": null
+                }
+            },
+            "webhook": null,
+            "temporary": false,
+            "stream_mode": [
+                "values"
+            ],
+            "feedback_keys": null,
+            "interrupt_after": null,
+            "interrupt_before": null
+        },
+        "multitask_strategy": "reject"
+    }
+
+
+Perfect! The run succeeded as we would expect. We can double check that the run worked as expected by printing out the final state:
+
+=== "Python"
+
+    ```python
+    final_result = await client.threads.get_state(thread["thread_id"])
+    print(final_result)
+    ```
+
+=== "Javascript"
+
+    ```js
+    let finalResult = await client.threads.getState(thread["thread_id"]);
+    console.log(finalResult);
+    ```
+
+=== "CURL"
+
+    ```bash
+    curl --request GET \
+        --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/state
+    ```
+
+Output:
+
+    {
+        "values": {
+            "messages": [
+                {
+                    "content": "what's the weather in sf",
+                    "additional_kwargs": {},
+                    "response_metadata": {},
+                    "type": "human",
+                    "name": null,
+                    "id": "beba31bf-320d-4125-9c37-cadf526ac47a",
+                    "example": false
+                },
+                {
+                    "content": [
+                        {
+                            "id": "toolu_01AaNPSPzqia21v7aAKwbKYm",
+                            "input": {},
+                            "name": "tavily_search_results_json",
+                            "type": "tool_use",
+                            "index": 0,
+                            "partial_json": "{\"query\": \"weather in san francisco\"}"
+                        }
+                    ],
+                    "additional_kwargs": {},
+                    "response_metadata": {
+                        "stop_reason": "tool_use",
+                        "stop_sequence": null
+                    },
+                    "type": "ai",
+                    "name": null,
+                    "id": "run-f220faf8-1d27-4f73-ad91-6bb3f47e8639",
+                    "example": false,
+                    "tool_calls": [
+                        {
+                            "name": "tavily_search_results_json",
+                            "args": {
+                                "query": "weather in san francisco"
+                            },
+                            "id": "toolu_01AaNPSPzqia21v7aAKwbKYm",
+                            "type": "tool_call"
+                        }
+                    ],
+                    "invalid_tool_calls": [],
+                    "usage_metadata": {
+                        "input_tokens": 273,
+                        "output_tokens": 61,
+                        "total_tokens": 334
+                    }
+                },
+                {
+                    "content": "[{\"url\": \"https://www.weatherapi.com/\", \"content\": \"{'location': {'name': 'San Francisco', 'region': 'California', 'country': 'United States of America', 'lat': 37.78, 'lon': -122.42, 'tz_id': 'America/Los_Angeles', 'localtime_epoch': 1725052131, 'localtime': '2024-08-30 14:08'}, 'current': {'last_updated_epoch': 1725051600, 'last_updated': '2024-08-30 14:00', 'temp_c': 21.1, 'temp_f': 70.0, 'is_day': 1, 'condition': {'text': 'Partly cloudy', 'icon': '//cdn.weatherapi.com/weather/64x64/day/116.png', 'code': 1003}, 'wind_mph': 11.9, 'wind_kph': 19.1, 'wind_degree': 290, 'wind_dir': 'WNW', 'pressure_mb': 1018.0, 'pressure_in': 30.07, 'precip_mm': 0.0, 'precip_in': 0.0, 'humidity': 59, 'cloud': 25, 'feelslike_c': 21.1, 'feelslike_f': 70.0, 'windchill_c': 18.6, 'windchill_f': 65.5, 'heatindex_c': 18.6, 'heatindex_f': 65.5, 'dewpoint_c': 12.2, 'dewpoint_f': 54.0, 'vis_km': 16.0, 'vis_miles': 9.0, 'uv': 5.0, 'gust_mph': 15.0, 'gust_kph': 24.2}}\"}]",
+                    "additional_kwargs": {},
+                    "response_metadata": {},
+                    "type": "tool",
+                    "name": "tavily_search_results_json",
+                    "id": "686b2487-f332-4e58-9508-89b3a814cd81",
+                    "tool_call_id": "toolu_01AaNPSPzqia21v7aAKwbKYm",
+                    "artifact": {
+                        "query": "weather in san francisco",
+                        "follow_up_questions": null,
+                        "answer": null,
+                        "images": [],
+                        "results": [
+                            {
+                                "title": "Weather in San Francisco",
+                                "url": "https://www.weatherapi.com/",
+                                "content": "{'location': {'name': 'San Francisco', 'region': 'California', 'country': 'United States of America', 'lat': 37.78, 'lon': -122.42, 'tz_id': 'America/Los_Angeles', 'localtime_epoch': 1725052131, 'localtime': '2024-08-30 14:08'}, 'current': {'last_updated_epoch': 1725051600, 'last_updated': '2024-08-30 14:00', 'temp_c': 21.1, 'temp_f': 70.0, 'is_day': 1, 'condition': {'text': 'Partly cloudy', 'icon': '//cdn.weatherapi.com/weather/64x64/day/116.png', 'code': 1003}, 'wind_mph': 11.9, 'wind_kph': 19.1, 'wind_degree': 290, 'wind_dir': 'WNW', 'pressure_mb': 1018.0, 'pressure_in': 30.07, 'precip_mm': 0.0, 'precip_in': 0.0, 'humidity': 59, 'cloud': 25, 'feelslike_c': 21.1, 'feelslike_f': 70.0, 'windchill_c': 18.6, 'windchill_f': 65.5, 'heatindex_c': 18.6, 'heatindex_f': 65.5, 'dewpoint_c': 12.2, 'dewpoint_f': 54.0, 'vis_km': 16.0, 'vis_miles': 9.0, 'uv': 5.0, 'gust_mph': 15.0, 'gust_kph': 24.2}}",
+                                "score": 0.976148,
+                                "raw_content": null
+                            }
+                        ],
+                        "response_time": 3.07
+                    },
+                    "status": "success"
+                },
+                {
+                    "content": [
+                        {
+                            "text": "\n\nThe search results provide the current weather conditions in San Francisco. According to the data, as of 2:00 PM on August 30, 2024, the temperature in San Francisco is 70\u00b0F (21.1\u00b0C) with partly cloudy skies. The wind is blowing from the west-northwest at around 12 mph (19 km/h). The humidity is 59% and visibility is 9 miles (16 km). Overall, it looks like a nice late summer day in San Francisco with comfortable temperatures and partly sunny conditions.",
+                            "type": "text",
+                            "index": 0
+                        }
+                    ],
+                    "additional_kwargs": {},
+                    "response_metadata": {
+                        "stop_reason": "end_turn",
+                        "stop_sequence": null
+                    },
+                    "type": "ai",
+                    "name": null,
+                    "id": "run-8fecc61d-3d9f-4e16-8e8a-92f702be498a",
+                    "example": false,
+                    "tool_calls": [],
+                    "invalid_tool_calls": [],
+                    "usage_metadata": {
+                        "input_tokens": 837,
+                        "output_tokens": 124,
+                        "total_tokens": 961
+                    }
+                }
+            ]
+        },
+        "next": [],
+        "tasks": [],
+        "metadata": {
+            "step": 3,
+            "run_id": "1ef67140-eb23-684b-8253-91d4c90bb05e",
+            "source": "loop",
+            "writes": {
+                "agent": {
+                    "messages": [
+                        {
+                            "id": "run-8fecc61d-3d9f-4e16-8e8a-92f702be498a",
+                            "name": null,
+                            "type": "ai",
+                            "content": [
+                                {
+                                    "text": "\n\nThe search results provide the current weather conditions in San Francisco. According to the data, as of 2:00 PM on August 30, 2024, the temperature in San Francisco is 70\u00b0F (21.1\u00b0C) with partly cloudy skies. The wind is blowing from the west-northwest at around 12 mph (19 km/h). The humidity is 59% and visibility is 9 miles (16 km). Overall, it looks like a nice late summer day in San Francisco with comfortable temperatures and partly sunny conditions.",
+                                    "type": "text",
+                                    "index": 0
+                                }
+                            ],
+                            "example": false,
+                            "tool_calls": [],
+                            "usage_metadata": {
+                                "input_tokens": 837,
+                                "total_tokens": 961,
+                                "output_tokens": 124
+                            },
+                            "additional_kwargs": {},
+                            "response_metadata": {
+                                "stop_reason": "end_turn",
+                                "stop_sequence": null
+                            },
+                            "invalid_tool_calls": []
+                        }
+                    ]
+                }
+            },
+            "user_id": "",
+            "graph_id": "agent",
+            "thread_id": "5cb1e8a1-34b3-4a61-a34e-71a9799bd00d",
+            "created_by": "system",
+            "assistant_id": "fe096781-5601-53d2-b2f6-0d3403f7e9ca"
+        },
+        "created_at": "2024-08-30T21:09:00.079909+00:00",
+        "checkpoint_id": "1ef67141-3ca2-6fae-8003-fe96832e57d6",
+        "parent_checkpoint_id": "1ef67141-2129-6b37-8002-61fc3bf69cb5"
+    }
+
+We can also just print the content of the last AIMessage:
+
+=== "Python"
+
+    ```python
+    print(final_result['values']['messages'][-1]['content'][0]['text'])
+    ```
+
+=== "Javascript"
+
+    ```js
+    console.log(finalResult['values']['messages'][finalResult['values']['messages'].length-1]['content'][0]['text']);
+    ```
+
+=== "CURL"
+
+    ```bash
+    curl --request GET \
+        --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/state | jq -r '.values.messages[-1].content.[0].text'
+    ```
+
+Output:
+
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 2:00 PM on August 30, 2024, the temperature in San Francisco is 70°F (21.1°C) with partly cloudy skies. The wind is blowing from the west-northwest at around 12 mph (19 km/h). The humidity is 59% and visibility is 9 miles (16 km). Overall, it looks like a nice late summer day in San Francisco with comfortable temperatures and partly sunny conditions.

docs/docs/cloud/how-tos/check_thread_status.md

@@ -13,6 +13,7 @@ First, we need to setup our client so that we can communicate with our hosted gr
     ```python
     from langgraph_sdk import get_client
     client = get_client(url=<DEPLOYMENT_URL>)
+    # Using the graph deployed with the name "agent"
     assistant_id = "agent"
     thread = await client.threads.create()
     ```
@@ -23,7 +24,8 @@ First, we need to setup our client so that we can communicate with our hosted gr
     import { Client } from "@langchain/langgraph-sdk";
 
     const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
-    const assistantId = agent;
+    // Using the graph deployed with the name "agent"
+    const assistantId = "agent";
     const thread = await client.threads.create();
     ```
 
@@ -48,7 +50,7 @@ We can use the following commands to find threads that are idle, which means tha
 === "Javascript"
 
     ```js
-    console.log(await client.threads.search({status: "idle",limit:1}));
+    console.log(await client.threads.search({ status: "idle", limit: 1 }));
     ```
 
 === "CURL"
@@ -83,7 +85,7 @@ We can use the following commands to find threads that have been interrupted in
 === "Javascript"
 
     ```js
-    console.log(await client.threads.search({status: "interrupted",limit:1}));
+    console.log(await client.threads.search({ status: "interrupted", limit: 1 }));
     ```
 
 === "CURL"
@@ -117,7 +119,7 @@ We can use the following commands to find threads that are busy, meaning they ar
 === "Javascript"
 
     ```js
-    console.log(await client.threads.search({status: "busy",limit: 1}));
+    console.log(await client.threads.search({ status: "busy", limit: 1 }));
     ```
 
 === "CURL"
@@ -183,7 +185,7 @@ The search endpoint for threads also allows you to filter on metadata, which can
 === "Javascript"
 
     ```js
-    console.log((await client.threads.search({metadata: {"foo":"bar"},limit: 1}))[0].status);
+    console.log((await client.threads.search({ metadata: { "foo": "bar" }, limit: 1 }))[0].status);
     ```
 
 === "CURL"

docs/docs/cloud/how-tos/configuration_cloud.md

@@ -0,0 +1,264 @@
+# How to create agents with configuration
+
+One of the benefits of LangGraph API is that it lets you create agents with different configurations.
+This is useful when you want to:
+
+- Define a cognitive architecture once as a LangGraph
+- Let that LangGraph be configurable across some attributes (for example, system message or LLM to use)
+- Let users create agents with arbitrary configurations, save them, and then use them in the future
+
+In this guide we will show how to do that for the default agent we have built in.
+
+If you look at the agent we defined, you can see that inside the `call_model` node we have created the model based on some configuration. That node looks like:
+
+=== "Python"
+
+    ```python
+    def call_model(state, config):
+        messages = state["messages"]
+        model_name = config.get('configurable', {}).get("model_name", "anthropic")
+        model = _get_model(model_name)
+        response = model.invoke(messages)
+        # We return a list, because this will get added to the existing list
+        return {"messages": [response]}
+    ```
+
+=== "Javascript"
+
+    ```js
+    function callModel(state: State, config: RunnableConfig) {
+      const messages = state.messages;
+      const modelName = config.configurable?.model_name ?? "anthropic";
+      const model = _getModel(modelName);
+      const response = model.invoke(messages);
+      // We return a list, because this will get added to the existing list
+      return { messages: [response] };
+    }
+    ```
+
+We are looking inside the config for a `model_name` parameter (which defaults to `anthropic` if none is found). That means that by default we are using Anthropic as our model provider. In this example we will see an example of how to create an example agent that is configured to use OpenAI.
+
+First let's set up our client and thread:
+
+=== "Python"
+
+    ```python
+    from langgraph_sdk import get_client
+
+    client = get_client(url=<DEPLOYMENT_URL>)
+    # Select an assistant that is not configured
+    assistants = await client.assistants.search()
+    assistant = [a for a in assistants if not a["config"]][0]
+    ```
+
+=== "Javascript"
+
+    ```js
+    import { Client } from "@langchain/langgraph-sdk";
+
+    const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
+    // Select an assistant that is not configured
+    const assistants = await client.assistants.search();
+    const assistant = assistants.find(a => !a.config);
+    ```
+
+=== "CURL"
+
+    ```bash
+    curl --request POST \
+        --url <DEPLOYMENT_URL>/assistants/search \
+        --header 'Content-Type: application/json' \
+        --data '{
+            "limit": 10,
+            "offset": 0
+        }' | jq -c 'map(select(.config == null or .config == {})) | .[0]'
+    ```
+
+We can now call `.get_schemas` to get schemas associated with this graph:
+
+=== "Python"
+
+    ```python
+    schemas = await client.assistants.get_schemas(
+        assistant_id=assistant["assistant_id"]
+    )
+    # There are multiple types of schemas
+    # We can get the `config_schema` to look at the the configurable parameters
+    print(schemas["config_schema"])
+    ```
+
+=== "Javascript"
+
+    ```js
+    const schemas = await client.assistants.getSchemas(
+      assistant["assistant_id"]
+    );
+    // There are multiple types of schemas
+    // We can get the `config_schema` to look at the the configurable parameters
+    console.log(schemas.config_schema);
+    ```
+
+=== "CURL"
+
+    ```bash
+    curl --request GET \
+        --url <DEPLOYMENT_URL>/assistants/<ASSISTANT_ID>/schemas | jq -r '.config_schema'
+    ```
+
+Output:
+
+    {
+        'model_name': 
+            {
+                'title': 'Model Name',
+                'enum': ['anthropic', 'openai'],
+                'type': 'string'
+            }
+    }
+
+Now we can initialize an assistant with config:
+
+=== "Python"
+
+    ```python
+    openai_assistant = await client.assistants.create(
+        # "agent" is the name of a graph we deployed
+        "agent", config={"configurable": {"model_name": "openai"}}
+    )
+
+    print(openai_assistant)
+    ```
+
+=== "Javascript"
+
+    ```js
+    let openAIAssistant = await client.assistants.create(
+      // "agent" is the name of a graph we deployed
+      "agent", { "configurable": { "model_name": "openai" } }
+    );
+
+    console.log(openAIAssistant);
+    ```
+
+=== "CURL"
+
+    ```bash
+    curl --request POST \
+        --url <DEPLOYMENT_URL>/assistants \
+        --header 'Content-Type: application/json' \
+        --data '{"graph_id":"agent","config":{"configurable":{"model_name":"open_ai"}}}'
+    ```
+
+Output:
+
+    {
+        "assistant_id": "62e209ca-9154-432a-b9e9-2d75c7a9219b",
+        "graph_id": "agent",
+        "created_at": "2024-08-31T03:09:10.230718+00:00",
+        "updated_at": "2024-08-31T03:09:10.230718+00:00",
+        "config": {
+            "configurable": {
+                "model_name": "open_ai"
+            }
+        },
+        "metadata": {}
+    }
+
+We can verify the config is indeed taking effect:
+
+=== "Python"
+
+    ```python
+    thread = await client.threads.create()
+    input = {"messages": [{"role": "user", "content": "who made you?"}]}
+    async for event in client.runs.stream(
+        thread["thread_id"],
+        openai_assistant["assistant_id"],
+        input=input,
+        stream_mode="updates",
+    ):
+        print(f"Receiving event of type: {event.event}")
+        print(event.data)
+        print("\n\n")
+    ```
+
+=== "Javascript"
+
+    ```js
+    const thread = await client.threads.create();
+    let input = { "messages": [{ "role": "user", "content": "who made you?" }] };
+
+    const streamResponse = client.runs.stream(
+      thread["thread_id"],
+      openAIAssistant["assistant_id"],
+      {
+        input,
+        streamMode: "updates"
+      }
+    );
+
+    for await (const event of streamResponse) {
+      console.log(`Receiving event of type: ${event.event}`);
+      console.log(event.data);
+      console.log("\n\n");
+    }
+    ```
+
+=== "CURL"
+
+    ```bash
+    thread_id=$(curl --request POST \
+        --url <DEPLOYMENT_URL>/threads \
+        --header 'Content-Type: application/json' \
+        --data '{}' | jq -r '.thread_id') && \
+    curl --request POST \
+        --url "<DEPLOYMENT_URL>/threads/${thread_id}/runs/stream" \
+        --header 'Content-Type: application/json' \
+        --data '{
+            "assistant_id": <OPENAI_ASSISTANT_ID>,
+            "input": {
+                "messages": [
+                    {
+                        "role": "human",
+                        "content": "who made you?"
+                    }
+                ]
+            },
+            "stream_mode": [
+                "updates"
+            ]
+        }' | \
+        sed 's/\r$//' | \
+        awk '
+        /^event:/ {
+            if (data_content != "") {
+                print data_content "\n"
+            }
+            sub(/^event: /, "Receiving event of type: ", $0)
+            printf "%s...\n", $0
+            data_content = ""
+        }
+        /^data:/ {
+            sub(/^data: /, "", $0)
+            data_content = $0
+        }
+        END {
+            if (data_content != "") {
+                print data_content "\n\n"
+            }
+        }
+    '
+    ```
+
+Output:
+
+    Receiving event of type: metadata
+    {'run_id': '1ef6746e-5893-67b1-978a-0f1cd4060e16'}
+
+
+
+    Receiving event of type: updates
+    {'agent': {'messages': [{'content': 'I was created by OpenAI, a research organization focused on developing and advancing artificial intelligence technology.', 'additional_kwargs': {}, 'response_metadata': {'finish_reason': 'stop', 'model_name': 'gpt-4o-2024-05-13', 'system_fingerprint': 'fp_157b3831f5'}, 'type': 'ai', 'name': None, 'id': 'run-e1a6b25c-8416-41f2-9981-f9cfe043f414', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]}}
+
+
+

docs/docs/cloud/how-tos/copy_threads.md

@@ -24,8 +24,8 @@ First, we need to setup our client so that we can communicate with our hosted gr
     ```js
     import { Client } from "@langchain/langgraph-sdk";
 
-    const client = new Client({ apiUrl:"<DEPLOYMENT_URL>" });
-    const assistantId = agent;
+    const client = new Client({ apiUrl: "<DEPLOYMENT_URL>" });
+    const assistantId = "agent";
     const thread = await client.threads.create();
     ```
 
@@ -92,21 +92,21 @@ We can verify that the history from the prior thread did indeed copy over correc
 
     ```js
     function removeThreadId(d) {
-        if (d.metadata && d.metadata.thread_id) {
-            delete d.metadata.thread_id;
-        }
-        return d;
+      if (d.metadata && d.metadata.thread_id) {
+        delete d.metadata.thread_id;
+      }
+      return d;
     }
 
     // Assuming `client.threads.getHistory(threadId)` is an async function that returns a list of dicts
     async function compareThreadHistories(threadId, copiedThreadId) {
-        const originalThreadHistory = (await client.threads.getHistory(threadId)).map(removeThreadId);
-        const copiedThreadHistory = (await client.threads.getHistory(copiedThreadId)).map(removeThreadId);
+      const originalThreadHistory = (await client.threads.getHistory(threadId)).map(removeThreadId);
+      const copiedThreadHistory = (await client.threads.getHistory(copiedThreadId)).map(removeThreadId);
 
-        // Compare the two histories
-        console.assert(JSON.stringify(originalThreadHistory) === JSON.stringify(copiedThreadHistory))
-        // if we made it here the assertion passed!
-        console.log("The histories are the same.");
+      // Compare the two histories
+      console.assert(JSON.stringify(originalThreadHistory) === JSON.stringify(copiedThreadHistory));
+      // if we made it here the assertion passed!
+      console.log("The histories are the same.");
     }
 
     // Example usage

docs/docs/cloud/how-tos/cron_jobs.md

@@ -0,0 +1,184 @@
+# Cron Jobs
+
+Sometimes you don't want to run your graph based on user interaction, but rather you would like to schedule your graph to run on a schedule - for example if you wish for your graph to compose and send out a weekly email of to-dos for your team. LangGraph Cloud allows you to do this without having to write your own script by using the `Crons` client. To schedule a graph job, you need to pass a [cron expression](https://crontab.cronhub.io/) to inform the client when you want to run the graph. `Cron` jobs are run in the background and do not interfere with normal invocations of the graph.
+
+## Setup
+
+First, let's setup our SDK client, assistant, and thread:
+
+=== "Python"
+
+    ```python
+    from langgraph_sdk import get_client
+
+    client = get_client(url=<DEPLOYMENT_URL>)
+    # Using the graph deployed with the name "agent"
+    assistant_id = "agent"
+    # create thread
+    thread = await client.threads.create()
+    print(thread)
+    ```
+
+=== "Javascript"
+
+    ```js
+    import { Client } from "@langchain/langgraph-sdk";
+
+    const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
+    // Using the graph deployed with the name "agent"
+    const assistantId = "agent";
+    // create thread
+    const thread = await client.threads.create();
+    console.log(thread);
+    ```
+
+=== "CURL"
+
+    ```bash
+    curl --request POST \
+        --url <DEPLOYMENT_URL>/assistants/search \
+        --header 'Content-Type: application/json' \
+        --data '{
+            "limit": 10,
+            "offset": 0
+        }' | jq -c 'map(select(.config == null or .config == {})) | .[0].graph_id' && \
+    curl --request POST \
+        --url <DEPLOYMENT_URL>/threads \
+        --header 'Content-Type: application/json' \
+        --data '{}'
+    ```
+
+Output:
+
+    {
+        'thread_id': '9dde5490-2b67-47c8-aa14-4bfec88af217', 
+        'created_at': '2024-08-30T23:07:38.242730+00:00', 
+        'updated_at': '2024-08-30T23:07:38.242730+00:00', 
+        'metadata': {}, 
+        'status': 'idle', 
+        'config': {}, 
+        'values': None
+    }
+
+## Cron job on a thread 
+
+To create a cron job associated with a specific thread, you can write:
+
+
+=== "Python"
+
+    ```python
+    # This schedules a job to run at 15:27 (3:27PM) every day
+    cron_job = await client.crons.create_for_thread(
+        thread["thread_id"],
+        assistant_id,
+        schedule="27 15 * * *",
+        input={"messages": [{"role": "user", "content": "What time is it?"}]},
+    )
+    ```
+
+=== "Javascript"
+
+    ```js
+    // This schedules a job to run at 15:27 (3:27PM) every day
+    const cronJob = await client.crons.create_for_thread(
+      thread["thread_id"],
+      assistantId,
+      {
+        schedule: "27 15 * * *",
+        input: { messages: [{ role: "user", content: "What time is it?" }] }
+      }
+    );
+    ```
+
+=== "CURL"
+
+    ```bash
+    curl --request POST \
+        --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/crons \
+        --header 'Content-Type: application/json' \
+        --data '{
+            "assistant_id": <ASSISTANT_ID>,
+        }'
+    ```
+
+Note that it is **very** important to delete `Cron` jobs that are no longer useful. Otherwise you could rack up unwanted API charges to the LLM! You can delete a `Cron` job using the following code:
+
+=== "Python"
+
+    ```python
+    await client.crons.delete(cron_job["cron_id"])
+    ```
+
+=== "Javascript"
+
+    ```js
+    await client.crons.delete(cronJob["cron_id"]);
+    ```
+
+=== "CURL"
+
+    ```bash
+    curl --request DELETE \
+        --url <DEPLOYMENT_URL>/runs/crons/<CRON_ID>
+    ```
+
+## Cron job stateless
+
+You can also create stateless cron jobs by using the following code:
+
+=== "Python"
+
+    ```python
+    # This schedules a job to run at 15:27 (3:27PM) every day
+    cron_job_stateless = await client.crons.create(
+        assistant_id,
+        schedule="27 15 * * *",
+        input={"messages": [{"role": "user", "content": "What time is it?"}]},
+    )
+    ```
+
+=== "Javascript"
+
+    ```js
+    // This schedules a job to run at 15:27 (3:27PM) every day
+    const cronJobStateless = await client.crons.create(
+      assistantId,
+      {
+        schedule: "27 15 * * *",
+        input: { messages: [{ role: "user", content: "What time is it?" }] }
+      }
+    );
+    ```
+
+=== "CURL"
+
+    ```bash
+    curl --request POST \
+        --url <DEPLOYMENT_URL>/runs/crons \
+        --header 'Content-Type: application/json' \
+        --data '{
+            "assistant_id": <ASSISTANT_ID>,
+        }'
+    ```
+
+Again, remember to delete your job once you are done with it!
+
+=== "Python"
+
+    ```python
+    await client.crons.delete(cron_job_stateless["cron_id"])
+    ```
+
+=== "Javascript"
+
+    ```js
+    await client.crons.delete(cronJobStateless["cron_id"]);
+    ```
+
+=== "CURL"
+
+    ```bash
+    curl --request DELETE \
+        --url <DEPLOYMENT_URL>/runs/crons/<CRON_ID>
+    ```

docs/docs/cloud/how-tos/enqueue_concurrent.md

@@ -5,20 +5,44 @@ This guide assumes knowledge of what double-texting is, which you can learn abou
 The guide covers the `enqueue` option for double texting, which adds the interruptions to a queue and executes them in the order they are received by the client. Below is a quick example of using the `enqueue` option.
 
 
-First, we will define a quick helper function for printing out JS model outputs (you can skip this if using Python):
+First, we will define a quick helper function for printing out JS and CURL model outputs (you can skip this if using Python):
 
-```js
-function prettyPrint(m) {
-  const padded = " " + m['type'] + " ";
-  const sepLen = Math.floor((80 - padded.length) / 2);
-  const sep = "=".repeat(sepLen);
-  const secondSep = sep + (padded.length % 2 ? "=" : "");
-  
-  console.log(`${sep}${padded}${secondSep}`);
-  console.log("\n\n");
-  console.log(m.content);
-}
-```
+=== "Javascript"
+
+    ```js
+    function prettyPrint(m) {
+      const padded = " " + m['type'] + " ";
+      const sepLen = Math.floor((80 - padded.length) / 2);
+      const sep = "=".repeat(sepLen);
+      const secondSep = sep + (padded.length % 2 ? "=" : "");
+      
+      console.log(`${sep}${padded}${secondSep}`);
+      console.log("\n\n");
+      console.log(m.content);
+    }
+    ```
+
+=== "CURL"
+
+    ```bash
+    # PLACE THIS IN A FILE CALLED pretty_print.sh
+    pretty_print() {
+      local type="$1"
+      local content="$2"
+      local padded=" $type "
+      local total_width=80
+      local sep_len=$(( (total_width - ${#padded}) / 2 ))
+      local sep=$(printf '=%.0s' $(eval "echo {1.."${sep_len}"}"))
+      local second_sep=$sep
+      if (( (total_width - ${#padded}) % 2 )); then
+        second_sep="${second_sep}="
+      fi
+
+      echo "${sep}${padded}${second_sep}"
+      echo
+      echo "$content"
+    }
+    ```
 
 Then, let's import our required packages and instantiate our client, assistant, and thread.
 
@@ -32,6 +56,7 @@ Then, let's import our required packages and instantiate our client, assistant,
     from langgraph_sdk import get_client
 
     client = get_client(url=<DEPLOYMENT_URL>)
+    # Using the graph deployed with the name "agent"
     assistant_id = "agent"
     thread = await client.threads.create()
     ```
@@ -43,9 +68,18 @@ Then, let's import our required packages and instantiate our client, assistant,
     
 
     const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
+    // Using the graph deployed with the name "agent"
     const assistantId = "agent";
     const thread = await client.threads.create();
     ```
+  
+=== "CURL"
+
+    ```bash
+    curl --request POST \
+      --url <DEPLOYMENT_URL>/threads \
+      --header 'Content-Type: application/json'
+    ```
 
 Now let's start two runs, with the second interrupting the first one with a multitask strategy of "enqueue":
 
@@ -82,6 +116,25 @@ Now let's start two runs, with the second interrupting the first one with a mult
     )
     ```
 
+=== "CURL"
+
+    ```bash
+    curl --request POST \
+    --url <DEPLOY<ENT_URL>>/threads/<THREAD_ID>/runs \
+    --header 'Content-Type: application/json' \
+    --data "{
+      \"assistant_id\": \"agent\",
+      \"input\": {\"messages\": [{\"role\": \"human\", \"content\": \"what\'s the weather in sf?\"}]},
+    }" && curl --request POST \
+    --url <DEPLOY<ENT_URL>>/threads/<THREAD_ID>/runs \
+    --header 'Content-Type: application/json' \
+    --data "{
+      \"assistant_id\": \"agent\",
+      \"input\": {\"messages\": [{\"role\": \"human\", \"content\": \"what\'s the weather in nyc?\"}]},
+      \"multitask_strategy\": \"enqueue\"
+    }"
+    ```
+
 Verify that the thread has data from both runs:
 
 === "Python"
@@ -108,12 +161,25 @@ Verify that the thread has data from both runs:
     }
     ```
 
+=== "CURL"
+
+    ```bash
+    source pretty_print.sh && curl --request GET \
+    --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/<RUN_ID>/join && \
+    curl --request GET --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/state | \
+    jq -c '.values.messages[]' | while read -r element; do
+        type=$(echo "$element" | jq -r '.type')
+        content=$(echo "$element" | jq -r '.content | if type == "array" then tostring else . end')
+        pretty_print "$type" "$content"
+    done
+    ```
+
 Output:
 
-    ================================ Human Message =================================
+    ================================ Human Message =================================
     
     what's the weather in sf?
-    ================================== Ai Message ==================================
+    ================================== Ai Message ==================================
     
     [{'id': 'toolu_01Dez1sJre4oA2Y7NsKJV6VT', 'input': {'query': 'weather in san francisco'}, 'name': 'tavily_search_results_json', 'type': 'tool_use'}]
     Tool Calls:
@@ -121,11 +187,11 @@ Output:
      Call ID: toolu_01Dez1sJre4oA2Y7NsKJV6VT
       Args:
         query: weather in san francisco
-    ================================= Tool Message =================================
+    ================================= Tool Message =================================
     Name: tavily_search_results_json
     
     [{"url": "https://www.accuweather.com/en/us/san-francisco/94103/weather-forecast/347629", "content": "Get the current and future weather conditions for San Francisco, CA, including temperature, precipitation, wind, air quality and more. See the hourly and 10-day outlook, radar maps, alerts and allergy information."}]
-    ================================== Ai Message ==================================
+    ================================== Ai Message ==================================
     
     According to AccuWeather, the current weather conditions in San Francisco are:
     
@@ -145,10 +211,10 @@ Output:
     Sunday: Partly sunny, high of 61°F (16°C)
     
     So in summary, expect seasonable spring weather in San Francisco over the next several days, with a mix of sun and clouds and temperatures ranging from the upper 40s at night to the low 60s during the days. Typical dry conditions with no rain in the forecast.
-    ================================ Human Message =================================
+    ================================ Human Message =================================
     
     what's the weather in nyc?
-    ================================== Ai Message ==================================
+    ================================== Ai Message ==================================
     
     [{'text': 'Here are the current weather conditions and forecast for New York City:', 'type': 'text'}, {'id': 'toolu_01FFft5Sx9oS6AdVJuRWWcGp', 'input': {'query': 'weather in new york city'}, 'name': 'tavily_search_results_json', 'type': 'tool_use'}]
     Tool Calls:
@@ -156,11 +222,11 @@ Output:
      Call ID: toolu_01FFft5Sx9oS6AdVJuRWWcGp
       Args:
         query: weather in new york city
-    ================================= Tool Message =================================
+    ================================= Tool Message =================================
     Name: tavily_search_results_json
     
     [{"url": "https://www.weatherapi.com/", "content": "{'location': {'name': 'New York', 'region': 'New York', 'country': 'United States of America', 'lat': 40.71, 'lon': -74.01, 'tz_id': 'America/New_York', 'localtime_epoch': 1718734479, 'localtime': '2024-06-18 14:14'}, 'current': {'last_updated_epoch': 1718733600, 'last_updated': '2024-06-18 14:00', 'temp_c': 29.4, 'temp_f': 84.9, 'is_day': 1, 'condition': {'text': 'Sunny', 'icon': '//cdn.weatherapi.com/weather/64x64/day/113.png', 'code': 1000}, 'wind_mph': 2.2, 'wind_kph': 3.6, 'wind_degree': 158, 'wind_dir': 'SSE', 'pressure_mb': 1025.0, 'pressure_in': 30.26, 'precip_mm': 0.0, 'precip_in': 0.0, 'humidity': 63, 'cloud': 0, 'feelslike_c': 31.3, 'feelslike_f': 88.3, 'windchill_c': 28.3, 'windchill_f': 82.9, 'heatindex_c': 29.6, 'heatindex_f': 85.3, 'dewpoint_c': 18.4, 'dewpoint_f': 65.2, 'vis_km': 16.0, 'vis_miles': 9.0, 'uv': 7.0, 'gust_mph': 16.5, 'gust_kph': 26.5}}"}]
-    ================================== Ai Message ==================================
+    ================================== Ai Message ==================================
     
     According to the weather data from WeatherAPI:
     

docs/docs/cloud/how-tos/human_in_the_loop_breakpoint.md

@@ -22,6 +22,7 @@ In this how-to we use a simple ReAct style hosted graph (you can see the full co
     ```python
     from langgraph_sdk import get_client
     client = get_client(url=<DEPLOYMENT_URL>)
+    # Using the graph deployed with the name "agent"
     assistant_id = "agent"
     thread = await client.threads.create()
     ```
@@ -32,7 +33,8 @@ In this how-to we use a simple ReAct style hosted graph (you can see the full co
     import { Client } from "@langchain/langgraph-sdk";
 
     const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
-    const assistantId = "agent"
+    // Using the graph deployed with the name "agent"
+    const assistantId = "agent";
     const thread = await client.threads.create();
     ```
 
@@ -73,7 +75,7 @@ And, now let's compile it with a breakpoint before the tool node:
 === "Javascript"
 
     ```js
-    const input = { "messages": [{ "role": "human", "content": "what's the weather in sf"}] }
+    const input = { messages: [{ role: "human", content: "what's the weather in sf" }] };
 
     const streamResponse = client.runs.stream(
       thread["thread_id"],
@@ -81,9 +83,10 @@ And, now let's compile it with a breakpoint before the tool node:
       {
         input: input,
         streamMode: "updates",
-        interruptBefore: ["action"],
+        interruptBefore: ["action"]
       }
     );
+
     for await (const chunk of streamResponse) {
       console.log(`Receiving new event of type: ${chunk.event}...`);
       console.log(chunk.data);

docs/docs/cloud/how-tos/human_in_the_loop_edit_state.md

@@ -18,6 +18,7 @@ First, we need to setup our client so that we can communicate with our hosted gr
     ```python
     from langgraph_sdk import get_client
     client = get_client(url=<DEPLOYMENT_URL>)
+    # Using the graph deployed with the name "agent"
     assistant_id = "agent"
     thread = await client.threads.create()
     ```
@@ -28,6 +29,7 @@ First, we need to setup our client so that we can communicate with our hosted gr
     import { Client } from "@langchain/langgraph-sdk";
 
     const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
+    // Using the graph deployed with the name "agent"
     const assistantId = "agent";
     const thread = await client.threads.create();
     ```
@@ -65,7 +67,7 @@ Now let's invoke our graph, making sure to interrupt before the `action` node.
 === "Javascript"
 
     ```js
-    const input = {"messages": [{ "role": "human", "content": "search for weather in SF"}] }
+    const input = { messages: [{ role: "human", content: "search for weather in SF" }] };
 
     const streamResponse = client.runs.stream(
       thread["thread_id"],
@@ -76,6 +78,7 @@ Now let's invoke our graph, making sure to interrupt before the `action` node.
         interruptBefore: ["action"],
       }
     );
+
     for await (const chunk of streamResponse) {
       if (chunk.data && chunk.event !== "metadata") {
         console.log(chunk.data);
@@ -154,15 +157,15 @@ Now, let's assume we actually meant to search for the weather in Sidi Frej (anot
 === "Javascript"
 
     ```js
-    // First, lets get the current state
-    const currentState = await client.threads.getState(thread['thread_id']);
+    // First, let's get the current state
+    const currentState = await client.threads.getState(thread["thread_id"]);
 
     // Let's now get the last message in the state
     // This is the one with the tool calls that we want to update
-    let lastMessage = currentState['values']['messages'][-1];
+    let lastMessage = currentState.values.messages.slice(-1)[0];
 
     // Let's now update the args for that tool call
-    lastMessage['tool_calls'][0]['args'] = {'query': 'current weather in Sidi Frej'};
+    lastMessage.tool_calls[0].args = { query: "current weather in Sidi Frej" };
 
     // Let's now call `update_state` to pass in this message in the `messages` key
     // This will get treated as any other update to the state
@@ -170,7 +173,7 @@ Now, let's assume we actually meant to search for the weather in Sidi Frej (anot
     // That reducer function will use the ID of the message to update it
     // It's important that it has the right ID! Otherwise it would get appended
     // as a new message
-    await client.threads.updateState(thread['thread_id'], {values:{"messages": lastMessage}});
+    await client.threads.updateState(thread["thread_id"], { values: { messages: lastMessage } });
     ```
 
 === "CURL"
@@ -220,6 +223,7 @@ Now we can resume our graph run but with the updated state:
         streamMode: "updates",
       }
     );
+
     for await (const chunk of streamResponse) {
       if (chunk.data && chunk.event !== "metadata") {
         console.log(chunk.data);

docs/docs/cloud/how-tos/human_in_the_loop_review_tool_calls.md

@@ -29,6 +29,7 @@ First, we need to setup our client so that we can communicate with our hosted gr
     ```python
     from langgraph_sdk import get_client
     client = get_client(url=<DEPLOYMENT_URL>)
+    # Using the graph deployed with the name "agent"
     assistant_id = "agent"
     thread = await client.threads.create()
     ```
@@ -39,10 +40,19 @@ First, we need to setup our client so that we can communicate with our hosted gr
     import { Client } from "@langchain/langgraph-sdk";
 
     const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
+    // Using the graph deployed with the name "agent"
     const assistantId = "agent";
     const thread = await client.threads.create();
     ```
 
+=== "CURL"
+
+    ```bash
+    curl --request POST \
+      --url <DEPLOYMENT_URL>/threads \
+      --header 'Content-Type: application/json'
+    ```
+
 ## Example with no review
 
 Let's look at an example when no review is required (because no tools are called)
@@ -66,7 +76,7 @@ Let's look at an example when no review is required (because no tools are called
 === "Javascript"
 
     ```js
-    const input = {"messages": [{ "role": "human", "content": "hi!"}] }
+    const input = { "messages": [{ "role": "human", "content": "hi!" }] };
 
     const streamResponse = client.runs.stream(
       thread["thread_id"],
@@ -77,6 +87,7 @@ Let's look at an example when no review is required (because no tools are called
         interruptBefore: ["action"],
       }
     );
+
     for await (const chunk of streamResponse) {
       if (chunk.data && chunk.event !== "metadata") {
         console.log(chunk.data);
@@ -84,6 +95,42 @@ Let's look at an example when no review is required (because no tools are called
     }
     ```
 
+=== "CURL"
+
+    ```bash
+    curl --request POST \
+     --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
+     --header 'Content-Type: application/json' \
+     --data "{
+       \"assistant_id\": \"agent\",
+       \"input\": {\"messages\": [{\"role\": \"human\", \"content\": \"hi!\"}]},
+       \"stream_mode\": [
+         \"updates\"
+       ],
+       \"interrupt_before\": [\"action\"]
+     }" | \
+     sed 's/\r$//' | \
+     awk '
+     /^event:/ {
+         if (data_content != "" && event_type != "metadata") {
+             print data_content "\n"
+         }
+         sub(/^event: /, "", $0)
+         event_type = $0
+         data_content = ""
+     }
+     /^data:/ {
+         sub(/^data: /, "", $0)
+         data_content = $0
+     }
+     END {
+         if (data_content != "" && event_type != "metadata") {
+             print data_content "\n"
+         }
+     }
+     '
+    ```
+
 Output:
 
     {'messages': [{'content': 'hi!', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '39c51f14-2d5c-4690-883a-d940854b1845', 'example': False}]}
@@ -108,6 +155,13 @@ If we check the state, we can see that it is finished
     console.log(state.next);
     ```
 
+=== "CURL"
+
+    ```bash
+    curl --request GET \
+        --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/state | jq -c '.next'
+    ```
+
 Output:
 
     []
@@ -125,7 +179,6 @@ Let's now look at what it looks like to approve a tool call. Note that we don't
         thread["thread_id"],
         "agent",
         input=input,
-        stream_mode="values",
     ):
         if chunk.data and chunk.event != "metadata": 
             print(chunk.data)
@@ -134,16 +187,16 @@ Let's now look at what it looks like to approve a tool call. Note that we don't
 === "Javascript"
 
     ```js
-    const input = {"messages": [{"role": "user", "content": "what's the weather in sf?"}]}
+    const input = { "messages": [{ "role": "user", "content": "what's the weather in sf?" }] };
 
     const streamResponse = client.runs.stream(
       thread["thread_id"],
       assistantId,
       {
         input: input,
-        streamMode: "values",
       }
     );
+
     for await (const chunk of streamResponse) {
       if (chunk.data && chunk.event !== "metadata") {
         console.log(chunk.data);
@@ -151,6 +204,38 @@ Let's now look at what it looks like to approve a tool call. Note that we don't
     }
     ```
 
+=== "CURL"
+
+    ```bash
+    curl --request POST \
+     --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
+     --header 'Content-Type: application/json' \
+     --data "{
+       \"assistant_id\": \"agent\",
+       \"input\": {\"messages\": [{\"role\": \"human\", \"content\": \"what's the weather in sf?\"}]}
+     }" | \
+     sed 's/\r$//' | \
+     awk '
+     /^event:/ {
+         if (data_content != "" && event_type != "metadata") {
+             print data_content "\n"
+         }
+         sub(/^event: /, "", $0)
+         event_type = $0
+         data_content = ""
+     }
+     /^data:/ {
+         sub(/^data: /, "", $0)
+         data_content = $0
+     }
+     END {
+         if (data_content != "" && event_type != "metadata") {
+             print data_content "\n"
+         }
+     }
+     '
+    ```
+
 Output:
 
     {'messages': [{'content': "what's the weather in sf?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '54e19d6e-89fa-44fb-b92c-12e7dd4ddf08', 'example': False}]}
@@ -175,6 +260,13 @@ If we now check, we can see that it is waiting on human review:
     console.log(state.next);
     ```
 
+=== "CURL"
+
+    ```bash
+    curl --request GET \
+        --url <DELPOYMENT_URL>/threads/<THREAD_ID>/state | jq -c '.next'
+    ```
+
 Output:
 
     ['human_review_node']
@@ -201,10 +293,11 @@ To approve the tool call, we can just continue the thread with no edits. To do t
       thread["thread_id"],
       assistantId,
       {
-        input: undefined,
+        input: null,
         streamMode: "values",
       }
     );
+
     for await (const chunk of streamResponse) {
       if (chunk.data && chunk.event !== "metadata") {
         console.log(chunk.data);
@@ -212,6 +305,37 @@ To approve the tool call, we can just continue the thread with no edits. To do t
     }
     ```
 
+=== "CURL"
+
+    ```bash
+    curl --request POST \
+     --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
+     --header 'Content-Type: application/json' \
+     --data "{
+       \"assistant_id\": \"agent\"
+     }" | \
+     sed 's/\r$//' | \
+     awk '
+     /^event:/ {
+         if (data_content != "" && event_type != "metadata") {
+             print data_content "\n"
+         }
+         sub(/^event: /, "", $0)
+         event_type = $0
+         data_content = ""
+     }
+     /^data:/ {
+         sub(/^data: /, "", $0)
+         data_content = $0
+     }
+     END {
+         if (data_content != "" && event_type != "metadata") {
+             print data_content "\n"
+         }
+     }
+     '
+    ```
+
 Output:
 
     {'messages': [{'content': "what's the weather in sf?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '54e19d6e-89fa-44fb-b92c-12e7dd4ddf08', 'example': False}, {'content': [{'text': "Certainly! I can help you check the weather in San Francisco. To get this information, I'll use the weather search function. Let me do that for you right away.", 'type': 'text', 'index': 0}, {'id': 'toolu_015yrR3GMDXe6X8m2p9CsEDN', 'input': {}, 'name': 'weather_search', 'type': 'tool_use', 'index': 1, 'partial_json': '{"city": "San Francisco"}'}], 'additional_kwargs': {}, 'response_metadata': {'stop_reason': 'tool_use', 'stop_sequence': None}, 'type': 'ai', 'name': None, 'id': 'run-45a6b6c3-ac69-42a4-8957-d982203d6392', 'example': False, 'tool_calls': [{'name': 'weather_search', 'args': {'city': 'San Francisco'}, 'id': 'toolu_015yrR3GMDXe6X8m2p9CsEDN', 'type': 'tool_call'}], 'invalid_tool_calls': [], 'usage_metadata': {'input_tokens': 360, 'output_tokens': 90, 'total_tokens': 450}}, {'content': 'Sunny!', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': 'weather_search', 'id': '826cd0f2-9cc6-46f0-b7df-daa6a05d13d2', 'tool_call_id': 'toolu_015yrR3GMDXe6X8m2p9CsEDN', 'artifact': None, 'status': 'success'}]}
@@ -239,7 +363,7 @@ Let's now say we want to edit the tool call. E.g. change some of the parameters
 === "Javascript"
 
     ```js
-    const input = {"messages": [{"role": "user", "content": "what's the weather in sf?"}]}
+    const input = { "messages": [{ "role": "user", "content": "what's the weather in sf?" }] };
 
     const streamResponse = client.runs.stream(
       thread["thread_id"],
@@ -249,6 +373,7 @@ Let's now say we want to edit the tool call. E.g. change some of the parameters
         streamMode: "values",
       }
     );
+
     for await (const chunk of streamResponse) {
       if (chunk.data && chunk.event !== "metadata") {
         console.log(chunk.data);
@@ -256,6 +381,38 @@ Let's now say we want to edit the tool call. E.g. change some of the parameters
     }
     ```
 
+=== "CURL"
+
+    ```bash
+    curl --request POST \
+     --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
+     --header 'Content-Type: application/json' \
+     --data "{
+       \"assistant_id\": \"agent\",
+       \"input\": {\"messages\": [{\"role\": \"human\", \"content\": \"what's the weather in sf?\"}]}
+     }" | \
+     sed 's/\r$//' | \
+     awk '
+     /^event:/ {
+         if (data_content != "" && event_type != "metadata") {
+             print data_content "\n"
+         }
+         sub(/^event: /, "", $0)
+         event_type = $0
+         data_content = ""
+     }
+     /^data:/ {
+         sub(/^data: /, "", $0)
+         data_content = $0
+     }
+     END {
+         if (data_content != "" && event_type != "metadata") {
+             print data_content "\n"
+         }
+     }
+     '
+    ```
+
 Output:
 
     {'messages': [{'content': "what's the weather in sf?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': 'cec11391-84da-464b-bd2a-bd4f0d93b9ee', 'example': False}]}
@@ -310,7 +467,6 @@ To do this, we first need to update the state. We can do this by passing a messa
         thread["thread_id"],
         "agent",
         input=None,
-        stream_mode="values",
     ):
         if chunk.data and chunk.event != "metadata": 
             print(chunk.data)
@@ -332,43 +488,93 @@ To do this, we first need to update the state. We can do this by passing a messa
 
     // Construct a replacement tool call
     const newMessage = {
-        role: "assistant",
-        content: currentContent,
-        tool_calls: [
-            {
-                id: toolCallId,
-                name: "weather_search",
-                args: { city: "San Francisco, USA" }
-            }
-        ],
-        // Ensure the ID is the same as the message you're replacing
-        id: currentId
+      role: "assistant",
+      content: currentContent,
+      tool_calls: [
+        {
+          id: toolCallId,
+          name: "weather_search",
+          args: { city: "San Francisco, USA" }
+        }
+      ],
+      // Ensure the ID is the same as the message you're replacing
+      id: currentId
     };
 
     await client.threads.updateState(
-        thread.thread_id,  // Thread ID
-        {
+      thread.thread_id,  // Thread ID
+      {
         values: { "messages": [newMessage] },  // Updated message
         asNode: "human_review_node"
-        }  // Acting as human_review_node
+      }  // Acting as human_review_node
     );
 
     console.log("\nResuming Execution");
     // Continue executing from here
     const streamResponseResumed = client.runs.stream(
-    thread["thread_id"],
-    assistantId,
-    {
-        input: undefined,
-        streamMode: "values",
-        interruptBefore: ["action"],
-    }
+      thread["thread_id"],
+      assistantId,
+      {
+        input: null,
+      }
     );
+
     for await (const chunk of streamResponseResumed) {
-    if (chunk.data && chunk.event !== "metadata") {
+      if (chunk.data && chunk.event !== "metadata") {
         console.log(chunk.data);
+      }
     }
+    ```
+
+=== "CURL"
+
+    ```bash
+    curl --request POST \
+    --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/state \
+    --header 'Content-Type: application/json' \
+    --data "{
+        \"values\": { \"messages\": [$(curl --request GET \
+            --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/state |
+            jq -c '{
+            role: "assistant",
+            content: .values.messages[-1].content,
+            tool_calls: [
+                {
+                id: .values.messages[-1].tool_calls[0].id,
+                name: "weather_search",
+                args: { city: "San Francisco, USA" }
+                }
+            ],
+            id: .values.messages[-1].id
+            }')
+        ]},
+        \"as_node\": \"human_review_node\"
+    }" && echo "Resuming Execution" && curl --request POST \
+    --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
+    --header 'Content-Type: application/json' \
+    --data '{
+    "assistant_id": "agent"
+    }' | \
+    sed 's/\r$//' | \
+    awk '
+    /^event:/ {
+        if (data_content != "" && event_type != "metadata") {
+            print data_content "\n"
+        }
+        sub(/^event: /, "", $0)
+        event_type = $0
+        data_content = ""
     }
+    /^data:/ {
+        sub(/^data: /, "", $0)
+        data_content = $0
+    }
+    END {
+        if (data_content != "" && event_type != "metadata") {
+            print data_content "\n"
+        }
+    }
+    '
     ```
 
 Output:
@@ -404,7 +610,6 @@ For this example we will just add a single tool call representing the feedback.
         thread["thread_id"],
         "agent",
         input=input,
-        stream_mode="values",
     ):
         if chunk.data and chunk.event != "metadata": 
             print(chunk.data)
@@ -413,16 +618,16 @@ For this example we will just add a single tool call representing the feedback.
 === "Javascript"
 
     ```js
-    const input = {"messages": [{"role": "user", "content": "what's the weather in sf?"}]}
+    const input = { "messages": [{ "role": "user", "content": "what's the weather in sf?" }] };
 
     const streamResponse = client.runs.stream(
       thread["thread_id"],
       assistantId,
       {
         input: input,
-        streamMode: "values",
       }
     );
+
     for await (const chunk of streamResponse) {
       if (chunk.data && chunk.event !== "metadata") {
         console.log(chunk.data);
@@ -430,6 +635,38 @@ For this example we will just add a single tool call representing the feedback.
     }
     ```
 
+=== "CURL"
+
+    ```bash
+    curl --request POST \
+     --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
+     --header 'Content-Type: application/json' \
+     --data "{
+       \"assistant_id\": \"agent\",
+       \"input\": {\"messages\": [{\"role\": \"human\", \"content\": \"what's the weather in sf?\"}]}
+     }" | \
+     sed 's/\r$//' | \
+     awk '
+     /^event:/ {
+         if (data_content != "" && event_type != "metadata") {
+             print data_content "\n"
+         }
+         sub(/^event: /, "", $0)
+         event_type = $0
+         data_content = ""
+     }
+     /^data:/ {
+         sub(/^data: /, "", $0)
+         data_content = $0
+     }
+     END {
+         if (data_content != "" && event_type != "metadata") {
+             print data_content "\n"
+         }
+     }
+     '
+    ```
+
 Output:
 
     {'messages': [{'content': "what's the weather in sf?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': 'c80f13d0-674d-4233-b6a0-3940509d3cf3', 'example': False}]}
@@ -493,38 +730,85 @@ To do this, we first need to update the state. We can do this by passing a messa
 
     // Construct a replacement tool call
     const newMessage = {
-        role: "tool",
-        content: "User requested changes: pass in the country as well",
-        name: "weather_search",
-        tool_call_id: toolCallId,
+      role: "tool",
+      content: "User requested changes: pass in the country as well",
+      name: "weather_search",
+      tool_call_id: toolCallId,
     };
 
     await client.threads.updateState(
-        thread.thread_id,  // Thread ID
-        {
+      thread.thread_id,  // Thread ID
+      {
         values: { "messages": [newMessage] },  // Updated message
         asNode: "human_review_node"
-        }  // Acting as human_review_node
+      }  // Acting as human_review_node
     );
 
     console.log("\nResuming Execution");
     // Continue executing from here
     const streamResponseEdited = client.runs.stream(
-    thread["thread_id"],
-    assistantId,
-    {
-        input: undefined,
+      thread["thread_id"],
+      assistantId,
+      {
+        input: null,
         streamMode: "values",
         interruptBefore: ["action"],
-    }
+      }
     );
+
     for await (const chunk of streamResponseEdited) {
-    if (chunk.data && chunk.event !== "metadata") {
+      if (chunk.data && chunk.event !== "metadata") {
         console.log(chunk.data);
-    }
+      }
     }
     ```
 
+=== "CURL"
+
+    ```bash
+    curl --request POST \
+    --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/state \
+    --header 'Content-Type: application/json' \
+    --data "{
+        \"values\": { \"messages\": [$(curl --request GET \
+            --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/state |
+            jq -c '{
+            role: "tool",
+            content: "User requested changes: pass in the country as well",
+            name: "get_weather",
+            tool_call_id: .values.messages[-1].id.tool_calls[0].id
+            }')
+        ]},
+        \"as_node\": \"human_review_node\"
+    }" && echo "Resuming Execution" && curl --request POST \
+    --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
+    --header 'Content-Type: application/json' \
+    --data '{
+    "assistant_id": "agent"
+    }' | \
+    sed 's/\r$//' | \
+    awk '
+    /^event:/ {
+        if (data_content != "" && event_type != "metadata") {
+            print data_content "\n"
+        }
+        sub(/^event: /, "", $0)
+        event_type = $0
+        data_content = ""
+    }
+    /^data:/ {
+        sub(/^data: /, "", $0)
+        data_content = $0
+    }
+    END {
+        if (data_content != "" && event_type != "metadata") {
+            print data_content "\n"
+        }
+    }
+    '
+    ```
+
+
 Output:
 
     Current State:
@@ -545,7 +829,6 @@ We can see that we now get to another breakpoint - because it went back to the m
         thread["thread_id"],
         "agent",
         input=None,
-        stream_mode="values",
     ):
         if chunk.data and chunk.event != "metadata": 
             print(chunk.data)
@@ -558,10 +841,10 @@ We can see that we now get to another breakpoint - because it went back to the m
       thread["thread_id"],
       assistantId,
       {
-        input: undefined,
-        streamMode: "values",
+        input: null,
       }
     );
+
     for await (const chunk of streamResponseResumed) {
       if (chunk.data && chunk.event !== "metadata") {
         console.log(chunk.data);
@@ -569,6 +852,37 @@ We can see that we now get to another breakpoint - because it went back to the m
     }
     ```
 
+=== "CURL"
+
+    ```bash
+    curl --request POST \
+     --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
+     --header 'Content-Type: application/json' \
+     --data "{
+       \"assistant_id\": \"agent\"
+     }" | \
+     sed 's/\r$//' | \
+     awk '
+     /^event:/ {
+         if (data_content != "" && event_type != "metadata") {
+             print data_content "\n"
+         }
+         sub(/^event: /, "", $0)
+         event_type = $0
+         data_content = ""
+     }
+     /^data:/ {
+         sub(/^data: /, "", $0)
+         data_content = $0
+     }
+     END {
+         if (data_content != "" && event_type != "metadata") {
+             print data_content "\n"
+         }
+     }
+     '
+    ```
+
 Output:
 
     {'messages': [{'content': "what's the weather in sf?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '3b2bbc38-d11b-49eb-80c0-c24a40dab5a8', 'example': False}, {'content': [{'text': 'To get the weather information for San Francisco, I can use the weather_search function. Let me do that for you.', 'type': 'text', 'index': 0}, {'id': 'toolu_01NNw18j57GEGPZvsa9f1wvX', 'input': {}, 'name': 'weather_search', 'type': 'tool_use', 'index': 1, 'partial_json': '{"city": "San Francisco"}'}], 'additional_kwargs': {}, 'response_metadata': {'stop_reason': 'tool_use', 'stop_sequence': None}, 'type': 'ai', 'name': None, 'id': 'run-c5a50900-abf5-4885-9cdb-da2bf0d892ac', 'example': False, 'tool_calls': [{'name': 'weather_search', 'args': {'city': 'San Francisco'}, 'id': 'toolu_01NNw18j57GEGPZvsa9f1wvX', 'type': 'tool_call'}], 'invalid_tool_calls': [], 'usage_metadata': {'input_tokens': 360, 'output_tokens': 80, 'total_tokens': 440}}, {'content': 'User requested changes: pass in the country as well', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': 'weather_search', 'id': '787288be-213c-4fd3-8503-4a009bdb1b00', 'tool_call_id': 'toolu_01NNw18j57GEGPZvsa9f1wvX', 'artifact': None, 'status': 'success'}, {'content': [{'text': '\n\nI apologize for the oversight. It seems the function requires additional information. Let me try again with a more specific request.', 'type': 'text', 'index': 0}, {'id': 'toolu_01YAbLBoKozJyRQnB8LUMpXC', 'input': {}, 'name': 'weather_search', 'type': 'tool_use', 'index': 1, 'partial_json': '{"city": "San Francisco, USA"}'}], 'additional_kwargs': {}, 'response_metadata': {'stop_reason': 'tool_use', 'stop_sequence': None}, 'type': 'ai', 'name': None, 'id': 'run-5c355a56-cfe3-4046-b49f-f5b09fc397ef', 'example': False, 'tool_calls': [{'name': 'weather_search', 'args': {'city': 'San Francisco, USA'}, 'id': 'toolu_01YAbLBoKozJyRQnB8LUMpXC', 'type': 'tool_call'}], 'invalid_tool_calls': [], 'usage_metadata': {'input_tokens': 461, 'output_tokens': 83, 'total_tokens': 544}}, {'content': 'Sunny!', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': 'weather_search', 'id': '3b857482-bca2-4a73-a9ab-1f35a3e43e5f', 'tool_call_id': 'toolu_01YAbLBoKozJyRQnB8LUMpXC', 'artifact': None, 'status': 'success'}]}

docs/docs/cloud/how-tos/human_in_the_loop_time_travel.md

@@ -15,6 +15,7 @@ First, we need to setup our client so that we can communicate with our hosted gr
     ```python
     from langgraph_sdk import get_client
     client = get_client(url=<DEPLOYMENT_URL>)
+    # Using the graph deployed with the name "agent"
     assistant_id = "agent"
     thread = await client.threads.create()
     ```
@@ -25,7 +26,8 @@ First, we need to setup our client so that we can communicate with our hosted gr
     import { Client } from "@langchain/langgraph-sdk";
 
     const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
-    const assistantId = agent;
+    // Using the graph deployed with the name "agent"
+    const assistantId = "agent";
     const thread = await client.threads.create();
     ```
 
@@ -46,11 +48,11 @@ Before replaying a state - we need to create states to replay from! In order to
 === "Python"
 
     ```python
-    input = { 'messages':[{ "role":"user", "content":"Please search the weather in SF" }] }
+    input = {"messages": [{"role": "user", "content": "Please search the weather in SF"}]}
 
     async for chunk in client.runs.stream(
         thread["thread_id"],
-        assistant_id, # graph_id
+        assistant_id,
         input=input,
         stream_mode="updates",
     ):
@@ -61,7 +63,7 @@ Before replaying a state - we need to create states to replay from! In order to
 === "Javascript"
 
     ```js
-    const input = {"messages": [{ "role": "human", "content": "Please search the weather in SF"}] }
+    const input = { "messages": [{ "role": "human", "content": "Please search the weather in SF" }] }
 
     const streamResponse = client.runs.stream(
       thread["thread_id"],
@@ -155,17 +157,23 @@ Output:
 
 
 
-To rerun from a state, we need to pass in the `checkpoint_id` into the config of the run like follows:
+To rerun from a state, we need first issue an empty update to the thread state. Then we need to pass in the resulting `checkpoint_id` as follows:
 
 === "Python"
 
     ```python
+    state_to_replay = states[2]
+    updated_config = await client.threads.update_state(
+        thread["thread_id"],
+        {"messages": []},
+        checkpoint_id=state_to_replay["checkpoint_id"]
+    )
     async for chunk in client.runs.stream(
         thread["thread_id"],
         assistant_id, # graph_id
         input=None,
         stream_mode="updates",
-        config={"configurable": {"checkpoint_id": state_to_replay['checkpoint_id']}}
+        checkpoint_id=updated_config["checkpoint_id"]
     ):
         if chunk.data and chunk.event != "metadata": 
             print(chunk.data)
@@ -174,13 +182,15 @@ To rerun from a state, we need to pass in the `checkpoint_id` into the config of
 === "Javascript"
 
     ```js
+    const stateToReplay = states[2];
+    const config = await client.threads.updateState(thread["thread_id"], { values: {"messages": [] }, checkpointId: stateToReplay["checkpoint_id"] });
     const streamResponse = client.runs.stream(
       thread["thread_id"],
       assistantId,
       {
         input: null,
         streamMode: "updates",
-        config: {"configurable": {"checkpoint_id": stateToReplay['checkpoint_id']}},
+        checkpointId: config["checkpoint_id"]
       }
     );
     for await (const chunk of streamResponse) {
@@ -193,38 +203,46 @@ To rerun from a state, we need to pass in the `checkpoint_id` into the config of
 === "CURL"
 
     ```bash
-    curl --request GET --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/history | jq -r '.[2].checkpoint_id' | {  
-    read checkpoint_id   
-    curl --request POST \                                                            
-         --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
-         --header 'Content-Type: application/json' \
-         --data "{                     
-           \"assistant_id\": \"agent\",
-           \"config\": {\"configurable\": {\"checkpoint_id\": \"$checkpoint_id\"}},
-           \"stream_mode\": [
-             \"updates\"
-           ]   
-         }" | \           
-         sed 's/\r$//' | \
-         awk '      
-         /^event:/ {                                              
-             if (data_content != "" && event_type != "metadata") {
-                 print data_content "\n"
-             }                      
-             sub(/^event: /, "", $0)
-             event_type = $0  
-             data_content = ""
-         }         
-         /^data:/ {                
-             sub(/^data: /, "", $0)
-             data_content = $0
-         }    
-         END {                                                    
-             if (data_content != "" && event_type != "metadata") {
-                 print data_content "\n"
-             }
+    curl --request GET --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/history | jq -c '
+        .[2] as $state_to_replay |
+        {
+            values: { messages: .[2].values.messages[-1] },
+            checkpoint_id: $state_to_replay.checkpoint_id
+        }' | \
+    curl --request POST \
+        --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/state \
+        --header 'Content-Type: application/json' \
+        --data @- | jq .checkpoint_id | \
+    curl --request POST \
+     --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
+     --header 'Content-Type: application/json' \
+     --data "{
+       \"assistant_id\": \"agent\",
+       \"checkpoint_id\": \"$1\",
+       \"stream_mode\": [
+         \"updates\"
+       ]
+     }" | \
+     sed 's/\r$//' | \
+     awk '
+     /^event:/ {
+         if (data_content != "" && event_type != "metadata") {
+             print data_content "\n"
          }
-         ' 
+         sub(/^event: /, "", $0)
+         event_type = $0
+         data_content = ""
+     }
+     /^data:/ {
+         sub(/^data: /, "", $0)
+         data_content = $0
+     }
+     END {
+         if (data_content != "" && event_type != "metadata") {
+             print data_content "\n"
+         }
+     }
+     '
     ```
 
 Output:
@@ -251,7 +269,7 @@ Let's show how to do this to edit the state at a particular point in time. Let's
     # Let's now update the args for that tool call
     last_message['tool_calls'][0]['args'] = {'query': 'current weather in SF'}
 
-    new_state = await client.threads.update_state(thread['thread_id'],{"messages":[last_message]},checkpoint_id=state_to_replay['checkpoint_id'])
+    config = await client.threads.update_state(thread['thread_id'],{"messages":[last_message]},checkpoint_id=state_to_replay['checkpoint_id'])
     ```
 
 === "Javascript"
@@ -262,9 +280,9 @@ Let's show how to do this to edit the state at a particular point in time. Let's
     let lastMessage = stateToReplay['values']['messages'][-1];
 
     // Let's now update the args for that tool call
-    lastMessage['tool_calls'][0]['args'] = {'query': 'current weather in SF'};
+    lastMessage['tool_calls'][0]['args'] = { 'query': 'current weather in SF' };
 
-    const newState = await client.threads.updateState(thread['thread_id'],{values:{"messages":[lastMessage]},checkpointId:stateToReplay['checkpoint_id']});
+    const config = await client.threads.updateState(thread['thread_id'], { values: { "messages": [lastMessage] }, checkpointId: stateToReplay['checkpoint_id'] });
     ```
 
 === "CURL"
@@ -291,10 +309,10 @@ Now we can rerun our graph with this new config, starting from the `new_state`,
     ```python
     async for chunk in client.runs.stream(
         thread["thread_id"],
-        assistant["assistant_id"], # graph_id
+        assistant_id,
         input=None,
         stream_mode="updates",
-        config={"configurable": {"checkpoint_id": new_state['configurable']['checkpoint_id']}}
+        checkpoint_id=config['checkpoint_id']
     ):
         if chunk.data and chunk.event != "metadata": 
             print(chunk.data)
@@ -305,11 +323,11 @@ Now we can rerun our graph with this new config, starting from the `new_state`,
     ```js
     const streamResponse = client.runs.stream(
       thread["thread_id"],
-      assistant["assistant_id"],
+      assistantId,
       {
         input: null,
         streamMode: "updates",
-        config: {"configurable": {"checkpoint_id": newState['configurable']['checkpoint_id']}},
+        checkpointId: config['checkpoint_id'],
       }
     );
     for await (const chunk of streamResponse) {
@@ -323,33 +341,37 @@ Now we can rerun our graph with this new config, starting from the `new_state`,
 
     ```bash
     curl -s --request GET --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/state | \
-    jq -r '.config.configurable.checkpoint_id' | \
-    sh -c '
-        CHECKPOINT_ID="$1"
-        curl --request POST \
-            --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
-            --header "Content-Type: application/json" \
-            --data "{\"assistant_id\": \"agent\", \"config\": {\"configurable\": {\"checkpoint_id\": \"$CHECKPOINT_ID\"}}, \"stream_mode\": [\"updates\"]}" | \
-        sed "s/\r$//" | \
-        awk "
-        /^event:/ {
-            if (data_content != \"\" && event_type != \"metadata\") {
-                print data_content \"\n\"
-            }
-            sub(/^event: /, \"\", \$0)
-            event_type = \$0
-            data_content = \"\"
-        }
-        /^data:/ {
-            sub(/^data: /, \"\", \$0)
-            data_content = \$0
-        }
-        END {
-            if (data_content != \"\" && event_type != \"metadata\") {
-                print data_content \"\n\"
-            }
-        }"
-    ' _ 
+    jq -c '.checkpoint_id' | \
+    curl --request POST \
+     --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
+     --header 'Content-Type: application/json' \
+     --data "{
+       \"assistant_id\": \"agent\",
+       \"checkpoint_id\": \"$1\",
+       \"stream_mode\": [
+         \"updates\"
+       ]
+     }" | \
+     sed 's/\r$//' | \
+     awk '
+     /^event:/ {
+         if (data_content != "" && event_type != "metadata") {
+             print data_content "\n"
+         }
+         sub(/^event: /, "", $0)
+         event_type = $0
+         data_content = ""
+     }
+     /^data:/ {
+         sub(/^data: /, "", $0)
+         data_content = $0
+     }
+     END {
+         if (data_content != "" && event_type != "metadata") {
+             print data_content "\n"
+         }
+     }
+     '
     ```
 
 Output:

docs/docs/cloud/how-tos/human_in_the_loop_user_input.md

@@ -25,6 +25,7 @@ First, we need to setup our client so that we can communicate with our hosted gr
     ```python
     from langgraph_sdk import get_client
     client = get_client(url=<DEPLOYMENT_URL>)
+    # Using the graph deployed with the name "agent"
     assistant_id = "agent"
     thread = await client.threads.create()
     ```
@@ -35,6 +36,7 @@ First, we need to setup our client so that we can communicate with our hosted gr
     import { Client } from "@langchain/langgraph-sdk";
 
     const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
+    // Using the graph deployed with the name "agent"
     const assistantId = "agent";
     const thread = await client.threads.create();
     ```
@@ -56,7 +58,14 @@ Now, let's invoke our graph by interrupting before `ask_human` node:
 === "Python"
 
     ```python
-    input = { 'messages':[{ "role":"user", "content":"Use the search tool to ask the user where they are, then look up the weather there" }] }
+    input = {
+        "messages": [
+            {
+                "role": "human",
+                "content": "Use the search tool to ask the user where they are, then look up the weather there",
+            }
+        ]
+    }
 
     async for chunk in client.runs.stream(
         thread["thread_id"],
@@ -71,7 +80,14 @@ Now, let's invoke our graph by interrupting before `ask_human` node:
 === "Javascript"
 
     ```js
-    const input = { "messages":[{ "role":"human", "content": "Use the search tool to ask the user where they are, then look up the weather there"}] }
+    const input = {
+      messages: [
+        {
+          role: "human",
+          content: "Use the search tool to ask the user where they are, then look up the weather there"
+        }
+      ]
+    };
 
     const streamResponse = client.runs.stream(
       thread["thread_id"],
@@ -79,9 +95,10 @@ Now, let's invoke our graph by interrupting before `ask_human` node:
       {
         input: input,
         streamMode: "updates",
-        interruptBefore: ["ask_human"],
+        interruptBefore: ["ask_human"]
       }
     );
+
     for await (const chunk of streamResponse) {
       if (chunk.data && chunk.event !== "metadata") {
         console.log(chunk.data);
@@ -152,13 +169,23 @@ Because we are treating this as a tool call, we will need to update the state as
 === "Javascript"
 
     ```js
-    const state = await client.threads.getState(thread['thread_id']);
-    const toolCallId = state['values']['messages'][-1]['tool_calls'][0]['id'];
+    const state = await client.threads.getState(thread["thread_id"]);
+    const toolCallId = state.values.messages[state.values.messages.length - 1].tool_calls[0].id;
 
-    # We now create the tool call with the id and the response we want
-    const toolMessage = [{"tool_call_id": toolCallId, "type": "tool", "content": "san francisco"}];
+    // We now create the tool call with the id and the response we want
+    const toolMessage = [
+      {
+        tool_call_id: toolCallId,
+        type: "tool",
+        content: "san francisco"
+      }
+    ];
 
-    await client.threads.updateState(thread['thread_id'], {values: {"messages": toolMessage}, asNode:"ask_human"})
+    await client.threads.updateState(
+      thread["thread_id"],
+      { values: { messages: toolMessage } },
+      { asNode: "ask_human" }
+    );
     ```
 
 === "CURL"
@@ -212,9 +239,10 @@ We can now tell the agent to continue. We can just pass in None as the input to
       assistantId,
       {
         input: null,
-        streamMode: "updates",
+        streamMode: "updates"
       }
     );
+
     for await (const chunk of streamResponse) {
       if (chunk.data && chunk.event !== "metadata") {
         console.log(chunk.data);

docs/docs/cloud/how-tos/index.md

@@ -13,9 +13,9 @@ LangGraph Cloud gives you best in class observability, testing, and hosting serv
 
 - [How to set up app for deployment (requirements.txt)](../deployment/setup.md)
 - [How to set up app for deployment (pyproject.toml)](../deployment/setup_pyproject.md)
+- [How to set up app for deployment (JavaScript)](../deployment/setup_javascript.md)
 - [How to test locally](../deployment/test_locally.md)
 - [How to deploy to LangGraph cloud](../deployment/cloud.md)
-- [How to self-host](../deployment/self_hosted.md)
 
 
 ## Streaming
@@ -61,17 +61,17 @@ LangGraph Studio is a built-in UI for visualizing, testing, and debugging your a
 
 LangGraph Cloud supports multiple types of runs besides streaming runs.
 
-- [How to run an agent in the background](cloud_examples/background_run.ipynb)
-- [How to run multiple agents in the same thread](cloud_examples/same-thread.ipynb)
-- [How to create cron jobs](cloud_examples/cron_jobs.ipynb)
-- [How to create stateless runs](cloud_examples/stateless_runs.ipynb)
+- [How to run an agent in the background](./background_run.md)
+- [How to run multiple agents in the same thread](./same-thread.md)
+- [How to create cron jobs](./cron_jobs.md)
+- [How to create stateless runs](./stateless_runs.md)
 
 ## Other 
 
 Other guides that may prove helpful!
 
-- [How to configure agents](cloud_examples/configuration_cloud.ipynb)
+- [How to configure agents](./configuration_cloud.md)
 - [How to convert LangGraph calls to LangGraph cloud calls](cloud_examples/langgraph_to_langgraph_cloud.ipynb)
-- [How to integrate webhooks](cloud_examples/webhooks.ipynb)
+- [How to integrate webhooks](./webhooks.md)
 - [How to copy threads](./copy_threads.md)
 - [How to check status of your threads](./check_thread_status.md)

docs/docs/cloud/how-tos/interrupt_concurrent.md

@@ -4,20 +4,44 @@ This guide assumes knowledge of what double-texting is, which you can learn abou
 
 The guide covers the `interrupt` option for double texting, which interrupts the prior run of the graph and starts a new one with the double-text. This option does not delete the first run, but rather keeps it in the database but sets its status to `interrupted`. Below is a quick example of using the `interrupt` option.
 
-First, we will define a quick helper function for printing out JS model outputs (you can skip this if using Python):
+First, we will define a quick helper function for printing out JS and CURL model outputs (you can skip this if using Python):
 
-```js
-function prettyPrint(m) {
-  const padded = " " + m['type'] + " ";
-  const sepLen = Math.floor((80 - padded.length) / 2);
-  const sep = "=".repeat(sepLen);
-  const secondSep = sep + (padded.length % 2 ? "=" : "");
-  
-  console.log(`${sep}${padded}${secondSep}`);
-  console.log("\n\n");
-  console.log(m.content);
-}
-```
+=== "Javascript"
+
+    ```js
+    function prettyPrint(m) {
+      const padded = " " + m['type'] + " ";
+      const sepLen = Math.floor((80 - padded.length) / 2);
+      const sep = "=".repeat(sepLen);
+      const secondSep = sep + (padded.length % 2 ? "=" : "");
+      
+      console.log(`${sep}${padded}${secondSep}`);
+      console.log("\n\n");
+      console.log(m.content);
+    }
+    ```
+
+=== "CURL"
+
+    ```bash
+    # PLACE THIS IN A FILE CALLED pretty_print.sh
+    pretty_print() {
+      local type="$1"
+      local content="$2"
+      local padded=" $type "
+      local total_width=80
+      local sep_len=$(( (total_width - ${#padded}) / 2 ))
+      local sep=$(printf '=%.0s' $(eval "echo {1.."${sep_len}"}"))
+      local second_sep=$sep
+      if (( (total_width - ${#padded}) % 2 )); then
+        second_sep="${second_sep}="
+      fi
+
+      echo "${sep}${padded}${second_sep}"
+      echo
+      echo "$content"
+    }
+    ```
 
 Now, let's import our required packages and instantiate our client, assistant, and thread.
 
@@ -30,6 +54,7 @@ Now, let's import our required packages and instantiate our client, assistant, a
     from langgraph_sdk import get_client
 
     client = get_client(url=<DEPLOYMENT_URL>)
+    # Using the graph deployed with the name "agent"
     assistant_id = "agent"
     thread = await client.threads.create()
     ```
@@ -40,10 +65,19 @@ Now, let's import our required packages and instantiate our client, assistant, a
     import { Client } from "@langchain/langgraph-sdk";
 
     const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
+    // Using the graph deployed with the name "agent"
     const assistantId = "agent";
     const thread = await client.threads.create();
     ```
 
+=== "CURL"
+
+    ```bash
+    curl --request POST \
+      --url <DEPLOYMENT_URL>/threads \
+      --header 'Content-Type: application/json'
+    ```
+
 Now we can start our two runs and join the second on euntil it has completed:
 
 === "Python"
@@ -60,7 +94,7 @@ Now we can start our two runs and join the second on euntil it has completed:
         thread["thread_id"],
         assistant_id,
         input={"messages": [{"role": "human", "content": "what's the weather in nyc?"}]},
-        multitask_strategychrom="interrupt",
+        multitask_strategy="interrupt",
     )
     # wait until the second run completes
     await client.runs.join(thread["thread_id"], run["run_id"])
@@ -90,6 +124,26 @@ Now we can start our two runs and join the second on euntil it has completed:
     await client.runs.join(thread["thread_id"], run["run_id"]);
     ```
 
+=== "CURL"
+
+    ```bash
+    curl --request POST \
+    --url <DEPLOY<ENT_URL>>/threads/<THREAD_ID>/runs \
+    --header 'Content-Type: application/json' \
+    --data "{
+      \"assistant_id\": \"agent\",
+      \"input\": {\"messages\": [{\"role\": \"human\", \"content\": \"what\'s the weather in sf?\"}]},
+    }" && sleep 2 && curl --request POST \
+    --url <DEPLOY<ENT_URL>>/threads/<THREAD_ID>/runs \
+    --header 'Content-Type: application/json' \
+    --data "{
+      \"assistant_id\": \"agent\",
+      \"input\": {\"messages\": [{\"role\": \"human\", \"content\": \"what\'s the weather in nyc?\"}]},
+      \"multitask_strategy\": \"interrupt\"
+    }" && curl --request GET \
+    --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/<RUN_ID>/join
+    ```
+
 We can see that the thread has partial data from the first run + data from the second run
 
 
@@ -112,12 +166,24 @@ We can see that the thread has partial data from the first run + data from the s
     }
     ```
 
+=== "CURL"
+
+    ```bash
+    source pretty_print.sh && curl --request GET \
+    --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/state | \
+    jq -c '.values.messages[]' | while read -r element; do
+        type=$(echo "$element" | jq -r '.type')
+        content=$(echo "$element" | jq -r '.content | if type == "array" then tostring else . end')
+        pretty_print "$type" "$content"
+    done
+    ```
+
 Output:
 
-    ================================ Human Message =================================
+    ================================ Human Message =================================
     
     what's the weather in sf?
-    ================================== Ai Message ==================================
+    ================================== Ai Message ==================================
     
     [{'id': 'toolu_01MjNtVJwEcpujRGrf3x6Pih', 'input': {'query': 'weather in san francisco'}, 'name': 'tavily_search_results_json', 'type': 'tool_use'}]
     Tool Calls:
@@ -125,14 +191,14 @@ Output:
      Call ID: toolu_01MjNtVJwEcpujRGrf3x6Pih
       Args:
         query: weather in san francisco
-    ================================= Tool Message =================================
+    ================================= Tool Message =================================
     Name: tavily_search_results_json
     
     [{"url": "https://www.wunderground.com/hourly/us/ca/san-francisco/KCASANFR2002/date/2024-6-18", "content": "High 64F. Winds W at 10 to 20 mph. A few clouds from time to time. Low 49F. Winds W at 10 to 20 mph. Temp. San Francisco Weather Forecasts. Weather Underground provides local & long-range weather ..."}]
-    ================================ Human Message =================================
+    ================================ Human Message =================================
     
     what's the weather in nyc?
-    ================================== Ai Message ==================================
+    ================================== Ai Message ==================================
     
     [{'id': 'toolu_01KtE1m1ifPLQAx4fQLyZL9Q', 'input': {'query': 'weather in new york city'}, 'name': 'tavily_search_results_json', 'type': 'tool_use'}]
     Tool Calls:
@@ -140,11 +206,11 @@ Output:
      Call ID: toolu_01KtE1m1ifPLQAx4fQLyZL9Q
       Args:
         query: weather in new york city
-    ================================= Tool Message =================================
+    ================================= Tool Message =================================
     Name: tavily_search_results_json
     
     [{"url": "https://www.accuweather.com/en/us/new-york/10021/june-weather/349727", "content": "Get the monthly weather forecast for New York, NY, including daily high/low, historical averages, to help you plan ahead."}]
-    ================================== Ai Message ==================================
+    ================================== Ai Message ==================================
     
     The search results provide weather forecasts and information for New York City. Based on the top result from AccuWeather, here are some key details about the weather in NYC:
     

docs/docs/cloud/how-tos/reject_concurrent.md

@@ -4,20 +4,44 @@ This guide assumes knowledge of what double-texting is, which you can learn abou
 
 The guide covers the `reject` option for double texting, which rejects the new run of the graph by throwing an error and continues with the original run until completion. Below is a quick example of using the `reject` option.
 
-First, we will define a quick helper function for printing out JS model outputs (you can skip this if using Python):
+First, we will define a quick helper function for printing out JS and CURL model outputs (you can skip this if using Python):
 
-```js
-function prettyPrint(m) {
-  const padded = " " + m['type'] + " ";
-  const sepLen = Math.floor((80 - padded.length) / 2);
-  const sep = "=".repeat(sepLen);
-  const secondSep = sep + (padded.length % 2 ? "=" : "");
-  
-  console.log(`${sep}${padded}${secondSep}`);
-  console.log("\n\n");
-  console.log(m.content);
-}
-```
+=== "Javascript"
+
+    ```js
+    function prettyPrint(m) {
+      const padded = " " + m['type'] + " ";
+      const sepLen = Math.floor((80 - padded.length) / 2);
+      const sep = "=".repeat(sepLen);
+      const secondSep = sep + (padded.length % 2 ? "=" : "");
+      
+      console.log(`${sep}${padded}${secondSep}`);
+      console.log("\n\n");
+      console.log(m.content);
+    }
+    ```
+
+=== "CURL"
+
+    ```bash
+    # PLACE THIS IN A FILE CALLED pretty_print.sh
+    pretty_print() {
+      local type="$1"
+      local content="$2"
+      local padded=" $type "
+      local total_width=80
+      local sep_len=$(( (total_width - ${#padded}) / 2 ))
+      local sep=$(printf '=%.0s' $(eval "echo {1.."${sep_len}"}"))
+      local second_sep=$sep
+      if (( (total_width - ${#padded}) % 2 )); then
+        second_sep="${second_sep}="
+      fi
+
+      echo "${sep}${padded}${second_sep}"
+      echo
+      echo "$content"
+    }
+    ```
 
 Now, let's import our required packages and instantiate our client, assistant, and thread.
 
@@ -29,6 +53,7 @@ Now, let's import our required packages and instantiate our client, assistant, a
     from langgraph_sdk import get_client
 
     client = get_client(url=<DEPLOYMENT_URL>)
+    # Using the graph deployed with the name "agent"
     assistant_id = "agent"
     thread = await client.threads.create()
     ```
@@ -39,10 +64,19 @@ Now, let's import our required packages and instantiate our client, assistant, a
     import { Client } from "@langchain/langgraph-sdk";
 
     const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
+    // Using the graph deployed with the name "agent"
     const assistantId = "agent";
     const thread = await client.threads.create();
     ```
 
+=== "CURL"
+
+    ```bash
+    curl --request POST \
+      --url <DEPLOYMENT_URL>/threads \
+      --header 'Content-Type: application/json'
+    ```
+
 Now we can run a thread and try to run a second one with the "reject" option, which should fail since we have already started a run:
 
 
@@ -90,6 +124,27 @@ Now we can run a thread and try to run a second one with the "reject" option, wh
     }
     ```
 
+=== "CURL"
+
+    ```bash
+    curl --request POST \
+    --url <DEPLOY<ENT_URL>>/threads/<THREAD_ID>/runs \
+    --header 'Content-Type: application/json' \
+    --data "{
+      \"assistant_id\": \"agent\",
+      \"input\": {\"messages\": [{\"role\": \"human\", \"content\": \"what\'s the weather in sf?\"}]},
+    }" && curl --request POST \
+    --url <DEPLOY<ENT_URL>>/threads/<THREAD_ID>/runs \
+    --header 'Content-Type: application/json' \
+    --data "{
+      \"assistant_id\": \"agent\",
+      \"input\": {\"messages\": [{\"role\": \"human\", \"content\": \"what\'s the weather in nyc?\"}]},
+      \"multitask_strategy\": \"reject\"
+    }" || { echo "Failed to start concurrent run"; echo "Error: $?" >&2; }
+    ```
+
+Output:
+
     Failed to start concurrent run Client error '409 Conflict' for url 'http://localhost:8123/threads/f9e7088b-8028-4e5c-88d2-9cc9a2870e50/runs'
     For more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/409
 
@@ -120,12 +175,25 @@ We can verify that the original thread finished executing:
     }
     ```
 
+=== "CURL"
+
+    ```bash
+    source pretty_print.sh && curl --request GET \
+    --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/<RUN_ID>/join && \
+    curl --request GET --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/state | \
+    jq -c '.values.messages[]' | while read -r element; do
+        type=$(echo "$element" | jq -r '.type')
+        content=$(echo "$element" | jq -r '.content | if type == "array" then tostring else . end')
+        pretty_print "$type" "$content"
+    done
+    ```
+
 Output:
 
-    ================================ Human Message =================================
+    ================================ Human Message =================================
     
     what's the weather in sf?
-    ================================== Ai Message ==================================
+    ================================== Ai Message ==================================
     
     [{'id': 'toolu_01CyewEifV2Kmi7EFKHbMDr1', 'input': {'query': 'weather in san francisco'}, 'name': 'tavily_search_results_json', 'type': 'tool_use'}]
     Tool Calls:
@@ -133,11 +201,11 @@ Output:
      Call ID: toolu_01CyewEifV2Kmi7EFKHbMDr1
       Args:
         query: weather in san francisco
-    ================================= Tool Message =================================
+    ================================= Tool Message =================================
     Name: tavily_search_results_json
     
     [{"url": "https://www.accuweather.com/en/us/san-francisco/94103/june-weather/347629", "content": "Get the monthly weather forecast for San Francisco, CA, including daily high/low, historical averages, to help you plan ahead."}]
-    ================================== Ai Message ==================================
+    ================================== Ai Message ==================================
     
     According to the search results from Tavily, the current weather in San Francisco is:
     

docs/docs/cloud/how-tos/rollback_concurrent.md

@@ -4,20 +4,44 @@ This guide assumes knowledge of what double-texting is, which you can learn abou
 
 The guide covers the `rollback` option for double texting, which interrupts the prior run of the graph and starts a new one with the double-text. This option is very similar to the `interrupt` option, but in this case the first run is completely deleted from the database and cannot be restarted. Below is a quick example of using the `rollback` option.
 
-First, we will define a quick helper function for printing out JS model outputs (you can skip this if using Python):
+First, we will define a quick helper function for printing out JS and CURL model outputs (you can skip this if using Python):
 
-```js
-function prettyPrint(m) {
-  const padded = " " + m['type'] + " ";
-  const sepLen = Math.floor((80 - padded.length) / 2);
-  const sep = "=".repeat(sepLen);
-  const secondSep = sep + (padded.length % 2 ? "=" : "");
-  
-  console.log(`${sep}${padded}${secondSep}`);
-  console.log("\n\n");
-  console.log(m.content);
-}
-```
+=== "Javascript"
+
+    ```js
+    function prettyPrint(m) {
+      const padded = " " + m['type'] + " ";
+      const sepLen = Math.floor((80 - padded.length) / 2);
+      const sep = "=".repeat(sepLen);
+      const secondSep = sep + (padded.length % 2 ? "=" : "");
+      
+      console.log(`${sep}${padded}${secondSep}`);
+      console.log("\n\n");
+      console.log(m.content);
+    }
+    ```
+
+=== "CURL"
+
+    ```bash
+    # PLACE THIS IN A FILE CALLED pretty_print.sh
+    pretty_print() {
+      local type="$1"
+      local content="$2"
+      local padded=" $type "
+      local total_width=80
+      local sep_len=$(( (total_width - ${#padded}) / 2 ))
+      local sep=$(printf '=%.0s' $(eval "echo {1.."${sep_len}"}"))
+      local second_sep=$sep
+      if (( (total_width - ${#padded}) % 2 )); then
+        second_sep="${second_sep}="
+      fi
+
+      echo "${sep}${padded}${second_sep}"
+      echo
+      echo "$content"
+    }
+    ```
 
 Now, let's import our required packages and instantiate our client, assistant, and thread.
 
@@ -31,6 +55,7 @@ Now, let's import our required packages and instantiate our client, assistant, a
     from langgraph_sdk import get_client
 
     client = get_client(url=<DEPLOYMENT_URL>)
+    # Using the graph deployed with the name "agent"
     assistant_id = "agent"
     thread = await client.threads.create()
     ```
@@ -41,10 +66,19 @@ Now, let's import our required packages and instantiate our client, assistant, a
     import { Client } from "@langchain/langgraph-sdk";
 
     const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
+    // Using the graph deployed with the name "agent"
     const assistantId = "agent";
     const thread = await client.threads.create();
     ```
 
+=== "CURL"
+
+    ```bash
+    curl --request POST \
+      --url <DEPLOYMENT_URL>/threads \
+      --header 'Content-Type: application/json'
+    ```
+
 Now let's run a thread with the multitask parameter set to "rollback":
 
 === "Python"
@@ -91,6 +125,26 @@ Now let's run a thread with the multitask parameter set to "rollback":
     await client.runs.join(thread["thread_id"], run["run_id"]);
     ```
 
+=== "CURL"
+
+    ```bash
+    curl --request POST \
+    --url <DEPLOY<ENT_URL>>/threads/<THREAD_ID>/runs \
+    --header 'Content-Type: application/json' \
+    --data "{
+      \"assistant_id\": \"agent\",
+      \"input\": {\"messages\": [{\"role\": \"human\", \"content\": \"what\'s the weather in sf?\"}]},
+    }" && sleep 2 && curl --request POST \
+    --url <DEPLOY<ENT_URL>>/threads/<THREAD_ID>/runs \
+    --header 'Content-Type: application/json' \
+    --data "{
+      \"assistant_id\": \"agent\",
+      \"input\": {\"messages\": [{\"role\": \"human\", \"content\": \"what\'s the weather in nyc?\"}]},
+      \"multitask_strategy\": \"rollback\"
+    }" && curl --request GET \
+    --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/<RUN_ID>/join
+    ```
+
 We can see that the thread has data only from the second run
 
 === "Python"
@@ -112,12 +166,24 @@ We can see that the thread has data only from the second run
     }
     ```
 
+=== "CURL"
+
+    ```bash
+    source pretty_print.sh && curl --request GET \
+    --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/state | \
+    jq -c '.values.messages[]' | while read -r element; do
+        type=$(echo "$element" | jq -r '.type')
+        content=$(echo "$element" | jq -r '.content | if type == "array" then tostring else . end')
+        pretty_print "$type" "$content"
+    done
+    ```
+
 Output:
 
-    ================================ Human Message =================================
+    ================================ Human Message =================================
     
     what's the weather in nyc?
-    ================================== Ai Message ==================================
+    ================================== Ai Message ==================================
     
     [{'id': 'toolu_01JzPqefao1gxwajHQ3Yh3JD', 'input': {'query': 'weather in nyc'}, 'name': 'tavily_search_results_json', 'type': 'tool_use'}]
     Tool Calls:
@@ -125,11 +191,11 @@ Output:
      Call ID: toolu_01JzPqefao1gxwajHQ3Yh3JD
       Args:
         query: weather in nyc
-    ================================= Tool Message =================================
+    ================================= Tool Message =================================
     Name: tavily_search_results_json
     
     [{"url": "https://www.weatherapi.com/", "content": "{'location': {'name': 'New York', 'region': 'New York', 'country': 'United States of America', 'lat': 40.71, 'lon': -74.01, 'tz_id': 'America/New_York', 'localtime_epoch': 1718734479, 'localtime': '2024-06-18 14:14'}, 'current': {'last_updated_epoch': 1718733600, 'last_updated': '2024-06-18 14:00', 'temp_c': 29.4, 'temp_f': 84.9, 'is_day': 1, 'condition': {'text': 'Sunny', 'icon': '//cdn.weatherapi.com/weather/64x64/day/113.png', 'code': 1000}, 'wind_mph': 2.2, 'wind_kph': 3.6, 'wind_degree': 158, 'wind_dir': 'SSE', 'pressure_mb': 1025.0, 'pressure_in': 30.26, 'precip_mm': 0.0, 'precip_in': 0.0, 'humidity': 63, 'cloud': 0, 'feelslike_c': 31.3, 'feelslike_f': 88.3, 'windchill_c': 28.3, 'windchill_f': 82.9, 'heatindex_c': 29.6, 'heatindex_f': 85.3, 'dewpoint_c': 18.4, 'dewpoint_f': 65.2, 'vis_km': 16.0, 'vis_miles': 9.0, 'uv': 7.0, 'gust_mph': 16.5, 'gust_kph': 26.5}}"}]
-    ================================== Ai Message ==================================
+    ================================== Ai Message ==================================
     
     The weather API results show that the current weather in New York City is sunny with a temperature of around 85°F (29°C). The wind is light at around 2-3 mph from the south-southeast. Overall it looks like a nice sunny summer day in NYC.
 

docs/docs/cloud/how-tos/same-thread.md

@@ -0,0 +1,310 @@
+# How to run multiple agents on the same thread
+
+In LangGraph Cloud, a thread is not explicitly associated with a particular agent.
+This means that you can run multiple agents on the same thread, which allows a different agent to continue from an initial agent's progress.
+
+In this example, we will create two agents and then call them both on the same thread.
+You'll see that the second agent will respond using information from the [checkpoint](https://langchain-ai.github.io/langgraph/concepts/low_level/#checkpointer-state) generated in the thread by the first agent as context.
+
+=== "Python"
+
+    ```python
+    from langgraph_sdk import get_client
+
+    client = get_client(url=<DEPLOYMENT_URL>)
+
+    openai_assistant = await client.assistants.create(
+        graph_id="agent", config={"configurable": {"model_name": "openai"}}
+    )
+
+    # There should always be a default assistant with no configuration
+    assistants = await client.assistants.search()
+    default_assistant = [a for a in assistants if not a["config"]][0]
+    ```
+
+=== "Javascript"
+
+    ```js
+    import { Client } from "@langchain/langgraph-sdk";
+
+    const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
+    
+    const openAIAssistant = await client.assistants.create(
+      { graphId: "agent", config: {"configurable": {"model_name": "openai"}}}
+    );
+
+    const assistants = await client.assistants.search();
+    const defaultAssistant = assistants.find(a => !a.config);
+    ```
+
+=== "CURL"
+
+    ```bash
+    curl --request POST \
+        --url <DEPLOYMENT_URL>/assistants \
+        --header 'Content-Type: application/json' \
+        --data '{
+            "graph_id": "agent",
+            "config": { "configurable": { "model_name": "openai" } }
+        }' && \
+    curl --request POST \
+        --url <DEPLOYMENT_URL>/assistants/search \
+        --header 'Content-Type: application/json' \
+        --data '{
+            "limit": 10,
+            "offset": 0
+        }' | jq -c 'map(select(.config == null or .config == {})) | .[0]'
+    ```
+
+We can see that these agents are different:
+
+=== "Python"
+
+    ```python
+    print(openai_assistant)
+    ```
+
+=== "Javascript"
+
+    ```js
+    console.log(openAIAssistant);
+    ```
+
+=== "CURL"
+
+    ```bash
+    curl --request GET \
+        --url <DEPLOYMENT_URL>/assistants/<OPENAI_ASSISTANT_ID>
+    ```
+
+Output:
+
+    {
+        "assistant_id": "db87f39d-b2b1-4da8-ac65-cf81beb3c766",
+        "graph_id": "agent",
+        "created_at": "2024-08-30T21:18:51.850581+00:00",
+        "updated_at": "2024-08-30T21:18:51.850581+00:00",
+        "config": {
+            "configurable": {
+                "model_name": "openai"
+            }
+        },
+        "metadata": {}
+    }
+
+=== "Python"
+
+    ```python
+    print(default_assistant)
+    ```
+
+=== "Javascript"
+
+    ```js
+    console.log(defaultAssistant);
+    ```
+
+=== "CURL"
+
+    ```bash
+    curl --request GET \
+        --url <DEPLOYMENT_URL>/assistants/<DEFAULT_ASSISTANT_ID>
+    ```
+
+Output:
+
+    {
+        "assistant_id": "fe096781-5601-53d2-b2f6-0d3403f7e9ca",
+        "graph_id": "agent",
+        "created_at": "2024-08-08T22:45:24.562906+00:00",
+        "updated_at": "2024-08-08T22:45:24.562906+00:00",
+        "config": {},
+        "metadata": {
+            "created_by": "system"
+        }
+    }
+
+We can now run the OpenAI assistant on the thread first.
+
+=== "Python"
+
+    ```python
+    thread = await client.threads.create()
+    input = {"messages": [{"role": "user", "content": "who made you?"}]}
+    async for event in client.runs.stream(
+        thread["thread_id"],
+        openai_assistant["assistant_id"],
+        input=input,
+        stream_mode="updates",
+    ):
+        print(f"Receiving event of type: {event.event}")
+        print(event.data)
+        print("\n\n")
+    ```
+
+=== "Javascript"
+
+    ```js
+    const thread = await client.threads.create();
+    let input =  {"messages": [{"role": "user", "content": "who made you?"}]}
+
+    const streamResponse = client.runs.stream(
+      thread["thread_id"],
+      openAIAssistant["assistant_id"],
+      {
+        input,
+        streamMode: "updates"
+      }
+    );
+    for await (const event of streamResponse) {
+      console.log(`Receiving event of type: ${event.event}`);
+      console.log(event.data);
+      console.log("\n\n");
+    }
+    ```
+
+=== "CURL"
+
+    ```bash
+    thread_id=$(curl --request POST \
+        --url <DEPLOYMENT_URL>/threads \
+        --header 'Content-Type: application/json' \
+        --data '{}' | jq -r '.thread_id') && \
+    curl --request POST \
+        --url "<DEPLOYMENT_URL>/threads/${thread_id}/runs/stream" \
+        --header 'Content-Type: application/json' \
+        --data '{
+            "assistant_id": <OPENAI_ASSISTANT_ID>,
+            "input": {
+                "messages": [
+                    {
+                        "role": "human",
+                        "content": "who made you?"
+                    }
+                ]
+            },
+            "stream_mode": [
+                "updates"
+            ]
+        }' | \
+        sed 's/\r$//' | \
+        awk '
+        /^event:/ {
+            if (data_content != "") {
+                print data_content "\n"
+            }
+            sub(/^event: /, "Receiving event of type: ", $0)
+            printf "%s...\n", $0
+            data_content = ""
+        }
+        /^data:/ {
+            sub(/^data: /, "", $0)
+            data_content = $0
+        }
+        END {
+            if (data_content != "") {
+                print data_content "\n\n"
+            }
+        }
+    '
+    ```
+
+Output:
+
+    Receiving event of type: metadata
+    {'run_id': '1ef671c5-fb83-6e70-b698-44dba2d9213e'}
+
+
+    Receiving event of type: updates
+    {'agent': {'messages': [{'content': 'I was created by OpenAI, a research organization focused on developing and advancing artificial intelligence technology.', 'additional_kwargs': {}, 'response_metadata': {'finish_reason': 'stop', 'model_name': 'gpt-4o-2024-05-13', 'system_fingerprint': 'fp_157b3831f5'}, 'type': 'ai', 'name': None, 'id': 'run-f5735b86-b80d-4c71-8dc3-4782b5a9c7c8', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]}}
+
+Now, we can run it on the default assistant and see that this second assistant is aware of the initial question, and can answer the question, "and you?":
+
+=== "Python"
+
+    ```python
+    input = {"messages": [{"role": "user", "content": "and you?"}]}
+    async for event in client.runs.stream(
+        thread["thread_id"],
+        default_assistant["assistant_id"],
+        input=input,
+        stream_mode="updates",
+    ):
+        print(f"Receiving event of type: {event.event}")
+        print(event.data)
+        print("\n\n")
+    ```
+
+=== "Javascript"
+
+    ```js
+    let input =  {"messages": [{"role": "user", "content": "and you?"}]}
+
+    const streamResponse = client.runs.stream(
+      thread["thread_id"],
+      defaultAssistant["assistant_id"],
+      {
+        input,
+        streamMode: "updates"
+      }
+    );
+    for await (const event of streamResponse) {
+      console.log(`Receiving event of type: ${event.event}`);
+      console.log(event.data);
+      console.log("\n\n");
+    }
+    ```
+
+=== "CURL"
+
+    ```bash
+    curl --request POST \
+        --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
+        --header 'Content-Type: application/json' \
+        --data '{
+            "assistant_id": <DEFAULT_ASSISTANT_ID>,
+            "input": {
+                "messages": [
+                    {
+                        "role": "human",
+                        "content": "and you?"
+                    }
+                ]
+            },
+            "stream_mode": [
+                "updates"
+            ]
+        }' | \
+        sed 's/\r$//' | \
+        awk '
+        /^event:/ {
+            if (data_content != "") {
+                print data_content "\n"
+            }
+            sub(/^event: /, "Receiving event of type: ", $0)
+            printf "%s...\n", $0
+            data_content = ""
+        }
+        /^data:/ {
+            sub(/^data: /, "", $0)
+            data_content = $0
+        }
+        END {
+            if (data_content != "") {
+                print data_content "\n\n"
+            }
+        }
+    '
+    ```
+
+Output:
+
+    Receiving event of type: metadata
+    {'run_id': '1ef6722d-80b3-6fbb-9324-253796b1cd13'}
+
+
+    Receiving event of type: updates
+    {'agent': {'messages': [{'content': [{'text': 'I am an artificial intelligence created by Anthropic, not by OpenAI. I should not have stated that OpenAI created me, as that is incorrect. Anthropic is the company that developed and trained me using advanced language models and AI technology. I will be more careful about providing accurate information regarding my origins in the future.', 'type': 'text', 'index': 0}], 'additional_kwargs': {}, 'response_metadata': {'stop_reason': 'end_turn', 'stop_sequence': None}, 'type': 'ai', 'name': None, 'id': 'run-ebaacf62-9dd9-4165-9535-db432e4793ec', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': {'input_tokens': 302, 'output_tokens': 72, 'total_tokens': 374}}]}}
+
+
+

docs/docs/cloud/how-tos/stateless_runs.md

@@ -0,0 +1,180 @@
+# Stateless Runs
+
+Most of the time, you provide a `thread_id` to your client when you run your graph in order to keep track of prior runs through the persistent state implemented in LangGraph Cloud. However, if you don't need to persist the runs you don't need to use the built in persistent state and can create stateless runs.
+
+## Setup
+
+First, let's setup our client:
+
+=== "Python"
+
+    ```python
+    from langgraph_sdk import get_client
+
+    client = get_client(url=<DEPLOYMENT_URL>)
+    # Using the graph deployed with the name "agent"
+    assistant_id = "agent"
+    # create thread
+    thread = await client.threads.create()
+    ```
+
+=== "Javascript"
+
+    ```js
+    import { Client } from "@langchain/langgraph-sdk";
+
+    const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
+    // Using the graph deployed with the name "agent"
+    const assistantId = "agent";
+    // create thread
+    const thread = await client.threads.create();
+    ```
+
+=== "CURL"
+
+    ```bash
+    curl --request POST \
+        --url <DEPLOYMENT_URL>/assistants/search \
+        --header 'Content-Type: application/json' \
+        --data '{
+            "limit": 10,
+            "offset": 0
+        }' | jq -c 'map(select(.config == null or .config == {})) | .[0].graph_id' && \
+    curl --request POST \
+        --url <DEPLOYMENT_URL>/threads \
+        --header 'Content-Type: application/json' \
+        --data '{}'
+    ```
+
+## Stateless streaming
+
+We can stream the results of a stateless run in an almost identical fashion to how we stream from a run with the state attribute, but instead of passing a value to the `thread_id` parameter, we pass `None`:
+
+=== "Python"
+
+    ```python
+    input = {
+        "messages": [
+            {"role": "user", "content": "Hello! My name is Bagatur and I am 26 years old."}
+        ]
+    }
+
+    async for chunk in client.runs.stream(
+        # Don't pass in a thread_id and the stream will be stateless
+        None,
+        assistant_id,
+        input=input,
+        stream_mode="updates",
+    ):
+        if chunk.data and "run_id" not in chunk.data:
+            print(chunk.data)
+    ```
+
+=== "Javascript"
+
+    ```js
+    let input = {
+      messages: [
+        { role: "user", content: "Hello! My name is Bagatur and I am 26 years old." }
+      ]
+    };
+
+    const streamResponse = client.runs.stream(
+      // Don't pass in a thread_id and the stream will be stateless
+      null,
+      assistantId,
+      {
+        input,
+        streamMode: "updates"
+      }
+    );
+    for await (const chunk of streamResponse) {
+      if (chunk.data && !("run_id" in chunk.data)) {
+        console.log(chunk.data);
+      }
+    }
+    ```
+
+=== "CURL"
+
+    ```bash
+    curl --request POST \
+        --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
+        --header 'Content-Type: application/json' \
+        --data "{
+            \"assistant_id\": \"agent\",
+            \"input\": {\"messages\": [{\"role\": \"human\", \"content\": \"Hello! My name is Bagatur and I am 26 years old.\"}]},
+            \"stream_mode\": [
+                \"updates\"
+            ]
+        }" | jq -c 'select(.data and (.data | has("run_id") | not)) | .data'
+    ```
+
+Output:
+
+    {'agent': {'messages': [{'content': "Hello Bagatur! It's nice to meet you. Thank you for introducing yourself and sharing your age. Is there anything specific you'd like to know or discuss? I'm here to help with any questions or topics you're interested in.", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-489ec573-1645-4ce2-a3b8-91b391d50a71', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]}}
+
+## Waiting for stateless results
+
+In addition to streaming, you can also wait for a stateless result by using the `.wait` function like follows:
+
+=== "Python"
+
+    ```python
+    stateless_run_result = await client.runs.wait(
+        None,
+        assistant_id,
+        input=input,
+    )
+    print(stateless_run_result)
+    ```
+
+=== "Javascript"
+
+    ```js
+    let statelessRunResult = await client.runs.wait(
+      null,
+      assistantId,
+      { input: input }
+    );
+    console.log(statelessRunResult);
+    ```
+
+=== "CURL"
+
+    ```bash
+    curl --request POST \
+        --url <DEPLOYMENT_URL>/runs/runs/wait \
+        --header 'Content-Type: application/json' \
+        --data '{
+            "assistant_id": <ASSISTANT_IDD>,
+        }'
+    ```
+
+Output:
+
+    {
+        'messages': [
+            {
+                'content': 'Hello! My name is Bagatur and I am 26 years old.',
+                'additional_kwargs': {},
+                'response_metadata': {},
+                'type': 'human',
+                'name': None,
+                'id': '5e088543-62c2-43de-9d95-6086ad7f8b48',
+                'example': False}
+            ,
+            {
+                'content': "Hello Bagatur! It's nice to meet you. Thank you for introducing yourself and sharing your age. Is there anything specific you'd like to know or discuss? I'm here to help with any questions or topics you'd like to explore.",
+                'additional_kwargs': {},
+                'response_metadata': {},
+                'type': 'ai',
+                'name': None,
+                'id': 'run-d6361e8d-4d4c-45bd-ba47-39520257f773',
+                'example': False,
+                'tool_calls': [],
+                'invalid_tool_calls': [],
+                'usage_metadata': None
+            }
+        ]
+    }

docs/docs/cloud/how-tos/stream_events.md

@@ -1,5 +1,6 @@
 # How to stream events
-This guide covers how to stream events from your graph (`stream_mode="events"`). Depending on the use case and user experience of your LangGraph application, your application may process event types differently.
+
+This guide covers how to stream events from your graph (`stream_mode="events"`). Depending on the use case and user experience of your LangGraph application, your application may process event types differently. Read more about events in this [conceptual guide](https://langchain-ai.github.io/langgraph/concepts/low_level/#astream_events-for-streaming-tokens-of-llm-calls).
 
 === "Python"
 
@@ -7,6 +8,8 @@ This guide covers how to stream events from your graph (`stream_mode="events"`).
     from langgraph_sdk import get_client
 
     client = get_client(url=<DEPLOYMENT_URL>)
+    # Using the graph deployed with the name "agent"
+    assistant_id = "agent"
     # create thread
     thread = await client.threads.create()
     print(thread)
@@ -18,9 +21,11 @@ This guide covers how to stream events from your graph (`stream_mode="events"`).
     import { Client } from "@langchain/langgraph-sdk";
 
     const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
+    // Using the graph deployed with the name "agent"
+    const assistantID = "agent";
     // create thread
     const thread = await client.threads.create();
-    console.log(thread)
+    console.log(thread);
     ```
 
 === "CURL"
@@ -34,12 +39,15 @@ This guide covers how to stream events from your graph (`stream_mode="events"`).
 Output:
 
 
-    {'thread_id': '3f4c64e0-f792-4a5e-aa07-a4404e06e0bd',
-     'created_at': '2024-06-24T22:16:29.301522+00:00',
-     'updated_at': '2024-06-24T22:16:29.301522+00:00',
-     'metadata': {},
-     'status': 'idle',
-     'config': {}}
+    {
+        'thread_id': '3f4c64e0-f792-4a5e-aa07-a4404e06e0bd',
+        'created_at': '2024-06-24T22:16:29.301522+00:00',
+        'updated_at': '2024-06-24T22:16:29.301522+00:00',
+        'metadata': {},
+        'status': 'idle',
+        'config': {},
+        'values': None
+    }
 
 
 
@@ -62,7 +70,7 @@ Streaming events produces responses containing an `event` key (in addition to ot
     # stream events
     async for chunk in client.runs.stream(
         thread_id=thread["thread_id"],
-        assistant_id="agent",
+        assistant_id=assistant_id,
         input=input,
         stream_mode="events",
     ):
@@ -76,27 +84,27 @@ Streaming events produces responses containing an `event` key (in addition to ot
     ```js
     // create input
     const input = {
-        "messages": [
-            {
-                "role": "human",
-                "content": "What's the weather in SF?",
-            }
-        ]
+      "messages": [
+        {
+          "role": "human",
+          "content": "What's the weather in SF?",
+        }
+      ]
     }
 
     // stream events
     const streamResponse = client.runs.stream(
       thread["thread_id"],
-      "agent",
+      assistantID,
       {
         input,
         streamMode: "events"
       }
     );
     for await (const chunk of streamResponse) {
-      console.log(f"Receiving new event of type: {chunk.event}...")
-      console.log(chunk.data)
-      console.log("\n\n")
+      console.log(`Receiving new event of type: ${chunk.event}...`);
+      console.log(chunk.data);
+      console.log("\n\n");
     }
     ```
 
@@ -279,9 +287,6 @@ Output:
     
     Receiving new event of type: end...
     None
-    
-    
-    
 
 
 ## Token-by-Token Streaming
@@ -296,7 +301,7 @@ Token-by-token streaming can be implemented with the `events` streaming mode. Th
     # stream token-by-token
     async for chunk in client.runs.stream(
         thread_id=thread["thread_id"],
-        assistant_id="agent",
+        assistant_id=assistant_id,
         input=input,
         stream_mode="events",
     ):
@@ -317,7 +322,7 @@ Token-by-token streaming can be implemented with the `events` streaming mode. Th
     // stream events
     const streamResponse = client.runs.stream(
       thread["thread_id"],
-      "agent",
+      assistantID,
       {
         input,
         streamMode: "events"

docs/docs/cloud/how-tos/stream_messages.md

@@ -1,15 +1,7 @@
 # How to stream messages from your graph
 
-LangGraph Cloud supports multiple streaming modes. The main ones are:
+This guide covers how to stream messages from your graph. In order to use this mode, the state of the graph you are interacting with MUST have a `messages` key that is a list of messages.
 
-- `values`: This streaming mode streams back values of the graph. This is the **full state of the graph** after each node is called.
-- `updates`: This streaming mode streams back updates to the graph. This is the **update to the state of the graph** after each node is called.
-- `messages`: This streaming mode streams back messages - both complete messages (at the end of a node) as well as **tokens** for any messages generated inside a node. This mode is primarily meant for powering chat applications.
-
-
-This guide covers `stream_mode="messages"`.
-
-In order to use this mode, the state of the graph you are interacting with MUST have a `messages` key that is a list of messages.
 E.g., the state should look something like:
 
 === "Python"
@@ -23,16 +15,28 @@ E.g., the state should look something like:
         messages: Annotated[list[AnyMessage], add_messages]
     ```
 
+=== "Javascript"
 
-Alternatively, you can use an instance or subclass of `from langgraph.graph import MessagesState` (`MessagesState` is equivalent to the implementation above).
+    ```js
+    import { type BaseMessage } from "@langchain/core/messages";
+    import { Annotation, messagesStateReducer } from "@langchain/langgraph";
 
-> [!NOTE]
-> LangGraph Cloud only supports hosting graphs written in Python at the moment.
+    export const StateAnnotation = Annotation.Root({
+      messages: Annotation<BaseMessage[]>({
+        reducer: messagesStateReducer,
+        default: () => [],
+      }),
+    });
+    ```
+
+Alternatively, you can use an instance or subclass of `from langgraph.graph import MessagesState` (`MessagesState` is equivalent to the implementation above). Or in Javascript: `import { MessagesAnnotation } from "@langchain/langgraph";`.
 
 With `stream_mode="messages"` two things will be streamed back:
 
 - It outputs messages produced by any chat model called inside (unless tagged in a special way)
-- It outputs messages returned from nodes (to allow for nodes to return `ToolMessages` and the like
+- It outputs messages returned from nodes (to allow for nodes to return `ToolMessages` and the like)
+
+Read more about how the `messages` streaming mode works [here](https://langchain-ai.github.io/langgraph/cloud/concepts/api/#modemessages)
 
 First let's set up our client and thread:
 
@@ -42,6 +46,8 @@ First let's set up our client and thread:
     from langgraph_sdk import get_client
 
     client = get_client(url=<DEPLOYMENT_URL>)
+    # Using the graph deployed with the name "agent"
+    assistant_id = "agent"
     # create thread
     thread = await client.threads.create()
     print(thread)
@@ -53,9 +59,11 @@ First let's set up our client and thread:
     import { Client } from "@langchain/langgraph-sdk";
 
     const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
+    // Using the graph deployed with the name "agent"
+    const assistantID = "agent";
     // create thread
     const thread = await client.threads.create();
-    console.log(thread)
+    console.log(thread);
     ```
 
 === "CURL"
@@ -68,12 +76,15 @@ First let's set up our client and thread:
 
 Output:
 
-    {'thread_id': 'e1431c95-e241-4d1d-a252-27eceb1e5c86',
-     'created_at': '2024-06-21T15:48:59.808924+00:00',
-     'updated_at': '2024-06-21T15:48:59.808924+00:00',
-     'metadata': {},
-     'status': 'idle',
-     'config': {}}
+    {
+        'thread_id': 'e1431c95-e241-4d1d-a252-27eceb1e5c86',
+        'created_at': '2024-06-21T15:48:59.808924+00:00',
+        'updated_at': '2024-06-21T15:48:59.808924+00:00',
+        'metadata': {},
+        'status': 'idle',
+        'config': {},
+        'values': None
+    }
 
 Let's also define a helper function for better formatting of the tool calls in messages (for CURL we will define a helper script called `process_stream.sh`)
 
@@ -178,7 +189,7 @@ Now we can stream by messages, which will return complete messages (at the end o
 
     async for event in client.runs.stream(
         thread["thread_id"],
-        assistant_id="agent",
+        assistant_id=assistant_id,
         input=input,
         config=config,
         stream_mode="messages",
@@ -217,24 +228,25 @@ Now we can stream by messages, which will return complete messages (at the end o
 
     ```js
     const input = {
-      "messages": [
+      messages: [
         {
-          "role": "human",
-          "content": "What's the weather in sf",
+          role: "human",
+          content: "What's the weather in sf",
         }
       ]
-    }
-    const config = {"configurable": {"model_name": "openai"}}
+    };
+    const config = { configurable: { model_name: "openai" } };
 
     const streamResponse = client.runs.stream(
       thread["thread_id"],
-      "agent",
+      assistantID,
       {
         input,
         config,
         streamMode: "messages"
       }
     );
+
     for await (const event of streamResponse) {
       if (event.event === "metadata") {
         console.log(`Metadata: Run ID - ${event.data.run_id}`);

docs/docs/cloud/how-tos/stream_multiple.md

@@ -10,6 +10,8 @@ First let's set up our client and thread:
     from langgraph_sdk import get_client
 
     client = get_client(url=<DEPLOYMENT_URL>)
+    # Using the graph deployed with the name "agent"
+    assistant_id = "agent"
     # create thread
     thread = await client.threads.create()
     print(thread)
@@ -21,9 +23,11 @@ First let's set up our client and thread:
     import { Client } from "@langchain/langgraph-sdk";
 
     const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
+    // Using the graph deployed with the name "agent"
+    const assistantID = "agent";
     // create thread
     const thread = await client.threads.create();
-    console.log(thread)
+    console.log(thread);
     ```
 
 === "CURL"
@@ -36,12 +40,15 @@ First let's set up our client and thread:
 
 Output:
 
-    {'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4',
-     'created_at': '2024-06-24T21:30:07.980789+00:00',
-     'updated_at': '2024-06-24T21:30:07.980789+00:00',
-     'metadata': {},
-     'status': 'idle',
-     'config': {}}
+    {
+        'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4',
+        'created_at': '2024-06-24T21:30:07.980789+00:00',
+        'updated_at': '2024-06-24T21:30:07.980789+00:00',
+        'metadata': {},
+        'status': 'idle',
+        'config': {},
+        'values': None
+    }
 
 When configuring multiple streaming modes for a run, responses for each respective mode will be produced. In the following example, note that a `list` of modes (`messages`, `events`, `debug`) is passed to the `stream_mode` parameter and the response contains `events`, `debug`, `messages/complete`, `messages/metadata`, and `messages/partial` event types.
 
@@ -61,7 +68,7 @@ When configuring multiple streaming modes for a run, responses for each respecti
     # stream events with multiple streaming modes
     async for chunk in client.runs.stream(
         thread_id=thread["thread_id"],
-        assistant_id="agent",
+        assistant_id=assistant_id,
         input=input,
         stream_mode=["messages", "events", "debug"],
     ):
@@ -75,27 +82,27 @@ When configuring multiple streaming modes for a run, responses for each respecti
     ```js
     // create input
     const input = {
-      "messages": [
+      messages: [
         {
-          "role": "human",
-          "content": "What's the weather in SF?",
+          role: "human",
+          content: "What's the weather in SF?",
         }
       ]
-    }
+    };
 
     // stream events with multiple streaming modes
     const streamResponse = client.runs.stream(
       thread["thread_id"],
-      "agent",
+      assistantID,
       {
         input,
         streamMode: ["messages", "events", "debug"]
       }
     );
     for await (const chunk of streamResponse) {
-      console.log(f"Receiving new event of type: {chunk.event}...")
-      console.log(chunk.data)
-      console.log("\n\n")
+      console.log(`Receiving new event of type: ${chunk.event}...`);
+      console.log(chunk.data);
+      console.log("\n\n");
     }
     ```
 
@@ -482,5 +489,4 @@ Output:
     None
     
     
-    
 

docs/docs/cloud/how-tos/stream_updates.md

@@ -1,13 +1,6 @@
 # How to stream state updates of your graph
 
-LangGraph Cloud supports multiple streaming modes. The main ones are:
-
-- `values`: This streaming mode streams back values of the graph. This is the **full state of the graph** after each node is called.
-- `updates`: This streaming mode streams back updates to the graph. This is the **update to the state of the graph** after each node is called.
-- `messages`: This streaming mode streams back messages - both complete messages (at the end of a node) as well as **tokens** for any messages generated inside a node. This mode is primarily meant for powering chat applications.
-
-
-This guide covers `stream_mode="updates"`.
+This guide covers how to use `stream_mode="updates"` for your graph, which will stream the updates to the graph state that are made after each node is executed. This differs from using `stream_mode="values"`: instead of streaming the entire value of the state at each superstep, it only streams the updates from each of the nodes that made an update to the state at that superstep. Read [this conceptual guide](https://langchain-ai.github.io/langgraph/concepts/low_level/#stream-and-astream) to learn more.
 
 First let's set up our client and thread:
 
@@ -30,7 +23,7 @@ First let's set up our client and thread:
     const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
     // create thread
     const thread = await client.threads.create();
-    console.log(thread)
+    console.log(thread);
     ```
 
 === "CURL"
@@ -43,12 +36,15 @@ First let's set up our client and thread:
 
 Output:
 
-    {'thread_id': '979e3c89-a702-4882-87c2-7a59a250ce16',
-     'created_at': '2024-06-21T15:22:07.453100+00:00',
-     'updated_at': '2024-06-21T15:22:07.453100+00:00',
-     'metadata': {},
-     'status': 'idle',
-     'config': {}}
+    {
+      'thread_id': '979e3c89-a702-4882-87c2-7a59a250ce16',
+      'created_at': '2024-06-21T15:22:07.453100+00:00',
+      'updated_at': '2024-06-21T15:22:07.453100+00:00',
+      'metadata': {},
+      'status': 'idle',
+      'config': {},
+      'values': None 
+    }
 
 Now we can stream by updates, which outputs updates made to the state by each node after it has executed:
 
@@ -79,13 +75,13 @@ Now we can stream by updates, which outputs updates made to the state by each no
 
     ```js
     const input = {
-      "messages": [
+      messages: [
         {
-          "role": "human",
-          "content": "What's the weather in la",
+          role: "human",
+          content: "What's the weather in la"
         }
       ]
-    }
+    };
 
     const streamResponse = client.runs.stream(
       thread["thread_id"],
@@ -95,10 +91,11 @@ Now we can stream by updates, which outputs updates made to the state by each no
         streamMode: "updates"
       }
     );
+
     for await (const chunk of streamResponse) {
-      console.log(f"Receiving new event of type: {chunk.event}...")
-      console.log(chunk.data)
-      console.log("\n\n")
+      console.log(`Receiving new event of type: ${chunk.event}...`);
+      console.log(chunk.data);
+      console.log("\n\n");
     }
     ```
 

docs/docs/cloud/how-tos/stream_values.md

@@ -1,13 +1,6 @@
 # How to stream full state of your graph
 
-LangGraph Cloud supports multiple streaming modes. The main ones are:
-
-- `values`: This streaming mode streams back values of the graph. This is the **full state of the graph** after each node is called.
-- `updates`: This streaming mode streams back updates to the graph. This is the **update to the state of the graph** after each node is called.
-- `messages`: This streaming mode streams back messages - both complete messages (at the end of a node) as well as **tokens** for any messages generated inside a node. This mode is primarily meant for powering chat applications.
-
-
-This guide covers `stream_mode="values"`.
+This guide covers how to use `stream_mode="values"`, which streams the value of the state at each superstep. This differs from using `stream_mode="updates"`: instead of streaming just the updates to the state from each node, it streams the entire graph state at that superstep. Read [this conceptual guide](https://langchain-ai.github.io/langgraph/concepts/low_level/#stream-and-astream) to learn more.
 
 First let's set up our client and thread:
 
@@ -30,7 +23,7 @@ First let's set up our client and thread:
     const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
     // create thread
     const thread = await client.threads.create();
-    console.log(thread)
+    console.log(thread);
     ```
 
 === "CURL"
@@ -43,12 +36,15 @@ First let's set up our client and thread:
 
 Output:
 
-    {'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4',
-     'created_at': '2024-06-24T21:30:07.980789+00:00',
-     'updated_at': '2024-06-24T21:30:07.980789+00:00',
-     'metadata': {},
-     'status': 'idle',
-     'config': {}}
+    {
+      'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4',
+      'created_at': '2024-06-24T21:30:07.980789+00:00',
+      'updated_at': '2024-06-24T21:30:07.980789+00:00',
+      'metadata': {},
+      'status': 'idle',
+      'config': {},
+      'values': None
+    }
 
 Now we can stream by values, which streams the full state of the graph after each node has finished executing:
 
@@ -83,9 +79,9 @@ Now we can stream by values, which streams the full state of the graph after eac
       }
     );
     for await (const chunk of streamResponse) {
-      console.log(f"Receiving new event of type: {chunk.event}...")
-      console.log(chunk.data)
-      console.log("\n\n")
+      console.log(`Receiving new event of type: ${chunk.event}...`);
+      console.log(chunk.data);
+      console.log("\n\n");
     }
     ```
 

docs/docs/cloud/how-tos/webhooks.md

@@ -0,0 +1,125 @@
+# Use Webhooks
+
+You may wish to use webhooks in your client, especially when using async streams in case you want to update something in your service once the API call to LangGraph Cloud has finished running. To do so, you will need to expose an endpoint that can accept POST requests, and then pass it to your API request in the "webhook" parameter.
+
+Currently, the SDK has not exposed this endpoint but you can access it through curl commands as follows.
+
+The following endpoints accept `webhook` as a parameter: 
+
+- Create Run -> POST /thread/{thread_id}/runs
+- Create Thread Cron -> POST /thread/{thread_id}/runs/crons
+- Stream Run -> POST /thread/{thread_id}/runs/stream
+- Wait Run -> POST /thread/{thread_id}/runs/wait
+- Create Cron -> POST /runs/crons
+- Stream Run Stateless -> POST /runs/stream
+- Wait Run Stateless -> POST /runs/wait
+
+In this example, we will show calling a webhook after streaming a run. First, let's setup our assistant and thread:
+
+=== "Python"
+
+    ```python
+    from langgraph_sdk import get_client
+
+    client = get_client(url=<DEPLOYMENT_URL>)
+    # Using the graph deployed with the name "agent"
+    assistant_id = "agent"
+    # create thread
+    thread = await client.threads.create()
+    print(thread)
+    ```
+
+=== "Javascript"
+
+    ```js
+    import { Client } from "@langchain/langgraph-sdk";
+
+    const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
+    // Using the graph deployed with the name "agent"
+    const assistantID = "agent";
+    // create thread
+    const thread = await client.threads.create();
+    console.log(thread);
+    ```
+
+=== "CURL"
+
+    ```bash
+    curl --request POST \
+        --url <DEPLOYMENT_URL>/assistants/search \
+        --header 'Content-Type: application/json' \
+        --data '{
+            "limit": 10,
+            "offset": 0
+        }' | jq -c 'map(select(.config == null or .config == {})) | .[0]' && \
+    curl --request POST \
+        --url <DEPLOYMENT_URL>/threads \
+        --header 'Content-Type: application/json' \
+        --data '{}'
+    ```
+
+Output:
+
+    {
+        'thread_id': '9dde5490-2b67-47c8-aa14-4bfec88af217', 
+        'created_at': '2024-08-30T23:07:38.242730+00:00', 
+        'updated_at': '2024-08-30T23:07:38.242730+00:00', 
+        'metadata': {}, 
+        'status': 'idle', 
+        'config': {}, 
+        'values': None
+    }
+
+Now we can invoke a run with a webhook:
+
+=== "Python"
+
+    ```python
+    # create input
+    input = { "messages": [{ "role": "human", "content": "Hello!" }] }
+
+    async for chunk in client.runs.stream(
+        thread_id=thread["thread_id"],
+        assistant_id=assistant_id,
+        input=input,
+        stream_mode="events",
+        webhook="your-webhook"
+    ):
+        # Do something with the stream output
+        pass
+    ```
+
+=== "Javascript"
+
+    ```js
+    // create input
+    const input = { messages: [{ role: "human", content: "Hello!" }] };
+
+    // stream events
+    const streamResponse = client.runs.stream(
+      thread["thread_id"],
+      assistantID,
+      {
+        input: input,
+        webhook: "your-webhook"
+      }
+    );
+    for await (const chunk of streamResponse) {
+      // Do something with the stream output
+    }
+    ```
+
+=== "CURL"
+
+    ```bash
+    curl --request POST \
+        --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
+        --header 'Content-Type: application/json' \
+        --data '{
+            "assistant_id": <ASSISTANT_ID>,
+            "input" : {"messages":[{"role": "user", "content": "Hello!"}]},
+            "webhook": <YOUR_WEBHOOK_URL>
+        }'
+    ```
+
+And that's it! Now you can trigger your custom webhooks whenever you want in your LangGraph applications!

docs/docs/cloud/quick_start.md

@@ -14,13 +14,25 @@ This tutorial will use:
 
 1.  Create a new application with the following directory and files:
 
+=== "Python"
+
         <my-app>/
         |-- agent.py            # code for your LangGraph agent
         |-- requirements.txt    # Python packages required for your graph
         |-- langgraph.json      # configuration file for LangGraph
         |-- .env                # environment files with API keys
 
-2.  The `agent.py` file should contain Python code for defining your graph. The following code is a simple example, the important thing is that at some point in your file you compile your graph and assign the compiled graph to a variable (in this case the `graph` variable). This example code uses `create_react_agent`, a prebuilt agent, read more about it [here](..//concepts/agentic_concepts.md#react-agent).
+=== "Javascript"
+
+        <my-app>/
+        |-- agent.ts            # code for your LangGraph agent
+        |-- package.json        # Javascript packages required for your graph
+        |-- langgraph.json      # configuration file for LangGraph
+        |-- .env                # environment files with API keys
+
+2.  The `agent.py`/`agent.ts` file should contain code for defining your graph. The following code is a simple example, the important thing is that at some point in your file you compile your graph and assign the compiled graph to a variable (in this case the `graph` variable). This example code uses `create_react_agent`, a prebuilt agent. You can read more about it [here](../concepts/agentic_concepts.md#react-agent).
+
+=== "Python"
 
     ```python
     from langchain_anthropic import ChatAnthropic
@@ -34,14 +46,53 @@ This tutorial will use:
     graph = create_react_agent(model, tools)
     ```
 
-3.  The `requirements.txt` file should contain any dependencies for your graph(s). In this case we only require four packages for our graph to run:
+=== "Javascript"
 
-        langgraph
-        langchain_anthropic
-        tavily-python
-        langchain_community
+    ```ts
+    import { ChatAnthropic } from "@langchain/anthropic";
+    import { TavilySearchResults } from "@langchain/community/tools/tavily_search";
+    import { createReactAgent } from "@langchain/langgraph/prebuilt";
 
-4.  The [`langgraph.json`][langgraph.json] file is a configuration file that describes what graph(s) you are going to host. In this case we only have one graph to host: the compiled `graph` object from `agent.py`.
+    const model = new ChatAnthropic({
+      model: "claude-3-5-sonnet-20240620",
+    });
+
+    const tools = [
+      new TavilySearchResults({ maxResults: 3, }),
+    ];
+
+    export const graph = createReactAgent({ llm: model, tools });
+    ```
+
+3.  The `requirements.txt`/`package.json` file should contain any dependencies for your graph(s). In this case we only require four packages for our graph to run:
+
+=== "Python"
+
+      ```python
+      langgraph
+      langchain_anthropic
+      tavily-python
+      langchain_community
+      ```
+
+=== "Javascript"
+
+      ```js
+      {
+        "name": "my-app",
+        "packageManager": "yarn@1.22.22",
+        "dependencies": {
+          "@langchain/community": "^0.2.31",
+          "@langchain/core": "^0.2.31",
+          "@langchain/langgraph": "0.2.0",
+          "@langchain/openai": "^0.2.8"
+        }
+      }
+      ```
+
+4.  The [`langgraph.json`][langgraph.json] file is a configuration file that describes what graph(s) you are going to host. In this case we only have one graph to host: the compiled `graph` object from `agent.py`/`agent.ts`.
+
+=== "Python"
 
     ```json
     {
@@ -53,7 +104,21 @@ This tutorial will use:
     }
     ```
 
-    Learn more about the LangGraph CLI configuration file [here](./reference/cli.md#configuration-file).
+=== "Javascript"
+
+    ```json
+    {
+      "node_version": "20",
+      "dockerfile_lines": [],
+      "dependencies": ["."],
+      "graphs": {
+        "agent": "./src/agent.ts:graph"
+      },
+      "env": ".env"
+    }
+    ```
+
+Learn more about the LangGraph CLI configuration file [here](./reference/cli.md#configuration-file).
 
 5.  The `.env` file should have any environment variables needed to run your graph. This will only be used for local testing, so if you are not testing locally you can skip this step. NOTE: if you do add this, you should NOT check this into git. For this graph, we need two environment variables:
 
@@ -206,36 +271,108 @@ export LANGSMITH_API_KEY=...
 
 The first thing to do when using the SDK is to setup our client, access our assistant, and create a thread to execute a run on:
 
-```python
-from langgraph_sdk import get_client
+=== "Python"
 
-# Replace this with the URL of your own deployed graph
-URL = "https://chatbot-23a570f3210f52a7b167f09f6158e3b3-ffoprvkqsa-uc.a.run.app"
-client = get_client(url=URL)
+     ```python
+     from langgraph_sdk import get_client
 
-# Search all hosted graphs
-assistants = await client.assistants.search()
-# In this example we select the first assistant since we are only hosting a single graph
-assistant = assistants[0]
+     client = get_client(url=<DEPLOYMENT_URL>)
+     # get default assistant
+     assistants = await client.assistants.search()
+     assistant = [a for a in assistants if not a["config"]][0]
+     # create thread
+     thread = await client.threads.create()
+     print(thread)
+     ```
 
-# We create a thread for tracking the state of our run
-thread = await client.threads.create()
-```
+=== "Javascript"
+
+     ```js
+     import { Client } from "@langchain/langgraph-sdk";
+
+     const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
+     // get default assistant
+     const assistants = await client.assistants.search();
+     const assistant = assistants.find(a => !a.config);
+     // create thread
+     const thread = await client.threads.create();
+     console.log(thread)
+     ```
+
+=== "CURL"
+
+     ```bash
+     curl --request POST \
+         --url <DEPLOYMENT_URL>/assistants/search \
+         --header 'Content-Type: application/json' \
+         --data '{
+             "limit": 10,
+             "offset": 0
+         }' | jq -c 'map(select(.config == null or .config == {})) | .[0]' && \
+     curl --request POST \
+         --url <DEPLOYMENT_URL>/threads \
+         --header 'Content-Type: application/json' \
+         --data '{}'
+     ```
 
 We can then execute a run on the thread:
 
-```python
-input = {"messages":[{"role": "user", "content": "Hello! My name is Bagatur and I am 26 years old."}]}
+=== "Python"
 
-async for chunk in client.runs.stream(
-        thread['thread_id'],
-        assistant["assistant_id"],
-        input=input,
-        stream_mode="updates",
-    ):
-    if chunk.data and chunk.event != "metadata":
-        print(chunk.data)
-```
+    ```python
+    input = {"messages":[{"role": "user", "content": "Hello! My name is Bagatur and I am 26 years old."}]}
+
+    async for chunk in client.runs.stream(
+            thread['thread_id'],
+            assistant["assistant_id"],
+            input=input,
+            stream_mode="updates",
+        ):
+        if chunk.data and chunk.event != "metadata":
+            print(chunk.data)
+    ```
+
+=== "Javascript"
+
+    ```js
+    const input = { "messages":[{ "role": "user", "content": "Hello! My name is Bagatur and I am 26 years old." }] };
+
+    const streamResponse = client.runs.stream(
+      thread["thread_id"],
+      assistant["assistant_id"],
+      {
+        input,
+      }
+    );
+    for await (const chunk of streamResponse) {
+      if (chunk.data && chunk.event !== "metadata" ) {
+        console.log(chunk.data);
+      }
+    }
+    ```
+
+=== "CURL"
+
+    ```bash
+    curl --request POST \
+      --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
+      --header 'Content-Type: application/json' \
+      --data "{
+        \"assistant_id\": <ASSISTANT_ID>,
+        \"input\": {\"messages\": [{\"role\": \"human\", \"content\": \"Hello! My name is Bagatur and I am 26 years old.\"}]},
+      }" | sed 's/\r$//' | awk '
+      /^event:/ { event = $2 }
+      /^data:/ {
+          json_data = substr($0, index($0, $2))
+
+          if (event != "metadata") {
+          print json_data
+          }
+      }'
+    ```
+
+
+Output:
 
     {'agent': {'messages': [{'content': "Hi Bagatur! It's nice to meet you. How can I assist you today?", 'additional_kwargs': {}, 'response_metadata': {'finish_reason': 'stop', 'model_name': 'gpt-4o-2024-05-13', 'system_fingerprint': 'fp_9cb5d38cf7'}, 'type': 'ai', 'name': None, 'id': 'run-c89118b7-1b1e-42b9-a85d-c43fe99881cd', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]}}
 

docs/docs/cloud/reference/api/api_ref.md

@@ -3,3 +3,20 @@
 The LangGraph Cloud API reference is available with each deployment at the `/docs` URL path (e.g. `http://localhost:8124/docs`).
 
 Click <a href="/langgraph/cloud/reference/api/api_ref.html" target="_blank">here</a> to view the API reference.
+
+## Authentication
+
+For deployments to LangGraph Cloud, authentication is required. Pass the `X-Api-Key` header with each request to the LangGraph Cloud API. The value of the header should be set to a valid LangSmith API key for the organization where the API is deployed.
+
+Example `curl` command:
+```shell
+curl --request POST \
+  --url http://localhost:8124/assistants/search \
+  --header 'Content-Type: application/json' \
+  --header 'X-Api-Key: LANGSMITH_API_KEY' \
+  --data '{
+  "metadata": {},
+  "limit": 10,
+  "offset": 0
+}'  
+```

docs/docs/concepts/low_level.md

@@ -401,7 +401,17 @@ def node_a(state, config):
     ...
 ```
 
-See [this guide](../how-tos/configuration.ipynb) for a full breakdown on configuration
+See [this guide](../how-tos/configuration.ipynb) for a full breakdown on configuration.
+
+### Recursion Limit
+
+The recursion limit sets the maximum number of [super-steps](#graphs) the graph can execute during a single execution. Once the limit is reached, LangGraph will raise `GraphRecursionError`. By default this value is set to 25 steps. The recursion limit can be set on any graph at runtime, and is passed to `.invoke`/`.stream` via the config dictionary. Importantly, `recursion_limit` is a standalone `config` key and should not be passed inside the `configurable` key as all other user-defined configuration. See the example below:
+
+```python
+graph.invoke(inputs, config={"recursion_limit": 5, "configurable":{"llm": "anthropic"}})
+```
+
+Read [this how-to](https://langchain-ai.github.io/langgraph/how-tos/recursion-limit/) to learn more about how the recursion limit works.
 
 ## Breakpoints
 
@@ -427,13 +437,202 @@ It's often nice to be able to visualize graphs, especially as they get more comp
 
 ## Streaming
 
-LangGraph is built with first class support for streaming. There are several different streaming modes that LangGraph supports:
+LangGraph is built with first class support for streaming. There are several different ways to stream back results
+
+### `.stream` and `.astream`
+
+`.stream` and `.astream` are sync and async methods for streaming back results.
+There are several different modes you can specify when calling these methods (e.g. `graph.stream(..., mode="...")):
 
 - [`"values"`](../how-tos/stream-values.ipynb): This streams the full value of the state after each step of the graph.
-- [`"updates`](../how-tos/stream-updates.ipynb): This streams the updates to the state after each step of the graph. If multiple updates are made in the same step (e.g. multiple nodes are run) then those updates are streamed separately.
+- [`"updates"`](../how-tos/stream-updates.ipynb): This streams the updates to the state after each step of the graph. If multiple updates are made in the same step (e.g. multiple nodes are run) then those updates are streamed separately.
 - `"debug"`: This streams as much information as possible throughout the execution of the graph.
 
+The below visualization shows the difference between the `values` and `updates` modes:
+
+![values vs updates](../static/values_vs_updates.png)
+
+
+### `.astream_events` (for streaming tokens of LLM calls)
+
 In addition, you can use the [`astream_events`](../how-tos/streaming-events-from-within-tools.ipynb) method to stream back events that happen _inside_ nodes. This is useful for [streaming tokens of LLM calls](../how-tos/streaming-tokens.ipynb).
 
+This is a standard method on all [LangChain objects](https://python.langchain.com/v0.2/docs/concepts/#runnable-interface). This means that as the graph is executed, certain events are emitted along the way and can be seen if you run the graph using `.astream_events`. 
+
+All events have (among other things) `event`, `name`, and `data` fields. What do these mean?
+
+- `event`: This is the type of event that is being emitted. You can find a detailed table of all callback events and triggers [here](https://python.langchain.com/v0.2/docs/concepts/#callback-events).
+- `name`: This is the name of event.
+- `data`: This is the data associated with the event.
+
+What types of things cause events to be emitted?
+
+* each node (runnable) emits `on_chain_start` when it starts execution, `on_chain_stream` during the node execution and `on_chain_end` when the node finishes. Node events will have the node name in the event's `name` field
+* the graph will emit `on_chain_start` in the beginning of the graph execution, `on_chain_stream` after each node execution and `on_chain_end` when the graph finishes. Graph events will have the `LangGraph` in the event's `name` field
+* Any writes to state channels (i.e. anytime you update the value of one of your state keys) will emit `on_chain_start` and `on_chain_end` events
+
+Additionally, any events that are created inside your nodes (LLM events, tool events, manually emitted events, etc.) will also be visible in the output of `.astream_events`.
+
+To make this more concrete and to see what this looks like, let's see what events are returned when we run a simple graph:
+
+```python
+from langchain_openai import ChatOpenAI
+from langgraph.graph import StateGraph, MessagesState, START, END
+
+model = ChatOpenAI(model="gpt-3.5-turbo")
+
+
+def call_model(state: MessagesState):
+    response = model.invoke(state['messages'])
+    return {"messages": response}
+
+workflow = StateGraph(MessagesState)
+workflow.add_node(call_model)
+workflow.add_edge(START, "call_model")
+workflow.add_edge("call_model", END)
+app = workflow.compile()
+
+inputs = [{"role": "user", "content": "hi!"}]
+async for event in app.astream_events({"messages": inputs}, version="v2"):
+    kind = event["event"]
+    print(f"{kind}: {event['name']}")
+```
+```shell
+on_chain_start: LangGraph
+on_chain_start: __start__
+on_chain_end: __start__
+on_chain_start: call_model
+on_chat_model_start: ChatOpenAI
+on_chat_model_stream: ChatOpenAI
+on_chat_model_stream: ChatOpenAI
+on_chat_model_stream: ChatOpenAI
+on_chat_model_stream: ChatOpenAI
+on_chat_model_stream: ChatOpenAI
+on_chat_model_stream: ChatOpenAI
+on_chat_model_stream: ChatOpenAI
+on_chat_model_stream: ChatOpenAI
+on_chat_model_stream: ChatOpenAI
+on_chat_model_stream: ChatOpenAI
+on_chat_model_stream: ChatOpenAI
+on_chat_model_end: ChatOpenAI
+on_chain_start: ChannelWrite<call_model,messages>
+on_chain_end: ChannelWrite<call_model,messages>
+on_chain_stream: call_model
+on_chain_end: call_model
+on_chain_stream: LangGraph
+on_chain_end: LangGraph
+```
+
+We start with the overall graph start (`on_chain_start: LangGraph`). We then write to the `__start__` node (this is special node to handle input).
+We then start the `call_model` node (`on_chain_start: call_model`). We then start the chat model invocation (`on_chat_model_start: ChatOpenAI`),
+stream back token by token (`on_chat_model_stream: ChatOpenAI`) and then finish the chat model (`on_chat_model_end: ChatOpenAI`). From there, 
+we write the results back to the channel (`ChannelWrite<call_model,messages>`) and then finish the `call_model` node and then the graph as a whole.
+
+This should hopefully give you a good sense of what events are emitted in a simple graph. But what data do these events contain?
+Each type of event contains data in a different format. Let's look at what `on_chat_model_stream` events look like. This is an important type of event
+since it is needed for streaming tokens from an LLM response.
+
+These events look like:
+
+```shell
+{'event': 'on_chat_model_stream',
+ 'name': 'ChatOpenAI',
+ 'run_id': '3fdbf494-acce-402e-9b50-4eab46403859',
+ 'tags': ['seq:step:1'],
+ 'metadata': {'langgraph_step': 1,
+  'langgraph_node': 'call_model',
+  'langgraph_triggers': ['start:call_model'],
+  'langgraph_task_idx': 0,
+  'checkpoint_id': '1ef657a0-0f9d-61b8-bffe-0c39e4f9ad6c',
+  'checkpoint_ns': 'call_model',
+  'ls_provider': 'openai',
+  'ls_model_name': 'gpt-3.5-turbo',
+  'ls_model_type': 'chat',
+  'ls_temperature': 0.7},
+ 'data': {'chunk': AIMessageChunk(content='Hello', id='run-3fdbf494-acce-402e-9b50-4eab46403859')},
+ 'parent_ids': []}
+```
+We can see that we have the event type and name (which we knew from before).
+
+We also have a bunch of stuff in metadata. Noticeably, `'langgraph_node': 'call_model',` is some really helpful information
+which tells us which node this model was invoked inside of.
+
+Finally, `data` is a really important field. This contains the actual data for this event! Which in this case
+is an AIMessageChunk. This contains the `content` for the message, as well as an `id`.
+This is the ID of the overall AIMessage (not just this chunk) and is super helpful - it helps
+us track which chunks are part of the same message (so we can show them together in the UI).
+
+This information contains all that is needed for creating a UI for streaming LLM tokens. You can see a 
+guide for that [here](../how-tos/streaming-tokens.ipynb).
+
+
 !!! warning "ASYNC IN PYTHON<=3.10"
-    You may fail to see events being emitted from inside a node when using `.astream_events` in Python <= 3.10. If you're using a Langchain RunnableLambda, a RunnableGenerator, or Tool asynchronously inside your node, you will have to propagate callbacks to these objects manually. This is because LangChain cannot automatically propagate callbacks to child objects in this case. Please see examples [here](../how-tos/streaming-content.ipynb) and [here](../how-tos/streaming-events-from-within-tools.ipynb).
+    You may fail to see events being emitted from inside a node when using `.astream_events` in Python <= 3.10. If you're using a Langchain RunnableLambda, a RunnableGenerator, or Tool asynchronously inside your node, you will have to propagate callbacks to these objects manually. This is because LangChain cannot automatically propagate callbacks to child objects in this case. Please see examples [here](../how-tos/streaming-content.ipynb) and [here](../how-tos/streaming-events-from-within-tools.ipynb).
+
+#### Only stream tokens from specific nodes/LLMs
+
+
+There are certain cases where you have multiple nodes in your graph that make LLM calls, and you do not wish to stream the tokens from every single LLM call. For example, you may use one LLM as a planner for the next steps to take, and another LLM somewhere else in the graph that actually responds to the user. In that case, you most likely WON'T want to stream tokens from the planner LLM but WILL want to stream them from the respond to user LLM. Below we show two different ways of doing this, one by streaming from specific nodes only and the second by streaming from specific LLMs only.
+
+First, let's define our graph:
+
+```python
+from langchain_openai import ChatOpenAI
+from langgraph.graph import StateGraph, MessagesState, START, END
+
+model_1 = ChatOpenAI(model="gpt-3.5-turbo", name="model_1")
+model_2 = ChatOpenAI(model="gpt-3.5-turbo", name="model_2")
+
+def call_first_model(state: MessagesState):
+    response = model_1.invoke(state['messages'])
+    return {"messages": response}
+
+def call_second_model(state: MessagesState):
+    response = model_2.invoke(state['messages'])
+    return {"messages": response}
+
+workflow = StateGraph(MessagesState)
+workflow.add_node(call_first_model)
+workflow.add_node(call_second_model)
+workflow.add_edge(START, "call_first_model")
+workflow.add_edge("call_first_model", "call_second_model")
+workflow.add_edge("call_second_model", END)
+app = workflow.compile()
+```
+
+**Streaming from specific node**
+
+In the case that we only want the output from a single node, we can use the event metadata to filter node names:
+
+```python
+inputs = [{"role": "user", "content": "hi!"}]
+
+async for event in app.astream_events({"messages": inputs}, version="v2"):
+    # Get chat model tokens from a particular node 
+    if event["event"] == "on_chat_model_stream" and event['metadata'].get('langgraph_node','') == "call_second_model":
+     print(event["data"]["chunk"].content, end="|", flush=True)
+```
+
+```shell
+|Hello|!| How| can| I| help| you| today|?||
+```
+
+As we can see only the response from the second LLM was streamed (you can tell because we only received a single response, if we had streamed both we would have received two "Hello! How can I help you today?" messages).
+
+**Streaming from specific LLM**
+
+Sometimes you might want to stream from specific LLMs instead of specific nodes. This could be the case if you have multiple LLM calls inside a single node, and only want to stream the output of a specific one or if you use the same LLM in different nodes and want to stream it's output anytime it is called. We can do this by using the `name` parameter for LLMs and events:
+
+```python
+inputs = [{"role": "user", "content": "hi!"}]
+async for event in app.astream_events({"messages": inputs}, version="v2"):
+    # Get chat model tokens from a particular LLM inside a particular node
+    if event["event"] == "on_chat_model_stream" and event['name'] == "model_2":
+        print(event["data"]["chunk"].content, end="|", flush=True)
+```
+
+```shell
+|Hello|!| How| can| I| assist| you| today|?||
+```
+
+As expected, we only see a single LLM response since the response from `model_1` was not streamed. 

docs/docs/how-tos/index.md

@@ -12,10 +12,9 @@ Welcome to the LangGraph how-to guides! These guides provide practical, step-by-
 LangGraph is known for being a highly controllable agent framework.
 These how-to guides show how to achieve that controllability.
 
-- [How to create subgraphs](subgraph.ipynb)
 - [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)
 
 ## Persistence
 
@@ -35,6 +34,7 @@ One of LangGraph's main benefits is that it makes human-in-the-loop workflows ea
 These guides cover common examples of that.
 
 - [How to add breakpoints](human_in_the_loop/breakpoints.ipynb)
+- [How to add dynamic breakpoints](human_in_the_loop/dynamic_breakpoints.ipynb)
 - [How to edit graph state](human_in_the_loop/edit-graph-state.ipynb)
 - [How to wait for user input](human_in_the_loop/wait-user-input.ipynb)
 - [How to view and update past graph state](human_in_the_loop/time-travel.ipynb)
@@ -63,6 +63,12 @@ These guides show how to use different streaming modes.
 - [How to pass config to tools](pass-config-to-tools.ipynb)
 - [How to handle large numbers of tools](many-tools.ipynb)
 
+## Subgraphs
+
+- [How to create subgraphs](subgraph.ipynb)
+- [How to manage state in subgraphs](subgraphs-manage-state.ipynb)
+- [How to transform inputs and outputs of a subgraph](subgraph-transform-state.ipynb)
+
 ## State Management
 
 - [Use Pydantic model as state](state-model.ipynb)
@@ -78,6 +84,7 @@ These guides show how to use different streaming modes.
 - [How to use a Pydantic model as your state](state-model.ipynb)
 - [How to use a context object in state](state-context-key.ipynb)
 - [How to add node retries](node-retries.ipynb)
+- [How to force function calling agent to structure output](react-agent-structured-output.ipynb)
 
 ## Prebuilt ReAct Agent
 

docs/mkdocs.yml

@@ -126,9 +126,9 @@ nav:
   - "How-to Guides":
       - "how-tos/index.md"
       - Controllability:
-          - Create subgraphs: how-tos/subgraph.ipynb
           - Create branches for parallel execution: how-tos/branching.ipynb
           - Create map-reduce branches for parallel execution: how-tos/map-reduce.ipynb
+          - Control graph recursion limit: how-tos/recursion-limit.ipynb
       - Persistence:
           - Add persistence ("memory"): how-tos/persistence.ipynb
           - Manage conversation history: how-tos/memory/manage-conversation-history.ipynb
@@ -139,6 +139,7 @@ nav:
           - Create custom checkpointer using Redis: how-tos/persistence_redis.ipynb
       - Human-in-the-loop:
           - Add breakpoints: how-tos/human_in_the_loop/breakpoints.ipynb
+          - Add dynamic breakpoints: how-tos/human_in_the_loop/dynamic_breakpoints.ipynb
           - Wait for user input: how-tos/human_in_the_loop/wait-user-input.ipynb
           - View and update past graph state: how-tos/human_in_the_loop/time-travel.ipynb
           - Edit graph state: how-tos/human_in_the_loop/edit-graph-state.ipynb
@@ -159,6 +160,10 @@ nav:
           - Pass graph state to tools: how-tos/pass-run-time-values-to-tools.ipynb
           - Pass config to tools: how-tos/pass-config-to-tools.ipynb
           - Handle many tools: how-tos/many-tools.ipynb
+      - Subgraphs:
+          - Create subgraphs: how-tos/subgraph.ipynb
+          - Manage state in subgraphs: how-tos/subgraphs-manage-state.ipynb
+          - Transform inputs and outputs of a subgraph: how-tos/subgraph-transform-state.ipynb
       - State Management:
           - Use Pydantic model as state: how-tos/state-model.ipynb
           - Use a context object in state: how-tos/state-context-key.ipynb
@@ -169,11 +174,12 @@ nav:
           - Visualize your graph: how-tos/visualization.ipynb
           - Add runtime configuration: how-tos/configuration.ipynb
           - Add node retries: how-tos/node-retries.ipynb
+          - How to return structured output from a ReAct agent: how-tos/react-agent-structured-output.ipynb
       - Prebuilt ReAct Agent:
           - Create a ReAct agent: how-tos/create-react-agent.ipynb
           - Add memory to a ReAct agent: how-tos/create-react-agent-memory.ipynb
           - Add a system prompt to a ReAct agent: how-tos/create-react-agent-system-prompt.ipynb
-          - Add human-in-the-Loop to a ReAct agent: how-tos/create-react-agent-hitl.ipynb
+          - Add Human-in-the-loop to a ReAct agent: how-tos/create-react-agent-hitl.ipynb
   - "Conceptual Guides":
       - "concepts/index.md"
       - LangGraph for Agentic Applications: concepts/high_level.md
@@ -194,11 +200,11 @@ nav:
           - Setup:
               - Setup App: "cloud/deployment/setup.md"
               - Setup App (pyproject.toml): "cloud/deployment/setup_pyproject.md"
+              - Setup App (JavaScript): "cloud/deployment/setup_javascript.md"
               - Rebuild Graph at Runtime: "cloud/deployment/graph_rebuild.md"
               - Test App Locally: "cloud/deployment/test_locally.md"
           - Deployment:
               - Deploy to Cloud: "cloud/deployment/cloud.md"
-              - Self-Host: "cloud/deployment/self_hosted.md"
           - Streaming:
               - Stream Values: "cloud/how-tos/stream_values.md"
               - Stream Updates: "cloud/how-tos/stream_updates.md"
@@ -223,14 +229,14 @@ nav:
               - Invoke graph in LangGraph Studio: "cloud/how-tos/invoke_studio.md"
               - Interact with threads in LangGraph Studio: "cloud/how-tos/threads_studio.md"
           - Different Types of Runs:
-              - Run an Agent in the Background: "cloud/how-tos/cloud_examples/background_run.ipynb"
-              - Run Multiple Agents in Same Thread: "cloud/how-tos/cloud_examples/same-thread.ipynb"
-              - Create Cron Jobs: "cloud/how-tos/cloud_examples/cron_jobs.ipynb"
-              - Create Stateless Runs: "cloud/how-tos/cloud_examples/stateless_runs.ipynb"
+              - Run an Agent in the Background: "cloud/how-tos/background_run.md"
+              - Run Multiple Agents in Same Thread: "cloud/how-tos/same-thread.md"
+              - Create Cron Jobs: "cloud/how-tos/cron_jobs.md"
+              - Create Stateless Runs: "cloud/how-tos/stateless_runs.md"
           - Other:
-              - Configure Agents: "cloud/how-tos/cloud_examples/configuration_cloud.ipynb"
+              - Configure Agents: "cloud/how-tos/configuration_cloud.md"
               - Convert LangGraph calls to LangGraph Cloud calls: "cloud/how-tos/cloud_examples/langgraph_to_langgraph_cloud.ipynb"
-              - Integrate Webhooks: 'cloud/how-tos/cloud_examples/webhooks.ipynb'
+              - Integrate Webhooks: 'cloud/how-tos/webhooks.md'
               - Copy Threads: 'cloud/how-tos/copy_threads.md'
               - Check Status of Threads: "cloud/how-tos/check_thread_status.md"
       - Conceptual Guides:

examples/chat_agent_executor_with_function_calling/high-level-tools.ipynb

@@ -103,14 +103,6 @@
     "    print(list(s.values())[0])\n",
     "    print(\"----\")"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "87f147e3-f96f-4b96-a3cc-ec7affd7a57f",
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {

examples/chatbot-simulation-evaluation/agent-simulation-evaluation.ipynb

@@ -235,7 +235,7 @@
     "    # Call the chat bot\n",
     "    chat_bot_response = my_chat_bot(messages)\n",
     "    # Respond with an AI Message\n",
-    "    return {\"messages\":[AIMessage(content=chat_bot_response[\"content\"])]}"
+    "    return {\"messages\": [AIMessage(content=chat_bot_response[\"content\"])]}"
    ]
   },
   {
@@ -270,7 +270,7 @@
     "    # Call the simulated user\n",
     "    response = simulated_user.invoke({\"messages\": new_messages})\n",
     "    # This response is an AI message - we need to flip this to be a human message\n",
-    "    return {\"messages\":[HumanMessage(content=response.content)]}"
+    "    return {\"messages\": [HumanMessage(content=response.content)]}"
    ]
   },
   {
@@ -331,6 +331,7 @@
     "class State(TypedDict):\n",
     "    messages: Annotated[list, add_messages]\n",
     "\n",
+    "\n",
     "graph_builder = StateGraph(State)\n",
     "graph_builder.add_node(\"user\", simulated_user_node)\n",
     "graph_builder.add_node(\"chat_bot\", chat_bot_node)\n",
@@ -398,14 +399,6 @@
     "        print(chunk)\n",
     "        print(\"----\")"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "dde4f2b5-cfe8-4ff0-99ea-fe2c5fed70c0",
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {

examples/chatbot-simulation-evaluation/langsmith-agent-simulation-evaluation.ipynb

@@ -359,14 +359,6 @@
     "    evaluation=evaluation,\n",
     ")"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "26735ed2-766d-4e0a-a185-b2295a0615b8",
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {

examples/cloud_examples/background_run.ipynb

@@ -1,388 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "51466c8d-8ce4-4b3d-be4e-18fdbeda5f53",
-   "metadata": {},
-   "source": [
-    "# How to kick off background runs\n",
-    "\n",
-    "This guide covers how to kick off background runs for your agent.\n",
-    "This can be useful for long running jobs."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "b8e6408a-b37e-428f-9567-077fa55d58e8",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Initialize the client\n",
-    "from langgraph_sdk import get_client\n",
-    "\n",
-    "client = get_client()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "4947e9bc-111f-4991-8c41-1041da9bf0ba",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'assistant_id': 'e90fee30-be91-43aa-a33c-d54bd219072e',\n",
-       " 'graph_id': 'agent',\n",
-       " 'created_at': '2024-06-18T18:06:55.102231+00:00',\n",
-       " 'updated_at': '2024-06-18T18:06:55.102231+00:00',\n",
-       " 'config': {'configurable': {'model_name': 'anthropic'}},\n",
-       " 'metadata': {}}"
-      ]
-     },
-     "execution_count": 2,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# List available assistants\n",
-    "assistants = await client.assistants.search()\n",
-    "assistants[0]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "230c0464-a6e5-420f-9e38-ca514e5634ce",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# NOTE: we can use `assistant_id` UUID from the above response, or just pass graph ID instead when creating runs. we'll use graph ID here\n",
-    "assistant_id = \"agent\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "56aa5159-5583-4134-9210-709b969bda6f",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'thread_id': '5fc20631-47b7-48cd-8aa2-9f2eace9778d',\n",
-       " 'created_at': '2024-06-21T14:58:02.079462+00:00',\n",
-       " 'updated_at': '2024-06-21T14:58:02.079462+00:00',\n",
-       " 'metadata': {}}"
-      ]
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Create a new thread\n",
-    "thread = await client.threads.create()\n",
-    "thread"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "147c3f98-f889-4f05-a090-6b31f2a0b291",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[]"
-      ]
-     },
-     "execution_count": 5,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# If we list runs on this thread, we can see it is empty\n",
-    "runs = await client.runs.list(thread[\"thread_id\"])\n",
-    "runs"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "8c7b44ef-4816-496d-88a1-2f7327cf576d",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Let's kick off a run\n",
-    "input = {\"messages\": [{\"role\": \"human\", \"content\": \"what's the weather in sf\"}]}\n",
-    "run = await client.runs.create(thread[\"thread_id\"], assistant_id, input=input)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "d84b4d80-b0aa-4d9f-a05d-0744b2fe8f72",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'run_id': '1ef2fdea-814c-6165-8b2a-a40e2a028198',\n",
-       " 'thread_id': '5fc20631-47b7-48cd-8aa2-9f2eace9778d',\n",
-       " 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca',\n",
-       " 'created_at': '2024-06-21T14:58:02.095911+00:00',\n",
-       " 'updated_at': '2024-06-21T14:58:02.095911+00:00',\n",
-       " 'metadata': {},\n",
-       " 'status': 'pending',\n",
-       " 'kwargs': {'input': {'messages': [{'role': 'human',\n",
-       "     'content': 'what's the weather in sf'}]},\n",
-       "  'config': {'metadata': {'created_by': 'system'},\n",
-       "   'configurable': {'run_id': '1ef2fdea-814c-6165-8b2a-a40e2a028198',\n",
-       "    'user_id': '',\n",
-       "    'graph_id': 'agent',\n",
-       "    'thread_id': '5fc20631-47b7-48cd-8aa2-9f2eace9778d',\n",
-       "    'thread_ts': None,\n",
-       "    'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'}},\n",
-       "  'webhook': None,\n",
-       "  'temporary': False,\n",
-       "  'stream_mode': ['events'],\n",
-       "  'feedback_keys': None,\n",
-       "  'interrupt_after': None,\n",
-       "  'interrupt_before': None},\n",
-       " 'multitask_strategy': 'reject'}"
-      ]
-     },
-     "execution_count": 7,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# The first time we poll it, we can see `status=pending`\n",
-    "await client.runs.get(thread[\"thread_id\"], run[\"run_id\"])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "3639da3c-bfe5-454c-ab1e-8ed7af394dfe",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Wait until the run finishes\n",
-    "await client.runs.join(thread[\"thread_id\"], run[\"run_id\"])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "8fa206ed-515e-4607-9a80-bebafe76cc24",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'run_id': '1ef2fdea-814c-6165-8b2a-a40e2a028198',\n",
-       " 'thread_id': '5fc20631-47b7-48cd-8aa2-9f2eace9778d',\n",
-       " 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca',\n",
-       " 'created_at': '2024-06-21T14:58:02.095911+00:00',\n",
-       " 'updated_at': '2024-06-21T14:58:02.095911+00:00',\n",
-       " 'metadata': {},\n",
-       " 'status': 'success',\n",
-       " 'kwargs': {'input': {'messages': [{'role': 'human',\n",
-       "     'content': 'what's the weather in sf'}]},\n",
-       "  'config': {'metadata': {'created_by': 'system'},\n",
-       "   'configurable': {'run_id': '1ef2fdea-814c-6165-8b2a-a40e2a028198',\n",
-       "    'user_id': '',\n",
-       "    'graph_id': 'agent',\n",
-       "    'thread_id': '5fc20631-47b7-48cd-8aa2-9f2eace9778d',\n",
-       "    'thread_ts': None,\n",
-       "    'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'}},\n",
-       "  'webhook': None,\n",
-       "  'temporary': False,\n",
-       "  'stream_mode': ['events'],\n",
-       "  'feedback_keys': None,\n",
-       "  'interrupt_after': None,\n",
-       "  'interrupt_before': None},\n",
-       " 'multitask_strategy': 'reject'}"
-      ]
-     },
-     "execution_count": 9,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Eventually, it should finish and we should see `status=success`\n",
-    "await client.runs.get(thread[\"thread_id\"], run[\"run_id\"])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "id": "8de4495f-7873-487c-b1a8-ad2a78a1ff35",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# We can get the final results\n",
-    "final_result = await client.threads.get_state(thread[\"thread_id\"])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "id": "9da76fce-66e4-4f1b-8c24-09759889e50e",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'values': {'messages': [{'content': 'what's the weather in sf',\n",
-       "    'additional_kwargs': {},\n",
-       "    'response_metadata': {},\n",
-       "    'type': 'human',\n",
-       "    'name': None,\n",
-       "    'id': 'bfe07fff-cb40-40be-84d5-a061d2c40006',\n",
-       "    'example': False},\n",
-       "   {'content': [{'id': 'toolu_01QUzhhfDQkpbPSediUrXvQb',\n",
-       "      'input': {'query': 'weather in san francisco'},\n",
-       "      'name': 'tavily_search_results_json',\n",
-       "      'type': 'tool_use'}],\n",
-       "    'additional_kwargs': {},\n",
-       "    'response_metadata': {},\n",
-       "    'type': 'ai',\n",
-       "    'name': None,\n",
-       "    'id': 'run-6d8665ca-a77d-4b44-9a7b-4e975b155fb1',\n",
-       "    'example': False,\n",
-       "    'tool_calls': [{'name': 'tavily_search_results_json',\n",
-       "      'args': {'query': 'weather in san francisco'},\n",
-       "      'id': 'toolu_01QUzhhfDQkpbPSediUrXvQb'}],\n",
-       "    'invalid_tool_calls': [],\n",
-       "    'usage_metadata': None},\n",
-       "   {'content': '[{\"url\": \"https://www.timeanddate.com/weather/usa/san-francisco/historic\", \"content\": \"San Francisco Weather History for the Previous 24 Hours Show weather for: Previous 24 hours June 17, 2024 June 16, 2024 June 15, 2024 June 14, 2024 June 13, 2024 June 12, 2024 June 11, 2024 June 10, 2024 June 9, 2024 June 8, 2024 June 7, 2024 June 6, 2024 June 5, 2024 June 4, 2024 June 3, 2024 June 2, 2024\"}]',\n",
-       "    'additional_kwargs': {},\n",
-       "    'response_metadata': {},\n",
-       "    'type': 'tool',\n",
-       "    'name': 'tavily_search_results_json',\n",
-       "    'id': '257a1f29-2f66-4f9e-b35d-c8818dbbaa3f',\n",
-       "    'tool_call_id': 'toolu_01QUzhhfDQkpbPSediUrXvQb'},\n",
-       "   {'content': [{'text': 'The search results provide historic weather data for San Francisco, but do not give the current weather conditions. To get the current weather forecast for San Francisco, I would need to refine my search query. Here is an updated search:',\n",
-       "      'type': 'text'},\n",
-       "     {'id': 'toolu_01RLJEcWYRvRoBhiHdrhoRZx',\n",
-       "      'input': {'query': 'san francisco weather forecast today'},\n",
-       "      'name': 'tavily_search_results_json',\n",
-       "      'type': 'tool_use'}],\n",
-       "    'additional_kwargs': {},\n",
-       "    'response_metadata': {},\n",
-       "    'type': 'ai',\n",
-       "    'name': None,\n",
-       "    'id': 'run-ca41dbf8-7e89-4ff2-a245-87098d7928ba',\n",
-       "    'example': False,\n",
-       "    'tool_calls': [{'name': 'tavily_search_results_json',\n",
-       "      'args': {'query': 'san francisco weather forecast today'},\n",
-       "      'id': 'toolu_01RLJEcWYRvRoBhiHdrhoRZx'}],\n",
-       "    'invalid_tool_calls': [],\n",
-       "    'usage_metadata': None},\n",
-       "   {'content': '[{\"url\": \"https://www.weatherapi.com/\", \"content\": \"{\\'location\\': {\\'name\\': \\'San Francisco\\', \\'region\\': \\'California\\', \\'country\\': \\'United States of America\\', \\'lat\\': 37.78, \\'lon\\': -122.42, \\'tz_id\\': \\'America/Los_Angeles\\', \\'localtime_epoch\\': 1718981382, \\'localtime\\': \\'2024-06-21 7:49\\'}, \\'current\\': {\\'last_updated_epoch\\': 1718981100, \\'last_updated\\': \\'2024-06-21 07:45\\', \\'temp_c\\': 12.8, \\'temp_f\\': 55.0, \\'is_day\\': 1, \\'condition\\': {\\'text\\': \\'Overcast\\', \\'icon\\': \\'//cdn.weatherapi.com/weather/64x64/day/122.png\\', \\'code\\': 1009}, \\'wind_mph\\': 6.9, \\'wind_kph\\': 11.2, \\'wind_degree\\': 200, \\'wind_dir\\': \\'SSW\\', \\'pressure_mb\\': 1011.0, \\'pressure_in\\': 29.84, \\'precip_mm\\': 0.01, \\'precip_in\\': 0.0, \\'humidity\\': 86, \\'cloud\\': 100, \\'feelslike_c\\': 12.2, \\'feelslike_f\\': 53.9, \\'windchill_c\\': 11.2, \\'windchill_f\\': 52.1, \\'heatindex_c\\': 12.0, \\'heatindex_f\\': 53.5, \\'dewpoint_c\\': 9.4, \\'dewpoint_f\\': 48.8, \\'vis_km\\': 16.0, \\'vis_miles\\': 9.0, \\'uv\\': 3.0, \\'gust_mph\\': 7.6, \\'gust_kph\\': 12.2}}\"}]',\n",
-       "    'additional_kwargs': {},\n",
-       "    'response_metadata': {},\n",
-       "    'type': 'tool',\n",
-       "    'name': 'tavily_search_results_json',\n",
-       "    'id': 'c80a3720-6a9f-4ff0-9ce2-6112e66a6f81',\n",
-       "    'tool_call_id': 'toolu_01RLJEcWYRvRoBhiHdrhoRZx'},\n",
-       "   {'content': 'The updated search provides the current weather forecast for San Francisco. According to the results, as of 7:49am on June 21, 2024 in San Francisco, the temperature is 55°F (12.8°C), it is overcast with 100% cloud cover, and there are light winds from the south-southwest around 7 mph (11 km/h). The forecast also shows low precipitation of 0.01 mm, high humidity of 86%, and visibility of 9 miles (16 km).\\n\\nIn summary, the current weather in San Francisco is cool, overcast, and breezy based on this weather forecast data. Let me know if you need any other details!',\n",
-       "    'additional_kwargs': {},\n",
-       "    'response_metadata': {},\n",
-       "    'type': 'ai',\n",
-       "    'name': None,\n",
-       "    'id': 'run-4f23b53d-a8ec-4038-b3ed-08b2560bf81c',\n",
-       "    'example': False,\n",
-       "    'tool_calls': [],\n",
-       "    'invalid_tool_calls': [],\n",
-       "    'usage_metadata': None}]},\n",
-       " 'next': [],\n",
-       " 'config': {'configurable': {'thread_id': '5fc20631-47b7-48cd-8aa2-9f2eace9778d',\n",
-       "   'thread_ts': '1ef2fdea-f879-65a5-8005-443b6a4039aa'}},\n",
-       " 'metadata': {'step': 5,\n",
-       "  'run_id': '1ef2fdea-814c-6165-8b2a-a40e2a028198',\n",
-       "  'source': 'loop',\n",
-       "  'writes': {'agent': {'messages': [{'id': 'run-4f23b53d-a8ec-4038-b3ed-08b2560bf81c',\n",
-       "      'name': None,\n",
-       "      'type': 'ai',\n",
-       "      'content': 'The updated search provides the current weather forecast for San Francisco. According to the results, as of 7:49am on June 21, 2024 in San Francisco, the temperature is 55°F (12.8°C), it is overcast with 100% cloud cover, and there are light winds from the south-southwest around 7 mph (11 km/h). The forecast also shows low precipitation of 0.01 mm, high humidity of 86%, and visibility of 9 miles (16 km).\\n\\nIn summary, the current weather in San Francisco is cool, overcast, and breezy based on this weather forecast data. Let me know if you need any other details!',\n",
-       "      'example': False,\n",
-       "      'tool_calls': [],\n",
-       "      'usage_metadata': None,\n",
-       "      'additional_kwargs': {},\n",
-       "      'response_metadata': {},\n",
-       "      'invalid_tool_calls': []}]}},\n",
-       "  'user_id': '',\n",
-       "  'graph_id': 'agent',\n",
-       "  'thread_id': '5fc20631-47b7-48cd-8aa2-9f2eace9778d',\n",
-       "  'created_by': 'system',\n",
-       "  'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'},\n",
-       " 'created_at': '2024-06-21T14:58:14.591805+00:00',\n",
-       " 'parent_config': {'configurable': {'thread_id': '5fc20631-47b7-48cd-8aa2-9f2eace9778d',\n",
-       "   'thread_ts': '1ef2fdea-d44c-6fc4-8004-d2713436777d'}}}"
-      ]
-     },
-     "execution_count": 11,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "final_result"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "id": "ddd6e698-4609-4389-b84a-bb8939fff08b",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'The updated search provides the current weather forecast for San Francisco. According to the results, as of 7:49am on June 21, 2024 in San Francisco, the temperature is 55°F (12.8°C), it is overcast with 100% cloud cover, and there are light winds from the south-southwest around 7 mph (11 km/h). The forecast also shows low precipitation of 0.01 mm, high humidity of 86%, and visibility of 9 miles (16 km).\\n\\nIn summary, the current weather in San Francisco is cool, overcast, and breezy based on this weather forecast data. Let me know if you need any other details!'"
-      ]
-     },
-     "execution_count": 12,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# We can get the content of the final message\n",
-    "final_result[\"values\"][\"messages\"][-1][\"content\"]"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "langgraph-example-dev",
-   "language": "python",
-   "name": "langgraph-example-dev"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.11.9"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

examples/cloud_examples/configuration_cloud.ipynb

@@ -1,206 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "68c0837d-c40a-4209-9f88-5d08c00c31b0",
-   "metadata": {},
-   "source": [
-    "# How to create agents with configuration\n",
-    "\n",
-    "One of the benefits of LangGraph API is that it lets you create agents with different configurations.\n",
-    "This is useful when you want to:\n",
-    "\n",
-    "- Define a cognitive architecture once as a LangGraph\n",
-    "- Let that LangGraph be configurable across some attributes (for example, system message or LLM to use)\n",
-    "- Let users create agents with arbitrary configurations, save them, and then use them in the future\n",
-    "\n",
-    "In this guide we will show how to do that for the default agent we have built in.\n",
-    "\n",
-    "If you look at the agent we defined, you can see that inside the `call_model` node we have created the model based on some configuration. That node looks like:\n",
-    "\n",
-    "```python\n",
-    "def call_model(state, config):\n",
-    "    messages = state[\"messages\"]\n",
-    "    model_name = config.get('configurable', {}).get(\"model_name\", \"anthropic\")\n",
-    "    model = _get_model(model_name)\n",
-    "    response = model.invoke(messages)\n",
-    "    # We return a list, because this will get added to the existing list\n",
-    "    return {\"messages\": [response]}\n",
-    "```\n",
-    "\n",
-    "We are looking inside the config for a `model_name` parameter (which defaults to `anthropic` if none is found).\n",
-    "That means that by default we are using Anthropic as our model provider.\n",
-    "In this example we will see an example of how to create an example agent that is configured to use OpenAI.\n",
-    "\n",
-    "We've also communicated to the graph that it should expect configuration with this key. \n",
-    "We've done this by passing `config_schema` when constructing the graph, eg:\n",
-    "\n",
-    "```python\n",
-    "class GraphConfig(TypedDict):\n",
-    "    model_name: Literal[\"anthropic\", \"openai\"]\n",
-    "\n",
-    "\n",
-    "# Define a new graph\n",
-    "workflow = StateGraph(AgentState, config_schema=GraphConfig)\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "id": "f69c9a4f-2ef9-4998-827b-fe86d12bfd76",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langgraph_sdk import get_client\n",
-    "\n",
-    "client = get_client()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "id": "9a37bfb5-7331-4004-8054-508838e54f18",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# First, let's check what valid configuration can be\n",
-    "# We can do this by getting the default assistant\n",
-    "# There should always be a default assistant with no configuration\n",
-    "assistants = await client.assistants.search()\n",
-    "assistants = [a for a in assistants if not a[\"config\"]]\n",
-    "base_assistant = assistants[0]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "id": "70193a08-127c-44b3-a102-10db260d7e3b",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'model_name': {'title': 'Model Name',\n",
-       "  'enum': ['anthropic', 'openai'],\n",
-       "  'type': 'string'}}"
-      ]
-     },
-     "execution_count": 17,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# We can now call `.get_schemas` to get schemas associated with this graph\n",
-    "schemas = await client.assistants.get_schemas(\n",
-    "    assistant_id=base_assistant[\"assistant_id\"]\n",
-    ")\n",
-    "# There are multiple types of schemas\n",
-    "# We can get the `config_schema` to look at the the configurable parameters\n",
-    "schemas[\"config_schema\"][\"definitions\"][\"Configurable\"][\"properties\"]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "id": "99be5aee-9a6b-4515-b72f-ba135a893c65",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "assistant = await client.assistants.create(\n",
-    "    graph_id=\"agent\", config={\"configurable\": {\"model_name\": \"openai\"}}\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "4f10d346-69e6-44f4-8ff0-ef539ba938df",
-   "metadata": {},
-   "source": [
-    "We can see that this assistant has saved the config"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "id": "3898ca35-eb2c-4b12-97ea-e0cc6a7c6a2e",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'assistant_id': '40a3a2bf-5319-4fae-a2ac-05e075615cdc',\n",
-       " 'graph_id': 'agent',\n",
-       " 'config': {'configurable': {'model_name': 'openai'}},\n",
-       " 'created_at': '2024-06-05T23:12:30.519458+00:00',\n",
-       " 'updated_at': '2024-06-05T23:12:30.519458+00:00',\n",
-       " 'metadata': {}}"
-      ]
-     },
-     "execution_count": 20,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "assistant"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 21,
-   "id": "68ed7a1b-74be-4560-8c55-c76d49d3d348",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "StreamPart(event='metadata', data={'run_id': '1ef23911-c23b-6d8c-b1dc-94bb982ca7b1'})\n",
-      "StreamPart(event='values', data={'messages': [{'role': 'user', 'content': 'who made you?'}]})\n",
-      "StreamPart(event='values', data={'messages': [{'content': 'who made you?', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': 'ed93c1c9-80d6-4f2b-a048-ef859ea533f9', 'example': False}, {'content': 'I was created by OpenAI, a research organization focused on developing and advancing artificial intelligence technology.', 'additional_kwargs': {}, 'response_metadata': {'finish_reason': 'stop'}, 'type': 'ai', 'name': None, 'id': 'run-6560cd65-5c9c-434b-8835-0baadc684760', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]})\n",
-      "StreamPart(event='end', data=None)\n"
-     ]
-    }
-   ],
-   "source": [
-    "thread = await client.threads.create()\n",
-    "input = {\"messages\": [{\"role\": \"user\", \"content\": \"who made you?\"}]}\n",
-    "async for event in client.runs.stream(\n",
-    "    thread[\"thread_id\"], assistant[\"assistant_id\"], input=input\n",
-    "):\n",
-    "    print(event)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "666d78f1-019a-433e-839e-52d2ebb3d9c8",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.11.1"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

examples/cloud_examples/cron_jobs.ipynb

@@ -1,132 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Cron Jobs\n",
-    "\n",
-    "Sometimes you don't want to run your graph based on user interaction, but rather you would like to schedule your graph to run on a schedule - for example if you wish for your graph to compose and send out a weekly email of to-dos for your team. LangGraph Cloud allows you to do this without having to write your own script by using the `Crons` client. To schedule a graph job, you need to pass a [cron expression](https://crontab.cronhub.io/) to inform the client when you want to run the graph. `Cron` jobs are run in the background and do not interfere with normal invocations of the graph.\n",
-    "\n",
-    "## Setup\n",
-    "\n",
-    "First, let's setup our SDK client, assistant, and thread:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 110,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langgraph_sdk import get_client\n",
-    "\n",
-    "client = get_client()\n",
-    "assistants = await client.assistants.search()\n",
-    "assistants = [a for a in assistants if not a[\"config\"]]\n",
-    "assistant = assistants[0]\n",
-    "thread = await client.threads.create()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Cron job on a thread \n",
-    "\n",
-    "To create a cron job associated with a specific thread, you can write:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# This schedules a job to run at 15:27 (3:27PM) every day\n",
-    "cron_1 = await client.crons.create_for_thread(\n",
-    "    thread[\"thread_id\"],\n",
-    "    assistant[\"assistant_id\"],\n",
-    "    schedule=\"27 15 * * *\",\n",
-    "    input={\"messages\": [{\"role\": \"user\", \"content\": \"What time is it?\"}]},\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Note that it is **very** important to delete `Cron` jobs that are no longer useful. Otherwise you could rack up unwanted API charges to the LLM! You can delete a `Cron` job using the following code:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "await client.crons.delete(cron_1[\"cron_id\"])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Cron job stateless\n",
-    "\n",
-    "You can also create stateless cron jobs by using the following code:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# This schedules a job to run at 15:27 (3:27PM) every day\n",
-    "cron_2 = await client.crons.create(\n",
-    "    assistant[\"assistant_id\"],\n",
-    "    schedule=\"27 15 * * *\",\n",
-    "    input={\"messages\": [{\"role\": \"user\", \"content\": \"What time is it?\"}]},\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Again, remember to delete your job once you are done with it!"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "await client.crons.delete(cron_2[\"cron_id\"])"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.11.9"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

examples/cloud_examples/same-thread.ipynb

@@ -1,200 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "68c0837d-c40a-4209-9f88-5d08c00c31b0",
-   "metadata": {},
-   "source": [
-    "# How to run multiple agents on the same thread\n",
-    "\n",
-    "In LangGraph Cloud, a thread is not explicitly associated with a particular agent.\n",
-    "This means that you can run multiple agents on the same thread, which allows a different\n",
-    "agent to continue from an initial agent's progress.\n",
-    "\n",
-    "In this example, we will create two agents and then call them both on the same thread.\n",
-    "You'll see that the second agent will respond using information from the [checkpoint](https://langchain-ai.github.io/langgraph/concepts/low_level/#checkpointer-state) generated in the thread\n",
-    "by the first agent as context."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "e06be1f6-07a5-4e93-8497-02473fc65d4f",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langgraph_sdk import get_client\n",
-    "\n",
-    "client = get_client()\n",
-    "\n",
-    "openai_assistant = await client.assistants.create(\n",
-    "    graph_id=\"agent\", config={\"configurable\": {\"model_name\": \"openai\"}}\n",
-    ")\n",
-    "\n",
-    "# There should always be a default assistant with no configuration\n",
-    "assistants = await client.assistants.search()\n",
-    "default_assistant = [a for a in assistants if not a[\"config\"]][0]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "4f10d346-69e6-44f4-8ff0-ef539ba938df",
-   "metadata": {},
-   "source": [
-    "We can see that these agents are different:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "3898ca35-eb2c-4b12-97ea-e0cc6a7c6a2e",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'assistant_id': '13ecc353-a9a9-474b-a824-b6a343cd74b1',\n",
-       " 'graph_id': 'agent',\n",
-       " 'config': {'configurable': {'model_name': 'openai'}},\n",
-       " 'created_at': '2024-05-21T16:22:59.258447+00:00',\n",
-       " 'updated_at': '2024-05-21T16:22:59.258447+00:00',\n",
-       " 'metadata': {}}"
-      ]
-     },
-     "execution_count": 8,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "openai_assistant"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "a8fa67b2-cb4f-43d3-a1fc-f8b3936c16b6",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca',\n",
-       " 'graph_id': 'agent',\n",
-       " 'config': {},\n",
-       " 'created_at': '2024-05-18T00:19:39.688822+00:00',\n",
-       " 'updated_at': '2024-05-18T00:19:39.688822+00:00',\n",
-       " 'metadata': {'created_by': 'system'}}"
-      ]
-     },
-     "execution_count": 9,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "default_assistant"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "5e655e61-c2ee-488a-90f6-6189c84841da",
-   "metadata": {},
-   "source": [
-    "We can now run the OpenAI assistant on the thread first."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "id": "68ed7a1b-74be-4560-8c55-c76d49d3d348",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "StreamPart(event='metadata', data={'run_id': 'f90b3029-8669-4d70-976c-b70368e355d8'})\n",
-      "StreamPart(event='updates', data={'agent': {'messages': [{'content': 'I was created by OpenAI, a research organization focused on developing and advancing artificial intelligence technology.', 'additional_kwargs': {}, 'response_metadata': {'finish_reason': 'stop'}, 'type': 'ai', 'name': None, 'id': 'run-9801a5ba-2f3c-43de-89cf-c740debf36fc', 'example': False, 'tool_calls': [], 'invalid_tool_calls': []}]}})\n",
-      "StreamPart(event='end', data=None)\n"
-     ]
-    }
-   ],
-   "source": [
-    "thread = await client.threads.create()\n",
-    "input = {\"messages\": [{\"role\": \"user\", \"content\": \"who made you?\"}]}\n",
-    "async for event in client.runs.stream(\n",
-    "    thread[\"thread_id\"],\n",
-    "    openai_assistant[\"assistant_id\"],\n",
-    "    input=input,\n",
-    "    stream_mode=\"updates\",\n",
-    "):\n",
-    "    print(event)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "c53709e9-ddb2-4429-9042-456eb6c91244",
-   "metadata": {},
-   "source": [
-    "Now, we can run it on a second Anthropic-based assistant and see that this second assistant is aware of the initial question, and can answer the question, `and you?`:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "id": "666d78f1-019a-433e-839e-52d2ebb3d9c8",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "StreamPart(event='metadata', data={'run_id': 'c3521302-48ae-4c29-a0f2-5eb865cbc6d7'})\n",
-      "StreamPart(event='updates', data={'agent': {'messages': [{'content': \"I am an AI assistant created by Anthropic to be helpful, harmless, and honest. I don't actually have a physical form or visual representation - I exist as a language model trained to have natural conversations.\", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-4d05ffd7-0505-43e1-a068-0207c56b7665', 'example': False, 'tool_calls': [], 'invalid_tool_calls': []}]}})\n",
-      "StreamPart(event='end', data=None)\n"
-     ]
-    }
-   ],
-   "source": [
-    "input = {\"messages\": [{\"role\": \"user\", \"content\": \"and you?\"}]}\n",
-    "async for event in client.runs.stream(\n",
-    "    thread[\"thread_id\"],\n",
-    "    default_assistant[\"assistant_id\"],\n",
-    "    input=input,\n",
-    "    stream_mode=\"updates\",\n",
-    "):\n",
-    "    print(event)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "4c26df68-c447-4a88-bc94-59df42b117b5",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.11.1"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

examples/cloud_examples/stateless_runs.ipynb

@@ -1,152 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Stateless Runs\n",
-    "\n",
-    "Most of the time, you provide a `thread_id` to your client when you run your graph in order to keep track of prior runs through the persistent state implemented in LangGraph Cloud. However, if you have your own database to save runs and don't need to use the built in persistent state, you can create stateless runs.\n",
-    "\n",
-    "## Setup\n",
-    "\n",
-    "First, let's setup our client"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 106,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langgraph_sdk import get_client\n",
-    "\n",
-    "client = get_client()\n",
-    "assistants = await client.assistants.search()\n",
-    "assistants = [a for a in assistants if not a[\"config\"]]\n",
-    "assistant = assistants[0]\n",
-    "thread = await client.threads.create()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Stateless streaming\n",
-    "\n",
-    "We can stream the results of a stateless run in an almost identical fashion to how we stream from a run with the state attribute, but instead of passing a value to the `thread_id` parameter, we pass `None`:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 107,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{'agent': {'messages': [{'content': \"Hello Bagatur! It's nice to meet you. Thank you for introducing yourself and sharing your age. Is there anything specific you'd like to know or discuss? I'm here to help with any questions or topics you're interested in.\", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-489ec573-1645-4ce2-a3b8-91b391d50a71', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]}}\n"
-     ]
-    }
-   ],
-   "source": [
-    "input = {\n",
-    "    \"messages\": [\n",
-    "        {\"role\": \"user\", \"content\": \"Hello! My name is Bagatur and I am 26 years old.\"}\n",
-    "    ]\n",
-    "}\n",
-    "\n",
-    "\n",
-    "async for chunk in client.runs.stream(\n",
-    "    # Don't pass in a thread_id and the stream will be stateless\n",
-    "    None,\n",
-    "    assistant[\"assistant_id\"],  # graph_id\n",
-    "    input=input,\n",
-    "    stream_mode=\"updates\",\n",
-    "):\n",
-    "    if chunk.data and \"run_id\" not in chunk.data:\n",
-    "        print(chunk.data)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Waiting for stateless results\n",
-    "\n",
-    "In addition to streaming, you can also wait for a stateless result by using the `.wait` function like follows:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 108,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "stateless_run_result = await client.runs.wait(\n",
-    "    None,\n",
-    "    assistant[\"assistant_id\"],  # graph_id\n",
-    "    input=input,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 109,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'messages': [{'content': 'Hello! My name is Bagatur and I am 26 years old.',\n",
-       "   'additional_kwargs': {},\n",
-       "   'response_metadata': {},\n",
-       "   'type': 'human',\n",
-       "   'name': None,\n",
-       "   'id': '5e088543-62c2-43de-9d95-6086ad7f8b48',\n",
-       "   'example': False},\n",
-       "  {'content': \"Hello Bagatur! It's nice to meet you. Thank you for introducing yourself and sharing your age. Is there anything specific you'd like to know or discuss? I'm here to help with any questions or topics you'd like to explore.\",\n",
-       "   'additional_kwargs': {},\n",
-       "   'response_metadata': {},\n",
-       "   'type': 'ai',\n",
-       "   'name': None,\n",
-       "   'id': 'run-d6361e8d-4d4c-45bd-ba47-39520257f773',\n",
-       "   'example': False,\n",
-       "   'tool_calls': [],\n",
-       "   'invalid_tool_calls': [],\n",
-       "   'usage_metadata': None}]}"
-      ]
-     },
-     "execution_count": 109,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "stateless_run_result"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.11.9"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

examples/cloud_examples/webhooks.ipynb

@@ -1,72 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Use Webhooks\n",
-    "\n",
-    "You may wish to use webhooks in your client, especially when using async streams in case you want to update something in your service once the API call to LangGraph Cloud has finished running. To do so, you will need to expose an endpoint that can accept POST requests, and then pass it to your API request in the \"webhook\" parameter.\n",
-    "\n",
-    "Currently, the SDK has not exposed this endpoint but you can access it through curl commands as follows.\n",
-    "\n",
-    "The following endpoints accept `webhook` as a parameter: \n",
-    "\n",
-    "- Create Run -> POST /thread/{thread_id}/runs\n",
-    "- Create Thread Cron -> POST /thread/{thread_id}/runs/crons\n",
-    "- Stream Run -> POST /thread/{thread_id}/runs/stream\n",
-    "- Wait Run -> POST /thread/{thread_id}/runs/wait\n",
-    "- Create Cron -> POST /runs/crons\n",
-    "- Stream Run Stateless -> POST /runs/stream\n",
-    "- Wait Run Stateless -> POST /runs/wait\n",
-    "\n",
-    "The following example uses a url from a public website that allows users to create free webhooks, but you should pass in the webhook that you wish to use. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "curl --request POST \\\n",
-    "  --url http://localhost:8123/threads/b76d1e94-f251-40e3-8933-796d775cdb4c/runs/stream \\\n",
-    "  --header 'Content-Type: application/json' \\\n",
-    "  --data '{\n",
-    "  \"assistant_id\": \"fe096781-5601-53d2-b2f6-0d3403f7e9ca\",\n",
-    "  \"input\" : {\"messages\":[{\"role\": \"user\", \"content\": \"Hello! My name is Bagatur and I am 26 years old.\"}]},\n",
-    "  \"metadata\": {},\n",
-    "  \"config\": {\n",
-    "    \"configurable\": {}\n",
-    "  },\n",
-    "  \"multitask_strategy\": \"reject\",\n",
-    "  \"stream_mode\": [\n",
-    "    \"values\"\n",
-    "  ],\n",
-    " \"webhook\": \"https://webhook.site/6ca33471-dd65-4103-a851-0a252dae0f2a\"\n",
-    "}'"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "To check that this worked as intended, we can go to the website where our webhook was created and confirm that it received a POST request:"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "![Webhook response](./img/webhook_results.png)"
-   ]
-  }
- ],
- "metadata": {
-  "language_info": {
-   "name": "python"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

examples/configuration.ipynb

@@ -24,15 +24,43 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 1,
    "id": "816523d0-0b59-47cf-9f4c-4838024efe22",
    "metadata": {},
    "outputs": [],
-   "source": ["import operator\nfrom typing import Annotated, Sequence, TypedDict\n\nfrom langchain_anthropic import ChatAnthropic\nfrom langchain_core.messages import BaseMessage, HumanMessage\n\nfrom langgraph.graph import END, StateGraph, START\n\nmodel = ChatAnthropic(model_name=\"claude-2.1\")\n\n\nclass AgentState(TypedDict):\n    messages: Annotated[Sequence[BaseMessage], operator.add]\n\n\ndef _call_model(state):\n    response = model.invoke(state[\"messages\"])\n    return {\"messages\": [response]}\n\n\n# Define a new graph\nworkflow = StateGraph(AgentState)\nworkflow.add_node(\"model\", _call_model)\nworkflow.add_edge(START, \"model\")\nworkflow.add_edge(\"model\", END)\n\napp = workflow.compile()"]
+   "source": [
+    "import operator\n",
+    "from typing import Annotated, Sequence, TypedDict\n",
+    "\n",
+    "from langchain_anthropic import ChatAnthropic\n",
+    "from langchain_core.messages import BaseMessage, HumanMessage\n",
+    "\n",
+    "from langgraph.graph import END, StateGraph, START\n",
+    "\n",
+    "model = ChatAnthropic(model_name=\"claude-2.1\")\n",
+    "\n",
+    "\n",
+    "class AgentState(TypedDict):\n",
+    "    messages: Annotated[Sequence[BaseMessage], operator.add]\n",
+    "\n",
+    "\n",
+    "def _call_model(state):\n",
+    "    response = model.invoke(state[\"messages\"])\n",
+    "    return {\"messages\": [response]}\n",
+    "\n",
+    "\n",
+    "# Define a new graph\n",
+    "workflow = StateGraph(AgentState)\n",
+    "workflow.add_node(\"model\", _call_model)\n",
+    "workflow.add_edge(START, \"model\")\n",
+    "workflow.add_edge(\"model\", END)\n",
+    "\n",
+    "app = workflow.compile()"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 2,
    "id": "070f11a6-2441-4db5-9df6-e318f110e281",
    "metadata": {},
    "outputs": [
@@ -40,15 +68,17 @@
      "data": {
       "text/plain": [
        "{'messages': [HumanMessage(content='hi'),\n",
-       "  AIMessage(content='Hello!', response_metadata={'id': 'msg_01YZj7CVCUSc76faX4VM9i5d', 'model': 'claude-2.1', 'stop_reason': 'end_turn', 'stop_sequence': None, 'usage': {'input_tokens': 10, 'output_tokens': 6}}, id='run-d343db34-598c-46a2-93d6-ffa886d9b264-0')]}"
+       "  AIMessage(content='Hello!', response_metadata={'id': 'msg_012SakNGNitBcKJgc9yZ1Asv', 'model': 'claude-2.1', 'stop_reason': 'end_turn', 'stop_sequence': None, 'usage': {'input_tokens': 10, 'output_tokens': 6}}, id='run-9e375cd7-ae84-4db2-981c-c7e18ecabddf-0', usage_metadata={'input_tokens': 10, 'output_tokens': 6, 'total_tokens': 16})]}"
       ]
      },
-     "execution_count": 8,
+     "execution_count": 2,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
-   "source": ["app.invoke({\"messages\": [HumanMessage(content=\"hi\")]})"]
+   "source": [
+    "app.invoke({\"messages\": [HumanMessage(content=\"hi\")]})"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -58,17 +88,44 @@
     "## Configure the graph\n",
     "\n",
     "Great! Now let's suppose that we want to extend this example so the user is able to choose from multiple llms.\n",
-    "We can easily do that by passing in a config.\n",
+    "We can easily do that by passing in a config. Any configuration information needs to be passed inside `configurable` key as shown below.\n",
     "This config is meant to contain things are not part of the input (and therefore that we don't want to track as part of the state)."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 6,
    "id": "c01f1e7c-8e8b-4e26-98f7-56ac225077b4",
    "metadata": {},
    "outputs": [],
-   "source": ["from langchain_openai import ChatOpenAI\n\nopenai_model = ChatOpenAI()\n\nmodels = {\n    \"anthropic\": model,\n    \"openai\": openai_model,\n}\n\n\ndef _call_model(state, config):\n    m = models[config[\"configurable\"].get(\"model\", \"anthropic\")]\n    response = m.invoke(state[\"messages\"])\n    return {\"messages\": [response]}\n\n\n# Define a new graph\nworkflow = StateGraph(AgentState)\nworkflow.add_node(\"model\", _call_model)\nworkflow.add_edge(START, \"model\")\nworkflow.add_edge(\"model\", END)\n\napp = workflow.compile()"]
+   "source": [
+    "from langchain_openai import ChatOpenAI\n",
+    "from typing import Optional\n",
+    "from langchain_core.runnables.config import RunnableConfig\n",
+    "\n",
+    "openai_model = ChatOpenAI()\n",
+    "\n",
+    "models = {\n",
+    "    \"anthropic\": model,\n",
+    "    \"openai\": openai_model,\n",
+    "}\n",
+    "\n",
+    "def _call_model(state: AgentState, config: RunnableConfig):\n",
+    "    # Access the config through the configurable key\n",
+    "    model_name = config[\"configurable\"].get(\"model\", \"anthropic\")\n",
+    "    model = models[model_name]\n",
+    "    response = model.invoke(state[\"messages\"])\n",
+    "    return {\"messages\": [response]}\n",
+    "\n",
+    "\n",
+    "# Define a new graph\n",
+    "workflow = StateGraph(AgentState)\n",
+    "workflow.add_node(\"model\", _call_model)\n",
+    "workflow.add_edge(START, \"model\")\n",
+    "workflow.add_edge(\"model\", END)\n",
+    "\n",
+    "app = workflow.compile()"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -80,7 +137,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 7,
    "id": "ef50f048-fc43-40c0-b713-346408fcf052",
    "metadata": {},
    "outputs": [
@@ -88,15 +145,17 @@
      "data": {
       "text/plain": [
        "{'messages': [HumanMessage(content='hi'),\n",
-       "  AIMessage(content='Hello!', response_metadata={'id': 'msg_01EedReFyXmonWXPKhYre7Jb', 'model': 'claude-2.1', 'stop_reason': 'end_turn', 'stop_sequence': None, 'usage': {'input_tokens': 10, 'output_tokens': 6}}, id='run-1c6feaa0-bd6f-433a-8264-209d72c85db7-0')]}"
+       "  AIMessage(content='Hello!', response_metadata={'id': 'msg_0133PAX5DyoUYL1gZiGR8NXs', 'model': 'claude-2.1', 'stop_reason': 'end_turn', 'stop_sequence': None, 'usage': {'input_tokens': 10, 'output_tokens': 6}}, id='run-03e8bd8b-fa09-4258-920d-8f53a7b91fcc-0', usage_metadata={'input_tokens': 10, 'output_tokens': 6, 'total_tokens': 16})]}"
       ]
      },
-     "execution_count": 12,
+     "execution_count": 7,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
-   "source": ["app.invoke({\"messages\": [HumanMessage(content=\"hi\")]})"]
+   "source": [
+    "app.invoke({\"messages\": [HumanMessage(content=\"hi\")]})"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -108,7 +167,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 8,
    "id": "f2f7c74b-9fb0-41c6-9728-dcf9d8a3c397",
    "metadata": {},
    "outputs": [
@@ -116,15 +175,18 @@
      "data": {
       "text/plain": [
        "{'messages': [HumanMessage(content='hi'),\n",
-       "  AIMessage(content='Hello! How can I assist you today?', response_metadata={'token_usage': {'completion_tokens': 9, 'prompt_tokens': 8, 'total_tokens': 17}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': 'fp_3b956da36b', 'finish_reason': 'stop', 'logprobs': None}, id='run-d41ffb62-e164-45a1-862c-d288c6ad100a-0')]}"
+       "  AIMessage(content='Hello! How can I assist you today?', additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 9, 'prompt_tokens': 8, 'total_tokens': 17}, 'model_name': 'gpt-3.5-turbo-0125', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}, id='run-6d0c7c25-03de-49d6-b3be-ff0858d17122-0', usage_metadata={'input_tokens': 8, 'output_tokens': 9, 'total_tokens': 17})]}"
       ]
      },
-     "execution_count": 13,
+     "execution_count": 8,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
-   "source": ["config = {\"configurable\": {\"model\": \"openai\"}}\napp.invoke({\"messages\": [HumanMessage(content=\"hi\")]}, config=config)"]
+   "source": [
+    "config = {\"configurable\": {\"model\": \"openai\"}}\n",
+    "app.invoke({\"messages\": [HumanMessage(content=\"hi\")]}, config=config)"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -136,15 +198,44 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 9,
    "id": "f0393a43-9fbe-4056-972f-3e91ea329041",
    "metadata": {},
    "outputs": [],
-   "source": ["from langchain_core.messages import SystemMessage\n\n\ndef _call_model(state, config):\n    m = models[config[\"configurable\"].get(\"model\", \"anthropic\")]\n    messages = state[\"messages\"]\n    if \"system_message\" in config[\"configurable\"]:\n        messages = [\n            SystemMessage(content=config[\"configurable\"][\"system_message\"])\n        ] + messages\n    response = m.invoke(messages)\n    return {\"messages\": [response]}\n\n\n# Define a new graph\nworkflow = StateGraph(AgentState)\nworkflow.add_node(\"model\", _call_model)\nworkflow.add_edge(START, \"model\")\nworkflow.add_edge(\"model\", END)\n\napp = workflow.compile()"]
+   "source": [
+    "from langchain_core.messages import SystemMessage\n",
+    "\n",
+    "# We can define a config schema to specify the configuration options for the graph\n",
+    "# A config schema is useful for indicating which fields are available in the configurable dict inside the config\n",
+    "class ConfigSchema(TypedDict):\n",
+    "    model: Optional[str]\n",
+    "    system_message: Optional[str]\n",
+    "\n",
+    "def _call_model(state: AgentState, config: RunnableConfig):\n",
+    "    # Access the config through the configurable key\n",
+    "    model_name = config[\"configurable\"].get(\"model\", \"anthropic\")\n",
+    "    model = models[model_name]\n",
+    "    messages = state[\"messages\"]\n",
+    "    if \"system_message\" in config[\"configurable\"]:\n",
+    "        messages = [\n",
+    "            SystemMessage(content=config[\"configurable\"][\"system_message\"])\n",
+    "        ] + messages\n",
+    "    response = model.invoke(messages)\n",
+    "    return {\"messages\": [response]}\n",
+    "\n",
+    "\n",
+    "# Define a new graph - note that we pass in the configuration schema here, but it is not necessary\n",
+    "workflow = StateGraph(AgentState, ConfigSchema)\n",
+    "workflow.add_node(\"model\", _call_model)\n",
+    "workflow.add_edge(START, \"model\")\n",
+    "workflow.add_edge(\"model\", END)\n",
+    "\n",
+    "app = workflow.compile()"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 10,
    "id": "718685f7-4cdd-4181-9fc8-e7762d584727",
    "metadata": {},
    "outputs": [
@@ -152,19 +243,21 @@
      "data": {
       "text/plain": [
        "{'messages': [HumanMessage(content='hi'),\n",
-       "  AIMessage(content='Hello!', response_metadata={'id': 'msg_01Ts56eVLSrUbzVMbzLnXc3M', 'model': 'claude-2.1', 'stop_reason': 'end_turn', 'stop_sequence': None, 'usage': {'input_tokens': 10, 'output_tokens': 6}}, id='run-f75a4389-b72e-4d47-8f3e-bedc6a060f66-0')]}"
+       "  AIMessage(content='Hello!', response_metadata={'id': 'msg_01TVJvxCXsCT9JVe7A4iUUi9', 'model': 'claude-2.1', 'stop_reason': 'end_turn', 'stop_sequence': None, 'usage': {'input_tokens': 10, 'output_tokens': 6}}, id='run-627eb685-c4d7-481d-9095-c0a1822e8c10-0', usage_metadata={'input_tokens': 10, 'output_tokens': 6, 'total_tokens': 16})]}"
       ]
      },
-     "execution_count": 19,
+     "execution_count": 10,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
-   "source": ["app.invoke({\"messages\": [HumanMessage(content=\"hi\")]})"]
+   "source": [
+    "app.invoke({\"messages\": [HumanMessage(content=\"hi\")]})"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 11,
    "id": "e043a719-f197-46ef-9d45-84740a39aeb0",
    "metadata": {},
    "outputs": [
@@ -172,23 +265,18 @@
      "data": {
       "text/plain": [
        "{'messages': [HumanMessage(content='hi'),\n",
-       "  AIMessage(content='Ciao!', response_metadata={'id': 'msg_01RzFCii8WhbbkFm16nUquxk', 'model': 'claude-2.1', 'stop_reason': 'end_turn', 'stop_sequence': None, 'usage': {'input_tokens': 14, 'output_tokens': 7}}, id='run-9492f0e4-f223-41c2-81a6-6f0cb6a14fe6-0')]}"
+       "  AIMessage(content='Ciao!', response_metadata={'id': 'msg_01CpBD1cMCYvvPX2cogUawJj', 'model': 'claude-2.1', 'stop_reason': 'end_turn', 'stop_sequence': None, 'usage': {'input_tokens': 14, 'output_tokens': 7}}, id='run-6ef2fea6-9bfa-4266-bd05-263160a1db7b-0', usage_metadata={'input_tokens': 14, 'output_tokens': 7, 'total_tokens': 21})]}"
       ]
      },
-     "execution_count": 20,
+     "execution_count": 11,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
-   "source": ["config = {\"configurable\": {\"system_message\": \"respond in italian\"}}\napp.invoke({\"messages\": [HumanMessage(content=\"hi\")]}, config=config)"]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "a5c5f7f4-4b0e-4cde-93a6-c1c6329b8591",
-   "metadata": {},
-   "outputs": [],
-   "source": [""]
+   "source": [
+    "config = {\"configurable\": {\"system_message\": \"respond in italian\"}}\n",
+    "app.invoke({\"messages\": [HumanMessage(content=\"hi\")]}, config=config)"
+   ]
   }
  ],
  "metadata": {
@@ -207,7 +295,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.1"
+   "version": "3.11.9"
   }
  },
  "nbformat": 4,

examples/create-react-agent-hitl.ipynb

@@ -73,7 +73,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 3,
+      "execution_count": 1,
       "id": "7a154152-973e-4b5d-aa13-48c617744a4c",
       "metadata": {},
       "outputs": [],
@@ -92,14 +92,14 @@
         "\n",
         "\n",
         "@tool\n",
-        "def get_weather(city: Literal[\"nyc\", \"sf\"]):\n",
-        "    \"\"\"Use this to get weather information.\"\"\"\n",
-        "    if city == \"nyc\":\n",
+        "def get_weather(location: str):\n",
+        "    \"\"\"Use this to get weather information from a given location.\"\"\"\n",
+        "    if location.lower() in [\"nyc\", \"new york\"]:\n",
         "        return \"It might be cloudy in nyc\"\n",
-        "    elif city == \"sf\":\n",
+        "    elif location.lower() in [\"sf\", \"san francisco\"]:\n",
         "        return \"It's always sunny in sf\"\n",
         "    else:\n",
-        "        raise AssertionError(\"Unknown city\")\n",
+        "        raise AssertionError(\"Unknown Location\")\n",
         "\n",
         "\n",
         "tools = [get_weather]\n",
@@ -144,7 +144,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 4,
+      "execution_count": 3,
       "id": "9ffff6c3-a4f5-47c9-b51d-97caaee85cd6",
       "metadata": {},
       "outputs": [
@@ -154,26 +154,35 @@
           "text": [
             "================================\u001b[1m Human Message \u001b[0m=================================\n",
             "\n",
-            "What's the weather in SF?\n",
+            "what is the weather in SF?\n",
             "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
             "Tool Calls:\n",
-            "  get_weather (call_0OMmuTLec9t8kxMVkllZCSxo)\n",
-            " Call ID: call_0OMmuTLec9t8kxMVkllZCSxo\n",
+            "  get_weather (call_TcDfLuoCKLmQ7eG71SedxLZ6)\n",
+            " Call ID: call_TcDfLuoCKLmQ7eG71SedxLZ6\n",
             "  Args:\n",
-            "    city: sf\n"
+            "    location: San Francisco, CA\n"
           ]
         }
       ],
       "source": [
+        "from langchain_core.messages import HumanMessage\n",
         "config = {\"configurable\": {\"thread_id\": \"42\"}}\n",
-        "inputs = {\"messages\": [(\"user\", \"What's the weather in SF?\")]}\n",
+        "inputs = {\"messages\": [(\"user\", \"what is the weather in SF?\")]}\n",
         "\n",
         "print_stream(graph.stream(inputs, config, stream_mode=\"values\"))"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "id": "ca40a719",
+      "metadata": {},
+      "source": [
+        "We can verify that our graph stopped at the right place:"
+      ]
+    },
     {
       "cell_type": "code",
-      "execution_count": 5,
+      "execution_count": 4,
       "id": "3decf001-7228-4ed5-8779-2b9ed98a74ea",
       "metadata": {},
       "outputs": [
@@ -190,9 +199,87 @@
         "print(\"Next step: \", snapshot.next)"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "id": "7de6ca78",
+      "metadata": {},
+      "source": [
+        "Now we can either approve or edit the tool call before proceeding to the next node. If we wanted to approve the tool call, we would simply continue streaming the graph with `None` input. If we wanted to edit the tool call we need to update the state to have the correct tool call, and then after the update has been applied we can continue.\n",
+        "\n",
+        "We can try resuming and we will see an error arise:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 5,
+      "id": "740bbaeb",
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "=================================\u001b[1m Tool Message \u001b[0m=================================\n",
+            "Name: get_weather\n",
+            "\n",
+            "Error: AssertionError('Unknown Location')\n",
+            " Please fix your mistakes.\n",
+            "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+            "\n",
+            "It seems there was an issue with the location provided. Let's try specifying \"San Francisco, California\" more clearly.\n",
+            "Tool Calls:\n",
+            "  get_weather (call_TZm9HCShGNEreglVJcmUdXqG)\n",
+            " Call ID: call_TZm9HCShGNEreglVJcmUdXqG\n",
+            "  Args:\n",
+            "    location: San Francisco, California\n"
+          ]
+        }
+      ],
+      "source": [
+        "print_stream(graph.stream(None, config, stream_mode=\"values\"))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "c1cf5950",
+      "metadata": {},
+      "source": [
+        "This error arose because our tool argument of \"San Francisco, CA\" is not a location our tool recognizes.\n",
+        "\n",
+        "Let's show how we would edit the tool call to search for \"San Francisco\" instead of \"San Francisco, CA\" - since our tool as written treats \"San Francisco, CA\" as an unknown location. We will update the state and then resume streaming the graph and should see no errors arise:"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 6,
+      "id": "1c81ed9f",
+      "metadata": {},
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "{'configurable': {'thread_id': '42',\n",
+              "  'checkpoint_ns': '',\n",
+              "  'checkpoint_id': '1ef66368-9772-67ea-8004-07c779869a0a'}}"
+            ]
+          },
+          "execution_count": 6,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "state = graph.get_state(config)\n",
+        "\n",
+        "last_message = state.values['messages'][-1]\n",
+        "last_message.tool_calls[0]['args'] = {\"location\": \"San Francisco\"}\n",
+        "\n",
+        "graph.update_state(config, {\"messages\": [ last_message]})"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 7,
       "id": "83148e08-63e8-49e5-a08b-02dc907bed1d",
       "metadata": {},
       "outputs": [
@@ -206,7 +293,7 @@
             "It's always sunny in sf\n",
             "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
             "\n",
-            "The weather in San Francisco is currently sunny.\n"
+            "The weather in San Francisco is currently sunny. Enjoy the sunshine!\n"
           ]
         }
       ],
@@ -215,12 +302,12 @@
       ]
     },
     {
-      "cell_type": "code",
-      "execution_count": null,
-      "id": "6f6f8965-b016-4e25-be63-31c00fc0a6de",
+      "cell_type": "markdown",
+      "id": "8202a5f9",
       "metadata": {},
-      "outputs": [],
-      "source": []
+      "source": [
+        "Fantastic! Our graph updated properly to query the weather in San Francisco and got the correct \"It's always sunny in sf\" response from the tool, and then responded to the user accordingly."
+      ]
     }
   ],
   "metadata": {
@@ -239,7 +326,7 @@
       "name": "python",
       "nbconvert_exporter": "python",
       "pygments_lexer": "ipython3",
-      "version": "3.11.1"
+      "version": "3.11.9"
     }
   },
   "nbformat": 4,

examples/create-react-agent-memory.ipynb

@@ -221,14 +221,6 @@
         "inputs = {\"messages\": [(\"user\", \"What's it known for?\")]}\n",
         "print_stream(graph.stream(inputs, config=config, stream_mode=\"values\"))"
       ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "id": "3decf001-7228-4ed5-8779-2b9ed98a74ea",
-      "metadata": {},
-      "outputs": [],
-      "source": []
     }
   ],
   "metadata": {

examples/create-react-agent-system-prompt.ipynb

@@ -173,14 +173,6 @@
     "\n",
     "print_stream(graph.stream(inputs, stream_mode=\"values\"))"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "3decf001-7228-4ed5-8779-2b9ed98a74ea",
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {

examples/customer-support/customer-support.ipynb

@@ -99,46 +99,50 @@
     "    # Backup - we will use this to \"reset\" our DB in each section\n",
     "    shutil.copy(local_file, backup_file)\n",
     "# Convert the flights to present time for our tutorial\n",
-    "conn = sqlite3.connect(local_file)\n",
-    "cursor = conn.cursor()\n",
+    "def update_dates(file):\n",
+    "    shutil.copy(backup_file, file)\n",
+    "    conn = sqlite3.connect(file)\n",
+    "    cursor = conn.cursor()\n",
     "\n",
-    "tables = pd.read_sql(\n",
-    "    \"SELECT name FROM sqlite_master WHERE type='table';\", conn\n",
-    ").name.tolist()\n",
-    "tdf = {}\n",
-    "for t in tables:\n",
-    "    tdf[t] = pd.read_sql(f\"SELECT * from {t}\", conn)\n",
+    "    tables = pd.read_sql(\n",
+    "        \"SELECT name FROM sqlite_master WHERE type='table';\", conn\n",
+    "    ).name.tolist()\n",
+    "    tdf = {}\n",
+    "    for t in tables:\n",
+    "        tdf[t] = pd.read_sql(f\"SELECT * from {t}\", conn)\n",
     "\n",
-    "example_time = pd.to_datetime(\n",
-    "    tdf[\"flights\"][\"actual_departure\"].replace(\"\\\\N\", pd.NaT)\n",
-    ").max()\n",
-    "current_time = pd.to_datetime(\"now\").tz_localize(example_time.tz)\n",
-    "time_diff = current_time - example_time\n",
+    "    example_time = pd.to_datetime(\n",
+    "        tdf[\"flights\"][\"actual_departure\"].replace(\"\\\\N\", pd.NaT)\n",
+    "    ).max()\n",
+    "    current_time = pd.to_datetime(\"now\").tz_localize(example_time.tz)\n",
+    "    time_diff = current_time - example_time\n",
     "\n",
-    "tdf[\"bookings\"][\"book_date\"] = (\n",
-    "    pd.to_datetime(tdf[\"bookings\"][\"book_date\"].replace(\"\\\\N\", pd.NaT), utc=True)\n",
-    "    + time_diff\n",
-    ")\n",
-    "\n",
-    "datetime_columns = [\n",
-    "    \"scheduled_departure\",\n",
-    "    \"scheduled_arrival\",\n",
-    "    \"actual_departure\",\n",
-    "    \"actual_arrival\",\n",
-    "]\n",
-    "for column in datetime_columns:\n",
-    "    tdf[\"flights\"][column] = (\n",
-    "        pd.to_datetime(tdf[\"flights\"][column].replace(\"\\\\N\", pd.NaT)) + time_diff\n",
+    "    tdf[\"bookings\"][\"book_date\"] = (\n",
+    "        pd.to_datetime(tdf[\"bookings\"][\"book_date\"].replace(\"\\\\N\", pd.NaT), utc=True)\n",
+    "        + time_diff\n",
     "    )\n",
     "\n",
-    "for table_name, df in tdf.items():\n",
-    "    df.to_sql(table_name, conn, if_exists=\"replace\", index=False)\n",
-    "del df\n",
-    "del tdf\n",
-    "conn.commit()\n",
-    "conn.close()\n",
+    "    datetime_columns = [\n",
+    "        \"scheduled_departure\",\n",
+    "        \"scheduled_arrival\",\n",
+    "        \"actual_departure\",\n",
+    "        \"actual_arrival\",\n",
+    "    ]\n",
+    "    for column in datetime_columns:\n",
+    "        tdf[\"flights\"][column] = (\n",
+    "            pd.to_datetime(tdf[\"flights\"][column].replace(\"\\\\N\", pd.NaT)) + time_diff\n",
+    "        )\n",
     "\n",
-    "db = local_file  # We'll be using this local file as our DB in this tutorial"
+    "    for table_name, df in tdf.items():\n",
+    "        df.to_sql(table_name, conn, if_exists=\"replace\", index=False)\n",
+    "    del df\n",
+    "    del tdf\n",
+    "    conn.commit()\n",
+    "    conn.close()\n",
+    "\n",
+    "    return file\n",
+    "\n",
+    "db = update_dates(local_file)"
    ]
   },
   {
@@ -225,7 +229,14 @@
     "\n",
     "Define the (`fetch_user_flight_information`) tool to let the agent see the current user's flight information.  Then define tools to search for flights and manage the passenger's bookings stored in the SQL database.\n",
     "\n",
-    "We use `ensure_config` to pass in the `passenger_id` in via configurable parameters. The LLM never has to provide these explicitly, they are provided for a given invocation of the graph so that each user cannot access other passengers' booking information."
+    "We the can [access the RunnableConfig](https://python.langchain.com/v0.2/docs/how_to/tool_configure/#inferring-by-parameter-type) for a given run to check the `passenger_id` of the user accessing this application. The LLM never has to provide these explicitly, they are provided for a given invocation of the graph so that each user cannot access other passengers' booking information.\n",
+    "\n",
+    "<div class=\"admonition warning\">\n",
+    "    <p class=\"admonition-title\">Compatibility</p>\n",
+    "    <p>\n",
+    "        This tutorial expects `langchain-core>=0.2.16` to use the injected RunnableConfig. Prior to that, you'd use `ensure_config` to collect the config from context.\n",
+    "    </p>\n",
+    "</div> \n"
    ]
   },
   {
@@ -240,18 +251,17 @@
     "from typing import Optional\n",
     "\n",
     "import pytz\n",
-    "from langchain_core.runnables import ensure_config\n",
+    "from langchain_core.runnables import RunnableConfig\n",
     "\n",
     "\n",
     "@tool\n",
-    "def fetch_user_flight_information() -> list[dict]:\n",
+    "def fetch_user_flight_information(config: RunnableConfig) -> list[dict]:\n",
     "    \"\"\"Fetch all tickets for the user along with corresponding flight information and seat assignments.\n",
     "\n",
     "    Returns:\n",
     "        A list of dictionaries where each dictionary contains the ticket details,\n",
     "        associated flight details, and the seat assignments for each ticket belonging to the user.\n",
     "    \"\"\"\n",
-    "    config = ensure_config()  # Fetch from the context\n",
     "    configuration = config.get(\"configurable\", {})\n",
     "    passenger_id = configuration.get(\"passenger_id\", None)\n",
     "    if not passenger_id:\n",
@@ -328,9 +338,10 @@
     "\n",
     "\n",
     "@tool\n",
-    "def update_ticket_to_new_flight(ticket_no: str, new_flight_id: int) -> str:\n",
+    "def update_ticket_to_new_flight(\n",
+    "    ticket_no: str, new_flight_id: int, *, config: RunnableConfig\n",
+    ") -> str:\n",
     "    \"\"\"Update the user's ticket to a new valid flight.\"\"\"\n",
-    "    config = ensure_config()\n",
     "    configuration = config.get(\"configurable\", {})\n",
     "    passenger_id = configuration.get(\"passenger_id\", None)\n",
     "    if not passenger_id:\n",
@@ -396,9 +407,8 @@
     "\n",
     "\n",
     "@tool\n",
-    "def cancel_ticket(ticket_no: str) -> str:\n",
+    "def cancel_ticket(ticket_no: str, *, config: RunnableConfig) -> str:\n",
     "    \"\"\"Cancel the user's ticket and remove it from the database.\"\"\"\n",
-    "    config = ensure_config()\n",
     "    configuration = config.get(\"configurable\", {})\n",
     "    passenger_id = configuration.get(\"passenger_id\", None)\n",
     "    if not passenger_id:\n",
@@ -1744,7 +1754,7 @@
     "]\n",
     "\n",
     "# Update with the backup file so we can restart from the original place in each section\n",
-    "shutil.copy(backup_file, db)\n",
+    "db = update_dates(db)\n",
     "thread_id = str(uuid.uuid4())\n",
     "\n",
     "config = {\n",
@@ -2298,7 +2308,7 @@
     "import uuid\n",
     "\n",
     "# Update with the backup file so we can restart from the original place in each section\n",
-    "shutil.copy(backup_file, db)\n",
+    "db = update_dates(db)\n",
     "thread_id = str(uuid.uuid4())\n",
     "\n",
     "config = {\n",
@@ -2902,7 +2912,7 @@
     "import uuid\n",
     "\n",
     "# Update with the backup file so we can restart from the original place in each section\n",
-    "shutil.copy(backup_file, db)\n",
+    "db = update_dates(db)\n",
     "thread_id = str(uuid.uuid4())\n",
     "\n",
     "config = {\n",
@@ -4324,7 +4334,7 @@
     "import uuid\n",
     "\n",
     "# Update with the backup file so we can restart from the original place in each section\n",
-    "shutil.copy(backup_file, db)\n",
+    "db = update_dates(db)\n",
     "thread_id = str(uuid.uuid4())\n",
     "\n",
     "config = {\n",
@@ -4407,7 +4417,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.2"
+   "version": "3.12.2"
   }
  },
  "nbformat": 4,

examples/extraction/retries.ipynb

@@ -1010,14 +1010,6 @@
     "\n",
     "If you notice high retry rates (using an observability tool like LangSmith), you can set up a rule to send the failure cases to a dataset alongside the corrected values and then automatically program those into your prompts or schemas (or use them as few-shots to have semantically relevant demonstrations)."
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "0ae295b1-da58-4cc9-834b-70e1466f8695",
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {

examples/human_in_the_loop/edit-graph-state.ipynb

@@ -541,14 +541,6 @@
         "for event in app.stream(None, thread, stream_mode=\"values\"):\n",
         "    event[\"messages\"][-1].pretty_print()"
       ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "id": "78780afe-409d-46cd-a734-e82538cdd8de",
-      "metadata": {},
-      "outputs": [],
-      "source": []
     }
   ],
   "metadata": {

examples/human_in_the_loop/review-tool-calls.ipynb

@@ -141,15 +141,18 @@
     "    print(\"----\")\n",
     "    return \"Sunny!\"\n",
     "\n",
-    "model = ChatAnthropic(model_name=\"claude-3-5-sonnet-20240620\").bind_tools([weather_search])\n",
+    "\n",
+    "model = ChatAnthropic(model_name=\"claude-3-5-sonnet-20240620\").bind_tools(\n",
+    "    [weather_search]\n",
+    ")\n",
+    "\n",
     "\n",
     "class State(MessagesState):\n",
     "    \"\"\"Simple state.\"\"\"\n",
     "\n",
+    "\n",
     "def call_llm(state):\n",
-    "    return {\n",
-    "        \"messages\": [model.invoke(state['messages'])]\n",
-    "    }\n",
+    "    return {\"messages\": [model.invoke(state[\"messages\"])]}\n",
     "\n",
     "\n",
     "def human_review_node(state):\n",
@@ -159,28 +162,30 @@
     "def run_tool(state):\n",
     "    new_messages = []\n",
     "    tools = {\"weather_search\": weather_search}\n",
-    "    tool_calls = state['messages'][-1].tool_calls\n",
+    "    tool_calls = state[\"messages\"][-1].tool_calls\n",
     "    for tool_call in tool_calls:\n",
-    "        tool = tools[tool_call['name']]\n",
-    "        result = tool.invoke(tool_call['args'])\n",
-    "        new_messages.append({\n",
-    "            \"role\": \"tool\",\n",
-    "            \"name\": tool_call['name'],\n",
-    "            \"content\": result,\n",
-    "            \"tool_call_id\": tool_call['id']\n",
-    "        })\n",
+    "        tool = tools[tool_call[\"name\"]]\n",
+    "        result = tool.invoke(tool_call[\"args\"])\n",
+    "        new_messages.append(\n",
+    "            {\n",
+    "                \"role\": \"tool\",\n",
+    "                \"name\": tool_call[\"name\"],\n",
+    "                \"content\": result,\n",
+    "                \"tool_call_id\": tool_call[\"id\"],\n",
+    "            }\n",
+    "        )\n",
     "    return {\"messages\": new_messages}\n",
     "\n",
     "\n",
     "def route_after_llm(state) -> Literal[END, \"human_review_node\"]:\n",
-    "    if len(state['messages'][-1].tool_calls) == 0:\n",
+    "    if len(state[\"messages\"][-1].tool_calls) == 0:\n",
     "        return END\n",
     "    else:\n",
     "        return \"human_review_node\"\n",
     "\n",
     "\n",
     "def route_after_human(state) -> Literal[\"run_tool\", \"call_llm\"]:\n",
-    "    if isinstance(state['messages'][-1], AIMessage):\n",
+    "    if isinstance(state[\"messages\"][-1], AIMessage):\n",
     "        return \"run_tool\"\n",
     "    else:\n",
     "        return \"call_llm\"\n",
@@ -460,35 +465,35 @@
     "print(\"Current State:\")\n",
     "print(state.values)\n",
     "print(\"\\nCurrent Tool Call ID:\")\n",
-    "current_content = state.values['messages'][-1].content\n",
-    "current_id = state.values['messages'][-1].id\n",
-    "tool_call_id = state.values['messages'][-1].tool_calls[0]['id']\n",
+    "current_content = state.values[\"messages\"][-1].content\n",
+    "current_id = state.values[\"messages\"][-1].id\n",
+    "tool_call_id = state.values[\"messages\"][-1].tool_calls[0][\"id\"]\n",
     "print(tool_call_id)\n",
     "\n",
     "# We now need to construct a replacement tool call.\n",
     "# We will change the argument to be `San Francisco, USA`\n",
     "# Note that we could change any number of arguments or tool names - it just has to be a valid one\n",
     "new_message = {\n",
-    "    \"role\": \"assistant\", \n",
+    "    \"role\": \"assistant\",\n",
     "    \"content\": current_content,\n",
     "    \"tool_calls\": [\n",
     "        {\n",
     "            \"id\": tool_call_id,\n",
     "            \"name\": \"weather_search\",\n",
-    "            \"args\": {\"city\": \"San Francisco, USA\"}\n",
+    "            \"args\": {\"city\": \"San Francisco, USA\"},\n",
     "        }\n",
     "    ],\n",
     "    # This is important - this needs to be the same as the message you replacing!\n",
     "    # Otherwise, it will show up as a separate message\n",
-    "    \"id\": current_id\n",
+    "    \"id\": current_id,\n",
     "}\n",
     "graph.update_state(\n",
     "    # This is the config which represents this thread\n",
-    "    thread, \n",
+    "    thread,\n",
     "    # This is the updated value we want to push\n",
-    "    {\"messages\": [new_message]}, \n",
+    "    {\"messages\": [new_message]},\n",
     "    # We push this update acting as our human_review_node\n",
-    "    as_node=\"human_review_node\"\n",
+    "    as_node=\"human_review_node\",\n",
     ")\n",
     "\n",
     "# Let's now continue executing from here\n",
@@ -595,26 +600,26 @@
     "print(\"Current State:\")\n",
     "print(state.values)\n",
     "print(\"\\nCurrent Tool Call ID:\")\n",
-    "tool_call_id = state.values['messages'][-1].tool_calls[0]['id']\n",
+    "tool_call_id = state.values[\"messages\"][-1].tool_calls[0][\"id\"]\n",
     "print(tool_call_id)\n",
     "\n",
     "# We now need to construct a replacement tool call.\n",
     "# We will change the argument to be `San Francisco, USA`\n",
     "# Note that we could change any number of arguments or tool names - it just has to be a valid one\n",
     "new_message = {\n",
-    "    \"role\": \"tool\", \n",
+    "    \"role\": \"tool\",\n",
     "    # This is our natural language feedback\n",
     "    \"content\": \"User requested changes: pass in the country as well\",\n",
     "    \"name\": \"weather_search\",\n",
-    "    \"tool_call_id\": tool_call_id\n",
+    "    \"tool_call_id\": tool_call_id,\n",
     "}\n",
     "graph.update_state(\n",
     "    # This is the config which represents this thread\n",
-    "    thread, \n",
+    "    thread,\n",
     "    # This is the updated value we want to push\n",
-    "    {\"messages\": [new_message]}, \n",
+    "    {\"messages\": [new_message]},\n",
     "    # We push this update acting as our human_review_node\n",
-    "    as_node=\"human_review_node\"\n",
+    "    as_node=\"human_review_node\",\n",
     ")\n",
     "\n",
     "# Let's now continue executing from here\n",
@@ -675,7 +680,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.1"
+   "version": "3.11.9"
   }
  },
  "nbformat": 4,

examples/human_in_the_loop/wait-user-input.ipynb

@@ -55,7 +55,7 @@
       "metadata": {},
       "outputs": [
         {
-          "name": "stdin",
+          "name": "stdout",
           "output_type": "stream",
           "text": [
             "ANTHROPIC_API_KEY:  ········\n"
@@ -227,7 +227,7 @@
       "metadata": {},
       "outputs": [
         {
-          "name": "stdin",
+          "name": "stdout",
           "output_type": "stream",
           "text": [
             "Tell me how you want to update the state:  go to step 3!\n"
@@ -636,14 +636,6 @@
         "for event in app.stream(None, config, stream_mode=\"values\"):\n",
         "    event[\"messages\"][-1].pretty_print()"
       ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "id": "f6f972d1-3d99-4fc1-8b33-92b71e74835d",
-      "metadata": {},
-      "outputs": [],
-      "source": []
     }
   ],
   "metadata": {

examples/input_output_schema.ipynb

@@ -33,15 +33,19 @@
     "from langgraph.graph import StateGraph, START, END\n",
     "from typing import TypedDict\n",
     "\n",
+    "\n",
     "class InputState(TypedDict):\n",
     "    question: str\n",
     "\n",
+    "\n",
     "class OutputState(TypedDict):\n",
     "    answer: str\n",
     "\n",
+    "\n",
     "def answer_node(state: InputState):\n",
     "    return {\"answer\": \"bye\"}\n",
     "\n",
+    "\n",
     "graph = StateGraph(input=InputState, output=OutputState)\n",
     "graph.add_node(answer_node)\n",
     "graph.add_edge(START, \"answer_node\")\n",
@@ -58,14 +62,6 @@
    "source": [
     "Notice that the output of invoke only includes the output schema."
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "b952a554-f2a4-4be3-81ab-2e08f0f441c2",
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {

examples/introduction.ipynb

@@ -1265,7 +1265,6 @@
     "\n",
     "from langchain_anthropic import ChatAnthropic\n",
     "from langchain_community.tools.tavily_search import TavilySearchResults\n",
-    "from langchain_core.messages import BaseMessage\n",
     "from typing_extensions import TypedDict\n",
     "\n",
     "from langgraph.checkpoint.memory import MemorySaver\n",
@@ -1504,7 +1503,7 @@
     "from langgraph.checkpoint.memory import MemorySaver\n",
     "from langgraph.graph import StateGraph\n",
     "from langgraph.graph.message import add_messages\n",
-    "from langgraph.prebuilt import ToolNode\n",
+    "from langgraph.prebuilt import ToolNode, tools_condition\n",
     "\n",
     "\n",
     "class State(TypedDict):\n",
@@ -1583,7 +1582,6 @@
     "\n",
     "from langchain_anthropic import ChatAnthropic\n",
     "from langchain_community.tools.tavily_search import TavilySearchResults\n",
-    "from langchain_core.messages import BaseMessage\n",
     "from typing_extensions import TypedDict\n",
     "\n",
     "from langgraph.checkpoint.memory import MemorySaver\n",
@@ -1698,7 +1696,7 @@
     }
    ],
    "source": [
-    "from langchain_core.messages import AIMessage\n",
+    "from langchain_core.messages import AIMessage, ToolMessage\n",
     "\n",
     "answer = (\n",
     "    \"LangGraph is a library for building stateful, multi-actor applications with LLMs.\"\n",
@@ -2082,7 +2080,6 @@
     "\n",
     "from langchain_anthropic import ChatAnthropic\n",
     "from langchain_community.tools.tavily_search import TavilySearchResults\n",
-    "from langchain_core.messages import BaseMessage\n",
     "from typing_extensions import TypedDict\n",
     "\n",
     "from langgraph.checkpoint.memory import MemorySaver\n",

examples/llm-compiler/LLMCompiler.ipynb

@@ -38,7 +38,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 2,
    "id": "abbd6948-e9a3-47ca-89c7-7ac2fc5eca8b",
    "metadata": {},
    "outputs": [],
@@ -73,7 +73,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 47,
    "id": "e7476bb2-1a51-42f6-b7ae-82a0300bbf84",
    "metadata": {},
    "outputs": [],
@@ -147,7 +147,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 78,
    "id": "15dd9639-691f-4906-9012-83fd6e9ac126",
    "metadata": {},
    "outputs": [
@@ -211,7 +211,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 79,
    "id": "45689d40-d8df-4316-a121-6ea9c87d2efe",
    "metadata": {},
    "outputs": [],
@@ -270,7 +270,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 80,
    "id": "bbdcb57b-5362-4b9e-88db-fb3fae443fb0",
    "metadata": {},
    "outputs": [],
@@ -282,7 +282,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 81,
    "id": "730490c6-6e3a-4173-82a1-9eb9d5eeff20",
    "metadata": {},
    "outputs": [
@@ -292,7 +292,7 @@
      "text": [
       "description='tavily_search_results_json(query=\"the search query\") - a search engine.' max_results=1 {'query': 'current temperature in San Francisco'}\n",
       "---\n",
-      "name='math' description='math(problem: str, context: Optional[List[str]] = None, config: Optional[langchain_core.runnables.config.RunnableConfig] = None) - math(problem: str, context: Optional[list[str]]) -> float:\\n - Solves the provided math problem.\\n - `problem` can be either a simple math problem (e.g. \"1 + 3\") or a word problem (e.g. \"how many apples are there if there are 3 apples and 2 apples\").\\n - You cannot calculate multiple expressions in one call. For instance, `math(\\'1 + 3, 2 + 4\\')` does not work. If you need to calculate multiple expressions, you need to call them separately like `math(\\'1 + 3\\')` and then `math(\\'2 + 4\\')`\\n - Minimize the number of `math` actions as much as possible. For instance, instead of calling 2. math(\"what is the 10% of $1\") and then call 3. math(\"$1 + $2\"), you MUST call 2. math(\"what is the 110% of $1\") instead, which will reduce the number of math actions.\\n - You can optionally provide a list of strings as `context` to help the agent solve the problem. If there are multiple contexts you need to answer the question, you can provide them as a list of strings.\\n - `math` action will not see the output of the previous actions unless you provide it as `context`. You MUST provide the output of the previous actions as `context` if you need to do math on it.\\n - You MUST NEVER provide `search` type action\\'s outputs as a variable in the `problem` argument. This is because `search` returns a text blob that contains the information about the entity, not a number or value. Therefore, when you need to provide an output of `search` action, you MUST provide it as a `context` argument to `math` action. For example, 1. search(\"Barack Obama\") and then 2. math(\"age of $1\") is NEVER allowed. Use 2. math(\"age of Barack Obama\", context=[\"$1\"]) instead.\\n - When you ask a question about `context`, specify the units. For instance, \"what is xx in height?\" or \"what is xx in millions?\" instead of \"what is xx?\"' args_schema=<class 'pydantic.v1.main.mathSchema'> func=<function get_math_tool.<locals>.calculate_expression at 0x10f354ea0> {'problem': 'raise $0 to the 3rd power', 'context': ['$0']}\n",
+      "name='math' description='math(problem: str, context: Optional[list[str]]) -> float:\\n - Solves the provided math problem.\\n - `problem` can be either a simple math problem (e.g. \"1 + 3\") or a word problem (e.g. \"how many apples are there if there are 3 apples and 2 apples\").\\n - You cannot calculate multiple expressions in one call. For instance, `math(\\'1 + 3, 2 + 4\\')` does not work. If you need to calculate multiple expressions, you need to call them separately like `math(\\'1 + 3\\')` and then `math(\\'2 + 4\\')`\\n - Minimize the number of `math` actions as much as possible. For instance, instead of calling 2. math(\"what is the 10% of $1\") and then call 3. math(\"$1 + $2\"), you MUST call 2. math(\"what is the 110% of $1\") instead, which will reduce the number of math actions.\\n - You can optionally provide a list of strings as `context` to help the agent solve the problem. If there are multiple contexts you need to answer the question, you can provide them as a list of strings.\\n - `math` action will not see the output of the previous actions unless you provide it as `context`. You MUST provide the output of the previous actions as `context` if you need to do math on it.\\n - You MUST NEVER provide `search` type action\\'s outputs as a variable in the `problem` argument. This is because `search` returns a text blob that contains the information about the entity, not a number or value. Therefore, when you need to provide an output of `search` action, you MUST provide it as a `context` argument to `math` action. For example, 1. search(\"Barack Obama\") and then 2. math(\"age of $1\") is NEVER allowed. Use 2. math(\"age of Barack Obama\", context=[\"$1\"]) instead.\\n - When you ask a question about `context`, specify the units. For instance, \"what is xx in height?\" or \"what is xx in millions?\" instead of \"what is xx?\"' args_schema=<class 'pydantic.v1.main.mathSchema'> func=<function get_math_tool.<locals>.calculate_expression at 0x14e1049a0> {'problem': 'x^3', 'context': ['$1']}\n",
       "---\n",
       "join ()\n",
       "---\n"
@@ -331,7 +331,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 82,
    "id": "c1fbafdd-42d4-4575-8466-e5951cee71f4",
    "metadata": {
     "jp-MarkdownHeadingCollapsed": true
@@ -493,7 +493,7 @@
     "    }\n",
     "    tool_messages = [\n",
     "        FunctionMessage(\n",
-    "            name=name, content=str(obs), additional_kwargs={\"idx\": k, \"args\": task_args}\n",
+    "            name=name, content=str(obs), additional_kwargs={\"idx\": k, \"args\": task_args}, tool_call_id = k\n",
     "        )\n",
     "        for k, (name, task_args, obs) in new_observations.items()\n",
     "    ]\n",
@@ -502,7 +502,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 83,
    "id": "052f6b16-103a-40e9-94dd-8fcc37e77ba4",
    "metadata": {},
    "outputs": [],
@@ -526,7 +526,7 @@
     "            \"tasks\": tasks,\n",
     "        }\n",
     "    )\n",
-    "    return {\"messages\":[scheduled_tasks]}"
+    "    return {\"messages\": scheduled_tasks}"
    ]
   },
   {
@@ -541,29 +541,29 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 84,
    "id": "55142257-2674-4a47-988e-0d2810917329",
    "metadata": {},
    "outputs": [],
    "source": [
-    "tool_messages = plan_and_schedule.invoke([HumanMessage(content=example_question)])"
+    "tool_messages = plan_and_schedule.invoke({\"messages\":[HumanMessage(content=example_question)]})['messages']"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 85,
    "id": "a98e0525-2fcf-4fa1-baf6-79858bb8a6bd",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "[FunctionMessage(content='[]', additional_kwargs={'idx': 0}, name='tavily_search_results_json'),\n",
-       " FunctionMessage(content='ValueError(\\'Failed to evaluate \"N/A\". Raised error: KeyError(\\\\\\'A\\\\\\'). Please try again with a valid numerical expression\\')', additional_kwargs={'idx': 1}, name='math'),\n",
-       " FunctionMessage(content='join', additional_kwargs={'idx': 2}, name='join')]"
+       "[FunctionMessage(content=\"[{'url': 'https://www.wunderground.com/weather/us/ca/san-francisco', 'content': 'Current Weather for Popular Cities . San Francisco, CA 82 ° F Sunny; Manhattan, NY warning 84 ° F Sunny; Schiller Park, IL (60176) warning 97 ° F Mostly Cloudy; Boston, MA warning 74 ° F ...'}]\", additional_kwargs={'idx': 1, 'args': {'query': 'current temperature in San Francisco'}}, name='tavily_search_results_json', tool_call_id=1),\n",
+       " FunctionMessage(content='551368', additional_kwargs={'idx': 2, 'args': {'problem': 'x ** 3', 'context': ['$1']}}, name='math', tool_call_id=2),\n",
+       " FunctionMessage(content='join', additional_kwargs={'idx': 3, 'args': ()}, name='join', tool_call_id=3)]"
       ]
      },
-     "execution_count": 12,
+     "execution_count": 85,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -589,12 +589,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 86,
    "id": "942dab42-ad42-4ba2-90d5-49edbe4fae68",
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.chains.openai_functions import create_structured_output_runnable\n",
     "from langchain_core.messages import AIMessage\n",
     "from langchain_core.pydantic_v1 import BaseModel, Field\n",
     "\n",
@@ -625,7 +624,7 @@
     ")  # You can optionally add examples\n",
     "llm = ChatOpenAI(model=\"gpt-4-turbo-preview\")\n",
     "\n",
-    "runnable = create_structured_output_runnable(JoinOutputs, llm, joiner_prompt)"
+    "runnable = joiner_prompt | llm.with_structured_output(JoinOutputs)"
    ]
   },
   {
@@ -639,7 +638,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 87,
    "id": "951a33cf-2a05-4a33-899a-0ab1d97122fa",
    "metadata": {},
    "outputs": [],
@@ -647,13 +646,14 @@
     "def _parse_joiner_output(decision: JoinOutputs) -> List[BaseMessage]:\n",
     "    response = [AIMessage(content=f\"Thought: {decision.thought}\")]\n",
     "    if isinstance(decision.action, Replan):\n",
-    "        return response + [\n",
+    "        return {\"messages\": response + [\n",
     "            SystemMessage(\n",
     "                content=f\"Context from last attempt: {decision.action.feedback}\"\n",
     "            )\n",
     "        ]\n",
+    "        }\n",
     "    else:\n",
-    "        return {\"messages\":response + [AIMessage(content=decision.action.response)]}\n",
+    "        return {\"messages\": response + [AIMessage(content=decision.action.response)]}\n",
     "\n",
     "\n",
     "def select_recent_messages(state) -> dict:\n",
@@ -671,7 +671,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 88,
    "id": "1e49d4b1-8266-4520-a566-1448b1c31c8f",
    "metadata": {},
    "outputs": [],
@@ -681,24 +681,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 89,
    "id": "31854dfd-b82f-4c24-9b58-6bae66777909",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "[AIMessage(content='Thought: The search did not return any results, and the attempt to calculate the temperature in San Francisco raised to the 3rd power failed due to missing temperature information.'),\n",
-       " SystemMessage(content='Context from last attempt: I need to find the current temperature in San Francisco before calculating its value raised to the 3rd power.')]"
+       "{'messages': [AIMessage(content=\"Thought: We have the current temperature in San Francisco (82 °F) and have calculated the temperature raised to the 3rd power (551368). Therefore, we can provide an answer to the user's question.\"),\n",
+       "  AIMessage(content='The temperature in San Francisco raised to the 3rd power is 551368.')]}"
       ]
      },
-     "execution_count": 16,
+     "execution_count": 89,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "joiner.invoke(input_messages)"
+    "joiner.invoke({\"messages\":input_messages})"
    ]
   },
   {
@@ -717,7 +717,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 90,
    "id": "768b5f11-e3d2-47be-8143-a7dcd8765243",
    "metadata": {},
    "outputs": [],
@@ -726,9 +726,11 @@
     "from langgraph.graph.message import add_messages\n",
     "from typing import Annotated\n",
     "\n",
+    "\n",
     "class State(TypedDict):\n",
     "    messages: Annotated[list, add_messages]\n",
     "\n",
+    "\n",
     "graph_builder = StateGraph(State)\n",
     "\n",
     "# 1.  Define vertices\n",
@@ -752,9 +754,9 @@
     "\n",
     "\n",
     "graph_builder.add_conditional_edges(\n",
-    "    start_key=\"join\",\n",
+    "    \"join\",\n",
     "    # Next, we pass in the function that will determine which node is called next.\n",
-    "    condition=should_continue,\n",
+    "    should_continue,\n",
     ")\n",
     "graph_builder.add_edge(START, \"plan_and_schedule\")\n",
     "chain = graph_builder.compile()"
@@ -772,7 +774,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 91,
    "id": "5bc4584a-e31c-4065-805e-76a6db30676a",
    "metadata": {},
    "outputs": [
@@ -780,28 +782,24 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "{'plan_and_schedule': [FunctionMessage(content='[{\\'url\\': \\'https://www.governor.ny.gov/programs/fy-2024-new-york-state-budget\\', \\'content\\': \"The $229 billion FY 2024 New York State Budget reflects Governor Hochul\\'s bold agenda to make New York more affordable,  FY 2024 Budget Assets FY 2024 New York State Budget Highlights Improving Public Safety  GOVERNOR HOME GOVERNOR KATHY HOCHUL FY 2024 New York State Budget  Transformative investments to support New York\\'s business community and boost the state economy.The $229 billion FY 2024 NYS Budget reflects Governor Hochul\\'s bold agenda to make New York more affordable, more livable, and safer.\"}]', additional_kwargs={'idx': 0}, name='tavily_search_results_json')]}\n",
+      "{'plan_and_schedule': {'messages': [FunctionMessage(content=\"[{'url': 'https://www.investopedia.com/articles/investing/011516/new-yorks-economy-6-industries-driving-gdp-growth.asp', 'content': 'The manufacturing sector is a leader in railroad rolling stock, as many of the earliest railroads were financed or founded in New York; garments, as New York City is the fashion capital of the U.S.; elevator parts; glass; and many other products.\\\\n Educational Services\\\\nThough not typically thought of as a leading industry, the educational sector in New York nonetheless has a substantial impact on the state and its residents, and in attracting new talent that eventually enters the New York business scene. New York has seen a large uptick in college attendees, both young and old, over the 21st century, and an increasing number of new employees in other New York sectors were educated in the state. New York City is the leading job hub for banking, finance, and communication in the U.S. New York is also a major manufacturing center and shipping port, and it has a thriving technological sector.\\\\n The state of New York has the third-largest economy in the United States with a gross domestic product (GDP) of $1.7 trillion, trailing only Texas and California.'}]\", additional_kwargs={'idx': 1, 'args': {'query': 'GDP of New York'}}, name='tavily_search_results_json', tool_call_id=1)]}}\n",
       "---\n",
-      "{'join': [AIMessage(content=\"Thought: The information provided does not specify the Gross Domestic Product (GDP) of New York, but instead provides details about the state's budget for fiscal year 2024, which is $229 billion. This budget figure cannot be accurately equated to the GDP.\"), SystemMessage(content=\"Context from last attempt: The search results provided information about New York's state budget rather than its GDP. To answer the user's question, we need to find specific data on New York's GDP, not its budget.\")]}\n",
-      "---\n",
-      "{'plan_and_schedule': [FunctionMessage(content=\"[{'url': 'https://en.wikipedia.org/wiki/Economy_of_New_York_(state)', 'content': 'The economy of the State of New York is reflected in its gross state product in 2022 of $2.053 trillion, ranking third  Contents Economy of New York (state)  New York City-centered metropolitan statistical area produced a gross metropolitan product (GMP) of $US2.0 trillion,  of the items in which New York ranks high nationally:The economy of the State of New York is reflected in its gross state product in 2022 of $2.053 trillion, ranking third in size behind the larger states of\\\\xa0...'}]\", additional_kwargs={'idx': 1}, name='tavily_search_results_json')]}\n",
-      "---\n",
-      "{'join': [AIMessage(content=\"Thought: The required information about New York's GDP is provided in the search results. In 2022, New York had a Gross State Product (GSP) of $2.053 trillion.\"), AIMessage(content='The Gross Domestic Product (GDP) of New York in 2022 was $2.053 trillion.')]}\n",
-      "---\n",
-      "{'__end__': [HumanMessage(content=\"What's the GDP of New York?\"), FunctionMessage(content='[{\\'url\\': \\'https://www.governor.ny.gov/programs/fy-2024-new-york-state-budget\\', \\'content\\': \"The $229 billion FY 2024 New York State Budget reflects Governor Hochul\\'s bold agenda to make New York more affordable,  FY 2024 Budget Assets FY 2024 New York State Budget Highlights Improving Public Safety  GOVERNOR HOME GOVERNOR KATHY HOCHUL FY 2024 New York State Budget  Transformative investments to support New York\\'s business community and boost the state economy.The $229 billion FY 2024 NYS Budget reflects Governor Hochul\\'s bold agenda to make New York more affordable, more livable, and safer.\"}]', additional_kwargs={'idx': 0}, name='tavily_search_results_json'), AIMessage(content=\"Thought: The information provided does not specify the Gross Domestic Product (GDP) of New York, but instead provides details about the state's budget for fiscal year 2024, which is $229 billion. This budget figure cannot be accurately equated to the GDP.\"), SystemMessage(content=\"Context from last attempt: The search results provided information about New York's state budget rather than its GDP. To answer the user's question, we need to find specific data on New York's GDP, not its budget. - Begin counting at : 1\"), FunctionMessage(content=\"[{'url': 'https://en.wikipedia.org/wiki/Economy_of_New_York_(state)', 'content': 'The economy of the State of New York is reflected in its gross state product in 2022 of $2.053 trillion, ranking third  Contents Economy of New York (state)  New York City-centered metropolitan statistical area produced a gross metropolitan product (GMP) of $US2.0 trillion,  of the items in which New York ranks high nationally:The economy of the State of New York is reflected in its gross state product in 2022 of $2.053 trillion, ranking third in size behind the larger states of\\\\xa0...'}]\", additional_kwargs={'idx': 1}, name='tavily_search_results_json'), AIMessage(content=\"Thought: The required information about New York's GDP is provided in the search results. In 2022, New York had a Gross State Product (GSP) of $2.053 trillion.\"), AIMessage(content='The Gross Domestic Product (GDP) of New York in 2022 was $2.053 trillion.')]}\n",
+      "{'join': {'messages': [AIMessage(content=\"Thought: The information required to answer the user's question has been found. The GDP of New York is mentioned as $1.7 trillion, making it the third-largest economy in the United States.\", id='d656a605-e4c4-470d-9b29-31794f298a71'), AIMessage(content='The GDP of New York is $1.7 trillion, making it the third-largest economy in the United States.', id='5135758e-d01e-4360-bb6a-31025b723d8c')]}}\n",
       "---\n"
      ]
     }
    ],
    "source": [
-    "for step in chain.stream({\"messages\":[HumanMessage(content=\"What's the GDP of New York?\")]}):\n",
+    "for step in chain.stream(\n",
+    "    {\"messages\": [HumanMessage(content=\"What's the GDP of New York?\")]}\n",
+    "):\n",
     "    print(step)\n",
     "    print(\"---\")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 92,
    "id": "b96efd08-5314-44f0-a694-3073b638adad",
    "metadata": {},
    "outputs": [
@@ -809,13 +807,13 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "The Gross Domestic Product (GDP) of New York in 2022 was $2.053 trillion.\n"
+      "The GDP of New York is $1.7 trillion, making it the third-largest economy in the United States.\n"
      ]
     }
    ],
    "source": [
     "# Final answer\n",
-    "print(step[END][-1].content)"
+    "print(step['join']['messages'][-1].content)"
    ]
   },
   {
@@ -830,7 +828,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 93,
    "id": "0b3a0916-d8ca-4092-b91c-d9e2b05259d8",
    "metadata": {},
    "outputs": [
@@ -838,26 +836,21 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "{'plan_and_schedule': [FunctionMessage(content=\"[{'url': 'https://a-z-animals.com/blog/discover-the-worlds-oldest-parrot/', 'content': 'How Old Is the World’s Oldest Parrot?  Discover the World’s Oldest Parrot Advertisement  of debate, so we’ll detail some other parrots whose lifespans may be longer but are hard to verify their exact age.  Comparing Parrots’ Lifespans to Other BirdsSep 8, 2023 — Sep 8, 2023The oldest parrot on record is Cookie, a pink cockatoo that survived to the age of 83 and survived his entire life at the Brookfield Zoo.'}]\", additional_kwargs={'idx': 0}, name='tavily_search_results_json'), FunctionMessage(content=\"HTTPError('502 Server Error: Bad Gateway for url: https://api.tavily.com/search')\", additional_kwargs={'idx': 1}, name='tavily_search_results_json'), FunctionMessage(content='join', additional_kwargs={'idx': 2}, name='join')]}\n",
+      "{'plan_and_schedule': {'messages': [FunctionMessage(content='[{\\'url\\': \\'https://en.wikipedia.org/wiki/Cookie_(cockatoo)\\', \\'content\\': \\'He was one of the longest-lived birds on record[4] and was recognised by the Guinness World Records as the oldest living parrot in the world.[5]\\\\nThe next-oldest pink cockatoo to be found in a zoological setting was a 31-year-old female bird located at Paradise Wildlife Sanctuary, England.[3] Information published by the World Parrot Trust states longevity for Cookie\\\\\\'s species in captivity is on average 40–60 years.[6]\\\\nLife[edit]\\\\nCookie was Brookfield Zoo\\\\\\'s oldest resident and the last surviving member of the animal collection from the time of the zoo\\\\\\'s opening in 1934, having arrived from Taronga Zoo of Sydney, New South Wales, Australia, in the same year and judged to be one year old at the time.[7]\\\\nIn the 1950s an attempt was made to introduce Cookie to a female pink cockatoo, but Cookie rejected her as \"she was not nice to him\".[8]\\\\n In 2007, Cookie was diagnosed with, and placed on medication and nutritional supplements for, osteoarthritis and osteoporosis\\\\xa0– medical conditions which occur commonly in aging animals and humans alike,[7] although it is believed that the latter may also have been brought on as a result of being fed a seed-only diet for the first 40 years of his life, in the years before the dietary requirements of his species were fully understood.[9]\\\\nCookie was \"retired\" from exhibition at the zoo in 2009 (following a few months of weekend-only appearances) in order to preserve his health, after it was noticed by staff that his appetite, demeanor and stress levels improved markedly when not on public display. age.[11] A memorial at the zoo was unveiled in September 2017.[12]\\\\nIn 2020, Cookie became the subject of a poetry collection by Barbara Gregorich entitled Cookie the Cockatoo: Everything Changes.[13]\\\\nSee also[edit]\\\\nReferences[edit]\\\\nExternal links[edit] He was believed to be the oldest member of his species alive in captivity, at the age of 82 in June 2015,[1][2] having significantly exceeded the average lifespan for his kind.[3] He was moved to a permanent residence in the keepers\\\\\\' office of the zoo\\\\\\'s Perching Bird House, although he made occasional appearances for special events, such as his birthday celebration, which was held each June.[3]\\'}]', additional_kwargs={'idx': 1, 'args': {'query': 'oldest parrot alive'}}, name='tavily_search_results_json', tool_call_id=1), FunctionMessage(content='[{\\'url\\': \\'https://www.thesprucepets.com/how-long-do-parrots-and-other-pet-birds-live-1238433\\', \\'content\\': \"It\\'s possible that a pet bird can outlive its owners\\\\nThe Spruce / Adrienne Legault\\\\nParrots and other birds can live up to 10 to 50 years or more depending on the type and the conditions they live in. They vary in size from small birds that can fit in the palm of your hand to large birds the size of a cat and their lifespans are just as variable.\\\\n Also, for birds who live longer some owners have to make a plan of where the bird is going in the circumstance the bird outlives the owner.\\\\n In reality, there is a wide range in the age that pet birds might reach and certainly, some will live longer (or shorter amounts of time) than the ages listed.\\\\n Potential owners need to be aware of the longevity of their bird so they can be prepared to provide proper care for them for as long as they live.\\\\n\"}]', additional_kwargs={'idx': 2, 'args': {'query': 'average lifespan of a parrot'}}, name='tavily_search_results_json', tool_call_id=2), FunctionMessage(content='join', additional_kwargs={'idx': 3, 'args': ()}, name='join', tool_call_id=3)]}}\n",
       "---\n",
-      "{'join': [AIMessage(content='Thought: The oldest parrot on record is Cookie, a pink cockatoo, who lived to be 83 years old. However, there was an error fetching additional search results to compare this age to the average lifespan of parrots.'), SystemMessage(content='Context from last attempt: I found the age of the oldest parrot, Cookie, who lived to be 83 years old. However, I need to search again to find the average lifespan of parrots to complete the comparison.')]}\n",
-      "---\n",
-      "{'plan_and_schedule': [FunctionMessage(content='[{\\'url\\': \\'https://www.turlockvet.com/site/blog/2023/07/15/parrot-lifespan--how-long-pet-parrots-live\\', \\'content\\': \"Parrot Lifespan  the lifespan of a parrot?\\'.  Parrot Lifespan: How Long Do Pet Parrots Live?  how long they actually live and what you should know about owning a parrot.Jul 15, 2023 — Jul 15, 2023Generally, the average lifespan of smaller species of parrots such as Budgies and Cockatiels is about 5 - 15 years, while larger parrots such as\\\\xa0...\"}]', additional_kwargs={'idx': 3}, name='tavily_search_results_json')]}\n",
-      "---\n",
-      "{'join': [AIMessage(content=\"Thought: I have found that the oldest parrot on record, Cookie, lived to be 83 years old. Additionally, I've found that the average lifespan of parrots varies by species, with smaller species like Budgies and Cockatiels living between 5-15 years, and larger parrots potentially living longer. This allows me to compare Cookie's age to the average lifespan of smaller parrot species.\"), AIMessage(content=\"The oldest parrot on record is Cookie, a pink cockatoo, who lived to be 83 years old. Compared to the average lifespan of smaller parrot species such as Budgies and Cockatiels, which is about 5-15 years, Cookie lived significantly longer. The average lifespan of larger parrot species wasn't specified, but it's implied that larger parrots may live longer than smaller species, yet likely still much less than 83 years.\")]}\n",
-      "---\n",
-      "{'__end__': [HumanMessage(content=\"What's the oldest parrot alive, and how much longer is that than the average?\"), FunctionMessage(content=\"[{'url': 'https://a-z-animals.com/blog/discover-the-worlds-oldest-parrot/', 'content': 'How Old Is the World’s Oldest Parrot?  Discover the World’s Oldest Parrot Advertisement  of debate, so we’ll detail some other parrots whose lifespans may be longer but are hard to verify their exact age.  Comparing Parrots’ Lifespans to Other BirdsSep 8, 2023 — Sep 8, 2023The oldest parrot on record is Cookie, a pink cockatoo that survived to the age of 83 and survived his entire life at the Brookfield Zoo.'}]\", additional_kwargs={'idx': 0}, name='tavily_search_results_json'), FunctionMessage(content=\"HTTPError('502 Server Error: Bad Gateway for url: https://api.tavily.com/search')\", additional_kwargs={'idx': 1}, name='tavily_search_results_json'), FunctionMessage(content='join', additional_kwargs={'idx': 2}, name='join'), AIMessage(content='Thought: The oldest parrot on record is Cookie, a pink cockatoo, who lived to be 83 years old. However, there was an error fetching additional search results to compare this age to the average lifespan of parrots.'), SystemMessage(content='Context from last attempt: I found the age of the oldest parrot, Cookie, who lived to be 83 years old. However, I need to search again to find the average lifespan of parrots to complete the comparison. - Begin counting at : 3'), FunctionMessage(content='[{\\'url\\': \\'https://www.turlockvet.com/site/blog/2023/07/15/parrot-lifespan--how-long-pet-parrots-live\\', \\'content\\': \"Parrot Lifespan  the lifespan of a parrot?\\'.  Parrot Lifespan: How Long Do Pet Parrots Live?  how long they actually live and what you should know about owning a parrot.Jul 15, 2023 — Jul 15, 2023Generally, the average lifespan of smaller species of parrots such as Budgies and Cockatiels is about 5 - 15 years, while larger parrots such as\\\\xa0...\"}]', additional_kwargs={'idx': 3}, name='tavily_search_results_json'), AIMessage(content=\"Thought: I have found that the oldest parrot on record, Cookie, lived to be 83 years old. Additionally, I've found that the average lifespan of parrots varies by species, with smaller species like Budgies and Cockatiels living between 5-15 years, and larger parrots potentially living longer. This allows me to compare Cookie's age to the average lifespan of smaller parrot species.\"), AIMessage(content=\"The oldest parrot on record is Cookie, a pink cockatoo, who lived to be 83 years old. Compared to the average lifespan of smaller parrot species such as Budgies and Cockatiels, which is about 5-15 years, Cookie lived significantly longer. The average lifespan of larger parrot species wasn't specified, but it's implied that larger parrots may live longer than smaller species, yet likely still much less than 83 years.\")]}\n",
+      "{'join': {'messages': [AIMessage(content=\"Thought: We have information on Cookie, the cockatoo, who was recognized as the oldest living parrot at 82 years old in June 2015. This significantly exceeds the average lifespan for his kind, which is stated to be 40-60 years. The second source provides a general lifespan range for parrots and other birds, which is 10-50 years. However, this range varies significantly depending on the species and conditions. Since Cookie's specific lifespan far exceeds the average for his species and falls outside the general range for parrots, we can answer the user's question.\", id='51a280ac-2327-40c5-a27a-c821697d5a4b'), AIMessage(content='The oldest parrot recorded was Cookie, a cockatoo, who lived to be 82 years old in June 2015. This is significantly longer than the average lifespan for his species, which is 40-60 years, and also exceeds the general lifespan range for parrots, which can vary from 10 to 50 years. Therefore, Cookie lived 22 to 42 years longer than the average lifespan for his species.', id='139ecedf-b090-4197-88c0-0fa39883b392')]}}\n",
       "---\n"
      ]
     }
    ],
    "source": [
-    "steps = chain.stream(\n",
+    "steps = chain.stream({\"messages\":\n",
     "    [\n",
     "        HumanMessage(\n",
     "            content=\"What's the oldest parrot alive, and how much longer is that than the average?\"\n",
     "        )\n",
-    "    ],\n",
+    "    ]\n",
+    "    },\n",
     "    {\n",
     "        \"recursion_limit\": 100,\n",
     "    },\n",
@@ -869,7 +862,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 94,
    "id": "6c65c414-7668-4fdf-ba97-f42f659b1317",
    "metadata": {},
    "outputs": [
@@ -877,13 +870,13 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "The oldest parrot on record is Cookie, a pink cockatoo, who lived to be 83 years old. Compared to the average lifespan of smaller parrot species such as Budgies and Cockatiels, which is about 5-15 years, Cookie lived significantly longer. The average lifespan of larger parrot species wasn't specified, but it's implied that larger parrots may live longer than smaller species, yet likely still much less than 83 years.\n"
+      "The oldest parrot recorded was Cookie, a cockatoo, who lived to be 82 years old in June 2015. This is significantly longer than the average lifespan for his species, which is 40-60 years, and also exceeds the general lifespan range for parrots, which can vary from 10 to 50 years. Therefore, Cookie lived 22 to 42 years longer than the average lifespan for his species.\n"
      ]
     }
    ],
    "source": [
     "# Final answer\n",
-    "print(step[END][-1].content)"
+    "print(step['join']['messages'][-1].content)"
    ]
   },
   {
@@ -896,7 +889,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": 96,
    "id": "38d3ea91-59ba-4267-8060-ed75bbc840c6",
    "metadata": {},
    "outputs": [
@@ -904,26 +897,25 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "{'plan_and_schedule': [FunctionMessage(content='3307.0', additional_kwargs={'idx': 1}, name='math'), FunctionMessage(content='7.565011820330969', additional_kwargs={'idx': 2}, name='math'), FunctionMessage(content='3314.565011820331', additional_kwargs={'idx': 3}, name='math'), FunctionMessage(content='join', additional_kwargs={'idx': 4}, name='join')]}\n",
-      "{'join': [AIMessage(content=\"Thought: The calculations for each part of the user's question have been successfully completed. The first calculation resulted in 3307.0, the second in 7.565011820330969, and the sum of those two values was correctly found to be 3314.565011820331.\"), AIMessage(content='The result of ((3*(4+5)/0.5)+3245) + 8 is 3307.0, the result of 32/4.23 is approximately 7.565, and the sum of those two values is approximately 3314.565.')]}\n",
-      "{'__end__': [HumanMessage(content=\"What's ((3*(4+5)/0.5)+3245) + 8? What's 32/4.23? What's the sum of those two values?\"), FunctionMessage(content='3307.0', additional_kwargs={'idx': 1}, name='math'), FunctionMessage(content='7.565011820330969', additional_kwargs={'idx': 2}, name='math'), FunctionMessage(content='3314.565011820331', additional_kwargs={'idx': 3}, name='math'), FunctionMessage(content='join', additional_kwargs={'idx': 4}, name='join'), AIMessage(content=\"Thought: The calculations for each part of the user's question have been successfully completed. The first calculation resulted in 3307.0, the second in 7.565011820330969, and the sum of those two values was correctly found to be 3314.565011820331.\"), AIMessage(content='The result of ((3*(4+5)/0.5)+3245) + 8 is 3307.0, the result of 32/4.23 is approximately 7.565, and the sum of those two values is approximately 3314.565.')]}\n"
+      "{'plan_and_schedule': {'messages': [FunctionMessage(content='3307.0', additional_kwargs={'idx': 1, 'args': {'problem': '((3*(4+5)/0.5)+3245) + 8'}}, name='math', tool_call_id=1), FunctionMessage(content='7.565011820330969', additional_kwargs={'idx': 2, 'args': {'problem': '32/4.23'}}, name='math', tool_call_id=2), FunctionMessage(content='join', additional_kwargs={'idx': 3, 'args': ()}, name='join', tool_call_id=3)]}}\n",
+      "{'join': {'messages': [AIMessage(content=\"Thought: The calculations for both individual questions have been provided: 3307.0 for the first equation and 7.565011820330969 for the second. To answer the user's final question, we need to sum these two values.\", id='96eb85f5-831f-434e-83d8-59deeebce05d'), AIMessage(content='The result of the first calculation is 3307.0, and the result of the second calculation is approximately 7.57. The sum of those two values is approximately 3314.57.', id='671a1a08-4725-4f98-997a-848815d61aa5')]}}\n"
      ]
     }
    ],
    "source": [
-    "for step in chain.stream(\n",
+    "for step in chain.stream({\"messages\":\n",
     "    [\n",
     "        HumanMessage(\n",
     "            content=\"What's ((3*(4+5)/0.5)+3245) + 8? What's 32/4.23? What's the sum of those two values?\"\n",
     "        )\n",
-    "    ]\n",
+    "    ]}\n",
     "):\n",
     "    print(step)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": 97,
    "id": "a6cf5fe0-f178-4197-950f-257711bff8d2",
    "metadata": {
     "scrolled": true
@@ -933,13 +925,53 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "The result of ((3*(4+5)/0.5)+3245) + 8 is 3307.0, the result of 32/4.23 is approximately 7.565, and the sum of those two values is approximately 3314.565.\n"
+      "The result of the first calculation is 3307.0, and the result of the second calculation is approximately 7.57. The sum of those two values is approximately 3314.57.\n"
      ]
     }
    ],
    "source": [
     "# Final answer\n",
-    "print(step[END][-1].content)"
+    "print(step['join']['messages'][-1].content)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f9487866",
+   "metadata": {},
+   "source": [
+    "#### Complex Replanning Example\n",
+    "\n",
+    "This question is likely to prompt the Replan functionality, but it may need to be run multiple times to see this in action."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "391d6931",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'plan_and_schedule': {'messages': [FunctionMessage(content=\"[{'url': 'https://www.timeanddate.com/weather/japan/tokyo', 'content': '88 / 84 °F. 13. 87 / 82 °F. 14. 84 / 80 °F. Detailed forecast for 14 days. Need some help? Current weather in Tokyo and forecast for today, tomorrow, and next 14 days.'}]\", additional_kwargs={'idx': 1, 'args': {'query': 'current temperature in Tokyo'}}, name='tavily_search_results_json', tool_call_id=1), FunctionMessage(content='join', additional_kwargs={'idx': 2, 'args': ()}, name='join', tool_call_id=2)]}}\n",
+      "{'join': {'messages': [AIMessage(content=\"Thought: The search result provides the current temperature in Tokyo but does not explicitly state which temperature (88 / 84 °F) corresponds to the current condition. It seems to be a range, possibly the day's high and low. Without a clear indication of the exact current temperature, it's challenging to provide a precise flashcard summary.\", id='8ef2a131-69db-4180-a76e-fd9d6f4037c1'), SystemMessage(content='Context from last attempt: The information provided does not explicitly state the current temperature in Tokyo; it provides a temperature range without specifying which is the current temperature. Need to find a source that gives the exact current temperature in Tokyo for a precise flashcard summary.', id='f5bd752c-b068-459a-8d9e-bd1f1b5fa4fe')]}}\n",
+      "{'plan_and_schedule': {'messages': [FunctionMessage(content='join', additional_kwargs={'idx': 3, 'args': ()}, name='join', tool_call_id=3)]}}\n",
+      "{'join': {'messages': [AIMessage(content=\"Thought: The search result provides a temperature range for Tokyo but does not specify the current temperature. This makes it challenging to create a precise flashcard without an exact current temperature. The user's request cannot be fully satisfied without this detail.\", id='3cc41891-4f47-4453-8edf-b989926ab25e'), SystemMessage(content='Context from last attempt: The search did not provide an exact current temperature for Tokyo, making it impossible to create a precise flashcard. A source that explicitly states the current temperature is needed for an accurate response.', id='96290b41-a4c4-4ab5-829a-89cc31dfe6c8')]}}\n",
+      "{'plan_and_schedule': {'messages': [FunctionMessage(content='join', additional_kwargs={'idx': 4, 'args': ()}, name='join', tool_call_id=4)]}}\n",
+      "{'join': {'messages': [AIMessage(content=\"Thought: The search result provides a temperature range for Tokyo but does not specify the current temperature. This makes it challenging to create a precise flashcard without an exact current temperature. The user's request cannot be fully satisfied without this detail.\", id='4724b242-ddb8-47e6-b235-de25de54fe45'), AIMessage(content='I was unable to find the exact current temperature in Tokyo. However, the temperature range for today in Tokyo is between 88°F and 84°F. For the most accurate and up-to-date temperature, I recommend checking a reliable weather forecasting website or app.', id='40e29a47-a001-4f65-a18f-65c2931d1ae5')]}}\n"
+     ]
+    }
+   ],
+   "source": [
+    "for step in chain.stream({\"messages\":\n",
+    "    [\n",
+    "        HumanMessage(\n",
+    "            content=\"Find the current temperature in Tokyo, then, respond with a flashcard summarizing this information\"\n",
+    "        )\n",
+    "    ]}\n",
+    "):\n",
+    "    print(step)"
    ]
   },
   {
@@ -955,14 +987,6 @@
     "2. Variable substitution is fragile in the example above. It could be made more robust by using a fine-tuned model and a more robust syntax (using e.g., Lark or a tool calling schema)\n",
     "3. The state can grow quite long if you require multiple re-planning runs. To handle, you could add a message compressor once you go above a certain token limit.\n"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "431217e6-4c00-409f-a2bd-40ebff902489",
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {
@@ -981,7 +1005,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.2"
+   "version": "3.11.9"
   }
  },
  "nbformat": 4,

examples/llm-compiler/math_tools.py

@@ -6,10 +6,10 @@ import numexpr
 from langchain.chains.openai_functions import create_structured_output_runnable
 from langchain_core.messages import SystemMessage
 from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
-from langchain_core.pydantic_v1 import BaseModel, Field
 from langchain_core.runnables import RunnableConfig
 from langchain_core.tools import StructuredTool
 from langchain_openai import ChatOpenAI
+from pydantic import BaseModel, Field
 
 _MATH_DESCRIPTION = (
     "math(problem: str, context: Optional[list[str]]) -> float:\n"
@@ -114,7 +114,7 @@ def get_math_tool(llm: ChatOpenAI):
             MessagesPlaceholder(variable_name="context", optional=True),
         ]
     )
-    extractor = create_structured_output_runnable(ExecuteCode, llm, prompt)
+    extractor = prompt | llm.with_structured_output(ExecuteCode)
 
     def calculate_expression(
         problem: str,

examples/many-tools.ipynb

@@ -328,9 +328,9 @@
     "            \"set more_information_needed False and populate a blank string for the query.\"\n",
     "        )\n",
     "        input_messages = [system] + state[\"messages\"]\n",
-    "        response = llm.bind_tools(\n",
-    "            [QueryForTools], tool_choice=True\n",
-    "        ).invoke(input_messages)\n",
+    "        response = llm.bind_tools([QueryForTools], tool_choice=True).invoke(\n",
+    "            input_messages\n",
+    "        )\n",
     "        query = response.tool_calls[0][\"args\"][\"query\"]\n",
     "    tool_documents = vector_store.similarity_search(query)\n",
     "    if hack_remove_tool_condition:\n",

examples/map-reduce.ipynb

@@ -25,7 +25,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "id": "3eb04cd1",
    "metadata": {},
    "outputs": [],
@@ -36,10 +36,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 2,
    "id": "dc292321",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdin",
+     "output_type": "stream",
+     "text": [
+      "ANTHROPIC_API_KEY:  ········\n"
+     ]
+    }
+   ],
    "source": [
     "import os\n",
     "import getpass\n",
@@ -55,7 +63,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 3,
    "id": "0f0f78e4-423d-4e2d-aa1a-01efaec4715f",
    "metadata": {},
    "outputs": [],
@@ -63,7 +71,7 @@
     "import operator\n",
     "from typing import Annotated, TypedDict\n",
     "\n",
-    "from langchain_core.pydantic_v1 import BaseModel\n",
+    "from langchain_core.pydantic_v1 import BaseModel, Field\n",
     "from langchain_anthropic import ChatAnthropic\n",
     "\n",
     "from langgraph.constants import Send\n",
@@ -87,7 +95,7 @@
     "\n",
     "\n",
     "class BestJoke(BaseModel):\n",
-    "    id: int\n",
+    "    id: int = Field(description=\"Index of the best joke, starting with 0\")\n",
     "\n",
     "\n",
     "model = ChatAnthropic(model=\"claude-3-5-sonnet-20240620\")\n",
@@ -161,7 +169,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 4,
    "id": "37ed1f71-63db-416f-b715-4617b33d4b7f",
    "metadata": {},
    "outputs": [
@@ -172,7 +180,7 @@
        "<IPython.core.display.Image object>"
       ]
      },
-     "execution_count": 11,
+     "execution_count": 4,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -185,7 +193,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 5,
    "id": "fd90cace",
    "metadata": {},
    "outputs": [
@@ -193,12 +201,12 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "{'generate_topics': {'subjects': ['lion', 'elephant', 'penguin', 'dolphin']}}\n",
+      "{'generate_topics': {'subjects': ['Lions', 'Elephants', 'Penguins', 'Dolphins']}}\n",
       "{'generate_joke': {'jokes': [\"Why don't elephants use computers? They're afraid of the mouse!\"]}}\n",
-      "{'generate_joke': {'jokes': [\"Why don't dolphins use smartphones? They're afraid of phishing!\"]}}\n",
-      "{'generate_joke': {'jokes': [\"Why don't lions like fast food? Because they can't catch it!\"]}}\n",
+      "{'generate_joke': {'jokes': [\"Why don't dolphins use smartphones? Because they're afraid of phishing!\"]}}\n",
       "{'generate_joke': {'jokes': [\"Why don't you see penguins in Britain? Because they're afraid of Wales!\"]}}\n",
-      "{'best_joke': {'best_selected_joke': \"Why don't you see penguins in Britain? Because they're afraid of Wales!\"}}\n"
+      "{'generate_joke': {'jokes': [\"Why don't lions like fast food? Because they can't catch it!\"]}}\n",
+      "{'best_joke': {'best_selected_joke': \"Why don't dolphins use smartphones? Because they're afraid of phishing!\"}}\n"
      ]
     }
    ],
@@ -207,21 +215,13 @@
     "for s in app.stream({\"topic\": \"animals\"}):\n",
     "    print(s)"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "f28eaf56",
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
+   "display_name": "langgraph",
    "language": "python",
-   "name": "python3"
+   "name": "langgraph"
   },
   "language_info": {
    "codemirror_mode": {
@@ -233,7 +233,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.8"
+   "version": "3.11.9"
   }
  },
  "nbformat": 4,

examples/memory/add-summary-conversation-history.ipynb

@@ -508,14 +508,6 @@
     "for event in app.stream({\"messages\": [input_message]}, config, stream_mode=\"updates\"):\n",
     "    print_update(event)"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "67d26013-1362-4cee-b135-ab5c3c4eb3d0",
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {

examples/memory/delete-messages.ipynb

@@ -52,7 +52,7 @@
    "metadata": {},
    "outputs": [
     {
-     "name": "stdin",
+     "name": "stdout",
      "output_type": "stream",
      "text": [
       "ANTHROPIC_API_KEY:  ········\n"
@@ -466,14 +466,6 @@
    "source": [
     "Remember, when deleting messages you will want to make sure that the remaining message list is still valid. This message list **may actually not be** - this is because it currently starts with an AI message, which some models do not allow."
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "4d7222cd-5767-42f0-bc69-10615127eba5",
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {

examples/memory/manage-conversation-history.ipynb

@@ -268,8 +268,8 @@
     "\n",
     "\n",
     "def filter_messages(messages: list):\n",
-    "    # This is very simple helper function which only ever uses the last two messages\n",
-    "    return messages[-2:]\n",
+    "    # This is very simple helper function which only ever uses the last message\n",
+    "    return messages[-1:]\n",
     "\n",
     "\n",
     "# Define the function that calls the model\n",
@@ -360,21 +360,13 @@
     "- [How to filter messages](https://python.langchain.com/v0.2/docs/how_to/filter_messages/)\n",
     "- [How to trim messages](https://python.langchain.com/v0.2/docs/how_to/trim_messages/)"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "686861bb-ec32-46f3-b7b3-fdac106f22f6",
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
+   "display_name": "langgraph-example-dev",
    "language": "python",
-   "name": "python3"
+   "name": "langgraph-example-dev"
   },
   "language_info": {
    "codemirror_mode": {
@@ -386,7 +378,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.1"
+   "version": "3.11.9"
   }
  },
  "nbformat": 4,

examples/multi_agent/agent_supervisor.ipynb

@@ -26,7 +26,10 @@
    "id": "0d30b6f7-3bec-4d9f-af50-43dfdc81ae6c",
    "metadata": {},
    "outputs": [],
-   "source": ["%%capture --no-stderr\n%pip install -U langgraph langchain langchain_openai langchain_experimental langsmith pandas"]
+   "source": [
+    "%%capture --no-stderr\n",
+    "%pip install -U langgraph langchain langchain_openai langchain_experimental langsmith pandas"
+   ]
   },
   {
    "cell_type": "code",
@@ -34,7 +37,24 @@
    "id": "30c2f3de-c730-4aec-85a6-af2c2f058803",
    "metadata": {},
    "outputs": [],
-   "source": ["import getpass\nimport os\n\n\ndef _set_if_undefined(var: str):\n    if not os.environ.get(var):\n        os.environ[var] = getpass.getpass(f\"Please provide your {var}\")\n\n\n_set_if_undefined(\"OPENAI_API_KEY\")\n_set_if_undefined(\"LANGCHAIN_API_KEY\")\n_set_if_undefined(\"TAVILY_API_KEY\")\n\n# Optional, add tracing in LangSmith\nos.environ[\"LANGCHAIN_TRACING_V2\"] = \"true\"\nos.environ[\"LANGCHAIN_PROJECT\"] = \"Multi-agent Collaboration\""]
+   "source": [
+    "import getpass\n",
+    "import os\n",
+    "\n",
+    "\n",
+    "def _set_if_undefined(var: str):\n",
+    "    if not os.environ.get(var):\n",
+    "        os.environ[var] = getpass.getpass(f\"Please provide your {var}\")\n",
+    "\n",
+    "\n",
+    "_set_if_undefined(\"OPENAI_API_KEY\")\n",
+    "_set_if_undefined(\"LANGCHAIN_API_KEY\")\n",
+    "_set_if_undefined(\"TAVILY_API_KEY\")\n",
+    "\n",
+    "# Optional, add tracing in LangSmith\n",
+    "os.environ[\"LANGCHAIN_TRACING_V2\"] = \"true\"\n",
+    "os.environ[\"LANGCHAIN_PROJECT\"] = \"Multi-agent Collaboration\""
+   ]
   },
   {
    "cell_type": "markdown",
@@ -48,45 +68,51 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 1,
    "id": "f04c6778-403b-4b49-9b93-678e910d5cec",
    "metadata": {},
    "outputs": [],
-   "source": ["from typing import Annotated\n\nfrom langchain_community.tools.tavily_search import TavilySearchResults\nfrom langchain_experimental.tools import PythonREPLTool\n\ntavily_tool = TavilySearchResults(max_results=5)\n\n# This executes code locally, which can be unsafe\npython_repl_tool = PythonREPLTool()"]
+   "source": [
+    "from typing import Annotated\n",
+    "\n",
+    "from langchain_community.tools.tavily_search import TavilySearchResults\n",
+    "from langchain_experimental.tools import PythonREPLTool\n",
+    "\n",
+    "tavily_tool = TavilySearchResults(max_results=5)\n",
+    "\n",
+    "# This executes code locally, which can be unsafe\n",
+    "python_repl_tool = PythonREPLTool()"
+   ]
   },
   {
    "cell_type": "markdown",
    "id": "d58d1e85-22d4-4c22-9062-72a346a0d709",
    "metadata": {},
    "source": [
-    "## Helper Utilities\n",
-    "\n",
-    "Define a helper function below, which make it easier to add new agent worker nodes."
+    "## Helper Utilities"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "c4823dd9-26bd-4e1a-8117-b97b2860211a",
-   "metadata": {},
-   "outputs": [],
-   "source": ["from langchain.agents import AgentExecutor, create_openai_tools_agent\nfrom langchain_core.messages import BaseMessage, HumanMessage\nfrom langchain_openai import ChatOpenAI\n\n\ndef create_agent(llm: ChatOpenAI, tools: list, system_prompt: str):\n    # Each worker node will be given a name and some tools.\n    prompt = ChatPromptTemplate.from_messages(\n        [\n            (\n                \"system\",\n                system_prompt,\n            ),\n            MessagesPlaceholder(variable_name=\"messages\"),\n            MessagesPlaceholder(variable_name=\"agent_scratchpad\"),\n        ]\n    )\n    agent = create_openai_tools_agent(llm, tools, prompt)\n    executor = AgentExecutor(agent=agent, tools=tools)\n    return executor"]
-  },
   {
    "cell_type": "markdown",
    "id": "b7c302b0-cd57-4913-986f-5dc7d6d77386",
    "metadata": {},
    "source": [
-    "We can also define a function that we will use to be the nodes in the graph - it takes care of converting the agent response to a human message. This is important because that is how we will add it the global state of the graph"
+    "Define a helper function that we will use to create the nodes in the graph - it takes care of converting the agent response to a human message. This is important because that is how we will add it the global state of the graph"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 2,
    "id": "80862241-a1a7-4726-bce5-f867b233832e",
    "metadata": {},
    "outputs": [],
-   "source": ["def agent_node(state, agent, name):\n    result = agent.invoke(state)\n    return {\"messages\": [HumanMessage(content=result[\"output\"], name=name)]}"]
+   "source": [
+    "from langchain_core.messages import HumanMessage\n",
+    "\n",
+    "def agent_node(state, agent, name):\n",
+    "    result = agent.invoke(state)\n",
+    "    return {\"messages\": [HumanMessage(content=result[\"messages\"][-1].content, name=name)]}"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -100,11 +126,53 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 13,
    "id": "311f0a58-b425-4496-adac-dc4cd8ffb912",
    "metadata": {},
    "outputs": [],
-   "source": ["from langchain_core.output_parsers.openai_functions import JsonOutputFunctionsParser\nfrom langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder\n\nmembers = [\"Researcher\", \"Coder\"]\nsystem_prompt = (\n    \"You are a supervisor tasked with managing a conversation between the\"\n    \" following workers:  {members}. Given the following user request,\"\n    \" respond with the worker to act next. Each worker will perform a\"\n    \" task and respond with their results and status. When finished,\"\n    \" respond with FINISH.\"\n)\n# Our team supervisor is an LLM node. It just picks the next agent to process\n# and decides when the work is completed\noptions = [\"FINISH\"] + members\n# Using openai function calling can make output parsing easier for us\nfunction_def = {\n    \"name\": \"route\",\n    \"description\": \"Select the next role.\",\n    \"parameters\": {\n        \"title\": \"routeSchema\",\n        \"type\": \"object\",\n        \"properties\": {\n            \"next\": {\n                \"title\": \"Next\",\n                \"anyOf\": [\n                    {\"enum\": options},\n                ],\n            }\n        },\n        \"required\": [\"next\"],\n    },\n}\nprompt = ChatPromptTemplate.from_messages(\n    [\n        (\"system\", system_prompt),\n        MessagesPlaceholder(variable_name=\"messages\"),\n        (\n            \"system\",\n            \"Given the conversation above, who should act next?\"\n            \" Or should we FINISH? Select one of: {options}\",\n        ),\n    ]\n).partial(options=str(options), members=\", \".join(members))\n\nllm = ChatOpenAI(model=\"gpt-4-1106-preview\")\n\nsupervisor_chain = (\n    prompt\n    | llm.bind_functions(functions=[function_def], function_call=\"route\")\n    | JsonOutputFunctionsParser()\n)"]
+   "source": [
+    "from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder\n",
+    "from langchain_openai import ChatOpenAI\n",
+    "from pydantic import BaseModel\n",
+    "from typing import Literal\n",
+    "\n",
+    "members = [\"Researcher\", \"Coder\"]\n",
+    "system_prompt = (\n",
+    "    \"You are a supervisor tasked with managing a conversation between the\"\n",
+    "    \" following workers:  {members}. Given the following user request,\"\n",
+    "    \" respond with the worker to act next. Each worker will perform a\"\n",
+    "    \" task and respond with their results and status. When finished,\"\n",
+    "    \" respond with FINISH.\"\n",
+    ")\n",
+    "# Our team supervisor is an LLM node. It just picks the next agent to process\n",
+    "# and decides when the work is completed\n",
+    "options = [\"FINISH\"] + members\n",
+    "\n",
+    "class routeResponse(BaseModel):\n",
+    "    next: Literal[*options]\n",
+    "\n",
+    "prompt = ChatPromptTemplate.from_messages(\n",
+    "    [\n",
+    "        (\"system\", system_prompt),\n",
+    "        MessagesPlaceholder(variable_name=\"messages\"),\n",
+    "        (\n",
+    "            \"system\",\n",
+    "            \"Given the conversation above, who should act next?\"\n",
+    "            \" Or should we FINISH? Select one of: {options}\",\n",
+    "        ),\n",
+    "    ]\n",
+    ").partial(options=str(options), members=\", \".join(members))\n",
+    "\n",
+    "\n",
+    "llm = ChatOpenAI(model=\"gpt-4o\")\n",
+    "\n",
+    "def supervisor_agent(state):\n",
+    "    supervisor_chain = (\n",
+    "        prompt\n",
+    "        | llm.with_structured_output(routeResponse)\n",
+    "    )\n",
+    "    return supervisor_chain.invoke(state)"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -118,11 +186,41 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 14,
    "id": "6a430af7-8fce-4e66-ba9e-d940c1bc48e8",
    "metadata": {},
    "outputs": [],
-   "source": ["import functools\nimport operator\nfrom typing import Sequence, TypedDict\n\nfrom langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder\n\nfrom langgraph.graph import END, StateGraph, START\n\n\n# The agent state is the input to each node in the graph\nclass AgentState(TypedDict):\n    # The annotation tells the graph that new messages will always\n    # be added to the current states\n    messages: Annotated[Sequence[BaseMessage], operator.add]\n    # The 'next' field indicates where to route to next\n    next: str\n\n\nresearch_agent = create_agent(llm, [tavily_tool], \"You are a web researcher.\")\nresearch_node = functools.partial(agent_node, agent=research_agent, name=\"Researcher\")\n\n# NOTE: THIS PERFORMS ARBITRARY CODE EXECUTION. PROCEED WITH CAUTION\ncode_agent = create_agent(\n    llm,\n    [python_repl_tool],\n    \"You may generate safe python code to analyze data and generate charts using matplotlib.\",\n)\ncode_node = functools.partial(agent_node, agent=code_agent, name=\"Coder\")\n\nworkflow = StateGraph(AgentState)\nworkflow.add_node(\"Researcher\", research_node)\nworkflow.add_node(\"Coder\", code_node)\nworkflow.add_node(\"supervisor\", supervisor_chain)"]
+   "source": [
+    "import functools\n",
+    "import operator\n",
+    "from typing import Sequence, TypedDict\n",
+    "\n",
+    "from langchain_core.messages import BaseMessage\n",
+    "\n",
+    "from langgraph.graph import END, StateGraph, START\n",
+    "from langgraph.prebuilt import create_react_agent\n",
+    "\n",
+    "# The agent state is the input to each node in the graph\n",
+    "class AgentState(TypedDict):\n",
+    "    # The annotation tells the graph that new messages will always\n",
+    "    # be added to the current states\n",
+    "    messages: Annotated[Sequence[BaseMessage], operator.add]\n",
+    "    # The 'next' field indicates where to route to next\n",
+    "    next: str\n",
+    "\n",
+    "\n",
+    "research_agent = create_react_agent(llm, tools=[tavily_tool])\n",
+    "research_node = functools.partial(agent_node, agent=research_agent, name=\"Researcher\")\n",
+    "\n",
+    "# NOTE: THIS PERFORMS ARBITRARY CODE EXECUTION. PROCEED WITH CAUTION\n",
+    "code_agent = create_react_agent(llm, tools=[python_repl_tool])\n",
+    "code_node = functools.partial(agent_node, agent=code_agent, name=\"Coder\")\n",
+    "\n",
+    "workflow = StateGraph(AgentState)\n",
+    "workflow.add_node(\"Researcher\", research_node)\n",
+    "workflow.add_node(\"Coder\", code_node)\n",
+    "workflow.add_node(\"supervisor\", supervisor_agent)"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -134,11 +232,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 15,
    "id": "14778e86-077b-4e6a-893c-400e59b0cdbf",
    "metadata": {},
    "outputs": [],
-   "source": ["for member in members:\n    # We want our workers to ALWAYS \"report back\" to the supervisor when done\n    workflow.add_edge(member, \"supervisor\")\n# The supervisor populates the \"next\" field in the graph state\n# which routes to a node or finishes\nconditional_map = {k: k for k in members}\nconditional_map[\"FINISH\"] = END\nworkflow.add_conditional_edges(\"supervisor\", lambda x: x[\"next\"], conditional_map)\n# Finally, add entrypoint\nworkflow.add_edge(START, \"supervisor\")\n\ngraph = workflow.compile()"]
+   "source": [
+    "for member in members:\n",
+    "    # We want our workers to ALWAYS \"report back\" to the supervisor when done\n",
+    "    workflow.add_edge(member, \"supervisor\")\n",
+    "# The supervisor populates the \"next\" field in the graph state\n",
+    "# which routes to a node or finishes\n",
+    "conditional_map = {k: k for k in members}\n",
+    "conditional_map[\"FINISH\"] = END\n",
+    "workflow.add_conditional_edges(\"supervisor\", lambda x: x[\"next\"], conditional_map)\n",
+    "# Finally, add entrypoint\n",
+    "workflow.add_edge(START, \"supervisor\")\n",
+    "\n",
+    "graph = workflow.compile()"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -152,7 +263,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 16,
    "id": "56ba78e9-d9c1-457c-a073-d606d5d3e013",
    "metadata": {},
    "outputs": [
@@ -161,32 +272,30 @@
      "output_type": "stream",
      "text": [
       "{'supervisor': {'next': 'Coder'}}\n",
-      "----\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Python REPL can execute arbitrary code. Use with caution.\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{'Coder': {'messages': [HumanMessage(content=\"The code `print('Hello, World!')` was executed, and the output is:\\n\\n```\\nHello, World!\\n```\", name='Coder')]}}\n",
+      "----\n",
+      "{'Coder': {'messages': [HumanMessage(content='The code to print \"Hello, World!\" to the terminal is:\\n\\n```python\\nprint(\\'Hello, World!\\')\\n```\\n\\nWhen executed, it prints:\\n```\\nHello, World!\\n```', name='Coder')]}}\n",
       "----\n",
       "{'supervisor': {'next': 'FINISH'}}\n",
       "----\n"
      ]
     }
    ],
-   "source": ["for s in graph.stream(\n    {\n        \"messages\": [\n            HumanMessage(content=\"Code hello world and print it to the terminal\")\n        ]\n    }\n):\n    if \"__end__\" not in s:\n        print(s)\n        print(\"----\")"]
+   "source": [
+    "for s in graph.stream(\n",
+    "    {\n",
+    "        \"messages\": [\n",
+    "            HumanMessage(content=\"Code hello world and print it to the terminal\")\n",
+    "        ]\n",
+    "    }\n",
+    "):\n",
+    "    if \"__end__\" not in s:\n",
+    "        print(s)\n",
+    "        print(\"----\")"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 7,
    "id": "45a92dfd-0e11-47f5-aad4-b68d24990e34",
    "metadata": {},
    "outputs": [
@@ -196,22 +305,22 @@
      "text": [
       "{'supervisor': {'next': 'Researcher'}}\n",
       "----\n",
-      "{'Researcher': {'messages': [HumanMessage(content='**Research Report on Pikas**\\n\\nPikas are small mammals related to rabbits, known for their distinctive chirping sounds. They inhabit some of the most challenging environments, particularly boulder fields at high elevations, such as those found along the treeless slopes of the Southern Rockies, where they can be found at altitudes of up to 14,000 feet. Pikas are well-adapted to cold climates and typically do not fare well in warmer temperatures.\\n\\nRecent studies have shown that pikas are being impacted by climate change. Research by Peter Billman, a Ph.D. student from the University of Connecticut, indicates that pikas have moved upslope by approximately 1,160 feet. This upslope retreat is a direct response to changing climatic conditions, as pikas seek cooler temperatures at higher elevations.\\n\\nPikas are also known to be industrious foragers, particularly during the summer months when they gather vegetation to create haypiles for winter sustenance. Their behavior is encapsulated in the saying, \"making hay while the sun shines,\" reflecting their proactive approach to survival in harsh conditions.\\n\\nThe effects of climate change on pikas are not limited to the Southern Rockies. Studies published in Global Change Biology suggest that climate change is influencing pikas even in areas where they were previously thought to be less vulnerable, such as the Northern Rockies. These findings point to a broader trend of pikas moving to higher elevations, a behavior that may indicate a search for cooler, more suitable habitats.\\n\\nMoreover, researchers are exploring the possibility that pikas at lower elevations may have developed warm adaptations that could be beneficial for their future survival, given the ongoing climatic shifts. This line of research could help conservationists understand how pikas might cope with a warming world.\\n\\nIn conclusion, pikas are a species that not only fascinate with their unique behaviors and adaptations but also serve as indicators of environmental changes. Their upslope migration in response to climate change highlights the urgency for understanding and mitigating the effects of global warming on mountain ecosystems and the species that inhabit them.\\n\\n**Sources:**\\n- [Colorado Sun](https://coloradosun.com/2023/08/27/colorado-pika-population-climate-change/)\\n- [Wildlife.org](https://wildlife.org/climate-change-affects-pikas-even-in-unlikely-areas/)', name='Researcher')]}}\n",
+      "{'Researcher': {'messages': [HumanMessage(content='# Research Report on Pikas\\n\\nPikas, belonging to the genus Ochotona, are small, short-legged, and virtually tailless mammals that are often found in the mountains of western North America and across much of Asia. Despite their rodent-like appearance, pikas are not rodents but rather are part of the order Lagomorpha, which also includes rabbits and hares.\\n\\n## Behavior and Ecology\\nPikas are known for their unique behavior of not hibernating and remaining active throughout the winter. They navigate through tunnels under rocks and snow and rely on dried plants, which they have stored during warmer months in caches known as \"haypiles.\" This foraging strategy, termed \"haying,\" is crucial for their survival during the harsh winter months.\\n\\nPikas have a preference for cooler temperatures, typically foraging in temperatures below 25°C (77°F). They tend to avoid direct sunlight and stay in shaded regions when it gets warmer. A study has shown that for every 1°C (1.8°F) increase in ambient temperature, pikas can lose 3% of their foraging time, making them sensitive to climate change.\\n\\n## Distribution and Habitat\\nThe American pika (Ochotona princeps) and its relative, the collared pika (O. collaris), are found throughout the high mountainous regions of western North America. These species prefer cooler climates and have been observed to retreat to higher elevations as a response to increasing temperatures. Their current distribution is believed to be a result of a retreat from much larger ranges they occupied in the past, which included Western Europe and Eastern North America.\\n\\n## Conservation Status\\nThe International Union for Conservation of Nature and Natural Resources (IUCN) lists the American pika as a species of Least Concern but notes that populations are declining and unlikely to rebound due to habitat loss from extreme temperatures. The sensitivity of pikas to summer heat makes them an indicator species for the potential effects of climate change. Studies have shown that some populations are in decline, and there have been cases of local extirpation, particularly in the Great Basin.\\n\\n## Human Impact\\nHuman activity has impacted the ecosystems where pikas live, with recorded interactions dating back to the 1970s. Such interactions have been linked to pikas having reduced foraging time, limiting the amount of food they can stockpile for winter. Additionally, pikas have been considered pests in regions like the Tibetan plateau, where high densities of burrowing pikas are thought to reduce forage for domestic livestock and damage grasslands.\\n\\n## Conclusion\\nPikas are fascinating creatures with distinct adaptations that allow them to thrive in alpine environments. However, their future is uncertain due to the looming threats of climate change and habitat alteration. Conservation efforts, research, and monitoring are vital to ensure the survival of these unique mammals in a changing world.\\n\\n---\\n\\n**Sources:**\\n- [Wikipedia - Pika](https://en.wikipedia.org/wiki/Pika)\\n- [Treehugger - American Pika](https://www.treehugger.com/surprising-facts-about-american-pika-4864528)\\n- [National Park Service - Pikas at Rocky Mountain National Park](https://www.nps.gov/romo/learn/nature/pikas.htm)\\n- [Wikipedia - American Pika](https://en.wikipedia.org/wiki/American_pika)\\n- [Britannica - Pika](https://www.britannica.com/animal/pika)', name='Researcher')]}}\n",
       "----\n",
       "{'supervisor': {'next': 'FINISH'}}\n",
       "----\n"
      ]
     }
    ],
-   "source": ["for s in graph.stream(\n    {\"messages\": [HumanMessage(content=\"Write a brief research report on pikas.\")]},\n    {\"recursion_limit\": 100},\n):\n    if \"__end__\" not in s:\n        print(s)\n        print(\"----\")"]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "1d363d2c-e0da-4cce-ba47-ad2aa9df0fef",
-   "metadata": {},
-   "outputs": [],
-   "source": [""]
+   "source": [
+    "for s in graph.stream(\n",
+    "    {\"messages\": [HumanMessage(content=\"Write a brief research report on pikas.\")]},\n",
+    "    {\"recursion_limit\": 100},\n",
+    "):\n",
+    "    if \"__end__\" not in s:\n",
+    "        print(s)\n",
+    "        print(\"----\")"
+   ]
   }
  ],
  "metadata": {
@@ -230,7 +339,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.1"
+   "version": "3.11.9"
   }
  },
  "nbformat": 4,

examples/pass-run-time-values-to-tools.ipynb

@@ -329,6 +329,7 @@
     "\n",
     "tools = [get_context, cite_context_sources]\n",
     "\n",
+    "\n",
     "# Define the function that calls the model\n",
     "def call_model(state, config):\n",
     "    messages = state[\"messages\"]\n",

examples/pass_private_state.ipynb

@@ -72,12 +72,12 @@
     "# Node to retrieve documents\n",
     "def retrieve_documents(state: QueryOutputState) -> DocumentOutputState:\n",
     "    # Replace this with real logic\n",
-    "    return {\"docs\": [state['query']] * 2}\n",
+    "    return {\"docs\": [state[\"query\"]] * 2}\n",
     "\n",
     "\n",
     "# Node to generate answer\n",
     "def generate(state: GenerateInputState) -> OverallState:\n",
-    "    return {\"answer\": \"\\n\\n\".join(state['docs'] + [state['question']])}\n",
+    "    return {\"answer\": \"\\n\\n\".join(state[\"docs\"] + [state[\"question\"]])}\n",
     "\n",
     "\n",
     "graph = StateGraph(OverallState)\n",
@@ -92,14 +92,6 @@
     "\n",
     "graph.invoke({\"question\": \"foo\"})"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "3ffc2d8c-717f-42c9-b0aa-15b178a5cc8b",
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {

examples/persistence.ipynb

@@ -561,14 +561,6 @@
         "):\n",
         "    event[\"messages\"][-1].pretty_print()"
       ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "id": "eb20430f",
-      "metadata": {},
-      "outputs": [],
-      "source": []
     }
   ],
   "metadata": {
@@ -587,7 +579,7 @@
       "name": "python",
       "nbconvert_exporter": "python",
       "pygments_lexer": "ipython3",
-      "version": "3.11.9"
+      "version": "3.12.2"
     }
   },
   "nbformat": 4,

examples/persistence_mongodb.ipynb

@@ -630,7 +630,7 @@
     "                    upsert=True,\n",
     "                )\n",
     "            )\n",
-    "        await self.db[\"checkpoint_writes\"].bulk_write(operations)\n"
+    "        await self.db[\"checkpoint_writes\"].bulk_write(operations)"
    ]
   },
   {
@@ -685,7 +685,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "with MongoDBSaver.from_conn_info(host=\"localhost\", port=27017, db_name=\"checkpoints\") as checkpointer:\n",
+    "with MongoDBSaver.from_conn_info(\n",
+    "    host=\"localhost\", port=27017, db_name=\"checkpoints\"\n",
+    ") as checkpointer:\n",
     "    graph = create_react_agent(model, tools=tools, checkpointer=checkpointer)\n",
     "    config = {\"configurable\": {\"thread_id\": \"1\"}}\n",
     "    res = graph.invoke({\"messages\": [(\"human\", \"what's the weather in sf\")]}, config)\n",
@@ -796,10 +798,14 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "async with AsyncMongoDBSaver.from_conn_info(host=\"localhost\", port=27017, db_name=\"checkpoints\") as checkpointer:\n",
+    "async with AsyncMongoDBSaver.from_conn_info(\n",
+    "    host=\"localhost\", port=27017, db_name=\"checkpoints\"\n",
+    ") as checkpointer:\n",
     "    graph = create_react_agent(model, tools=tools, checkpointer=checkpointer)\n",
     "    config = {\"configurable\": {\"thread_id\": \"2\"}}\n",
-    "    res = await graph.ainvoke({\"messages\": [(\"human\", \"what's the weather in nyc\")]}, config)\n",
+    "    res = await graph.ainvoke(\n",
+    "        {\"messages\": [(\"human\", \"what's the weather in nyc\")]}, config\n",
+    "    )\n",
     "\n",
     "    latest_checkpoint = await checkpointer.aget(config)\n",
     "    latest_checkpoint_tuple = await checkpointer.aget_tuple(config)\n",

examples/persistence_postgres.ipynb

@@ -122,7 +122,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "DB_URI = \"postgresql://postgres:postgres@localhost:5441/postgres?sslmode=disable\""
+    "DB_URI = \"postgresql://postgres:postgres@localhost:5442/postgres?sslmode=disable\""
    ]
   },
   {
@@ -132,12 +132,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from psycopg.rows import dict_row\n",
-    "\n",
-    "connection_kwargs ={\n",
+    "connection_kwargs = {\n",
     "    \"autocommit\": True,\n",
     "    \"prepare_threshold\": 0,\n",
-    "    \"row_factory\": dict_row,\n",
     "}"
    ]
   },
@@ -162,15 +159,13 @@
    "source": [
     "from psycopg_pool import ConnectionPool\n",
     "\n",
-    "pool = ConnectionPool(\n",
+    "with ConnectionPool(\n",
     "    # Example configuration\n",
     "    conninfo=DB_URI,\n",
     "    max_size=20,\n",
-    "    kwargs=connection_kwargs\n",
-    ")\n",
-    "\n",
-    "with pool.connection() as conn:\n",
-    "    checkpointer = PostgresSaver(conn)\n",
+    "    kwargs=connection_kwargs,\n",
+    ") as pool:\n",
+    "    checkpointer = PostgresSaver(pool)\n",
     "\n",
     "    # NOTE: you need to call .setup() the first time you're using your checkpointer\n",
     "    checkpointer.setup()\n",
@@ -394,9 +389,9 @@
     "    # Example configuration\n",
     "    conninfo=DB_URI,\n",
     "    max_size=20,\n",
-    "    kwargs=connection_kwargs\n",
-    ") as pool, pool.connection() as conn:\n",
-    "    checkpointer = AsyncPostgresSaver(conn)\n",
+    "    kwargs=connection_kwargs,\n",
+    ") as pool:\n",
+    "    checkpointer = AsyncPostgresSaver(pool)\n",
     "\n",
     "    # NOTE: you need to call .setup() the first time you're using your checkpointer\n",
     "    # await checkpointer.setup()\n",
@@ -551,9 +546,9 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "langgraph-postgres",
+   "display_name": "langgraph",
    "language": "python",
-   "name": "langgraph-postgres"
+   "name": "langgraph"
   },
   "language_info": {
    "codemirror_mode": {

examples/persistence_redis.ipynb

@@ -530,7 +530,9 @@
     "\n",
     "    @classmethod\n",
     "    @asynccontextmanager\n",
-    "    async def from_conn_info(cls, *, host: str, port: int, db: int) -> AsyncIterator[\"AsyncRedisSaver\"]:\n",
+    "    async def from_conn_info(\n",
+    "        cls, *, host: str, port: int, db: int\n",
+    "    ) -> AsyncIterator[\"AsyncRedisSaver\"]:\n",
     "        conn = None\n",
     "        try:\n",
     "            conn = AsyncRedis(host=host, port=port, db=db)\n",
@@ -887,10 +889,14 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "async with AsyncRedisSaver.from_conn_info(host=\"localhost\", port=6379, db=0) as checkpointer:\n",
+    "async with AsyncRedisSaver.from_conn_info(\n",
+    "    host=\"localhost\", port=6379, db=0\n",
+    ") as checkpointer:\n",
     "    graph = create_react_agent(model, tools=tools, checkpointer=checkpointer)\n",
     "    config = {\"configurable\": {\"thread_id\": \"2\"}}\n",
-    "    res = await graph.ainvoke({\"messages\": [(\"human\", \"what's the weather in nyc\")]}, config)\n",
+    "    res = await graph.ainvoke(\n",
+    "        {\"messages\": [(\"human\", \"what's the weather in nyc\")]}, config\n",
+    "    )\n",
     "\n",
     "    latest_checkpoint = await checkpointer.aget(config)\n",
     "    latest_checkpoint_tuple = await checkpointer.aget_tuple(config)\n",

examples/rag/langgraph_agentic_rag.ipynb

@@ -20,7 +20,10 @@
    "id": "969fb438",
    "metadata": {},
    "outputs": [],
-   "source": ["%%capture --no-stderr\n%pip install -U --quiet langchain-community tiktoken langchain-openai langchainhub chromadb langchain langgraph langchain-text-splitters"]
+   "source": [
+    "%%capture --no-stderr\n",
+    "%pip install -U --quiet langchain-community tiktoken langchain-openai langchainhub chromadb langchain langgraph langchain-text-splitters"
+   ]
   },
   {
    "cell_type": "code",
@@ -28,7 +31,22 @@
    "id": "e4958a8c",
    "metadata": {},
    "outputs": [],
-   "source": ["import getpass\nimport os\n\n\ndef _set_env(key: str):\n    if key not in os.environ:\n        os.environ[key] = getpass.getpass(f\"{key}:\")\n\n\n_set_env(\"OPENAI_API_KEY\")\n\n# (Optional) For tracing\nos.environ[\"LANGCHAIN_TRACING_V2\"] = \"true\"\n_set_env(\"LANGCHAIN_API_KEY\")"]
+   "source": [
+    "import getpass\n",
+    "import os\n",
+    "\n",
+    "\n",
+    "def _set_env(key: str):\n",
+    "    if key not in os.environ:\n",
+    "        os.environ[key] = getpass.getpass(f\"{key}:\")\n",
+    "\n",
+    "\n",
+    "_set_env(\"OPENAI_API_KEY\")\n",
+    "\n",
+    "# (Optional) For tracing\n",
+    "os.environ[\"LANGCHAIN_TRACING_V2\"] = \"true\"\n",
+    "_set_env(\"LANGCHAIN_API_KEY\")"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -46,7 +64,34 @@
    "id": "e50c9efe-4abe-42fa-b35a-05eeeede9ec6",
    "metadata": {},
    "outputs": [],
-   "source": ["from langchain_community.document_loaders import WebBaseLoader\nfrom langchain_community.vectorstores import Chroma\nfrom langchain_openai import OpenAIEmbeddings\nfrom langchain_text_splitters import RecursiveCharacterTextSplitter\n\nurls = [\n    \"https://lilianweng.github.io/posts/2023-06-23-agent/\",\n    \"https://lilianweng.github.io/posts/2023-03-15-prompt-engineering/\",\n    \"https://lilianweng.github.io/posts/2023-10-25-adv-attack-llm/\",\n]\n\ndocs = [WebBaseLoader(url).load() for url in urls]\ndocs_list = [item for sublist in docs for item in sublist]\n\ntext_splitter = RecursiveCharacterTextSplitter.from_tiktoken_encoder(\n    chunk_size=100, chunk_overlap=50\n)\ndoc_splits = text_splitter.split_documents(docs_list)\n\n# Add to vectorDB\nvectorstore = Chroma.from_documents(\n    documents=doc_splits,\n    collection_name=\"rag-chroma\",\n    embedding=OpenAIEmbeddings(),\n)\nretriever = vectorstore.as_retriever()"]
+   "source": [
+    "from langchain_community.document_loaders import WebBaseLoader\n",
+    "from langchain_community.vectorstores import Chroma\n",
+    "from langchain_openai import OpenAIEmbeddings\n",
+    "from langchain_text_splitters import RecursiveCharacterTextSplitter\n",
+    "\n",
+    "urls = [\n",
+    "    \"https://lilianweng.github.io/posts/2023-06-23-agent/\",\n",
+    "    \"https://lilianweng.github.io/posts/2023-03-15-prompt-engineering/\",\n",
+    "    \"https://lilianweng.github.io/posts/2023-10-25-adv-attack-llm/\",\n",
+    "]\n",
+    "\n",
+    "docs = [WebBaseLoader(url).load() for url in urls]\n",
+    "docs_list = [item for sublist in docs for item in sublist]\n",
+    "\n",
+    "text_splitter = RecursiveCharacterTextSplitter.from_tiktoken_encoder(\n",
+    "    chunk_size=100, chunk_overlap=50\n",
+    ")\n",
+    "doc_splits = text_splitter.split_documents(docs_list)\n",
+    "\n",
+    "# Add to vectorDB\n",
+    "vectorstore = Chroma.from_documents(\n",
+    "    documents=doc_splits,\n",
+    "    collection_name=\"rag-chroma\",\n",
+    "    embedding=OpenAIEmbeddings(),\n",
+    ")\n",
+    "retriever = vectorstore.as_retriever()"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -62,7 +107,17 @@
    "id": "0b97bdd8-d7e3-444d-ac96-5ef4725f9048",
    "metadata": {},
    "outputs": [],
-   "source": ["from langchain.tools.retriever import create_retriever_tool\n\nretriever_tool = create_retriever_tool(\n    retriever,\n    \"retrieve_blog_posts\",\n    \"Search and return information about Lilian Weng blog posts on LLM agents, prompt engineering, and adversarial attacks on LLMs.\",\n)\n\ntools = [retriever_tool]"]
+   "source": [
+    "from langchain.tools.retriever import create_retriever_tool\n",
+    "\n",
+    "retriever_tool = create_retriever_tool(\n",
+    "    retriever,\n",
+    "    \"retrieve_blog_posts\",\n",
+    "    \"Search and return information about Lilian Weng blog posts on LLM agents, prompt engineering, and adversarial attacks on LLMs.\",\n",
+    ")\n",
+    "\n",
+    "tools = [retriever_tool]"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -71,7 +126,7 @@
    "source": [
     "## Agent state\n",
     " \n",
-    "We will defined a graph.\n",
+    "We will define a graph.\n",
     "\n",
     "A `state` object that it passes around to each node.\n",
     "\n",
@@ -86,7 +141,19 @@
    "id": "0e378706-47d5-425a-8ba0-57b9acffbd0c",
    "metadata": {},
    "outputs": [],
-   "source": ["from typing import Annotated, Sequence, TypedDict\n\nfrom langchain_core.messages import BaseMessage\n\nfrom langgraph.graph.message import add_messages\n\n\nclass AgentState(TypedDict):\n    # The add_messages function defines how an update should be processed\n    # Default is to replace. add_messages says \"append\"\n    messages: Annotated[Sequence[BaseMessage], add_messages]"]
+   "source": [
+    "from typing import Annotated, Sequence, TypedDict\n",
+    "\n",
+    "from langchain_core.messages import BaseMessage\n",
+    "\n",
+    "from langgraph.graph.message import add_messages\n",
+    "\n",
+    "\n",
+    "class AgentState(TypedDict):\n",
+    "    # The add_messages function defines how an update should be processed\n",
+    "    # Default is to replace. add_messages says \"append\"\n",
+    "    messages: Annotated[Sequence[BaseMessage], add_messages]"
+   ]
   },
   {
    "attachments": {
@@ -129,7 +196,173 @@
      ]
     }
    ],
-   "source": ["from typing import Annotated, Literal, Sequence, TypedDict\n\nfrom langchain import hub\nfrom langchain_core.messages import BaseMessage, HumanMessage\nfrom langchain_core.output_parsers import StrOutputParser\nfrom langchain_core.prompts import PromptTemplate\nfrom langchain_core.pydantic_v1 import BaseModel, Field\nfrom langchain_openai import ChatOpenAI\n\nfrom langgraph.prebuilt import tools_condition\n\n### Edges\n\n\ndef grade_documents(state) -> Literal[\"generate\", \"rewrite\"]:\n    \"\"\"\n    Determines whether the retrieved documents are relevant to the question.\n\n    Args:\n        state (messages): The current state\n\n    Returns:\n        str: A decision for whether the documents are relevant or not\n    \"\"\"\n\n    print(\"---CHECK RELEVANCE---\")\n\n    # Data model\n    class grade(BaseModel):\n        \"\"\"Binary score for relevance check.\"\"\"\n\n        binary_score: str = Field(description=\"Relevance score 'yes' or 'no'\")\n\n    # LLM\n    model = ChatOpenAI(temperature=0, model=\"gpt-4-0125-preview\", streaming=True)\n\n    # LLM with tool and validation\n    llm_with_tool = model.with_structured_output(grade)\n\n    # Prompt\n    prompt = PromptTemplate(\n        template=\"\"\"You are a grader assessing relevance of a retrieved document to a user question. \\n \n        Here is the retrieved document: \\n\\n {context} \\n\\n\n        Here is the user question: {question} \\n\n        If the document contains keyword(s) or semantic meaning related to the user question, grade it as relevant. \\n\n        Give a binary score 'yes' or 'no' score to indicate whether the document is relevant to the question.\"\"\",\n        input_variables=[\"context\", \"question\"],\n    )\n\n    # Chain\n    chain = prompt | llm_with_tool\n\n    messages = state[\"messages\"]\n    last_message = messages[-1]\n\n    question = messages[0].content\n    docs = last_message.content\n\n    scored_result = chain.invoke({\"question\": question, \"context\": docs})\n\n    score = scored_result.binary_score\n\n    if score == \"yes\":\n        print(\"---DECISION: DOCS RELEVANT---\")\n        return \"generate\"\n\n    else:\n        print(\"---DECISION: DOCS NOT RELEVANT---\")\n        print(score)\n        return \"rewrite\"\n\n\n### Nodes\n\n\ndef agent(state):\n    \"\"\"\n    Invokes the agent model to generate a response based on the current state. Given\n    the question, it will decide to retrieve using the retriever tool, or simply end.\n\n    Args:\n        state (messages): The current state\n\n    Returns:\n        dict: The updated state with the agent response appended to messages\n    \"\"\"\n    print(\"---CALL AGENT---\")\n    messages = state[\"messages\"]\n    model = ChatOpenAI(temperature=0, streaming=True, model=\"gpt-4-turbo\")\n    model = model.bind_tools(tools)\n    response = model.invoke(messages)\n    # We return a list, because this will get added to the existing list\n    return {\"messages\": [response]}\n\n\ndef rewrite(state):\n    \"\"\"\n    Transform the query to produce a better question.\n\n    Args:\n        state (messages): The current state\n\n    Returns:\n        dict: The updated state with re-phrased question\n    \"\"\"\n\n    print(\"---TRANSFORM QUERY---\")\n    messages = state[\"messages\"]\n    question = messages[0].content\n\n    msg = [\n        HumanMessage(\n            content=f\"\"\" \\n \n    Look at the input and try to reason about the underlying semantic intent / meaning. \\n \n    Here is the initial question:\n    \\n ------- \\n\n    {question} \n    \\n ------- \\n\n    Formulate an improved question: \"\"\",\n        )\n    ]\n\n    # Grader\n    model = ChatOpenAI(temperature=0, model=\"gpt-4-0125-preview\", streaming=True)\n    response = model.invoke(msg)\n    return {\"messages\": [response]}\n\n\ndef generate(state):\n    \"\"\"\n    Generate answer\n\n    Args:\n        state (messages): The current state\n\n    Returns:\n         dict: The updated state with re-phrased question\n    \"\"\"\n    print(\"---GENERATE---\")\n    messages = state[\"messages\"]\n    question = messages[0].content\n    last_message = messages[-1]\n\n    question = messages[0].content\n    docs = last_message.content\n\n    # Prompt\n    prompt = hub.pull(\"rlm/rag-prompt\")\n\n    # LLM\n    llm = ChatOpenAI(model_name=\"gpt-3.5-turbo\", temperature=0, streaming=True)\n\n    # Post-processing\n    def format_docs(docs):\n        return \"\\n\\n\".join(doc.page_content for doc in docs)\n\n    # Chain\n    rag_chain = prompt | llm | StrOutputParser()\n\n    # Run\n    response = rag_chain.invoke({\"context\": docs, \"question\": question})\n    return {\"messages\": [response]}\n\n\nprint(\"*\" * 20 + \"Prompt[rlm/rag-prompt]\" + \"*\" * 20)\nprompt = hub.pull(\"rlm/rag-prompt\").pretty_print()  # Show what the prompt looks like"]
+   "source": [
+    "from typing import Annotated, Literal, Sequence, TypedDict\n",
+    "\n",
+    "from langchain import hub\n",
+    "from langchain_core.messages import BaseMessage, HumanMessage\n",
+    "from langchain_core.output_parsers import StrOutputParser\n",
+    "from langchain_core.prompts import PromptTemplate\n",
+    "from langchain_core.pydantic_v1 import BaseModel, Field\n",
+    "from langchain_openai import ChatOpenAI\n",
+    "\n",
+    "from langgraph.prebuilt import tools_condition\n",
+    "\n",
+    "### Edges\n",
+    "\n",
+    "\n",
+    "def grade_documents(state) -> Literal[\"generate\", \"rewrite\"]:\n",
+    "    \"\"\"\n",
+    "    Determines whether the retrieved documents are relevant to the question.\n",
+    "\n",
+    "    Args:\n",
+    "        state (messages): The current state\n",
+    "\n",
+    "    Returns:\n",
+    "        str: A decision for whether the documents are relevant or not\n",
+    "    \"\"\"\n",
+    "\n",
+    "    print(\"---CHECK RELEVANCE---\")\n",
+    "\n",
+    "    # Data model\n",
+    "    class grade(BaseModel):\n",
+    "        \"\"\"Binary score for relevance check.\"\"\"\n",
+    "\n",
+    "        binary_score: str = Field(description=\"Relevance score 'yes' or 'no'\")\n",
+    "\n",
+    "    # LLM\n",
+    "    model = ChatOpenAI(temperature=0, model=\"gpt-4-0125-preview\", streaming=True)\n",
+    "\n",
+    "    # LLM with tool and validation\n",
+    "    llm_with_tool = model.with_structured_output(grade)\n",
+    "\n",
+    "    # Prompt\n",
+    "    prompt = PromptTemplate(\n",
+    "        template=\"\"\"You are a grader assessing relevance of a retrieved document to a user question. \\n \n",
+    "        Here is the retrieved document: \\n\\n {context} \\n\\n\n",
+    "        Here is the user question: {question} \\n\n",
+    "        If the document contains keyword(s) or semantic meaning related to the user question, grade it as relevant. \\n\n",
+    "        Give a binary score 'yes' or 'no' score to indicate whether the document is relevant to the question.\"\"\",\n",
+    "        input_variables=[\"context\", \"question\"],\n",
+    "    )\n",
+    "\n",
+    "    # Chain\n",
+    "    chain = prompt | llm_with_tool\n",
+    "\n",
+    "    messages = state[\"messages\"]\n",
+    "    last_message = messages[-1]\n",
+    "\n",
+    "    question = messages[0].content\n",
+    "    docs = last_message.content\n",
+    "\n",
+    "    scored_result = chain.invoke({\"question\": question, \"context\": docs})\n",
+    "\n",
+    "    score = scored_result.binary_score\n",
+    "\n",
+    "    if score == \"yes\":\n",
+    "        print(\"---DECISION: DOCS RELEVANT---\")\n",
+    "        return \"generate\"\n",
+    "\n",
+    "    else:\n",
+    "        print(\"---DECISION: DOCS NOT RELEVANT---\")\n",
+    "        print(score)\n",
+    "        return \"rewrite\"\n",
+    "\n",
+    "\n",
+    "### Nodes\n",
+    "\n",
+    "\n",
+    "def agent(state):\n",
+    "    \"\"\"\n",
+    "    Invokes the agent model to generate a response based on the current state. Given\n",
+    "    the question, it will decide to retrieve using the retriever tool, or simply end.\n",
+    "\n",
+    "    Args:\n",
+    "        state (messages): The current state\n",
+    "\n",
+    "    Returns:\n",
+    "        dict: The updated state with the agent response appended to messages\n",
+    "    \"\"\"\n",
+    "    print(\"---CALL AGENT---\")\n",
+    "    messages = state[\"messages\"]\n",
+    "    model = ChatOpenAI(temperature=0, streaming=True, model=\"gpt-4-turbo\")\n",
+    "    model = model.bind_tools(tools)\n",
+    "    response = model.invoke(messages)\n",
+    "    # We return a list, because this will get added to the existing list\n",
+    "    return {\"messages\": [response]}\n",
+    "\n",
+    "\n",
+    "def rewrite(state):\n",
+    "    \"\"\"\n",
+    "    Transform the query to produce a better question.\n",
+    "\n",
+    "    Args:\n",
+    "        state (messages): The current state\n",
+    "\n",
+    "    Returns:\n",
+    "        dict: The updated state with re-phrased question\n",
+    "    \"\"\"\n",
+    "\n",
+    "    print(\"---TRANSFORM QUERY---\")\n",
+    "    messages = state[\"messages\"]\n",
+    "    question = messages[0].content\n",
+    "\n",
+    "    msg = [\n",
+    "        HumanMessage(\n",
+    "            content=f\"\"\" \\n \n",
+    "    Look at the input and try to reason about the underlying semantic intent / meaning. \\n \n",
+    "    Here is the initial question:\n",
+    "    \\n ------- \\n\n",
+    "    {question} \n",
+    "    \\n ------- \\n\n",
+    "    Formulate an improved question: \"\"\",\n",
+    "        )\n",
+    "    ]\n",
+    "\n",
+    "    # Grader\n",
+    "    model = ChatOpenAI(temperature=0, model=\"gpt-4-0125-preview\", streaming=True)\n",
+    "    response = model.invoke(msg)\n",
+    "    return {\"messages\": [response]}\n",
+    "\n",
+    "\n",
+    "def generate(state):\n",
+    "    \"\"\"\n",
+    "    Generate answer\n",
+    "\n",
+    "    Args:\n",
+    "        state (messages): The current state\n",
+    "\n",
+    "    Returns:\n",
+    "         dict: The updated state with re-phrased question\n",
+    "    \"\"\"\n",
+    "    print(\"---GENERATE---\")\n",
+    "    messages = state[\"messages\"]\n",
+    "    question = messages[0].content\n",
+    "    last_message = messages[-1]\n",
+    "\n",
+    "    docs = last_message.content\n",
+    "\n",
+    "    # Prompt\n",
+    "    prompt = hub.pull(\"rlm/rag-prompt\")\n",
+    "\n",
+    "    # LLM\n",
+    "    llm = ChatOpenAI(model_name=\"gpt-3.5-turbo\", temperature=0, streaming=True)\n",
+    "\n",
+    "    # Post-processing\n",
+    "    def format_docs(docs):\n",
+    "        return \"\\n\\n\".join(doc.page_content for doc in docs)\n",
+    "\n",
+    "    # Chain\n",
+    "    rag_chain = prompt | llm | StrOutputParser()\n",
+    "\n",
+    "    # Run\n",
+    "    response = rag_chain.invoke({\"context\": docs, \"question\": question})\n",
+    "    return {\"messages\": [response]}\n",
+    "\n",
+    "\n",
+    "print(\"*\" * 20 + \"Prompt[rlm/rag-prompt]\" + \"*\" * 20)\n",
+    "prompt = hub.pull(\"rlm/rag-prompt\").pretty_print()  # Show what the prompt looks like"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -150,7 +383,48 @@
    "id": "8718a37f-83c2-4f16-9850-e61e0f49c3d4",
    "metadata": {},
    "outputs": [],
-   "source": ["from langgraph.graph import END, StateGraph, START\nfrom langgraph.prebuilt import ToolNode\n\n# Define a new graph\nworkflow = StateGraph(AgentState)\n\n# Define the nodes we will cycle between\nworkflow.add_node(\"agent\", agent)  # agent\nretrieve = ToolNode([retriever_tool])\nworkflow.add_node(\"retrieve\", retrieve)  # retrieval\nworkflow.add_node(\"rewrite\", rewrite)  # Re-writing the question\nworkflow.add_node(\n    \"generate\", generate\n)  # Generating a response after we know the documents are relevant\n# Call agent node to decide to retrieve or not\nworkflow.add_edge(START, \"agent\")\n\n# Decide whether to retrieve\nworkflow.add_conditional_edges(\n    \"agent\",\n    # Assess agent decision\n    tools_condition,\n    {\n        # Translate the condition outputs to nodes in our graph\n        \"tools\": \"retrieve\",\n        END: END,\n    },\n)\n\n# Edges taken after the `action` node is called.\nworkflow.add_conditional_edges(\n    \"retrieve\",\n    # Assess agent decision\n    grade_documents,\n)\nworkflow.add_edge(\"generate\", END)\nworkflow.add_edge(\"rewrite\", \"agent\")\n\n# Compile\ngraph = workflow.compile()"]
+   "source": [
+    "from langgraph.graph import END, StateGraph, START\n",
+    "from langgraph.prebuilt import ToolNode\n",
+    "\n",
+    "# Define a new graph\n",
+    "workflow = StateGraph(AgentState)\n",
+    "\n",
+    "# Define the nodes we will cycle between\n",
+    "workflow.add_node(\"agent\", agent)  # agent\n",
+    "retrieve = ToolNode([retriever_tool])\n",
+    "workflow.add_node(\"retrieve\", retrieve)  # retrieval\n",
+    "workflow.add_node(\"rewrite\", rewrite)  # Re-writing the question\n",
+    "workflow.add_node(\n",
+    "    \"generate\", generate\n",
+    ")  # Generating a response after we know the documents are relevant\n",
+    "# Call agent node to decide to retrieve or not\n",
+    "workflow.add_edge(START, \"agent\")\n",
+    "\n",
+    "# Decide whether to retrieve\n",
+    "workflow.add_conditional_edges(\n",
+    "    \"agent\",\n",
+    "    # Assess agent decision\n",
+    "    tools_condition,\n",
+    "    {\n",
+    "        # Translate the condition outputs to nodes in our graph\n",
+    "        \"tools\": \"retrieve\",\n",
+    "        END: END,\n",
+    "    },\n",
+    ")\n",
+    "\n",
+    "# Edges taken after the `action` node is called.\n",
+    "workflow.add_conditional_edges(\n",
+    "    \"retrieve\",\n",
+    "    # Assess agent decision\n",
+    "    grade_documents,\n",
+    ")\n",
+    "workflow.add_edge(\"generate\", END)\n",
+    "workflow.add_edge(\"rewrite\", \"agent\")\n",
+    "\n",
+    "# Compile\n",
+    "graph = workflow.compile()"
+   ]
   },
   {
    "cell_type": "code",
@@ -169,7 +443,15 @@
      "output_type": "display_data"
     }
    ],
-   "source": ["from IPython.display import Image, display\n\ntry:\n    display(Image(graph.get_graph(xray=True).draw_mermaid_png()))\nexcept Exception:\n    # This requires some extra dependencies and is optional\n    pass"]
+   "source": [
+    "from IPython.display import Image, display\n",
+    "\n",
+    "try:\n",
+    "    display(Image(graph.get_graph(xray=True).draw_mermaid_png()))\n",
+    "except Exception:\n",
+    "    # This requires some extra dependencies and is optional\n",
+    "    pass"
+   ]
   },
   {
    "cell_type": "code",
@@ -203,15 +485,21 @@
      ]
     }
    ],
-   "source": ["import pprint\n\ninputs = {\n    \"messages\": [\n        (\"user\", \"What does Lilian Weng say about the types of agent memory?\"),\n    ]\n}\nfor output in graph.stream(inputs):\n    for key, value in output.items():\n        pprint.pprint(f\"Output from node '{key}':\")\n        pprint.pprint(\"---\")\n        pprint.pprint(value, indent=2, width=80, depth=None)\n    pprint.pprint(\"\\n---\\n\")"]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "189333cc-5d34-4869-9f9b-741210e1096f",
-   "metadata": {},
-   "outputs": [],
-   "source": [""]
+   "source": [
+    "import pprint\n",
+    "\n",
+    "inputs = {\n",
+    "    \"messages\": [\n",
+    "        (\"user\", \"What does Lilian Weng say about the types of agent memory?\"),\n",
+    "    ]\n",
+    "}\n",
+    "for output in graph.stream(inputs):\n",
+    "    for key, value in output.items():\n",
+    "        pprint.pprint(f\"Output from node '{key}':\")\n",
+    "        pprint.pprint(\"---\")\n",
+    "        pprint.pprint(value, indent=2, width=80, depth=None)\n",
+    "    pprint.pprint(\"\\n---\\n\")"
+   ]
   }
  ],
  "metadata": {

examples/rag/langgraph_crag_local.ipynb

@@ -429,6 +429,14 @@
     "]\n",
     "\n",
     "\n",
+    "def find_tool_calls_react(messages):\n",
+    "    \"\"\"\n",
+    "    Find all tool calls in the messages returned\n",
+    "    \"\"\"\n",
+    "    tool_calls = [tc['name'] for m in messages['messages'] for tc in getattr(m, 'tool_calls', [])]\n",
+    "    return tool_calls\n",
+    "\n",
+    "\n",
     "def check_trajectory_react(root_run: Run, example: Example) -> dict:\n",
     "    \"\"\"\n",
     "    Check if all expected tools are called in exact order and without any additional tool calls.\n",

examples/reflexion/reflexion.ipynb

@@ -392,6 +392,7 @@
     "class State(TypedDict):\n",
     "    messages: Annotated[list, add_messages]\n",
     "\n",
+    "\n",
     "MAX_ITERATIONS = 5\n",
     "builder = StateGraph(State)\n",
     "builder.add_node(\"draft\", first_responder.respond)\n",
@@ -572,7 +573,7 @@
    ],
    "source": [
     "events = graph.stream(\n",
-    "    [HumanMessage(content=\"How should we handle the climate crisis?\")],\n",
+    "    {\"messages\": [(\"user\", \"How should we handle the climate crisis?\")]},\n",
     "    stream_mode=\"values\",\n",
     ")\n",
     "for i, step in enumerate(events):\n",

examples/self-discover/self-discover.ipynb

@@ -246,14 +246,6 @@
     "):\n",
     "    print(s)"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "20cac598",
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {

examples/state-context-key.ipynb

@@ -465,14 +465,6 @@
     "for chunk in app.stream(inputs, stream_mode=\"values\"):\n",
     "    chunk[\"messages\"][-1].pretty_print()"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "296c7456-da05-4326-95dc-47d6b312da9d",
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {

examples/state-model.ipynb

@@ -439,14 +439,6 @@
     "for chunk in app.stream(inputs, stream_mode=\"values\"):\n",
     "    chunk[\"messages\"][-1].pretty_print()"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "296c7456-da05-4326-95dc-47d6b312da9d",
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {

examples/storm/storm.ipynb

@@ -48,7 +48,10 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "%%capture --no-stderr\n%pip install -U langchain_community langchain_openai langgraph wikipedia  scikit-learn  langchain_fireworks\n# We use one or the other search engine below\n%pip install -U duckduckgo tavily-python"
+        "%%capture --no-stderr\n",
+        "%pip install -U langchain_community langchain_openai langgraph wikipedia  scikit-learn  langchain_fireworks\n",
+        "# We use one or the other search engine below\n",
+        "%pip install -U duckduckgo tavily-python"
       ]
     },
     {
@@ -57,7 +60,10 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "# Uncomment if you want to draw the pretty graph diagrams.\n# If you are on MacOS, you will need to run brew install graphviz before installing and update some environment flags\n# ! brew install graphviz\n# !CFLAGS=\"-I $(brew --prefix graphviz)/include\" LDFLAGS=\"-L $(brew --prefix graphviz)/lib\" pip install -U pygraphviz"
+        "# Uncomment if you want to draw the pretty graph diagrams.\n",
+        "# If you are on MacOS, you will need to run brew install graphviz before installing and update some environment flags\n",
+        "# ! brew install graphviz\n",
+        "# !CFLAGS=\"-I $(brew --prefix graphviz)/include\" LDFLAGS=\"-L $(brew --prefix graphviz)/lib\" pip install -U pygraphviz"
       ]
     },
     {
@@ -66,7 +72,21 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "import getpass\nimport os\n\n\ndef _set_env(var: str):\n    if os.environ.get(var):\n        return\n    os.environ[var] = getpass.getpass(var + \":\")\n\n\n# Set for tracing\nos.environ[\"LANGCHAIN_TRACING_V2\"] = \"true\"\nos.environ[\"LANGCHAIN_PROJECT\"] = \"STORM\"\n_set_env(\"LANGCHAIN_API_KEY\")\n_set_env(\"OPENAI_API_KEY\")"
+        "import getpass\n",
+        "import os\n",
+        "\n",
+        "\n",
+        "def _set_env(var: str):\n",
+        "    if os.environ.get(var):\n",
+        "        return\n",
+        "    os.environ[var] = getpass.getpass(var + \":\")\n",
+        "\n",
+        "\n",
+        "# Set for tracing\n",
+        "os.environ[\"LANGCHAIN_TRACING_V2\"] = \"true\"\n",
+        "os.environ[\"LANGCHAIN_PROJECT\"] = \"STORM\"\n",
+        "_set_env(\"LANGCHAIN_API_KEY\")\n",
+        "_set_env(\"OPENAI_API_KEY\")"
       ]
     },
     {
@@ -84,7 +104,12 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "from langchain_openai import ChatOpenAI\n\nfast_llm = ChatOpenAI(model=\"gpt-3.5-turbo\")\n# Uncomment for a Fireworks model\n# fast_llm = ChatFireworks(model=\"accounts/fireworks/models/firefunction-v1\", max_tokens=32_000)\nlong_context_llm = ChatOpenAI(model=\"gpt-4-turbo-preview\")"
+        "from langchain_openai import ChatOpenAI\n",
+        "\n",
+        "fast_llm = ChatOpenAI(model=\"gpt-3.5-turbo\")\n",
+        "# Uncomment for a Fireworks model\n",
+        "# fast_llm = ChatFireworks(model=\"accounts/fireworks/models/firefunction-v1\", max_tokens=32_000)\n",
+        "long_context_llm = ChatOpenAI(model=\"gpt-4-turbo-preview\")"
       ]
     },
     {
@@ -112,7 +137,64 @@
         }
       ],
       "source": [
-        "from typing import List, Optional\n\nfrom langchain_core.prompts import ChatPromptTemplate\nfrom langchain_core.pydantic_v1 import BaseModel, Field\n\ndirect_gen_outline_prompt = ChatPromptTemplate.from_messages(\n    [\n        (\n            \"system\",\n            \"You are a Wikipedia writer. Write an outline for a Wikipedia page about a user-provided topic. Be comprehensive and specific.\",\n        ),\n        (\"user\", \"{topic}\"),\n    ]\n)\n\n\nclass Subsection(BaseModel):\n    subsection_title: str = Field(..., title=\"Title of the subsection\")\n    description: str = Field(..., title=\"Content of the subsection\")\n\n    @property\n    def as_str(self) -> str:\n        return f\"### {self.subsection_title}\\n\\n{self.description}\".strip()\n\n\nclass Section(BaseModel):\n    section_title: str = Field(..., title=\"Title of the section\")\n    description: str = Field(..., title=\"Content of the section\")\n    subsections: Optional[List[Subsection]] = Field(\n        default=None,\n        title=\"Titles and descriptions for each subsection of the Wikipedia page.\",\n    )\n\n    @property\n    def as_str(self) -> str:\n        subsections = \"\\n\\n\".join(\n            f\"### {subsection.subsection_title}\\n\\n{subsection.description}\"\n            for subsection in self.subsections or []\n        )\n        return f\"## {self.section_title}\\n\\n{self.description}\\n\\n{subsections}\".strip()\n\n\nclass Outline(BaseModel):\n    page_title: str = Field(..., title=\"Title of the Wikipedia page\")\n    sections: List[Section] = Field(\n        default_factory=list,\n        title=\"Titles and descriptions for each section of the Wikipedia page.\",\n    )\n\n    @property\n    def as_str(self) -> str:\n        sections = \"\\n\\n\".join(section.as_str for section in self.sections)\n        return f\"# {self.page_title}\\n\\n{sections}\".strip()\n\n\ngenerate_outline_direct = direct_gen_outline_prompt | fast_llm.with_structured_output(\n    Outline\n)"
+        "from typing import List, Optional\n",
+        "\n",
+        "from langchain_core.prompts import ChatPromptTemplate\n",
+        "from langchain_core.pydantic_v1 import BaseModel, Field\n",
+        "\n",
+        "direct_gen_outline_prompt = ChatPromptTemplate.from_messages(\n",
+        "    [\n",
+        "        (\n",
+        "            \"system\",\n",
+        "            \"You are a Wikipedia writer. Write an outline for a Wikipedia page about a user-provided topic. Be comprehensive and specific.\",\n",
+        "        ),\n",
+        "        (\"user\", \"{topic}\"),\n",
+        "    ]\n",
+        ")\n",
+        "\n",
+        "\n",
+        "class Subsection(BaseModel):\n",
+        "    subsection_title: str = Field(..., title=\"Title of the subsection\")\n",
+        "    description: str = Field(..., title=\"Content of the subsection\")\n",
+        "\n",
+        "    @property\n",
+        "    def as_str(self) -> str:\n",
+        "        return f\"### {self.subsection_title}\\n\\n{self.description}\".strip()\n",
+        "\n",
+        "\n",
+        "class Section(BaseModel):\n",
+        "    section_title: str = Field(..., title=\"Title of the section\")\n",
+        "    description: str = Field(..., title=\"Content of the section\")\n",
+        "    subsections: Optional[List[Subsection]] = Field(\n",
+        "        default=None,\n",
+        "        title=\"Titles and descriptions for each subsection of the Wikipedia page.\",\n",
+        "    )\n",
+        "\n",
+        "    @property\n",
+        "    def as_str(self) -> str:\n",
+        "        subsections = \"\\n\\n\".join(\n",
+        "            f\"### {subsection.subsection_title}\\n\\n{subsection.description}\"\n",
+        "            for subsection in self.subsections or []\n",
+        "        )\n",
+        "        return f\"## {self.section_title}\\n\\n{self.description}\\n\\n{subsections}\".strip()\n",
+        "\n",
+        "\n",
+        "class Outline(BaseModel):\n",
+        "    page_title: str = Field(..., title=\"Title of the Wikipedia page\")\n",
+        "    sections: List[Section] = Field(\n",
+        "        default_factory=list,\n",
+        "        title=\"Titles and descriptions for each section of the Wikipedia page.\",\n",
+        "    )\n",
+        "\n",
+        "    @property\n",
+        "    def as_str(self) -> str:\n",
+        "        sections = \"\\n\\n\".join(section.as_str for section in self.sections)\n",
+        "        return f\"# {self.page_title}\\n\\n{sections}\".strip()\n",
+        "\n",
+        "\n",
+        "generate_outline_direct = direct_gen_outline_prompt | fast_llm.with_structured_output(\n",
+        "    Outline\n",
+        ")"
       ]
     },
     {
@@ -145,7 +227,11 @@
         }
       ],
       "source": [
-        "example_topic = \"Impact of million-plus token context window language models on RAG\"\n\ninitial_outline = generate_outline_direct.invoke({\"topic\": example_topic})\n\nprint(initial_outline.as_str)"
+        "example_topic = \"Impact of million-plus token context window language models on RAG\"\n",
+        "\n",
+        "initial_outline = generate_outline_direct.invoke({\"topic\": example_topic})\n",
+        "\n",
+        "print(initial_outline.as_str)"
       ]
     },
     {
@@ -165,7 +251,25 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "gen_related_topics_prompt = ChatPromptTemplate.from_template(\n    \"\"\"I'm writing a Wikipedia page for a topic mentioned below. Please identify and recommend some Wikipedia pages on closely related subjects. I'm looking for examples that provide insights into interesting aspects commonly associated with this topic, or examples that help me understand the typical content and structure included in Wikipedia pages for similar topics.\n\nPlease list the as many subjects and urls as you can.\n\nTopic of interest: {topic}\n\"\"\"\n)\n\n\nclass RelatedSubjects(BaseModel):\n    topics: List[str] = Field(\n        description=\"Comprehensive list of related subjects as background research.\",\n    )\n\n\nexpand_chain = gen_related_topics_prompt | fast_llm.with_structured_output(\n    RelatedSubjects\n)"
+        "gen_related_topics_prompt = ChatPromptTemplate.from_template(\n",
+        "    \"\"\"I'm writing a Wikipedia page for a topic mentioned below. Please identify and recommend some Wikipedia pages on closely related subjects. I'm looking for examples that provide insights into interesting aspects commonly associated with this topic, or examples that help me understand the typical content and structure included in Wikipedia pages for similar topics.\n",
+        "\n",
+        "Please list the as many subjects and urls as you can.\n",
+        "\n",
+        "Topic of interest: {topic}\n",
+        "\"\"\"\n",
+        ")\n",
+        "\n",
+        "\n",
+        "class RelatedSubjects(BaseModel):\n",
+        "    topics: List[str] = Field(\n",
+        "        description=\"Comprehensive list of related subjects as background research.\",\n",
+        "    )\n",
+        "\n",
+        "\n",
+        "expand_chain = gen_related_topics_prompt | fast_llm.with_structured_output(\n",
+        "    RelatedSubjects\n",
+        ")"
       ]
     },
     {
@@ -185,7 +289,8 @@
         }
       ],
       "source": [
-        "related_subjects = await expand_chain.ainvoke({\"topic\": example_topic})\nrelated_subjects"
+        "related_subjects = await expand_chain.ainvoke({\"topic\": example_topic})\n",
+        "related_subjects"
       ]
     },
     {
@@ -204,7 +309,49 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "class Editor(BaseModel):\n    affiliation: str = Field(\n        description=\"Primary affiliation of the editor.\",\n    )\n    name: str = Field(\n        description=\"Name of the editor.\", pattern=r\"^[a-zA-Z0-9_-]{1,64}$\"\n    )\n    role: str = Field(\n        description=\"Role of the editor in the context of the topic.\",\n    )\n    description: str = Field(\n        description=\"Description of the editor's focus, concerns, and motives.\",\n    )\n\n    @property\n    def persona(self) -> str:\n        return f\"Name: {self.name}\\nRole: {self.role}\\nAffiliation: {self.affiliation}\\nDescription: {self.description}\\n\"\n\n\nclass Perspectives(BaseModel):\n    editors: List[Editor] = Field(\n        description=\"Comprehensive list of editors with their roles and affiliations.\",\n        # Add a pydantic validation/restriction to be at most M editors\n    )\n\n\ngen_perspectives_prompt = ChatPromptTemplate.from_messages(\n    [\n        (\n            \"system\",\n            \"\"\"You need to select a diverse (and distinct) group of Wikipedia editors who will work together to create a comprehensive article on the topic. Each of them represents a different perspective, role, or affiliation related to this topic.\\\n    You can use other Wikipedia pages of related topics for inspiration. For each editor, add a description of what they will focus on.\n\n    Wiki page outlines of related topics for inspiration:\n    {examples}\"\"\",\n        ),\n        (\"user\", \"Topic of interest: {topic}\"),\n    ]\n)\n\ngen_perspectives_chain = gen_perspectives_prompt | ChatOpenAI(\n    model=\"gpt-3.5-turbo\"\n).with_structured_output(Perspectives)"
+        "class Editor(BaseModel):\n",
+        "    affiliation: str = Field(\n",
+        "        description=\"Primary affiliation of the editor.\",\n",
+        "    )\n",
+        "    name: str = Field(\n",
+        "        description=\"Name of the editor.\", pattern=r\"^[a-zA-Z0-9_-]{1,64}$\"\n",
+        "    )\n",
+        "    role: str = Field(\n",
+        "        description=\"Role of the editor in the context of the topic.\",\n",
+        "    )\n",
+        "    description: str = Field(\n",
+        "        description=\"Description of the editor's focus, concerns, and motives.\",\n",
+        "    )\n",
+        "\n",
+        "    @property\n",
+        "    def persona(self) -> str:\n",
+        "        return f\"Name: {self.name}\\nRole: {self.role}\\nAffiliation: {self.affiliation}\\nDescription: {self.description}\\n\"\n",
+        "\n",
+        "\n",
+        "class Perspectives(BaseModel):\n",
+        "    editors: List[Editor] = Field(\n",
+        "        description=\"Comprehensive list of editors with their roles and affiliations.\",\n",
+        "        # Add a pydantic validation/restriction to be at most M editors\n",
+        "    )\n",
+        "\n",
+        "\n",
+        "gen_perspectives_prompt = ChatPromptTemplate.from_messages(\n",
+        "    [\n",
+        "        (\n",
+        "            \"system\",\n",
+        "            \"\"\"You need to select a diverse (and distinct) group of Wikipedia editors who will work together to create a comprehensive article on the topic. Each of them represents a different perspective, role, or affiliation related to this topic.\\\n",
+        "    You can use other Wikipedia pages of related topics for inspiration. For each editor, add a description of what they will focus on.\n",
+        "\n",
+        "    Wiki page outlines of related topics for inspiration:\n",
+        "    {examples}\"\"\",\n",
+        "        ),\n",
+        "        (\"user\", \"Topic of interest: {topic}\"),\n",
+        "    ]\n",
+        ")\n",
+        "\n",
+        "gen_perspectives_chain = gen_perspectives_prompt | ChatOpenAI(\n",
+        "    model=\"gpt-3.5-turbo\"\n",
+        ").with_structured_output(Perspectives)"
       ]
     },
     {
@@ -213,7 +360,37 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "from langchain_community.retrievers import WikipediaRetriever\nfrom langchain_core.runnables import RunnableLambda\nfrom langchain_core.runnables import chain as as_runnable\n\nwikipedia_retriever = WikipediaRetriever(load_all_available_meta=True, top_k_results=1)\n\n\ndef format_doc(doc, max_length=1000):\n    related = \"- \".join(doc.metadata[\"categories\"])\n    return f\"### {doc.metadata['title']}\\n\\nSummary: {doc.page_content}\\n\\nRelated\\n{related}\"[\n        :max_length\n    ]\n\n\ndef format_docs(docs):\n    return \"\\n\\n\".join(format_doc(doc) for doc in docs)\n\n\n@as_runnable\nasync def survey_subjects(topic: str):\n    related_subjects = await expand_chain.ainvoke({\"topic\": topic})\n    retrieved_docs = await wikipedia_retriever.abatch(\n        related_subjects.topics, return_exceptions=True\n    )\n    all_docs = []\n    for docs in retrieved_docs:\n        if isinstance(docs, BaseException):\n            continue\n        all_docs.extend(docs)\n    formatted = format_docs(all_docs)\n    return await gen_perspectives_chain.ainvoke({\"examples\": formatted, \"topic\": topic})"
+        "from langchain_community.retrievers import WikipediaRetriever\n",
+        "from langchain_core.runnables import RunnableLambda\n",
+        "from langchain_core.runnables import chain as as_runnable\n",
+        "\n",
+        "wikipedia_retriever = WikipediaRetriever(load_all_available_meta=True, top_k_results=1)\n",
+        "\n",
+        "\n",
+        "def format_doc(doc, max_length=1000):\n",
+        "    related = \"- \".join(doc.metadata[\"categories\"])\n",
+        "    return f\"### {doc.metadata['title']}\\n\\nSummary: {doc.page_content}\\n\\nRelated\\n{related}\"[\n",
+        "        :max_length\n",
+        "    ]\n",
+        "\n",
+        "\n",
+        "def format_docs(docs):\n",
+        "    return \"\\n\\n\".join(format_doc(doc) for doc in docs)\n",
+        "\n",
+        "\n",
+        "@as_runnable\n",
+        "async def survey_subjects(topic: str):\n",
+        "    related_subjects = await expand_chain.ainvoke({\"topic\": topic})\n",
+        "    retrieved_docs = await wikipedia_retriever.abatch(\n",
+        "        related_subjects.topics, return_exceptions=True\n",
+        "    )\n",
+        "    all_docs = []\n",
+        "    for docs in retrieved_docs:\n",
+        "        if isinstance(docs, BaseException):\n",
+        "            continue\n",
+        "        all_docs.extend(docs)\n",
+        "    formatted = format_docs(all_docs)\n",
+        "    return await gen_perspectives_chain.ainvoke({\"examples\": formatted, \"topic\": topic})"
       ]
     },
     {
@@ -280,7 +457,40 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "from typing import Annotated\n\nfrom langchain_core.messages import AnyMessage\nfrom typing_extensions import TypedDict\n\nfrom langgraph.graph import END, StateGraph, START\n\n\ndef add_messages(left, right):\n    if not isinstance(left, list):\n        left = [left]\n    if not isinstance(right, list):\n        right = [right]\n    return left + right\n\n\ndef update_references(references, new_references):\n    if not references:\n        references = {}\n    references.update(new_references)\n    return references\n\n\ndef update_editor(editor, new_editor):\n    # Can only set at the outset\n    if not editor:\n        return new_editor\n    return editor\n\n\nclass InterviewState(TypedDict):\n    messages: Annotated[List[AnyMessage], add_messages]\n    references: Annotated[Optional[dict], update_references]\n    editor: Annotated[Optional[Editor], update_editor]"
+        "from typing import Annotated\n",
+        "\n",
+        "from langchain_core.messages import AnyMessage\n",
+        "from typing_extensions import TypedDict\n",
+        "\n",
+        "from langgraph.graph import END, StateGraph, START\n",
+        "\n",
+        "\n",
+        "def add_messages(left, right):\n",
+        "    if not isinstance(left, list):\n",
+        "        left = [left]\n",
+        "    if not isinstance(right, list):\n",
+        "        right = [right]\n",
+        "    return left + right\n",
+        "\n",
+        "\n",
+        "def update_references(references, new_references):\n",
+        "    if not references:\n",
+        "        references = {}\n",
+        "    references.update(new_references)\n",
+        "    return references\n",
+        "\n",
+        "\n",
+        "def update_editor(editor, new_editor):\n",
+        "    # Can only set at the outset\n",
+        "    if not editor:\n",
+        "        return new_editor\n",
+        "    return editor\n",
+        "\n",
+        "\n",
+        "class InterviewState(TypedDict):\n",
+        "    messages: Annotated[List[AnyMessage], add_messages]\n",
+        "    references: Annotated[Optional[dict], update_references]\n",
+        "    editor: Annotated[Optional[Editor], update_editor]"
       ]
     },
     {
@@ -298,7 +508,56 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "from langchain_core.messages import AIMessage, HumanMessage, ToolMessage\nfrom langchain_core.prompts import MessagesPlaceholder\n\ngen_qn_prompt = ChatPromptTemplate.from_messages(\n    [\n        (\n            \"system\",\n            \"\"\"You are an experienced Wikipedia writer and want to edit a specific page. \\\nBesides your identity as a Wikipedia writer, you have a specific focus when researching the topic. \\\nNow, you are chatting with an expert to get information. Ask good questions to get more useful information.\n\nWhen you have no more questions to ask, say \"Thank you so much for your help!\" to end the conversation.\\\nPlease only ask one question at a time and don't ask what you have asked before.\\\nYour questions should be related to the topic you want to write.\nBe comprehensive and curious, gaining as much unique insight from the expert as possible.\\\n\nStay true to your specific perspective:\n\n{persona}\"\"\",\n        ),\n        MessagesPlaceholder(variable_name=\"messages\", optional=True),\n    ]\n)\n\n\ndef tag_with_name(ai_message: AIMessage, name: str):\n    ai_message.name = name\n    return ai_message\n\n\ndef swap_roles(state: InterviewState, name: str):\n    converted = []\n    for message in state[\"messages\"]:\n        if isinstance(message, AIMessage) and message.name != name:\n            message = HumanMessage(**message.dict(exclude={\"type\"}))\n        converted.append(message)\n    return {\"messages\": converted}\n\n\n@as_runnable\nasync def generate_question(state: InterviewState):\n    editor = state[\"editor\"]\n    gn_chain = (\n        RunnableLambda(swap_roles).bind(name=editor.name)\n        | gen_qn_prompt.partial(persona=editor.persona)\n        | fast_llm\n        | RunnableLambda(tag_with_name).bind(name=editor.name)\n    )\n    result = await gn_chain.ainvoke(state)\n    return {\"messages\": [result]}"
+        "from langchain_core.messages import AIMessage, HumanMessage, ToolMessage\n",
+        "from langchain_core.prompts import MessagesPlaceholder\n",
+        "\n",
+        "gen_qn_prompt = ChatPromptTemplate.from_messages(\n",
+        "    [\n",
+        "        (\n",
+        "            \"system\",\n",
+        "            \"\"\"You are an experienced Wikipedia writer and want to edit a specific page. \\\n",
+        "Besides your identity as a Wikipedia writer, you have a specific focus when researching the topic. \\\n",
+        "Now, you are chatting with an expert to get information. Ask good questions to get more useful information.\n",
+        "\n",
+        "When you have no more questions to ask, say \"Thank you so much for your help!\" to end the conversation.\\\n",
+        "Please only ask one question at a time and don't ask what you have asked before.\\\n",
+        "Your questions should be related to the topic you want to write.\n",
+        "Be comprehensive and curious, gaining as much unique insight from the expert as possible.\\\n",
+        "\n",
+        "Stay true to your specific perspective:\n",
+        "\n",
+        "{persona}\"\"\",\n",
+        "        ),\n",
+        "        MessagesPlaceholder(variable_name=\"messages\", optional=True),\n",
+        "    ]\n",
+        ")\n",
+        "\n",
+        "\n",
+        "def tag_with_name(ai_message: AIMessage, name: str):\n",
+        "    ai_message.name = name\n",
+        "    return ai_message\n",
+        "\n",
+        "\n",
+        "def swap_roles(state: InterviewState, name: str):\n",
+        "    converted = []\n",
+        "    for message in state[\"messages\"]:\n",
+        "        if isinstance(message, AIMessage) and message.name != name:\n",
+        "            message = HumanMessage(**message.dict(exclude={\"type\"}))\n",
+        "        converted.append(message)\n",
+        "    return {\"messages\": converted}\n",
+        "\n",
+        "\n",
+        "@as_runnable\n",
+        "async def generate_question(state: InterviewState):\n",
+        "    editor = state[\"editor\"]\n",
+        "    gn_chain = (\n",
+        "        RunnableLambda(swap_roles).bind(name=editor.name)\n",
+        "        | gen_qn_prompt.partial(persona=editor.persona)\n",
+        "        | fast_llm\n",
+        "        | RunnableLambda(tag_with_name).bind(name=editor.name)\n",
+        "    )\n",
+        "    result = await gn_chain.ainvoke(state)\n",
+        "    return {\"messages\": [result]}"
       ]
     },
     {
@@ -318,7 +577,17 @@
         }
       ],
       "source": [
-        "messages = [\n    HumanMessage(f\"So you said you were writing an article on {example_topic}?\")\n]\nquestion = await generate_question.ainvoke(\n    {\n        \"editor\": perspectives.editors[0],\n        \"messages\": messages,\n    }\n)\n\nquestion[\"messages\"][0].content"
+        "messages = [\n",
+        "    HumanMessage(f\"So you said you were writing an article on {example_topic}?\")\n",
+        "]\n",
+        "question = await generate_question.ainvoke(\n",
+        "    {\n",
+        "        \"editor\": perspectives.editors[0],\n",
+        "        \"messages\": messages,\n",
+        "    }\n",
+        ")\n",
+        "\n",
+        "question[\"messages\"][0].content"
       ]
     },
     {
@@ -336,7 +605,24 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "class Queries(BaseModel):\n    queries: List[str] = Field(\n        description=\"Comprehensive list of search engine queries to answer the user's questions.\",\n    )\n\n\ngen_queries_prompt = ChatPromptTemplate.from_messages(\n    [\n        (\n            \"system\",\n            \"You are a helpful research assistant. Query the search engine to answer the user's questions.\",\n        ),\n        MessagesPlaceholder(variable_name=\"messages\", optional=True),\n    ]\n)\ngen_queries_chain = gen_queries_prompt | ChatOpenAI(\n    model=\"gpt-3.5-turbo\"\n).with_structured_output(Queries, include_raw=True)"
+        "class Queries(BaseModel):\n",
+        "    queries: List[str] = Field(\n",
+        "        description=\"Comprehensive list of search engine queries to answer the user's questions.\",\n",
+        "    )\n",
+        "\n",
+        "\n",
+        "gen_queries_prompt = ChatPromptTemplate.from_messages(\n",
+        "    [\n",
+        "        (\n",
+        "            \"system\",\n",
+        "            \"You are a helpful research assistant. Query the search engine to answer the user's questions.\",\n",
+        "        ),\n",
+        "        MessagesPlaceholder(variable_name=\"messages\", optional=True),\n",
+        "    ]\n",
+        ")\n",
+        "gen_queries_chain = gen_queries_prompt | ChatOpenAI(\n",
+        "    model=\"gpt-3.5-turbo\"\n",
+        ").with_structured_output(Queries, include_raw=True)"
       ]
     },
     {
@@ -357,7 +643,10 @@
         }
       ],
       "source": [
-        "queries = await gen_queries_chain.ainvoke(\n    {\"messages\": [HumanMessage(content=question[\"messages\"][0].content)]}\n)\nqueries[\"parsed\"].queries"
+        "queries = await gen_queries_chain.ainvoke(\n",
+        "    {\"messages\": [HumanMessage(content=question[\"messages\"][0].content)]}\n",
+        ")\n",
+        "queries[\"parsed\"].queries"
       ]
     },
     {
@@ -366,7 +655,38 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "class AnswerWithCitations(BaseModel):\n    answer: str = Field(\n        description=\"Comprehensive answer to the user's question with citations.\",\n    )\n    cited_urls: List[str] = Field(\n        description=\"List of urls cited in the answer.\",\n    )\n\n    @property\n    def as_str(self) -> str:\n        return f\"{self.answer}\\n\\nCitations:\\n\\n\" + \"\\n\".join(\n            f\"[{i+1}]: {url}\" for i, url in enumerate(self.cited_urls)\n        )\n\n\ngen_answer_prompt = ChatPromptTemplate.from_messages(\n    [\n        (\n            \"system\",\n            \"\"\"You are an expert who can use information effectively. You are chatting with a Wikipedia writer who wants\\\n to write a Wikipedia page on the topic you know. You have gathered the related information and will now use the information to form a response.\n\nMake your response as informative as possible and make sure every sentence is supported by the gathered information.\nEach response must be backed up by a citation from a reliable source, formatted as a footnote, reproducing the URLS after your response.\"\"\",\n        ),\n        MessagesPlaceholder(variable_name=\"messages\", optional=True),\n    ]\n)\n\ngen_answer_chain = gen_answer_prompt | fast_llm.with_structured_output(\n    AnswerWithCitations, include_raw=True\n).with_config(run_name=\"GenerateAnswer\")"
+        "class AnswerWithCitations(BaseModel):\n",
+        "    answer: str = Field(\n",
+        "        description=\"Comprehensive answer to the user's question with citations.\",\n",
+        "    )\n",
+        "    cited_urls: List[str] = Field(\n",
+        "        description=\"List of urls cited in the answer.\",\n",
+        "    )\n",
+        "\n",
+        "    @property\n",
+        "    def as_str(self) -> str:\n",
+        "        return f\"{self.answer}\\n\\nCitations:\\n\\n\" + \"\\n\".join(\n",
+        "            f\"[{i+1}]: {url}\" for i, url in enumerate(self.cited_urls)\n",
+        "        )\n",
+        "\n",
+        "\n",
+        "gen_answer_prompt = ChatPromptTemplate.from_messages(\n",
+        "    [\n",
+        "        (\n",
+        "            \"system\",\n",
+        "            \"\"\"You are an expert who can use information effectively. You are chatting with a Wikipedia writer who wants\\\n",
+        " to write a Wikipedia page on the topic you know. You have gathered the related information and will now use the information to form a response.\n",
+        "\n",
+        "Make your response as informative as possible and make sure every sentence is supported by the gathered information.\n",
+        "Each response must be backed up by a citation from a reliable source, formatted as a footnote, reproducing the URLS after your response.\"\"\",\n",
+        "        ),\n",
+        "        MessagesPlaceholder(variable_name=\"messages\", optional=True),\n",
+        "    ]\n",
+        ")\n",
+        "\n",
+        "gen_answer_chain = gen_answer_prompt | fast_llm.with_structured_output(\n",
+        "    AnswerWithCitations, include_raw=True\n",
+        ").with_config(run_name=\"GenerateAnswer\")"
       ]
     },
     {
@@ -375,7 +695,29 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "from langchain_community.utilities.duckduckgo_search import DuckDuckGoSearchAPIWrapper\nfrom langchain_core.tools import tool\n\n'''\n# Tavily is typically a better search engine, but your free queries are limited\nsearch_engine = TavilySearchResults(max_results=4)\n\n@tool\nasync def search_engine(query: str):\n    \"\"\"Search engine to the internet.\"\"\"\n    results = tavily_search.invoke(query)\n    return [{\"content\": r[\"content\"], \"url\": r[\"url\"]} for r in results]\n'''\n\n# DDG\nsearch_engine = DuckDuckGoSearchAPIWrapper()\n\n\n@tool\nasync def search_engine(query: str):\n    \"\"\"Search engine to the internet.\"\"\"\n    results = DuckDuckGoSearchAPIWrapper()._ddgs_text(query)\n    return [{\"content\": r[\"body\"], \"url\": r[\"href\"]} for r in results]"
+        "from langchain_community.utilities.duckduckgo_search import DuckDuckGoSearchAPIWrapper\n",
+        "from langchain_core.tools import tool\n",
+        "\n",
+        "'''\n",
+        "# Tavily is typically a better search engine, but your free queries are limited\n",
+        "search_engine = TavilySearchResults(max_results=4)\n",
+        "\n",
+        "@tool\n",
+        "async def search_engine(query: str):\n",
+        "    \"\"\"Search engine to the internet.\"\"\"\n",
+        "    results = tavily_search.invoke(query)\n",
+        "    return [{\"content\": r[\"content\"], \"url\": r[\"url\"]} for r in results]\n",
+        "'''\n",
+        "\n",
+        "# DDG\n",
+        "search_engine = DuckDuckGoSearchAPIWrapper()\n",
+        "\n",
+        "\n",
+        "@tool\n",
+        "async def search_engine(query: str):\n",
+        "    \"\"\"Search engine to the internet.\"\"\"\n",
+        "    results = DuckDuckGoSearchAPIWrapper()._ddgs_text(query)\n",
+        "    return [{\"content\": r[\"body\"], \"url\": r[\"href\"]} for r in results]"
       ]
     },
     {
@@ -384,7 +726,43 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "import json\n\nfrom langchain_core.runnables import RunnableConfig\n\n\nasync def gen_answer(\n    state: InterviewState,\n    config: Optional[RunnableConfig] = None,\n    name: str = \"Subject_Matter_Expert\",\n    max_str_len: int = 15000,\n):\n    swapped_state = swap_roles(state, name)  # Convert all other AI messages\n    queries = await gen_queries_chain.ainvoke(swapped_state)\n    query_results = await search_engine.abatch(\n        queries[\"parsed\"].queries, config, return_exceptions=True\n    )\n    successful_results = [\n        res for res in query_results if not isinstance(res, Exception)\n    ]\n    all_query_results = {\n        res[\"url\"]: res[\"content\"] for results in successful_results for res in results\n    }\n    # We could be more precise about handling max token length if we wanted to here\n    dumped = json.dumps(all_query_results)[:max_str_len]\n    ai_message: AIMessage = queries[\"raw\"]\n    tool_call = queries[\"raw\"].additional_kwargs[\"tool_calls\"][0]\n    tool_id = tool_call[\"id\"]\n    tool_message = ToolMessage(tool_call_id=tool_id, content=dumped)\n    swapped_state[\"messages\"].extend([ai_message, tool_message])\n    # Only update the shared state with the final answer to avoid\n    # polluting the dialogue history with intermediate messages\n    generated = await gen_answer_chain.ainvoke(swapped_state)\n    cited_urls = set(generated[\"parsed\"].cited_urls)\n    # Save the retrieved information to a the shared state for future reference\n    cited_references = {k: v for k, v in all_query_results.items() if k in cited_urls}\n    formatted_message = AIMessage(name=name, content=generated[\"parsed\"].as_str)\n    return {\"messages\": [formatted_message], \"references\": cited_references}"
+        "import json\n",
+        "\n",
+        "from langchain_core.runnables import RunnableConfig\n",
+        "\n",
+        "\n",
+        "async def gen_answer(\n",
+        "    state: InterviewState,\n",
+        "    config: Optional[RunnableConfig] = None,\n",
+        "    name: str = \"Subject_Matter_Expert\",\n",
+        "    max_str_len: int = 15000,\n",
+        "):\n",
+        "    swapped_state = swap_roles(state, name)  # Convert all other AI messages\n",
+        "    queries = await gen_queries_chain.ainvoke(swapped_state)\n",
+        "    query_results = await search_engine.abatch(\n",
+        "        queries[\"parsed\"].queries, config, return_exceptions=True\n",
+        "    )\n",
+        "    successful_results = [\n",
+        "        res for res in query_results if not isinstance(res, Exception)\n",
+        "    ]\n",
+        "    all_query_results = {\n",
+        "        res[\"url\"]: res[\"content\"] for results in successful_results for res in results\n",
+        "    }\n",
+        "    # We could be more precise about handling max token length if we wanted to here\n",
+        "    dumped = json.dumps(all_query_results)[:max_str_len]\n",
+        "    ai_message: AIMessage = queries[\"raw\"]\n",
+        "    tool_call = queries[\"raw\"].tool_calls[0]\n",
+        "    tool_id = tool_call[\"id\"]\n",
+        "    tool_message = ToolMessage(tool_call_id=tool_id, content=dumped)\n",
+        "    swapped_state[\"messages\"].extend([ai_message, tool_message])\n",
+        "    # Only update the shared state with the final answer to avoid\n",
+        "    # polluting the dialogue history with intermediate messages\n",
+        "    generated = await gen_answer_chain.ainvoke(swapped_state)\n",
+        "    cited_urls = set(generated[\"parsed\"].cited_urls)\n",
+        "    # Save the retrieved information to a the shared state for future reference\n",
+        "    cited_references = {k: v for k, v in all_query_results.items() if k in cited_urls}\n",
+        "    formatted_message = AIMessage(name=name, content=generated[\"parsed\"].as_str)\n",
+        "    return {\"messages\": [formatted_message], \"references\": cited_references}"
       ]
     },
     {
@@ -404,7 +782,10 @@
         }
       ],
       "source": [
-        "example_answer = await gen_answer(\n    {\"messages\": [HumanMessage(content=question[\"messages\"][0].content)]}\n)\nexample_answer[\"messages\"][-1].content"
+        "example_answer = await gen_answer(\n",
+        "    {\"messages\": [HumanMessage(content=question[\"messages\"][0].content)]}\n",
+        ")\n",
+        "example_answer[\"messages\"][-1].content"
       ]
     },
     {
@@ -423,7 +804,31 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "max_num_turns = 5\n\n\ndef route_messages(state: InterviewState, name: str = \"Subject_Matter_Expert\"):\n    messages = state[\"messages\"]\n    num_responses = len(\n        [m for m in messages if isinstance(m, AIMessage) and m.name == name]\n    )\n    if num_responses >= max_num_turns:\n        return END\n    last_question = messages[-2]\n    if last_question.content.endswith(\"Thank you so much for your help!\"):\n        return END\n    return \"ask_question\"\n\n\nbuilder = StateGraph(InterviewState)\n\nbuilder.add_node(\"ask_question\", generate_question)\nbuilder.add_node(\"answer_question\", gen_answer)\nbuilder.add_conditional_edges(\"answer_question\", route_messages)\nbuilder.add_edge(\"ask_question\", \"answer_question\")\n\nbuilder.add_edge(START, \"ask_question\")\ninterview_graph = builder.compile().with_config(run_name=\"Conduct Interviews\")"
+        "max_num_turns = 5\n",
+        "\n",
+        "\n",
+        "def route_messages(state: InterviewState, name: str = \"Subject_Matter_Expert\"):\n",
+        "    messages = state[\"messages\"]\n",
+        "    num_responses = len(\n",
+        "        [m for m in messages if isinstance(m, AIMessage) and m.name == name]\n",
+        "    )\n",
+        "    if num_responses >= max_num_turns:\n",
+        "        return END\n",
+        "    last_question = messages[-2]\n",
+        "    if last_question.content.endswith(\"Thank you so much for your help!\"):\n",
+        "        return END\n",
+        "    return \"ask_question\"\n",
+        "\n",
+        "\n",
+        "builder = StateGraph(InterviewState)\n",
+        "\n",
+        "builder.add_node(\"ask_question\", generate_question)\n",
+        "builder.add_node(\"answer_question\", gen_answer)\n",
+        "builder.add_conditional_edges(\"answer_question\", route_messages)\n",
+        "builder.add_edge(\"ask_question\", \"answer_question\")\n",
+        "\n",
+        "builder.add_edge(START, \"ask_question\")\n",
+        "interview_graph = builder.compile().with_config(run_name=\"Conduct Interviews\")"
       ]
     },
     {
@@ -444,7 +849,11 @@
         }
       ],
       "source": [
-        "from IPython.display import Image\n\n# Feel free to comment out if you have\n# not installed pygraphviz\nImage(interview_graph.get_graph().draw_png())"
+        "from IPython.display import Image\n",
+        "\n",
+        "# Feel free to comment out if you have\n",
+        "# not installed pygraphviz\n",
+        "Image(interview_graph.get_graph().draw_png())"
       ]
     },
     {
@@ -474,7 +883,23 @@
         }
       ],
       "source": [
-        "final_step = None\n\ninitial_state = {\n    \"editor\": perspectives.editors[0],\n    \"messages\": [\n        AIMessage(\n            content=f\"So you said you were writing an article on {example_topic}?\",\n            name=\"Subject_Matter_Expert\",\n        )\n    ],\n}\nasync for step in interview_graph.astream(initial_state):\n    name = next(iter(step))\n    print(name)\n    print(\"-- \", str(step[name][\"messages\"])[:300])\n    if END in step:\n        final_step = step"
+        "final_step = None\n",
+        "\n",
+        "initial_state = {\n",
+        "    \"editor\": perspectives.editors[0],\n",
+        "    \"messages\": [\n",
+        "        AIMessage(\n",
+        "            content=f\"So you said you were writing an article on {example_topic}?\",\n",
+        "            name=\"Subject_Matter_Expert\",\n",
+        "        )\n",
+        "    ],\n",
+        "}\n",
+        "async for step in interview_graph.astream(initial_state):\n",
+        "    name = next(iter(step))\n",
+        "    print(name)\n",
+        "    print(\"-- \", str(step[name][\"messages\"])[:300])\n",
+        "    if END in step:\n",
+        "        final_step = step"
       ]
     },
     {
@@ -501,7 +926,29 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "refine_outline_prompt = ChatPromptTemplate.from_messages(\n    [\n        (\n            \"system\",\n            \"\"\"You are a Wikipedia writer. You have gathered information from experts and search engines. Now, you are refining the outline of the Wikipedia page. \\\nYou need to make sure that the outline is comprehensive and specific. \\\nTopic you are writing about: {topic} \n\nOld outline:\n\n{old_outline}\"\"\",\n        ),\n        (\n            \"user\",\n            \"Refine the outline based on your conversations with subject-matter experts:\\n\\nConversations:\\n\\n{conversations}\\n\\nWrite the refined Wikipedia outline:\",\n        ),\n    ]\n)\n\n# Using turbo preview since the context can get quite long\nrefine_outline_chain = refine_outline_prompt | long_context_llm.with_structured_output(\n    Outline\n)"
+        "refine_outline_prompt = ChatPromptTemplate.from_messages(\n",
+        "    [\n",
+        "        (\n",
+        "            \"system\",\n",
+        "            \"\"\"You are a Wikipedia writer. You have gathered information from experts and search engines. Now, you are refining the outline of the Wikipedia page. \\\n",
+        "You need to make sure that the outline is comprehensive and specific. \\\n",
+        "Topic you are writing about: {topic} \n",
+        "\n",
+        "Old outline:\n",
+        "\n",
+        "{old_outline}\"\"\",\n",
+        "        ),\n",
+        "        (\n",
+        "            \"user\",\n",
+        "            \"Refine the outline based on your conversations with subject-matter experts:\\n\\nConversations:\\n\\n{conversations}\\n\\nWrite the refined Wikipedia outline:\",\n",
+        "        ),\n",
+        "    ]\n",
+        ")\n",
+        "\n",
+        "# Using turbo preview since the context can get quite long\n",
+        "refine_outline_chain = refine_outline_prompt | long_context_llm.with_structured_output(\n",
+        "    Outline\n",
+        ")"
       ]
     },
     {
@@ -510,7 +957,15 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "refined_outline = refine_outline_chain.invoke(\n    {\n        \"topic\": example_topic,\n        \"old_outline\": initial_outline.as_str,\n        \"conversations\": \"\\n\\n\".join(\n            f\"### {m.name}\\n\\n{m.content}\" for m in final_state[\"messages\"]\n        ),\n    }\n)"
+        "refined_outline = refine_outline_chain.invoke(\n",
+        "    {\n",
+        "        \"topic\": example_topic,\n",
+        "        \"old_outline\": initial_outline.as_str,\n",
+        "        \"conversations\": \"\\n\\n\".join(\n",
+        "            f\"### {m.name}\\n\\n{m.content}\" for m in final_state[\"messages\"]\n",
+        "        ),\n",
+        "    }\n",
+        ")"
       ]
     },
     {
@@ -595,7 +1050,23 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "from langchain_community.vectorstores import SKLearnVectorStore\nfrom langchain_core.documents import Document\nfrom langchain_openai import OpenAIEmbeddings\n\nembeddings = OpenAIEmbeddings(model=\"text-embedding-3-small\")\nreference_docs = [\n    Document(page_content=v, metadata={\"source\": k})\n    for k, v in final_state[\"references\"].items()\n]\n# This really doesn't need to be a vectorstore for this size of data.\n# It could just be a numpy matrix. Or you could store documents\n# across requests if you want.\nvectorstore = SKLearnVectorStore.from_documents(\n    reference_docs,\n    embedding=embeddings,\n)\nretriever = vectorstore.as_retriever(k=10)"
+        "from langchain_community.vectorstores import SKLearnVectorStore\n",
+        "from langchain_core.documents import Document\n",
+        "from langchain_openai import OpenAIEmbeddings\n",
+        "\n",
+        "embeddings = OpenAIEmbeddings(model=\"text-embedding-3-small\")\n",
+        "reference_docs = [\n",
+        "    Document(page_content=v, metadata={\"source\": k})\n",
+        "    for k, v in final_state[\"references\"].items()\n",
+        "]\n",
+        "# This really doesn't need to be a vectorstore for this size of data.\n",
+        "# It could just be a numpy matrix. Or you could store documents\n",
+        "# across requests if you want.\n",
+        "vectorstore = SKLearnVectorStore.from_documents(\n",
+        "    reference_docs,\n",
+        "    embedding=embeddings,\n",
+        ")\n",
+        "retriever = vectorstore.as_retriever(k=10)"
       ]
     },
     {
@@ -636,7 +1107,67 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "class SubSection(BaseModel):\n    subsection_title: str = Field(..., title=\"Title of the subsection\")\n    content: str = Field(\n        ...,\n        title=\"Full content of the subsection. Include [#] citations to the cited sources where relevant.\",\n    )\n\n    @property\n    def as_str(self) -> str:\n        return f\"### {self.subsection_title}\\n\\n{self.content}\".strip()\n\n\nclass WikiSection(BaseModel):\n    section_title: str = Field(..., title=\"Title of the section\")\n    content: str = Field(..., title=\"Full content of the section\")\n    subsections: Optional[List[Subsection]] = Field(\n        default=None,\n        title=\"Titles and descriptions for each subsection of the Wikipedia page.\",\n    )\n    citations: List[str] = Field(default_factory=list)\n\n    @property\n    def as_str(self) -> str:\n        subsections = \"\\n\\n\".join(\n            subsection.as_str for subsection in self.subsections or []\n        )\n        citations = \"\\n\".join([f\" [{i}] {cit}\" for i, cit in enumerate(self.citations)])\n        return (\n            f\"## {self.section_title}\\n\\n{self.content}\\n\\n{subsections}\".strip()\n            + f\"\\n\\n{citations}\".strip()\n        )\n\n\nsection_writer_prompt = ChatPromptTemplate.from_messages(\n    [\n        (\n            \"system\",\n            \"You are an expert Wikipedia writer. Complete your assigned WikiSection from the following outline:\\n\\n\"\n            \"{outline}\\n\\nCite your sources, using the following references:\\n\\n<Documents>\\n{docs}\\n<Documents>\",\n        ),\n        (\"user\", \"Write the full WikiSection for the {section} section.\"),\n    ]\n)\n\n\nasync def retrieve(inputs: dict):\n    docs = await retriever.ainvoke(inputs[\"topic\"] + \": \" + inputs[\"section\"])\n    formatted = \"\\n\".join(\n        [\n            f'<Document href=\"{doc.metadata[\"source\"]}\"/>\\n{doc.page_content}\\n</Document>'\n            for doc in docs\n        ]\n    )\n    return {\"docs\": formatted, **inputs}\n\n\nsection_writer = (\n    retrieve\n    | section_writer_prompt\n    | long_context_llm.with_structured_output(WikiSection)\n)"
+        "class SubSection(BaseModel):\n",
+        "    subsection_title: str = Field(..., title=\"Title of the subsection\")\n",
+        "    content: str = Field(\n",
+        "        ...,\n",
+        "        title=\"Full content of the subsection. Include [#] citations to the cited sources where relevant.\",\n",
+        "    )\n",
+        "\n",
+        "    @property\n",
+        "    def as_str(self) -> str:\n",
+        "        return f\"### {self.subsection_title}\\n\\n{self.content}\".strip()\n",
+        "\n",
+        "\n",
+        "class WikiSection(BaseModel):\n",
+        "    section_title: str = Field(..., title=\"Title of the section\")\n",
+        "    content: str = Field(..., title=\"Full content of the section\")\n",
+        "    subsections: Optional[List[Subsection]] = Field(\n",
+        "        default=None,\n",
+        "        title=\"Titles and descriptions for each subsection of the Wikipedia page.\",\n",
+        "    )\n",
+        "    citations: List[str] = Field(default_factory=list)\n",
+        "\n",
+        "    @property\n",
+        "    def as_str(self) -> str:\n",
+        "        subsections = \"\\n\\n\".join(\n",
+        "            subsection.as_str for subsection in self.subsections or []\n",
+        "        )\n",
+        "        citations = \"\\n\".join([f\" [{i}] {cit}\" for i, cit in enumerate(self.citations)])\n",
+        "        return (\n",
+        "            f\"## {self.section_title}\\n\\n{self.content}\\n\\n{subsections}\".strip()\n",
+        "            + f\"\\n\\n{citations}\".strip()\n",
+        "        )\n",
+        "\n",
+        "\n",
+        "section_writer_prompt = ChatPromptTemplate.from_messages(\n",
+        "    [\n",
+        "        (\n",
+        "            \"system\",\n",
+        "            \"You are an expert Wikipedia writer. Complete your assigned WikiSection from the following outline:\\n\\n\"\n",
+        "            \"{outline}\\n\\nCite your sources, using the following references:\\n\\n<Documents>\\n{docs}\\n<Documents>\",\n",
+        "        ),\n",
+        "        (\"user\", \"Write the full WikiSection for the {section} section.\"),\n",
+        "    ]\n",
+        ")\n",
+        "\n",
+        "\n",
+        "async def retrieve(inputs: dict):\n",
+        "    docs = await retriever.ainvoke(inputs[\"topic\"] + \": \" + inputs[\"section\"])\n",
+        "    formatted = \"\\n\".join(\n",
+        "        [\n",
+        "            f'<Document href=\"{doc.metadata[\"source\"]}\"/>\\n{doc.page_content}\\n</Document>'\n",
+        "            for doc in docs\n",
+        "        ]\n",
+        "    )\n",
+        "    return {\"docs\": formatted, **inputs}\n",
+        "\n",
+        "\n",
+        "section_writer = (\n",
+        "    retrieve\n",
+        "    | section_writer_prompt\n",
+        "    | long_context_llm.with_structured_output(WikiSection)\n",
+        ")"
       ]
     },
     {
@@ -663,7 +1194,14 @@
         }
       ],
       "source": [
-        "section = await section_writer.ainvoke(\n    {\n        \"outline\": refined_outline.as_str,\n        \"section\": refined_outline.sections[1].section_title,\n        \"topic\": example_topic,\n    }\n)\nprint(section.as_str)"
+        "section = await section_writer.ainvoke(\n",
+        "    {\n",
+        "        \"outline\": refined_outline.as_str,\n",
+        "        \"section\": refined_outline.sections[1].section_title,\n",
+        "        \"topic\": example_topic,\n",
+        "    }\n",
+        ")\n",
+        "print(section.as_str)"
       ]
     },
     {
@@ -681,7 +1219,24 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "from langchain_core.output_parsers import StrOutputParser\n\nwriter_prompt = ChatPromptTemplate.from_messages(\n    [\n        (\n            \"system\",\n            \"You are an expert Wikipedia author. Write the complete wiki article on {topic} using the following section drafts:\\n\\n\"\n            \"{draft}\\n\\nStrictly follow Wikipedia format guidelines.\",\n        ),\n        (\n            \"user\",\n            'Write the complete Wiki article using markdown format. Organize citations using footnotes like \"[1]\",'\n            \" avoiding duplicates in the footer. Include URLs in the footer.\",\n        ),\n    ]\n)\n\nwriter = writer_prompt | long_context_llm | StrOutputParser()"
+        "from langchain_core.output_parsers import StrOutputParser\n",
+        "\n",
+        "writer_prompt = ChatPromptTemplate.from_messages(\n",
+        "    [\n",
+        "        (\n",
+        "            \"system\",\n",
+        "            \"You are an expert Wikipedia author. Write the complete wiki article on {topic} using the following section drafts:\\n\\n\"\n",
+        "            \"{draft}\\n\\nStrictly follow Wikipedia format guidelines.\",\n",
+        "        ),\n",
+        "        (\n",
+        "            \"user\",\n",
+        "            'Write the complete Wiki article using markdown format. Organize citations using footnotes like \"[1]\",'\n",
+        "            \" avoiding duplicates in the footer. Include URLs in the footer.\",\n",
+        "        ),\n",
+        "    ]\n",
+        ")\n",
+        "\n",
+        "writer = writer_prompt | long_context_llm | StrOutputParser()"
       ]
     },
     {
@@ -774,7 +1329,8 @@
         }
       ],
       "source": [
-        "for tok in writer.stream({\"topic\": example_topic, \"draft\": section.as_str}):\n    print(tok, end=\"\")"
+        "for tok in writer.stream({\"topic\": example_topic, \"draft\": section.as_str}):\n",
+        "    print(tok, end=\"\")"
       ]
     },
     {
@@ -801,7 +1357,14 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "class ResearchState(TypedDict):\n    topic: str\n    outline: Outline\n    editors: List[Editor]\n    interview_results: List[InterviewState]\n    # The final sections output\n    sections: List[WikiSection]\n    article: str"
+        "class ResearchState(TypedDict):\n",
+        "    topic: str\n",
+        "    outline: Outline\n",
+        "    editors: List[Editor]\n",
+        "    interview_results: List[InterviewState]\n",
+        "    # The final sections output\n",
+        "    sections: List[WikiSection]\n",
+        "    article: str"
       ]
     },
     {
@@ -810,7 +1373,109 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "import asyncio\n\n\nasync def initialize_research(state: ResearchState):\n    topic = state[\"topic\"]\n    coros = (\n        generate_outline_direct.ainvoke({\"topic\": topic}),\n        survey_subjects.ainvoke(topic),\n    )\n    results = await asyncio.gather(*coros)\n    return {\n        **state,\n        \"outline\": results[0],\n        \"editors\": results[1].editors,\n    }\n\n\nasync def conduct_interviews(state: ResearchState):\n    topic = state[\"topic\"]\n    initial_states = [\n        {\n            \"editor\": editor,\n            \"messages\": [\n                AIMessage(\n                    content=f\"So you said you were writing an article on {topic}?\",\n                    name=\"Subject_Matter_Expert\",\n                )\n            ],\n        }\n        for editor in state[\"editors\"]\n    ]\n    # We call in to the sub-graph here to parallelize the interviews\n    interview_results = await interview_graph.abatch(initial_states)\n\n    return {\n        **state,\n        \"interview_results\": interview_results,\n    }\n\n\ndef format_conversation(interview_state):\n    messages = interview_state[\"messages\"]\n    convo = \"\\n\".join(f\"{m.name}: {m.content}\" for m in messages)\n    return f'Conversation with {interview_state[\"editor\"].name}\\n\\n' + convo\n\n\nasync def refine_outline(state: ResearchState):\n    convos = \"\\n\\n\".join(\n        [\n            format_conversation(interview_state)\n            for interview_state in state[\"interview_results\"]\n        ]\n    )\n\n    updated_outline = await refine_outline_chain.ainvoke(\n        {\n            \"topic\": state[\"topic\"],\n            \"old_outline\": state[\"outline\"].as_str,\n            \"conversations\": convos,\n        }\n    )\n    return {**state, \"outline\": updated_outline}\n\n\nasync def index_references(state: ResearchState):\n    all_docs = []\n    for interview_state in state[\"interview_results\"]:\n        reference_docs = [\n            Document(page_content=v, metadata={\"source\": k})\n            for k, v in interview_state[\"references\"].items()\n        ]\n        all_docs.extend(reference_docs)\n    await vectorstore.aadd_documents(all_docs)\n    return state\n\n\nasync def write_sections(state: ResearchState):\n    outline = state[\"outline\"]\n    sections = await section_writer.abatch(\n        [\n            {\n                \"outline\": refined_outline.as_str,\n                \"section\": section.section_title,\n                \"topic\": state[\"topic\"],\n            }\n            for section in outline.sections\n        ]\n    )\n    return {\n        **state,\n        \"sections\": sections,\n    }\n\n\nasync def write_article(state: ResearchState):\n    topic = state[\"topic\"]\n    sections = state[\"sections\"]\n    draft = \"\\n\\n\".join([section.as_str for section in sections])\n    article = await writer.ainvoke({\"topic\": topic, \"draft\": draft})\n    return {\n        **state,\n        \"article\": article,\n    }"
+        "import asyncio\n",
+        "\n",
+        "\n",
+        "async def initialize_research(state: ResearchState):\n",
+        "    topic = state[\"topic\"]\n",
+        "    coros = (\n",
+        "        generate_outline_direct.ainvoke({\"topic\": topic}),\n",
+        "        survey_subjects.ainvoke(topic),\n",
+        "    )\n",
+        "    results = await asyncio.gather(*coros)\n",
+        "    return {\n",
+        "        **state,\n",
+        "        \"outline\": results[0],\n",
+        "        \"editors\": results[1].editors,\n",
+        "    }\n",
+        "\n",
+        "\n",
+        "async def conduct_interviews(state: ResearchState):\n",
+        "    topic = state[\"topic\"]\n",
+        "    initial_states = [\n",
+        "        {\n",
+        "            \"editor\": editor,\n",
+        "            \"messages\": [\n",
+        "                AIMessage(\n",
+        "                    content=f\"So you said you were writing an article on {topic}?\",\n",
+        "                    name=\"Subject_Matter_Expert\",\n",
+        "                )\n",
+        "            ],\n",
+        "        }\n",
+        "        for editor in state[\"editors\"]\n",
+        "    ]\n",
+        "    # We call in to the sub-graph here to parallelize the interviews\n",
+        "    interview_results = await interview_graph.abatch(initial_states)\n",
+        "\n",
+        "    return {\n",
+        "        **state,\n",
+        "        \"interview_results\": interview_results,\n",
+        "    }\n",
+        "\n",
+        "\n",
+        "def format_conversation(interview_state):\n",
+        "    messages = interview_state[\"messages\"]\n",
+        "    convo = \"\\n\".join(f\"{m.name}: {m.content}\" for m in messages)\n",
+        "    return f'Conversation with {interview_state[\"editor\"].name}\\n\\n' + convo\n",
+        "\n",
+        "\n",
+        "async def refine_outline(state: ResearchState):\n",
+        "    convos = \"\\n\\n\".join(\n",
+        "        [\n",
+        "            format_conversation(interview_state)\n",
+        "            for interview_state in state[\"interview_results\"]\n",
+        "        ]\n",
+        "    )\n",
+        "\n",
+        "    updated_outline = await refine_outline_chain.ainvoke(\n",
+        "        {\n",
+        "            \"topic\": state[\"topic\"],\n",
+        "            \"old_outline\": state[\"outline\"].as_str,\n",
+        "            \"conversations\": convos,\n",
+        "        }\n",
+        "    )\n",
+        "    return {**state, \"outline\": updated_outline}\n",
+        "\n",
+        "\n",
+        "async def index_references(state: ResearchState):\n",
+        "    all_docs = []\n",
+        "    for interview_state in state[\"interview_results\"]:\n",
+        "        reference_docs = [\n",
+        "            Document(page_content=v, metadata={\"source\": k})\n",
+        "            for k, v in interview_state[\"references\"].items()\n",
+        "        ]\n",
+        "        all_docs.extend(reference_docs)\n",
+        "    await vectorstore.aadd_documents(all_docs)\n",
+        "    return state\n",
+        "\n",
+        "\n",
+        "async def write_sections(state: ResearchState):\n",
+        "    outline = state[\"outline\"]\n",
+        "    sections = await section_writer.abatch(\n",
+        "        [\n",
+        "            {\n",
+        "                \"outline\": refined_outline.as_str,\n",
+        "                \"section\": section.section_title,\n",
+        "                \"topic\": state[\"topic\"],\n",
+        "            }\n",
+        "            for section in outline.sections\n",
+        "        ]\n",
+        "    )\n",
+        "    return {\n",
+        "        **state,\n",
+        "        \"sections\": sections,\n",
+        "    }\n",
+        "\n",
+        "\n",
+        "async def write_article(state: ResearchState):\n",
+        "    topic = state[\"topic\"]\n",
+        "    sections = state[\"sections\"]\n",
+        "    draft = \"\\n\\n\".join([section.as_str for section in sections])\n",
+        "    article = await writer.ainvoke({\"topic\": topic, \"draft\": draft})\n",
+        "    return {\n",
+        "        **state,\n",
+        "        \"article\": article,\n",
+        "    }"
       ]
     },
     {
@@ -826,7 +1491,27 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "from langgraph.checkpoint.memory import MemorySaver\n\nbuilder_of_storm = StateGraph(ResearchState)\n\nnodes = [\n    (\"init_research\", initialize_research),\n    (\"conduct_interviews\", conduct_interviews),\n    (\"refine_outline\", refine_outline),\n    (\"index_references\", index_references),\n    (\"write_sections\", write_sections),\n    (\"write_article\", write_article),\n]\nfor i in range(len(nodes)):\n    name, node = nodes[i]\n    builder_of_storm.add_node(name, node)\n    if i > 0:\n        builder_of_storm.add_edge(nodes[i - 1][0], name)\n\nbuilder_of_storm.add_edge(START, nodes[0][0])\nbuilder_of_storm.add_edge(nodes[-1][0], END)\nstorm = builder_of_storm.compile(checkpointer=MemorySaver())"
+        "from langgraph.checkpoint.memory import MemorySaver\n",
+        "\n",
+        "builder_of_storm = StateGraph(ResearchState)\n",
+        "\n",
+        "nodes = [\n",
+        "    (\"init_research\", initialize_research),\n",
+        "    (\"conduct_interviews\", conduct_interviews),\n",
+        "    (\"refine_outline\", refine_outline),\n",
+        "    (\"index_references\", index_references),\n",
+        "    (\"write_sections\", write_sections),\n",
+        "    (\"write_article\", write_article),\n",
+        "]\n",
+        "for i in range(len(nodes)):\n",
+        "    name, node = nodes[i]\n",
+        "    builder_of_storm.add_node(name, node)\n",
+        "    if i > 0:\n",
+        "        builder_of_storm.add_edge(nodes[i - 1][0], name)\n",
+        "\n",
+        "builder_of_storm.add_edge(START, nodes[0][0])\n",
+        "builder_of_storm.add_edge(nodes[-1][0], END)\n",
+        "storm = builder_of_storm.compile(checkpointer=MemorySaver())"
       ]
     },
     {
@@ -877,7 +1562,16 @@
         }
       ],
       "source": [
-        "config = {\"configurable\": {\"thread_id\": \"my-thread\"}}\nasync for step in storm.astream(\n    {\n        \"topic\": \"Groq, NVIDIA, Llamma.cpp and the future of LLM Inference\",\n    },\n    config,\n):\n    name = next(iter(step))\n    print(name)\n    print(\"-- \", str(step[name])[:300])"
+        "config = {\"configurable\": {\"thread_id\": \"my-thread\"}}\n",
+        "async for step in storm.astream(\n",
+        "    {\n",
+        "        \"topic\": \"Groq, NVIDIA, Llamma.cpp and the future of LLM Inference\",\n",
+        "    },\n",
+        "    config,\n",
+        "):\n",
+        "    name = next(iter(step))\n",
+        "    print(name)\n",
+        "    print(\"-- \", str(step[name])[:300])"
       ]
     },
     {
@@ -886,7 +1580,8 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "checkpoint = storm.get_state(config)\narticle = checkpoint.values[\"article\"]"
+        "checkpoint = storm.get_state(config)\n",
+        "article = checkpoint.values[\"article\"]"
       ]
     },
     {
@@ -967,16 +1662,10 @@
         }
       ],
       "source": [
-        "from IPython.display import Markdown\n\n# We will down-header the sections to create less confusion in this notebook\nMarkdown(article.replace(\"\\n#\", \"\\n##\"))"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        ""
+        "from IPython.display import Markdown\n",
+        "\n",
+        "# We will down-header the sections to create less confusion in this notebook\n",
+        "Markdown(article.replace(\"\\n#\", \"\\n##\"))"
       ]
     }
   ],

examples/stream-multiple.ipynb

@@ -50,7 +50,7 @@
    "metadata": {},
    "outputs": [
     {
-     "name": "stdin",
+     "name": "stdout",
      "output_type": "stream",
      "text": [
       "OPENAI_API_KEY:  ········\n"
@@ -175,14 +175,6 @@
     "    print(chunk)\n",
     "    print(\"\\n\\n\")"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "8cc57240-243c-4d9a-a845-cb55ef973a59",
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {

examples/stream-updates.ipynb

@@ -55,7 +55,7 @@
    "metadata": {},
    "outputs": [
     {
-     "name": "stdin",
+     "name": "stdout",
      "output_type": "stream",
      "text": [
       "OPENAI_API_KEY:  ········\n"
@@ -151,14 +151,6 @@
     "        print(values)\n",
     "        print(\"\\n\\n\")"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "8cc57240-243c-4d9a-a845-cb55ef973a59",
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {

examples/streaming-content.ipynb

@@ -68,7 +68,9 @@
     "    # It's completely optional, but useful if you have many functions with similar names\n",
     "    gen = RunnableGenerator(my_generator).with_config(\n",
     "        tags=[\"should_stream\"],\n",
-    "        callbacks=config.get(\"callbacks\", [])  # <-- Propagate callbacks (Python <= 3.10)\n",
+    "        callbacks=config.get(\n",
+    "            \"callbacks\", []\n",
+    "        ),  # <-- Propagate callbacks (Python <= 3.10)\n",
     "    )\n",
     "    async for message in gen.astream(state):\n",
     "        messages.append(message)\n",
@@ -118,14 +120,6 @@
     "            # So we only print non-empty content\n",
     "            print(data, end=\"|\")"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "615cb9d2-bfa2-4f83-90b0-c6c2d1e6df95",
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {

examples/streaming-events-from-within-tools-without-langchain.ipynb

@@ -30,10 +30,7 @@
    "id": "47f79af8-58d8-4a48-8d9a-88823d88701f",
    "metadata": {},
    "outputs": [],
-   "source": [
-    "%%capture --no-stderr\n",
-    "%pip install -U langgraph openai"
-   ]
+   "source": ["%%capture --no-stderr\n%pip install -U langgraph openai"]
   },
   {
    "cell_type": "code",
@@ -49,18 +46,7 @@
      ]
     }
    ],
-   "source": [
-    "import getpass\n",
-    "import os\n",
-    "\n",
-    "\n",
-    "def _set_env(var: str):\n",
-    "    if not os.environ.get(var):\n",
-    "        os.environ[var] = getpass.getpass(f\"{var}: \")\n",
-    "\n",
-    "\n",
-    "_set_env(\"OPENAI_API_KEY\")"
-   ]
+   "source": ["import getpass\nimport os\n\n\ndef _set_env(var: str):\n    if not os.environ.get(var):\n        os.environ[var] = getpass.getpass(f\"{var}: \")\n\n\n_set_env(\"OPENAI_API_KEY\")"]
   },
   {
    "cell_type": "markdown",
@@ -84,94 +70,7 @@
    "id": "d59234f9-173e-469d-a725-c13e0979663e",
    "metadata": {},
    "outputs": [],
-   "source": [
-    "from openai import AsyncOpenAI\n",
-    "from langchain_core.language_models.chat_models import ChatGenerationChunk\n",
-    "from langchain_core.messages import AIMessageChunk\n",
-    "from langchain_core.runnables.config import (\n",
-    "    ensure_config,\n",
-    "    get_callback_manager_for_config,\n",
-    ")\n",
-    "\n",
-    "openai_client = AsyncOpenAI()\n",
-    "# define tool schema for openai tool calling\n",
-    "\n",
-    "tool = {\n",
-    "    \"type\": \"function\",\n",
-    "    \"function\": {\n",
-    "        \"name\": \"get_items\",\n",
-    "        \"description\": \"Use this tool to look up which items are in the given place.\",\n",
-    "        \"parameters\": {\n",
-    "            \"type\": \"object\",\n",
-    "            \"properties\": {\"place\": {\"type\": \"string\"}},\n",
-    "            \"required\": [\"place\"],\n",
-    "        },\n",
-    "    },\n",
-    "}\n",
-    "\n",
-    "\n",
-    "async def call_model(state, config=None):\n",
-    "    config = ensure_config(config | {\"tags\": [\"agent_llm\"]})\n",
-    "    callback_manager = get_callback_manager_for_config(config)\n",
-    "    messages = state[\"messages\"]\n",
-    "\n",
-    "    llm_run_manager = callback_manager.on_chat_model_start({}, [messages])[0]\n",
-    "    response = await openai_client.chat.completions.create(\n",
-    "        messages=messages, model=\"gpt-3.5-turbo\", tools=[tool], stream=True\n",
-    "    )\n",
-    "\n",
-    "    response_content = \"\"\n",
-    "    role = None\n",
-    "\n",
-    "    tool_call_id = None\n",
-    "    tool_call_function_name = None\n",
-    "    tool_call_function_arguments = \"\"\n",
-    "    async for chunk in response:\n",
-    "        delta = chunk.choices[0].delta\n",
-    "        if delta.role is not None:\n",
-    "            role = delta.role\n",
-    "\n",
-    "        if delta.content:\n",
-    "            response_content += delta.content\n",
-    "            llm_run_manager.on_llm_new_token(delta.content)\n",
-    "\n",
-    "        if delta.tool_calls:\n",
-    "            # note: for simplicity we're only handling a single tool call here\n",
-    "            if delta.tool_calls[0].function.name is not None:\n",
-    "                tool_call_function_name = delta.tool_calls[0].function.name\n",
-    "                tool_call_id = delta.tool_calls[0].id\n",
-    "\n",
-    "            # note: we're wrapping the tools calls in ChatGenerationChunk so that the events from .astream_events in the graph can render tool calls correctly\n",
-    "            tool_call_chunk = ChatGenerationChunk(\n",
-    "                message=AIMessageChunk(\n",
-    "                    content=\"\",\n",
-    "                    additional_kwargs={\"tool_calls\": [delta.tool_calls[0].dict()]},\n",
-    "                )\n",
-    "            )\n",
-    "            llm_run_manager.on_llm_new_token(\"\", chunk=tool_call_chunk)\n",
-    "            tool_call_function_arguments += delta.tool_calls[0].function.arguments\n",
-    "\n",
-    "    if tool_call_function_name is not None:\n",
-    "        tool_calls = [\n",
-    "            {\n",
-    "                \"id\": tool_call_id,\n",
-    "                \"function\": {\n",
-    "                    \"name\": tool_call_function_name,\n",
-    "                    \"arguments\": tool_call_function_arguments,\n",
-    "                },\n",
-    "                \"type\": \"function\",\n",
-    "            }\n",
-    "        ]\n",
-    "    else:\n",
-    "        tool_calls = None\n",
-    "\n",
-    "    response_message = {\n",
-    "        \"role\": role,\n",
-    "        \"content\": response_content,\n",
-    "        \"tool_calls\": tool_calls,\n",
-    "    }\n",
-    "    return {\"messages\": [response_message]}"
-   ]
+   "source": ["from openai import AsyncOpenAI\nfrom langchain_core.language_models.chat_models import ChatGenerationChunk\nfrom langchain_core.messages import AIMessageChunk\nfrom langchain_core.runnables.config import (\n    ensure_config,\n    get_callback_manager_for_config,\n)\n\nopenai_client = AsyncOpenAI()\n# define tool schema for openai tool calling\n\ntool = {\n    \"type\": \"function\",\n    \"function\": {\n        \"name\": \"get_items\",\n        \"description\": \"Use this tool to look up which items are in the given place.\",\n        \"parameters\": {\n            \"type\": \"object\",\n            \"properties\": {\"place\": {\"type\": \"string\"}},\n            \"required\": [\"place\"],\n        },\n    },\n}\n\n\nasync def call_model(state, config=None):\n    config = ensure_config(config | {\"tags\": [\"agent_llm\"]})\n    callback_manager = get_callback_manager_for_config(config)\n    messages = state[\"messages\"]\n\n    llm_run_manager = callback_manager.on_chat_model_start({}, [messages])[0]\n    response = await openai_client.chat.completions.create(\n        messages=messages, model=\"gpt-3.5-turbo\", tools=[tool], stream=True\n    )\n\n    response_content = \"\"\n    role = None\n\n    tool_call_id = None\n    tool_call_function_name = None\n    tool_call_function_arguments = \"\"\n    async for chunk in response:\n        delta = chunk.choices[0].delta\n        if delta.role is not None:\n            role = delta.role\n\n        if delta.content:\n            response_content += delta.content\n            llm_run_manager.on_llm_new_token(delta.content)\n\n        if delta.tool_calls:\n            # note: for simplicity we're only handling a single tool call here\n            if delta.tool_calls[0].function.name is not None:\n                tool_call_function_name = delta.tool_calls[0].function.name\n                tool_call_id = delta.tool_calls[0].id\n\n            # note: we're wrapping the tools calls in ChatGenerationChunk so that the events from .astream_events in the graph can render tool calls correctly\n            tool_call_chunk = ChatGenerationChunk(\n                message=AIMessageChunk(\n                    content=\"\",\n                    additional_kwargs={\"tool_calls\": [delta.tool_calls[0].dict()]},\n                )\n            )\n            llm_run_manager.on_llm_new_token(\"\", chunk=tool_call_chunk)\n            tool_call_function_arguments += delta.tool_calls[0].function.arguments\n\n    if tool_call_function_name is not None:\n        tool_calls = [\n            {\n                \"id\": tool_call_id,\n                \"function\": {\n                    \"name\": tool_call_function_name,\n                    \"arguments\": tool_call_function_arguments,\n                },\n                \"type\": \"function\",\n            }\n        ]\n    else:\n        tool_calls = None\n\n    response_message = {\n        \"role\": role,\n        \"content\": response_content,\n        \"tool_calls\": tool_calls,\n    }\n    return {\"messages\": [response_message]}"]
   },
   {
    "cell_type": "markdown",
@@ -187,62 +86,7 @@
    "id": "b90941d8-afe4-42ec-9262-9c3b87c3b1ec",
    "metadata": {},
    "outputs": [],
-   "source": [
-    "import json\n",
-    "from langchain_core.callbacks import adispatch_custom_event\n",
-    "\n",
-    "\n",
-    "async def get_items(place: str) -> str:\n",
-    "    \"\"\"Use this tool to look up which items are in the given place.\"\"\"\n",
-    "\n",
-    "    # this can be replaced with any actual streaming logic that you might have\n",
-    "    def stream(place: str):\n",
-    "        if \"bed\" in place:  # For under the bed\n",
-    "            yield from [\"socks\", \"shoes\", \"dust bunnies\"]\n",
-    "        elif \"shelf\" in place:  # For 'shelf'\n",
-    "            yield from [\"books\", \"penciles\", \"pictures\"]\n",
-    "        else:  # if the agent decides to ask about a different place\n",
-    "            yield \"cat snacks\"\n",
-    "\n",
-    "    tokens = []\n",
-    "    for token in stream(place):\n",
-    "        await adispatch_custom_event(\n",
-    "            # this will allow you to filter events by name\n",
-    "            \"tool_call_token_stream\",\n",
-    "            {\n",
-    "                \"function_name\": \"get_items\",\n",
-    "                \"arguments\": {\"place\": place},\n",
-    "                \"tool_output_token\": token,\n",
-    "            },\n",
-    "            # this will allow you to filter events by tags\n",
-    "            config={\"tags\": [\"tool_call\"]},\n",
-    "        )\n",
-    "        tokens.append(token)\n",
-    "\n",
-    "    return \", \".join(tokens)\n",
-    "\n",
-    "\n",
-    "# define mapping to look up functions when running tools\n",
-    "function_name_to_function = {\"get_items\": get_items}\n",
-    "\n",
-    "\n",
-    "async def call_tools(state):\n",
-    "    messages = state[\"messages\"]\n",
-    "\n",
-    "    tool_call = messages[-1][\"tool_calls\"][0]\n",
-    "    function_name = tool_call[\"function\"][\"name\"]\n",
-    "    function_arguments = tool_call[\"function\"][\"arguments\"]\n",
-    "    arguments = json.loads(function_arguments)\n",
-    "\n",
-    "    function_response = await function_name_to_function[function_name](**arguments)\n",
-    "    tool_message = {\n",
-    "        \"tool_call_id\": tool_call[\"id\"],\n",
-    "        \"role\": \"tool\",\n",
-    "        \"name\": function_name,\n",
-    "        \"content\": function_response,\n",
-    "    }\n",
-    "    return {\"messages\": [tool_message]}"
-   ]
+   "source": ["import json\nfrom langchain_core.callbacks import adispatch_custom_event\n\n\nasync def get_items(place: str) -> str:\n    \"\"\"Use this tool to look up which items are in the given place.\"\"\"\n\n    # this can be replaced with any actual streaming logic that you might have\n    def stream(place: str):\n        if \"bed\" in place:  # For under the bed\n            yield from [\"socks\", \"shoes\", \"dust bunnies\"]\n        elif \"shelf\" in place:  # For 'shelf'\n            yield from [\"books\", \"penciles\", \"pictures\"]\n        else:  # if the agent decides to ask about a different place\n            yield \"cat snacks\"\n\n    tokens = []\n    for token in stream(place):\n        await adispatch_custom_event(\n            # this will allow you to filter events by name\n            \"tool_call_token_stream\",\n            {\n                \"function_name\": \"get_items\",\n                \"arguments\": {\"place\": place},\n                \"tool_output_token\": token,\n            },\n            # this will allow you to filter events by tags\n            config={\"tags\": [\"tool_call\"]},\n        )\n        tokens.append(token)\n\n    return \", \".join(tokens)\n\n\n# define mapping to look up functions when running tools\nfunction_name_to_function = {\"get_items\": get_items}\n\n\nasync def call_tools(state):\n    messages = state[\"messages\"]\n\n    tool_call = messages[-1][\"tool_calls\"][0]\n    function_name = tool_call[\"function\"][\"name\"]\n    function_arguments = tool_call[\"function\"][\"arguments\"]\n    arguments = json.loads(function_arguments)\n\n    function_response = await function_name_to_function[function_name](**arguments)\n    tool_message = {\n        \"tool_call_id\": tool_call[\"id\"],\n        \"role\": \"tool\",\n        \"name\": function_name,\n        \"content\": function_response,\n    }\n    return {\"messages\": [tool_message]}"]
   },
   {
    "cell_type": "markdown",
@@ -258,33 +102,7 @@
    "id": "228260be-1f9a-4195-80e0-9604f8a5dba6",
    "metadata": {},
    "outputs": [],
-   "source": [
-    "import operator\n",
-    "from typing import Annotated, TypedDict, Literal\n",
-    "\n",
-    "from langgraph.graph import StateGraph, END\n",
-    "\n",
-    "\n",
-    "class State(TypedDict):\n",
-    "    messages: Annotated[list, operator.add]\n",
-    "\n",
-    "\n",
-    "def should_continue(state) -> Literal[\"tools\", END]:\n",
-    "    messages = state[\"messages\"]\n",
-    "    last_message = messages[-1]\n",
-    "    if last_message[\"tool_calls\"]:\n",
-    "        return \"tools\"\n",
-    "    return END\n",
-    "\n",
-    "\n",
-    "workflow = StateGraph(State)\n",
-    "workflow.set_entry_point(\"model\")\n",
-    "workflow.add_node(\"model\", call_model)  # i.e. our \"agent\"\n",
-    "workflow.add_node(\"tools\", call_tools)\n",
-    "workflow.add_conditional_edges(\"model\", should_continue)\n",
-    "workflow.add_edge(\"tools\", \"model\")\n",
-    "graph = workflow.compile()"
-   ]
+   "source": ["import operator\nfrom typing import Annotated, TypedDict, Literal\n\nfrom langgraph.graph import StateGraph, END, START\n\n\nclass State(TypedDict):\n    messages: Annotated[list, operator.add]\n\n\ndef should_continue(state) -> Literal[\"tools\", END]:\n    messages = state[\"messages\"]\n    last_message = messages[-1]\n    if last_message[\"tool_calls\"]:\n        return \"tools\"\n    return END\n\n\nworkflow = StateGraph(State)\nworkflow.add_edge(START, \"model\")\nworkflow.add_node(\"model\", call_model)  # i.e. our \"agent\"\nworkflow.add_node(\"tools\", call_tools)\nworkflow.add_conditional_edges(\"model\", should_continue)\nworkflow.add_edge(\"tools\", \"model\")\ngraph = workflow.compile()"]
   },
   {
    "cell_type": "markdown",
@@ -318,14 +136,7 @@
      ]
     }
    ],
-   "source": [
-    "async for event in graph.astream_events(\n",
-    "    {\"messages\": [{\"role\": \"user\", \"content\": \"what's in the bedroom\"}]}, version=\"v2\"\n",
-    "):\n",
-    "    tags = event.get(\"tags\", [])\n",
-    "    if event[\"event\"] == \"on_custom_event\" and \"tool_call\" in tags:\n",
-    "        print(\"Tool token\", event[\"data\"][\"tool_output_token\"])"
-   ]
+   "source": ["async for event in graph.astream_events(\n    {\"messages\": [{\"role\": \"user\", \"content\": \"what's in the bedroom\"}]}, version=\"v2\"\n):\n    tags = event.get(\"tags\", [])\n    if event[\"event\"] == \"on_custom_event\" and \"tool_call\" in tags:\n        print(\"Tool token\", event[\"data\"][\"tool_output_token\"])"]
   }
  ],
  "metadata": {

examples/streaming-tokens-without-langchain.ipynb

@@ -30,10 +30,7 @@
    "id": "47f79af8-58d8-4a48-8d9a-88823d88701f",
    "metadata": {},
    "outputs": [],
-   "source": [
-    "%%capture --no-stderr\n",
-    "%pip install -U langgraph openai"
-   ]
+   "source": ["%%capture --no-stderr\n%pip install -U langgraph openai"]
   },
   {
    "cell_type": "code",
@@ -49,18 +46,7 @@
      ]
     }
    ],
-   "source": [
-    "import getpass\n",
-    "import os\n",
-    "\n",
-    "\n",
-    "def _set_env(var: str):\n",
-    "    if not os.environ.get(var):\n",
-    "        os.environ[var] = getpass.getpass(f\"{var}: \")\n",
-    "\n",
-    "\n",
-    "_set_env(\"OPENAI_API_KEY\")"
-   ]
+   "source": ["import getpass\nimport os\n\n\ndef _set_env(var: str):\n    if not os.environ.get(var):\n        os.environ[var] = getpass.getpass(f\"{var}: \")\n\n\n_set_env(\"OPENAI_API_KEY\")"]
   },
   {
    "cell_type": "markdown",
@@ -84,94 +70,7 @@
    "id": "d59234f9-173e-469d-a725-c13e0979663e",
    "metadata": {},
    "outputs": [],
-   "source": [
-    "from openai import AsyncOpenAI\n",
-    "from langchain_core.language_models.chat_models import ChatGenerationChunk\n",
-    "from langchain_core.messages import AIMessageChunk\n",
-    "from langchain_core.runnables.config import (\n",
-    "    ensure_config,\n",
-    "    get_callback_manager_for_config,\n",
-    ")\n",
-    "\n",
-    "openai_client = AsyncOpenAI()\n",
-    "# define tool schema for openai tool calling\n",
-    "\n",
-    "tool = {\n",
-    "    \"type\": \"function\",\n",
-    "    \"function\": {\n",
-    "        \"name\": \"get_items\",\n",
-    "        \"description\": \"Use this tool to look up which items are in the given place.\",\n",
-    "        \"parameters\": {\n",
-    "            \"type\": \"object\",\n",
-    "            \"properties\": {\"place\": {\"type\": \"string\"}},\n",
-    "            \"required\": [\"place\"],\n",
-    "        },\n",
-    "    },\n",
-    "}\n",
-    "\n",
-    "\n",
-    "async def call_model(state, config=None):\n",
-    "    config = ensure_config(config | {\"tags\": [\"agent_llm\"]})\n",
-    "    callback_manager = get_callback_manager_for_config(config)\n",
-    "    messages = state[\"messages\"]\n",
-    "\n",
-    "    llm_run_manager = callback_manager.on_chat_model_start({}, [messages])[0]\n",
-    "    response = await openai_client.chat.completions.create(\n",
-    "        messages=messages, model=\"gpt-3.5-turbo\", tools=[tool], stream=True\n",
-    "    )\n",
-    "\n",
-    "    response_content = \"\"\n",
-    "    role = None\n",
-    "\n",
-    "    tool_call_id = None\n",
-    "    tool_call_function_name = None\n",
-    "    tool_call_function_arguments = \"\"\n",
-    "    async for chunk in response:\n",
-    "        delta = chunk.choices[0].delta\n",
-    "        if delta.role is not None:\n",
-    "            role = delta.role\n",
-    "\n",
-    "        if delta.content:\n",
-    "            response_content += delta.content\n",
-    "            llm_run_manager.on_llm_new_token(delta.content)\n",
-    "\n",
-    "        if delta.tool_calls:\n",
-    "            # note: for simplicity we're only handling a single tool call here\n",
-    "            if delta.tool_calls[0].function.name is not None:\n",
-    "                tool_call_function_name = delta.tool_calls[0].function.name\n",
-    "                tool_call_id = delta.tool_calls[0].id\n",
-    "\n",
-    "            # note: we're wrapping the tools calls in ChatGenerationChunk so that the events from .astream_events in the graph can render tool calls correctly\n",
-    "            tool_call_chunk = ChatGenerationChunk(\n",
-    "                message=AIMessageChunk(\n",
-    "                    content=\"\",\n",
-    "                    additional_kwargs={\"tool_calls\": [delta.tool_calls[0].dict()]},\n",
-    "                )\n",
-    "            )\n",
-    "            llm_run_manager.on_llm_new_token(\"\", chunk=tool_call_chunk)\n",
-    "            tool_call_function_arguments += delta.tool_calls[0].function.arguments\n",
-    "\n",
-    "    if tool_call_function_name is not None:\n",
-    "        tool_calls = [\n",
-    "            {\n",
-    "                \"id\": tool_call_id,\n",
-    "                \"function\": {\n",
-    "                    \"name\": tool_call_function_name,\n",
-    "                    \"arguments\": tool_call_function_arguments,\n",
-    "                },\n",
-    "                \"type\": \"function\",\n",
-    "            }\n",
-    "        ]\n",
-    "    else:\n",
-    "        tool_calls = None\n",
-    "\n",
-    "    response_message = {\n",
-    "        \"role\": role,\n",
-    "        \"content\": response_content,\n",
-    "        \"tool_calls\": tool_calls,\n",
-    "    }\n",
-    "    return {\"messages\": [response_message]}"
-   ]
+   "source": ["from openai import AsyncOpenAI\nfrom langchain_core.language_models.chat_models import ChatGenerationChunk\nfrom langchain_core.messages import AIMessageChunk\nfrom langchain_core.runnables.config import (\n    ensure_config,\n    get_callback_manager_for_config,\n)\n\nopenai_client = AsyncOpenAI()\n# define tool schema for openai tool calling\n\ntool = {\n    \"type\": \"function\",\n    \"function\": {\n        \"name\": \"get_items\",\n        \"description\": \"Use this tool to look up which items are in the given place.\",\n        \"parameters\": {\n            \"type\": \"object\",\n            \"properties\": {\"place\": {\"type\": \"string\"}},\n            \"required\": [\"place\"],\n        },\n    },\n}\n\n\nasync def call_model(state, config=None):\n    config = ensure_config(config | {\"tags\": [\"agent_llm\"]})\n    callback_manager = get_callback_manager_for_config(config)\n    messages = state[\"messages\"]\n\n    llm_run_manager = callback_manager.on_chat_model_start({}, [messages])[0]\n    response = await openai_client.chat.completions.create(\n        messages=messages, model=\"gpt-3.5-turbo\", tools=[tool], stream=True\n    )\n\n    response_content = \"\"\n    role = None\n\n    tool_call_id = None\n    tool_call_function_name = None\n    tool_call_function_arguments = \"\"\n    async for chunk in response:\n        delta = chunk.choices[0].delta\n        if delta.role is not None:\n            role = delta.role\n\n        if delta.content:\n            response_content += delta.content\n            llm_run_manager.on_llm_new_token(delta.content)\n\n        if delta.tool_calls:\n            # note: for simplicity we're only handling a single tool call here\n            if delta.tool_calls[0].function.name is not None:\n                tool_call_function_name = delta.tool_calls[0].function.name\n                tool_call_id = delta.tool_calls[0].id\n\n            # note: we're wrapping the tools calls in ChatGenerationChunk so that the events from .astream_events in the graph can render tool calls correctly\n            tool_call_chunk = ChatGenerationChunk(\n                message=AIMessageChunk(\n                    content=\"\",\n                    additional_kwargs={\"tool_calls\": [delta.tool_calls[0].dict()]},\n                )\n            )\n            llm_run_manager.on_llm_new_token(\"\", chunk=tool_call_chunk)\n            tool_call_function_arguments += delta.tool_calls[0].function.arguments\n\n    if tool_call_function_name is not None:\n        tool_calls = [\n            {\n                \"id\": tool_call_id,\n                \"function\": {\n                    \"name\": tool_call_function_name,\n                    \"arguments\": tool_call_function_arguments,\n                },\n                \"type\": \"function\",\n            }\n        ]\n    else:\n        tool_calls = None\n\n    response_message = {\n        \"role\": role,\n        \"content\": response_content,\n        \"tool_calls\": tool_calls,\n    }\n    return {\"messages\": [response_message]}"]
   },
   {
    "cell_type": "markdown",
@@ -187,41 +86,7 @@
    "id": "b756ea32",
    "metadata": {},
    "outputs": [],
-   "source": [
-    "import json\n",
-    "\n",
-    "\n",
-    "async def get_items(place: str) -> str:\n",
-    "    \"\"\"Use this tool to look up which items are in the given place.\"\"\"\n",
-    "    if \"bed\" in place:  # For under the bed\n",
-    "        return \"socks, shoes and dust bunnies\"\n",
-    "    if \"shelf\" in place:  # For 'shelf'\n",
-    "        return \"books, penciles and pictures\"\n",
-    "    else:  # if the agent decides to ask about a different place\n",
-    "        return \"cat snacks\"\n",
-    "\n",
-    "\n",
-    "# define mapping to look up functions when running tools\n",
-    "function_name_to_function = {\"get_items\": get_items}\n",
-    "\n",
-    "\n",
-    "async def call_tools(state):\n",
-    "    messages = state[\"messages\"]\n",
-    "\n",
-    "    tool_call = messages[-1][\"tool_calls\"][0]\n",
-    "    function_name = tool_call[\"function\"][\"name\"]\n",
-    "    function_arguments = tool_call[\"function\"][\"arguments\"]\n",
-    "    arguments = json.loads(function_arguments)\n",
-    "\n",
-    "    function_response = await function_name_to_function[function_name](**arguments)\n",
-    "    tool_message = {\n",
-    "        \"tool_call_id\": tool_call[\"id\"],\n",
-    "        \"role\": \"tool\",\n",
-    "        \"name\": function_name,\n",
-    "        \"content\": function_response,\n",
-    "    }\n",
-    "    return {\"messages\": [tool_message]}"
-   ]
+   "source": ["import json\n\n\nasync def get_items(place: str) -> str:\n    \"\"\"Use this tool to look up which items are in the given place.\"\"\"\n    if \"bed\" in place:  # For under the bed\n        return \"socks, shoes and dust bunnies\"\n    if \"shelf\" in place:  # For 'shelf'\n        return \"books, penciles and pictures\"\n    else:  # if the agent decides to ask about a different place\n        return \"cat snacks\"\n\n\n# define mapping to look up functions when running tools\nfunction_name_to_function = {\"get_items\": get_items}\n\n\nasync def call_tools(state):\n    messages = state[\"messages\"]\n\n    tool_call = messages[-1][\"tool_calls\"][0]\n    function_name = tool_call[\"function\"][\"name\"]\n    function_arguments = tool_call[\"function\"][\"arguments\"]\n    arguments = json.loads(function_arguments)\n\n    function_response = await function_name_to_function[function_name](**arguments)\n    tool_message = {\n        \"tool_call_id\": tool_call[\"id\"],\n        \"role\": \"tool\",\n        \"name\": function_name,\n        \"content\": function_response,\n    }\n    return {\"messages\": [tool_message]}"]
   },
   {
    "cell_type": "markdown",
@@ -237,33 +102,7 @@
    "id": "228260be-1f9a-4195-80e0-9604f8a5dba6",
    "metadata": {},
    "outputs": [],
-   "source": [
-    "import operator\n",
-    "from typing import Annotated, TypedDict, Literal\n",
-    "\n",
-    "from langgraph.graph import StateGraph, END\n",
-    "\n",
-    "\n",
-    "class State(TypedDict):\n",
-    "    messages: Annotated[list, operator.add]\n",
-    "\n",
-    "\n",
-    "def should_continue(state) -> Literal[\"tools\", END]:\n",
-    "    messages = state[\"messages\"]\n",
-    "    last_message = messages[-1]\n",
-    "    if last_message[\"tool_calls\"]:\n",
-    "        return \"tools\"\n",
-    "    return END\n",
-    "\n",
-    "\n",
-    "workflow = StateGraph(State)\n",
-    "workflow.set_entry_point(\"model\")\n",
-    "workflow.add_node(\"model\", call_model)  # i.e. our \"agent\"\n",
-    "workflow.add_node(\"tools\", call_tools)\n",
-    "workflow.add_conditional_edges(\"model\", should_continue)\n",
-    "workflow.add_edge(\"tools\", \"model\")\n",
-    "graph = workflow.compile()"
-   ]
+   "source": ["import operator\nfrom typing import Annotated, TypedDict, Literal\n\nfrom langgraph.graph import StateGraph, END, START\n\n\nclass State(TypedDict):\n    messages: Annotated[list, operator.add]\n\n\ndef should_continue(state) -> Literal[\"tools\", END]:\n    messages = state[\"messages\"]\n    last_message = messages[-1]\n    if last_message[\"tool_calls\"]:\n        return \"tools\"\n    return END\n\n\nworkflow = StateGraph(State)\nworkflow.add_edge(START, \"model\")\nworkflow.add_node(\"model\", call_model)  # i.e. our \"agent\"\nworkflow.add_node(\"tools\", call_tools)\nworkflow.add_conditional_edges(\"model\", should_continue)\nworkflow.add_edge(\"tools\", \"model\")\ngraph = workflow.compile()"]
   },
   {
    "cell_type": "markdown",
@@ -328,14 +167,7 @@
      ]
     }
    ],
-   "source": [
-    "async for event in graph.astream_events(\n",
-    "    {\"messages\": [{\"role\": \"user\", \"content\": \"what's in the bedroom\"}]}, version=\"v2\"\n",
-    "):\n",
-    "    tags = event.get(\"tags\", [])\n",
-    "    if event[\"event\"] == \"on_chat_model_stream\" and \"agent_llm\" in tags:\n",
-    "        print(\"LLM token\", event[\"data\"][\"chunk\"].dict())"
-   ]
+   "source": ["async for event in graph.astream_events(\n    {\"messages\": [{\"role\": \"user\", \"content\": \"what's in the bedroom\"}]}, version=\"v2\"\n):\n    tags = event.get(\"tags\", [])\n    if event[\"event\"] == \"on_chat_model_stream\" and \"agent_llm\" in tags:\n        print(\"LLM token\", event[\"data\"][\"chunk\"].dict())"]
   },
   {
    "cell_type": "code",
@@ -343,7 +175,7 @@
    "id": "adb0f7bc-6e51-478e-bd32-8f72df072d6c",
    "metadata": {},
    "outputs": [],
-   "source": []
+   "source": [""]
   }
  ],
  "metadata": {