checkpoint: release 1.0.9 (#1628)

Split out prepare_single_task from prepare_next_tasks

.github/workflows/_test.yml

@@ -21,16 +21,14 @@ 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: Get changed files
-        id: changed-files
-        uses: Ana06/get-changed-files@v2.2.0
-        with:
-          filter: "${{ inputs.working-directory }}/**"
       - name: Set up Python ${{ matrix.python-version }} + Poetry ${{ env.POETRY_VERSION }}
-        if: steps.changed-files.outputs.all
         uses: "./.github/actions/poetry_setup"
         with:
           python-version: ${{ matrix.python-version }}
@@ -39,20 +37,21 @@ jobs:
           cache-key: core
 
       - name: Install dependencies
-        if: steps.changed-files.outputs.all
         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
-        if: steps.changed-files.outputs.all
         shell: bash
         working-directory: ${{ inputs.working-directory }}
         run: |
           make test
 
       - name: Ensure the tests did not create any additional files
-        if: steps.changed-files.outputs.all
         shell: bash
         working-directory: ${{ inputs.working-directory }}
         run: |

.github/workflows/ci.yml

@@ -36,7 +36,10 @@
             working-directory: [
                 "libs/langgraph",
                 "libs/sdk-py",
-                "libs/cli"
+                "libs/cli",
+                "libs/checkpoint",
+                "libs/checkpoint-sqlite",
+                "libs/checkpoint-postgres"
             ]
         uses: ./.github/workflows/_lint.yml
         with:
@@ -50,7 +53,10 @@
           matrix:
             working-directory: [
                 "libs/langgraph",
-                "libs/cli"
+                "libs/cli",
+                "libs/checkpoint",
+                "libs/checkpoint-sqlite",
+                "libs/checkpoint-postgres"
             ]
         uses: ./.github/workflows/_test.yml
         with:

.github/workflows/release.yml

@@ -6,7 +6,7 @@ on:
       working-directory:
         required: true
         type: string
-        default: 'libs/langgraph'
+        default: "libs/langgraph"
 
 env:
   PYTHON_VERSION: "3.11"
@@ -104,7 +104,7 @@ jobs:
             REGEX="^$SHORT_PKG_NAME==\\d+\\.\\d+\\.\\d+((a|b|rc)\\d+)?\$"
           fi
           echo $REGEX
-          PREV_TAG=$(git tag --sort=-creatordate | grep -P $REGEX | head -1)
+          PREV_TAG=$(git tag --sort=-creatordate | grep -P $REGEX | head -1 || echo "")
           echo $PREV_TAG
           if [ "$TAG" == "$PREV_TAG" ]; then
             echo "No new version to release"
@@ -137,8 +137,7 @@ jobs:
       - build
       - release-notes
     permissions: write-all
-    uses:
-      ./.github/workflows/_test_release.yml
+    uses: ./.github/workflows/_test_release.yml
     with:
       working-directory: ${{ inputs.working-directory }}
     secrets: inherit
@@ -198,9 +197,15 @@ jobs:
               "$PKG_NAME==$VERSION" \
           )
 
-          # Replace all dashes in the package name with underscores,
-          # since that's how Python imports packages with dashes in the name.
-          IMPORT_NAME="$(echo "$PKG_NAME" | sed s/-/_/g)"
+          if [[ "$PKG_NAME" == *checkpoint* ]]; then
+            # since checkpoint packages are namespace packages, import them with . convention
+            # i.e. import langgraph.checkpoint or langgraph.checkpoint.sqlite
+            IMPORT_NAME="$(echo "$PKG_NAME" | sed s/-/./g)"
+          else
+            # Replace all dashes in the package name with underscores,
+            # since that's how Python imports packages with dashes in the name.
+            IMPORT_NAME="$(echo "$PKG_NAME" | sed s/-/_/g)"
+          fi
 
           poetry run python -c "import $IMPORT_NAME; print(dir($IMPORT_NAME))"
 

.github/workflows/size.yml

@@ -0,0 +1,28 @@
+name: Check File Size
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+  workflow_dispatch:
+
+jobs:
+  file-size-check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Get changed files
+        id: changed-files
+        uses: tj-actions/changed-files@v44
+      - name: Filter by size
+        run: |
+          large_added_files=$(find ${{ steps.changed-files.outputs.added_files }} -maxdepth 0 -size +1M)
+          if [ -n "$large_added_files" ]; then
+            echo "Large files added: $large_added_files"
+            echo "# Large files added:" >> $GITHUB_STEP_SUMMARY
+            echo "$large_added_files" >> $GITHUB_STEP_SUMMARY
+            exit 1
+          fi

README.md

@@ -3,7 +3,6 @@
 ![Version](https://img.shields.io/pypi/v/langgraph)
 [![Downloads](https://static.pepy.tech/badge/langgraph/month)](https://pepy.tech/project/langgraph)
 [![Open Issues](https://img.shields.io/github/issues-raw/langchain-ai/langgraph)](https://github.com/langchain-ai/langgraph/issues)
-[![](https://dcbadge.vercel.app/api/server/6adMQxSpJS?compact=true&style=flat)](https://discord.com/channels/1038097195422978059/1170024642245832774)
 [![Docs](https://img.shields.io/badge/docs-latest-blue)](https://langchain-ai.github.io/langgraph/)
 
 ⚡ Building language agents as graphs ⚡
@@ -11,9 +10,6 @@
 > [!NOTE]
 > Looking for the JS version? Click [here](https://github.com/langchain-ai/langgraphjs) ([JS docs](https://langchain-ai.github.io/langgraphjs/)).
 
-> [!TIP]
-> Looking to deploy your LangGraph application? [Join the waitlist](https://www.langchain.com/langgraph-cloud-beta) for [LangGraph Cloud](https://langchain-ai.github.io/langgraph/cloud/), our managed service for deploying and hosting LangGraph applications.
-
 ## Overview
 
 [LangGraph](https://langchain-ai.github.io/langgraph/) is a library for building stateful, multi-actor applications with LLMs, used to create agent and multi-agent workflows. Compared to other LLM frameworks, it offers these core benefits: cycles, controllability, and persistence. LangGraph allows you to define flows that involve cycles, essential for most agentic architectures, differentiating it from DAG-based solutions. As a very low-level framework, it provides fine-grained control over both the flow and state of your application, crucial for creating reliable agents. Additionally, LangGraph includes built-in persistence, enabling advanced human-in-the-loop and memory features.
@@ -62,8 +58,8 @@ from typing import Annotated, Literal, TypedDict
 from langchain_core.messages import HumanMessage
 from langchain_anthropic import ChatAnthropic
 from langchain_core.tools import tool
-from langgraph.checkpoint import MemorySaver
-from langgraph.graph import END, StateGraph, MessagesState
+from langgraph.checkpoint.memory import MemorySaver
+from langgraph.graph import END, START, StateGraph, MessagesState
 from langgraph.prebuilt import ToolNode
 
 
@@ -111,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,11 +40,13 @@ _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",
         "tool-calling-errors.ipynb",
         "pass-config-to-tools.ipynb",
+        "many-tools.ipynb",
         "dynamic-returning-direct.ipynb",
         "managing-agent-steps.ipynb",
         "respond-in-format.ipynb",
@@ -55,10 +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",
@@ -101,6 +109,7 @@ _HIDE = set(
         "docs/quickstart.ipynb",
         "tutorials/rag-agent-testing.ipynb",
         "tutorials/rag-agent-testing-local.ipynb",
+        "tutorials/tool-calling-agent-local.ipynb",
         "time-travel.ipynb",
         "code_assistant/langgraph_code_assistant_mistral.ipynb",
     ]

docs/docs/cloud/concepts/api.md

@@ -10,7 +10,11 @@ The LangGraph Cloud API consists of a few core data models: [Assistants](#assist
 
 An assistant is a configured instance of a [`CompiledGraph`][compiledgraph]. It abstracts the cognitive architecture of the graph and contains instance specific configuration and metadata. Multiple assistants can reference the same graph but can contain different configuration and metadata, which may differentiate the behavior of the assistants. An assistant (i.e. the graph) is invoked as part of a run.
 
-The LangGraph Cloud API provides several endpoints for creating and managing assistants. See the <a href="../reference/api/api_ref.html#tag/assistantscreate" target="_blank">API reference</a> for more details.
+The LangGraph Cloud API provides several endpoints for creating and managing assistants. See the [API reference](../reference/api/api_ref.html#tag/assistantscreate) for more details.
+
+#### Configuring Assistants
+
+You can save custom assistants from the same graph to set different default prompts, models, and other configurations without changing a line of code in your graph. This allows you the ability to quickly test out different configurations without having to rewrite your graph every time, and also give users the flexibility to select different configurations when using your LangGraph application. See <a href="https://langchain-ai.github.io/langgraph/cloud/how-tos/cloud_examples/configuration_cloud/">this</a> how-to for information on how to configure a deployed graph. 
 
 ### Threads
 
@@ -20,13 +24,13 @@ The state of a thread at a particular point in time is called a checkpoint.
 
 For more on threads and checkpoints, see this section of the [LangGraph conceptual guide](../../concepts/low_level.md#checkpointer).
 
-The LangGraph Cloud API provides several endpoints for creating and managing threads and thread state. See the <a href="../reference/api/api_ref.html#tag/threadscreate" target="_blank">API reference</a> for more details.
+The LangGraph Cloud API provides several endpoints for creating and managing threads and thread state. See the [API reference](../reference/api/api_ref.html#tag/threadscreate) for more details.
 
 ### Runs
 
 A run is an invocation of an assistant. Each run may have its own input, configuration, and metadata, which may affect execution and output of the underlying graph. A run can optionally be executed on a thread.
 
-The LangGraph Cloud API provides several endpoints for creating and managing runs. See the <a href="../reference/api/api_ref.html#tag/runscreate" target="_blank">API reference</a> for more details.
+The LangGraph Cloud API provides several endpoints for creating and managing runs. See the [API reference](../reference/api/api_ref.html#tag/runscreate) for more details.
 
 ### Cron Jobs
 
@@ -35,9 +39,9 @@ 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 <a href="../reference/api/api_ref.html#tag/runscreate/POST/threads/{thread_id}/runs/crons" target="_blank">API reference</a> for more details.
+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.
 
 ## Features
 
@@ -47,15 +51,107 @@ 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 <a href="../reference/api/api_ref.html#tag/runscreate/POST/threads/{thread_id}/runs/stream" target="_blank">API reference</a> for how to create streaming runs.
+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
 
@@ -86,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

@@ -0,0 +1,146 @@
+# Rebuild Graph at Runtime
+
+You might need to rebuild your graph with a different configuration for a new run. For example, you might need to use a different graph state or graph structure depending on the config. This guide shows how you can do this.
+
+!!! note "Note"
+    In most cases, customizing behavior based on the config should be handled by a single graph where each node can read a config and change its behavior based on it
+
+## Prerequisites
+
+Make sure to check out [this how-to guide](./setup.md) on setting up your app for deployment first.
+
+## Define graphs
+
+Let's say you have an app with a simple graph that calls an LLM and returns the response to the user. The app file directory looks like the following:
+
+```
+my-app/
+|-- requirements.txt
+|-- .env
+|-- openai_agent.py     # code for your graph
+```
+
+where the graph is defined in `openai_agent.py`. 
+
+### No rebuild
+
+In the standard LangGraph API configuration, the server uses the compiled graph instance that's defined at the top level of `openai_agent.py`, which looks like the following:
+
+```python
+from langchain_openai import ChatOpenAI
+from langgraph.graph import END, START, MessageGraph
+
+model = ChatOpenAI(temperature=0)
+
+graph_workflow = MessageGraph()
+
+graph_workflow.add_node("agent", model)
+graph_workflow.add_edge("agent", END)
+graph_workflow.add_edge(START, "agent")
+
+agent = graph_workflow.compile()
+```
+
+To make the server aware of your graph, you need to specify a path to the variable that contains the `CompiledStateGraph` instance in your LangGraph API configuration (`langgraph.json`), e.g.:
+
+```
+{
+    "dependencies": ["."],
+    "graphs": {
+        "openai_agent": "./openai_agent.py:agent",
+    },
+    "env": "./.env"
+}
+```
+
+### Rebuild
+
+To make your graph rebuild on each new run with custom configuration, you need to rewrite `openai_agent.py` to instead provide a _function_ that takes a config and returns a graph (or compiled graph) instance. Let's say we want to return our existing graph for user ID '1', and a tool-calling agent for other users. We can modify `openai_agent.py` as follows:
+
+```python
+from typing import Annotated, TypedDict
+from langchain_openai import ChatOpenAI
+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
+from langchain_core.tools import tool
+from langchain_core.messages import BaseMessage
+from langchain_core.runnables import RunnableConfig
+
+
+class State(TypedDict):
+    messages: Annotated[list[BaseMessage], add_messages]
+
+
+model = ChatOpenAI(temperature=0)
+
+def make_default_graph():
+    """Make a simple LLM agent"""
+    graph_workflow = StateGraph(State)
+    def call_model(state):
+        return {"messages": [model.invoke(state["messages"])]}
+
+    graph_workflow.add_node("agent", call_model)
+    graph_workflow.add_edge("agent", END)
+    graph_workflow.add_edge(START, "agent")
+
+    agent = graph_workflow.compile()
+    return agent
+
+
+def make_alternative_graph():
+    """Make a tool-calling agent"""
+
+    @tool
+    def add(a: float, b: float):
+        """Adds two numbers."""
+        return a + b
+
+    tool_node = ToolNode([add])
+    model_with_tools = model.bind_tools([add])
+    def call_model(state):
+        return {"messages": [model_with_tools.invoke(state["messages"])]}
+
+    def should_continue(state: State):
+        if state["messages"][-1].tool_calls:
+            return "tools"
+        else:
+            return END
+
+    graph_workflow = StateGraph(State)
+
+    graph_workflow.add_node("agent", call_model)
+    graph_workflow.add_node("tools", tool_node)
+    graph_workflow.add_edge("tools", "agent")
+    graph_workflow.add_edge(START, "agent")
+    graph_workflow.add_conditional_edges("agent", should_continue)
+
+    agent = graph_workflow.compile()
+    return agent
+
+
+# this is the graph making function that will decide which graph to
+# build based on the provided config
+def make_graph(config: RunnableConfig):
+    user_id = config.get("configurable", {}).get("user_id")
+    # route to different graph state / structure based on the user ID
+    if user_id == "1":
+        return make_default_graph()
+    else:
+        return make_alternative_graph()
+```
+
+Finally, you need to specify the path to your graph-making function (`make_graph`) in `langgraph.json`:
+
+```
+{
+    "dependencies": ["."],
+    "graphs": {
+        "openai_agent": "./openai_agent.py:make_graph",
+    },
+    "env": "./.env"
+}
+```
+
+See more info on LangGraph API configuration file [here](../reference/cli.md#configuration-file)

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,16 +1,30 @@
 # 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. If you prefer using poetry for dependency management, check out [this how-to guide](./setup_pyproject.md) on using `pyproject.toml` for LangGraph Cloud.
+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.
+
+!!! 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.
 
 The final repo structure will look something like this:
 
 ```bash
 my-app/
-|-- requirements.txt    # package dependencies
-|-- .env                # environment variables
-|-- openai_agent.py     # code for an agent
-|-- anthropic_agent.py  # code for another agent
-|-- langgraph.json      # configuration file for LangGraph
+├── my_agent # all project code lies within here
+│   ├── utils # utilities for your graph
+│   │   ├── __init__.py
+│   │   ├── tools.py # tools for your graph
+│   │   ├── nodes.py # node functions for you graph
+│   │   └── state.py # state definition of your graph
+│   ├── requirements.txt # package dependencies
+│   ├── __init__.py
+│   └── agent.py # code for constructing your graph
+├── .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.
@@ -20,33 +34,42 @@ 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.1.7
-langchain-core>=0.2.7
-orjson>=3.10.1
-langsmith>=0.1.50
-httpx>=0.27.0
-langchain-core>=0.2.8
+langgraph>=0.2.7,<0.3.0
+langgraph-checkpoint>=1.0.4
+langchain-core>=0.2.27,<0.3.0
 langsmith>=0.1.63
-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>=23.1.0
+redis>=5.0.0,<6.0.0
 ```
 
 Example `requirements.txt` file:
+
 ```
 langgraph
+langchain_anthropic
+tavily-python
+langchain_community
 langchain_openai
+
 ```
 
 Example file directory:
-```
+
+```bash
 my-app/
-|-- requirements.txt    # Python packages required for your graph
+├── my_agent # all project code lies within here
+│   └── requirements.txt # package dependencies
 ```
 
 ## Specify Environment Variables
@@ -54,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
@@ -61,42 +85,66 @@ OPENAI_API_KEY=key
 ```
 
 Example file directory:
-```
+
+```bash
 my-app/
-|-- requirements.txt
-|-- .env                # file with environment variables
+├── my_agent # all project code lies within here
+│   └── requirements.txt # package dependencies
+└── .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 [CompiledGraph][compiledgraph] 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).
 
-Example `openai_agent.py` file:
+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
-from langchain_openai import ChatOpenAI
-from langgraph.graph import END, MessageGraph
+# my_agent/agent.py
+from typing import TypedDict, Literal
 
-model = ChatOpenAI(temperature=0)
+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
 
-graph_workflow = MessageGraph()
+# Define the config
+class GraphConfig(TypedDict):
+    model_name: Literal["anthropic", "openai"]
 
-graph_workflow.add_node("agent", model)
-graph_workflow.add_edge("agent", END)
-graph_workflow.set_entry_point("agent")
+workflow = StateGraph(AgentState, config_schema=GraphConfig)
+workflow.add_node("agent", call_model)
+workflow.add_node("action", tool_node)
+workflow.add_edge(START, "agent")
+workflow.add_conditional_edges(
+    "agent",
+    should_continue,
+    {
+        "continue": "action",
+        "end": END,
+    },
+)
+workflow.add_edge("action", "agent")
 
-agent = graph_workflow.compile()
+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.
+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/
-|-- requirements.txt
-|-- .env
-|-- openai_agent.py     # code for your graph
-|-- anthropic_agent.py  # code for your graph
+├── my_agent # all project code lies within here
+│   ├── utils # utilities for your graph
+│   │   ├── __init__.py
+│   │   ├── tools.py # tools for your graph
+│   │   ├── nodes.py # node functions for you graph
+│   │   └── state.py # state definition of your graph
+│   ├── requirements.txt # package dependencies
+│   ├── __init__.py
+│   └── agent.py # code for constructing your graph
+└── .env # environment variables
 ```
 
 ## Create LangGraph API Config
@@ -104,39 +152,39 @@ 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": [
-        "."
-    ],
-    "graphs": {
-        "openai_agent": "./openai_agent.py:agent",
-        "anthropic_agent": "./anthropic_agent.py:agent"
-    },
-    "env": "./.env"
+  "dependencies": ["./my_agent"],
+  "graphs": {
+    "agent": "./my_agent/agent.py: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>`).
 
 !!! 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:
 
 ```bash
 my-app/
-|-- requirements.txt
-|-- .env
-|-- openai_agent.py
-|-- anthropic_agent.py
-|-- langgraph.json      # configuration file for LangGraph
+├── my_agent # all project code lies within here
+│   ├── utils # utilities for your graph
+│   │   ├── __init__.py
+│   │   ├── tools.py # tools for your graph
+│   │   ├── nodes.py # node functions for you graph
+│   │   └── state.py # state definition of your graph
+│   ├── requirements.txt # package dependencies
+│   ├── __init__.py
+│   └── agent.py # code for constructing your graph
+├── .env # environment variables
+└── langgraph.json # configuration file for LangGraph
 ```
 
-## Upload to GitHub
-
-To deploy the LangGraph application to LangGraph Cloud, the code must be uploaded to a GitHub repository.
-
 ## Next
 
-After you setup your repo, it's time to [deploy your app](./cloud.md).
+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_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,16 +1,29 @@
 # 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. If you prefer using `requirements.txt` for dependency management, check out [this how-to guide](./setup.md).
+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-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).
+
+!!! 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.
 
 The final repo structure will look something like this:
 
 ```bash
 my-app/
 ├── my_agent # all project code lies within here
+│   ├── utils # utilities for your graph
+│   │   ├── __init__.py
+│   │   ├── tools.py # tools for your graph
+│   │   ├── nodes.py # node functions for you graph
+│   │   └── state.py # state definition of your graph
 │   ├── __init__.py
-│   └── agent.py # code for your graph
-│-- .env # environment variables
-│-- langgraph.json  # configuration file for LangGraph
+│   └── agent.py # code for constructing your graph
+├── .env # environment variables
+├── langgraph.json  # configuration file for LangGraph
 └── pyproject.toml # dependencies for your project
 ```
 
@@ -21,21 +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.1.7
-langchain-core>=0.2.7
-orjson>=3.10.1
-langsmith>=0.1.50
-httpx>=0.27.0
-langchain-core>=0.2.8
+langgraph>=0.2.7,<0.3.0
+langgraph-checkpoint>=1.0.4
+langchain-core>=0.2.27,<0.3.0
 langsmith>=0.1.63
-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:
@@ -51,7 +66,7 @@ readme = "README.md"
 
 [tool.poetry.dependencies]
 python = ">=3.9.0,<3.13"
-langgraph = "^0.1.7"
+langgraph = "^0.2.0"
 langchain-fireworks = "^0.1.3"
 
 
@@ -64,9 +79,6 @@ Example file directory:
 
 ```bash
 my-app/
-├── my_agent
-│   ├── __init__.py
-│   └── agent.py
 └── pyproject.toml   # Python packages required for your graph
 ```
 
@@ -86,10 +98,7 @@ Example file directory:
 
 ```bash
 my-app/
-├── my_agent
-│   ├── __init__.py
-│   └── agent.py
-|-- .env             # file with environment variables
+├── .env             # file with environment variables
 └── pyproject.toml
 ```
 
@@ -97,26 +106,35 @@ my-app/
 
 Implement your graphs! Graphs can be defined in a single file or multiple files. Make note of the variable names of each [CompiledGraph][compiledgraph] 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).
 
-Example `agent.py` file:
+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-pyproject) to see their implementation):
 
 ```python
 # my_agent/agent.py
-from langchain_fireworks import ChatFireworks
-from langgraph.graph import END, StateGraph, add_messages
-from typing_extensions import TypedDict, Annotated
+from typing import TypedDict, Literal
 
-model = ChatFireworks(model="accounts/fireworks/models/firefunction-v2", temperature=0)
+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
 
-class State(TypedDict):
-    messages: Annotated[list, add_messages]
+# Define the config
+class GraphConfig(TypedDict):
+    model_name: Literal["anthropic", "openai"]
 
-graph_workflow = StateGraph(State)
+workflow = StateGraph(AgentState, config_schema=GraphConfig)
+workflow.add_node("agent", call_model)
+workflow.add_node("action", tool_node)
+workflow.add_edge(START, "agent")
+workflow.add_conditional_edges(
+    "agent",
+    should_continue,
+    {
+        "continue": "action",
+        "end": END,
+    },
+)
+workflow.add_edge("action", "agent")
 
-graph_workflow.add_node("agent", model)
-graph_workflow.add_edge("agent", END)
-graph_workflow.set_entry_point("agent")
-
-agent = graph_workflow.compile()
+graph = workflow.compile()
 ```
 
 !!! warning "Assign `CompiledGraph` to Variable"
@@ -126,10 +144,15 @@ Example file directory:
 
 ```bash
 my-app/
-├── my_agent
+├── my_agent # all project code lies within here
+│   ├── utils # utilities for your graph
+│   │   ├── __init__.py
+│   │   ├── tools.py # tools for your graph
+│   │   ├── nodes.py # node functions for you graph
+│   │   └── state.py # state definition of your graph
 │   ├── __init__.py
-│   └── agent.py # code for your graph
-|-- .env
+│   └── agent.py # code for constructing your graph
+├── .env
 └── pyproject.toml
 ```
 
@@ -143,9 +166,9 @@ Example `langgraph.json` file:
 {
   "dependencies": ["."],
   "graphs": {
-    "my_fantastic_agent": "./my_agent/agent.py:agent"
+    "agent": "./my_agent/agent.py:graph"
   },
-  "env": "./.env"
+  "env": ".env"
 }
 ```
 
@@ -158,18 +181,19 @@ Example file directory:
 
 ```bash
 my-app/
-├── my_agent
+├── my_agent # all project code lies within here
+│   ├── utils # utilities for your graph
+│   │   ├── __init__.py
+│   │   ├── tools.py # tools for your graph
+│   │   ├── nodes.py # node functions for you graph
+│   │   └── state.py # state definition of your graph
 │   ├── __init__.py
-│   └── agent.py # code for your graph
-│-- .env
-│-- langgraph.json      # configuration file for LangGraph
-└── pyproject.toml
+│   └── agent.py # code for constructing your graph
+├── .env # environment variables
+├── langgraph.json  # configuration file for LangGraph
+└── pyproject.toml # dependencies for your project
 ```
 
-## Upload to GitHub
-
-To deploy the LangGraph application to LangGraph Cloud, the code must be uploaded to a GitHub repository.
-
 ## Next
 
-After you setup your repo, it's time to [deploy your app](./cloud.md).
+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/test_locally.md

@@ -38,6 +38,48 @@ Ready!
 
 We can now interact with the API server using the LangGraph SDK. First, we need to start our client, select our assistant (in this case a graph we called "agent", make sure to select the proper assistant you wish to test).
 
+You can either initialize by passing authentication or by setting an environment variable.
+
+#### Initialize with authentication
+
+=== "Python"
+
+    ```python
+    from langgraph_sdk import get_client
+
+    # 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()
+    ```
+
+=== "Javascript"
+
+    ```js
+    import { Client } from "@langchain/langgraph-sdk";
+
+    // 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> });
+    // 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'
+      --header 'x-api-key: <LANGCHAIN_API_KEY>'
+    ```
+  
+
+#### Initialize with environment variables
+
+If you have a `LANGCHAIN_API_KEY` set in your environment, you do not need to explicitly pass authentication to the client
+
 === "Python"
 
     ```python
@@ -45,6 +87,7 @@ We can now interact with the API server using the LangGraph SDK. First, we need
 
     # 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()
     ```
@@ -56,10 +99,19 @@ We can now interact with the API server using the LangGraph SDK. First, we need
 
     // 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();
     ```
 
+=== "CURL"
+
+    ```bash
+    curl --request POST \
+      --url <DEPLOYMENT_URL>/threads \
+      --header 'Content-Type: application/json'
+    ```
+
 Now we can invoke our graph to ensure it is working. Make sure to change the input to match the proper schema for your graph. 
 
 === "Python"
@@ -96,4 +148,39 @@ Now we can invoke our graph to ensure it is working. Make sure to change the inp
     }
     ```
 
+  === "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\"}]},
+       \"stream_mode\": [
+         \"events\"
+       ]
+     }" | \
+     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"
+         }
+     }
+     ' 
+    ```
+
 If your graph works correctly, you should see your graph output displayed in the console. Of course, there are many more ways you might need to test your graph, for a full list of commands you can send with the SDK, see the [Python](https://langchain-ai.github.io/langgraph/cloud/reference/sdk/python_sdk_ref/) and [JS/TS](https://langchain-ai.github.io/langgraph/cloud/reference/sdk/js_ts_sdk_ref/) references.

docs/docs/cloud/faq/studio.md

@@ -0,0 +1,73 @@
+# Studio FAQs
+
+## Why is my project failing to start?
+
+There are a few reasons that your project might fail to start, here are some of the most common ones.
+
+### Docker issues
+
+LangGraph Studio requires Docker Desktop version 4.24 or higher. Please make sure you have a version of Docker installed that satisfies that requirement and also make sure you have the Docker Desktop app up and running before trying to use LangGraph Studio. In addition, make sure you have docker-compose updated to version 2.22.0 or higher.
+
+### Configuration or environment issues
+
+Another reason your project might fail to start is because your configuration file is defined incorrectly, or you are missing required environment variables. 
+
+## How does interrupt work?
+
+When you select the `Interrupts` dropdown and select a node to interrupt the graph will pause execution before and after (unless the node goes straight to `END`) that node has run. This means that you will be able to both edit the state before the node is ran and the state after the node has ran. This is intended to allow developers more fine-grained control over the behavior of a node and make it easier to observe how the node is behaving. You will not be able to edit the state after the node has ran if the node is the final node in the graph.
+
+## How do I reload the app?
+
+If you would like to reload the app, don't use Command+R as you might normally do. Instead, close and reopen the app for a full refresh.
+
+## How does automatic rebuilding work?
+
+One of the key features of LangGraph Studio is that it automatically rebuilds your image when you change the source code. This allows for a super fast development and testing cycle which makes it easy to iterate on your graph. There are two different ways that LangGraph rebuilds your image: either by editing the image or completely rebuilding it.
+
+### Rebuilds from source code changes
+
+If you modified the source code only (no configuration or dependency changes!) then the image does not require a full rebuild, and LangGraph Studio will only update the relevant parts. The UI status in the bottom left will switch from `Online` to `Stopping` temporarily while the image gets edited. The logs will be shown as this process is happening, and after the image has been edited the status will change back to `Online` and you will be able to run your graph with the modified code!
+
+
+### Rebuilds from configuration or dependency changes
+
+If you edit your graph configuration file (`langgraph.json`) or the dependencies (either `pyproject.toml` or `requirements.txt`) then the entire image will be rebuilt. This will cause the UI to switch away from the graph view and start showing the logs of the new image building process. This can take a minute or two, and once it is done your updated image will be ready to use!
+
+## Why is my graph taking so long to startup?
+
+The LangGraph Studio interacts with a local LangGraph API server. To stay aligned with ongoing updates, the LangGraph API requires regular rebuilding. As a result, you may occasionally experience slight delays when starting up your project.
+
+## Why are extra edges showing up in my graph?
+
+If you don't define your conditional edges carefully, you might notice extra edges appearing in your graph. This is because without proper definition, LangGraph Studio assumes the conditional edge could access all other nodes. In order for this to not be the case, you need to be explicit about how you define the nodes the conditional edge routes to. There are two ways you can do this:
+
+### 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 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"
+
+    ```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 (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:
+
+```python
+def routing_function(state: GraphState) -> Literal["node_b","node_c"]:
+    if state['some_condition'] == True:
+        return "node_a"
+    else:
+        return "node_b"
+```
+

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

@@ -0,0 +1,202 @@
+# Check the Status of your Threads
+
+## Setup
+
+To start, we can setup our client with whatever URL you are hosting your graph from:
+
+### SDK initialization
+
+First, we need to setup our client so that we can communicate with our hosted graph:
+
+=== "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"
+    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";
+    const thread = await client.threads.create();
+    ```
+
+=== "CURL"
+
+    ```bash
+    curl --request POST \
+      --url <DEPLOYMENT_URL>/threads \
+      --header 'Content-Type: application/json'
+    ```
+
+## Find idle threads
+
+We can use the following commands to find threads that are idle, which means that all runs executed on the thread have finished running:
+
+=== "Python"
+
+    ```python
+    print(await client.threads.search(status="idle",limit=1))
+    ```
+
+=== "Javascript"
+
+    ```js
+    console.log(await client.threads.search({ status: "idle", limit: 1 }));
+    ```
+
+=== "CURL"
+
+    ```bash
+    curl --request POST \  
+    --url <DEPLOYMENT_URL>/threads/search \
+    --header 'Content-Type: application/json' \
+    --data '{"status": "idle", "limit": 1}'
+    ```
+
+Output:
+
+    [{'thread_id': 'cacf79bb-4248-4d01-aabc-938dbd60ed2c',
+    'created_at': '2024-08-14T17:36:38.921660+00:00',
+    'updated_at': '2024-08-14T17:36:38.921660+00:00',
+    'metadata': {'graph_id': 'agent'},
+    'status': 'idle',
+    'config': {'configurable': {}}}]
+
+
+## Find interrupted threads
+
+We can use the following commands to find threads that have been interrupted in the middle of a run, which could either mean an error occurred before the run finished or a human-in-the-loop breakpoint was reached and the run is waiting to continue: 
+
+=== "Python"
+
+    ```python
+    print(await client.threads.search(status="interrupted",limit=1))
+    ```
+
+=== "Javascript"
+
+    ```js
+    console.log(await client.threads.search({ status: "interrupted", limit: 1 }));
+    ```
+
+=== "CURL"
+
+    ```bash
+    curl --request POST \  
+    --url <DEPLOYMENT_URL>/threads/search \
+    --header 'Content-Type: application/json' \
+    --data '{"status": "interrupted", "limit": 1}'
+    ```
+
+Output:
+
+    [{'thread_id': '0d282b22-bbd5-4d95-9c61-04dcc2e302a5',
+    'created_at': '2024-08-14T17:41:50.235455+00:00',
+    'updated_at': '2024-08-14T17:41:50.235455+00:00',
+    'metadata': {'graph_id': 'agent'},
+    'status': 'interrupted',
+    'config': {'configurable': {}}}]
+    
+## Find busy threads
+
+We can use the following commands to find threads that are busy, meaning they are currently handling the execution of a run:
+
+=== "Python"
+
+    ```python
+    print(await client.threads.search(status="busy",limit=1))
+    ```
+
+=== "Javascript"
+
+    ```js
+    console.log(await client.threads.search({ status: "busy", limit: 1 }));
+    ```
+
+=== "CURL"
+
+    ```bash
+    curl --request POST \  
+    --url <DEPLOYMENT_URL>/threads/search \
+    --header 'Content-Type: application/json' \
+    --data '{"status": "busy", "limit": 1}'
+    ```
+
+Output:
+
+    [{'thread_id': '0d282b22-bbd5-4d95-9c61-04dcc2e302a5',
+    'created_at': '2024-08-14T17:41:50.235455+00:00',
+    'updated_at': '2024-08-14T17:41:50.235455+00:00',
+    'metadata': {'graph_id': 'agent'},
+    'status': 'busy',
+    'config': {'configurable': {}}}]
+
+## Find specific threads
+
+You may also want to check the status of specific threads, which you can do in a few ways:
+
+### Find by ID
+
+You can use the `get` function to find the status of a specific thread, as long as you have the ID saved
+
+=== "Python"
+
+    ```python
+    print((await client.threads.get(<THREAD_ID>))['status'])
+    ```
+
+=== "Javascript"
+
+    ```js
+    console.log((await client.threads.get(<THREAD_ID>)).status);
+    ```
+
+=== "CURL"
+
+    ```bash
+    curl --request GET \ 
+    --url <DEPLOYMENT_URL>/threads/<THREAD_ID> \
+    --header 'Content-Type: application/json' | jq -r '.status'
+    ```
+
+Output:
+
+    'idle'
+
+### Find by metadata
+
+The search endpoint for threads also allows you to filter on metadata, which can be helpful if you use metadata to tag threads in order to keep them organized:
+
+=== "Python"
+
+    ```python
+    print((await client.threads.search(metadata={"foo":"bar"},limit=1))[0]['status'])
+    ```
+
+=== "Javascript"
+
+    ```js
+    console.log((await client.threads.search({ metadata: { "foo": "bar" }, limit: 1 }))[0].status);
+    ```
+
+=== "CURL"
+
+    ```bash
+    curl --request POST \  
+    --url <DEPLOYMENT_URL>/threads/search \
+    --header 'Content-Type: application/json' \
+    --data '{"metadata": {"foo":"bar"}, "limit": 1}' | jq -r '.[0].status'
+    ```
+
+Output:
+
+    'idle'

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

@@ -0,0 +1,132 @@
+# Copying Threads
+
+You may wish to copy (i.e. "fork") an existing thread in order to keep the existing thread's history and create independent runs that do not affect the original thread. This guide shows how you can do that.
+
+## Setup
+
+This code assumes you already have a thread to copy. You can read about what a thread is [here](https://langchain-ai.github.io/langgraph/cloud/concepts/api/#threads) and learn how to stream a run on a thread in [these how-to guides](https://langchain-ai.github.io/langgraph/cloud/how-tos/#streaming).
+
+### SDK initialization
+
+First, we need to setup our client so that we can communicate with our hosted graph:
+
+=== "Python"
+
+    ```python
+    from langgraph_sdk import get_client
+    client = get_client(url="<DEPLOYMENT_URL>")
+    assistant_id = "agent"
+    thread = await client.threads.create()
+    ```
+
+=== "Javascript"
+
+    ```js
+    import { Client } from "@langchain/langgraph-sdk";
+
+    const client = new Client({ apiUrl: "<DEPLOYMENT_URL>" });
+    const assistantId = "agent";
+    const thread = await client.threads.create();
+    ```
+
+=== "CURL"
+
+    ```bash
+    curl --request POST \
+      --url <DEPLOYMENT_URL>/threads \
+      --header 'Content-Type: application/json' \
+      --data '{
+        "metadata": {}
+      }'
+    ```
+
+## Copying a thread
+
+The code below assumes that a thread you'd like to copy already exists.
+
+Copying a thread will create a new thread with the same history as the existing thread, and then allow you to continue executing runs.
+
+### Create copy
+
+=== "Python"
+
+    ```python
+    copied_thread = await client.threads.copy(<THREAD_ID>)
+    ```
+
+=== "Javascript"
+
+    ```js
+    let copiedThread = await client.threads.copy(<THREAD_ID>);
+    ```
+
+=== "CURL"
+
+    ```bash
+    curl --request POST --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/copy \
+    --header 'Content-Type: application/json'
+    ```
+
+### Verify copy
+
+We can verify that the history from the prior thread did indeed copy over correctly:
+
+=== "Python"
+
+    ```python
+    def remove_thread_id(d):
+      if 'metadata' in d and 'thread_id' in d['metadata']:
+          del d['metadata']['thread_id']
+      return d
+
+    original_thread_history = list(map(remove_thread_id,await client.threads.get_history(<THREAD_ID>)))
+    copied_thread_history = list(map(remove_thread_id,await client.threads.get_history(copied_thread['thread_id'])))
+
+    # Compare the two histories
+    assert original_thread_history == copied_thread_history
+    # if we made it here the assertion passed!
+    print("The histories are the same.")
+    ```
+
+=== "Javascript"
+
+    ```js
+    function removeThreadId(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);
+
+      // 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
+    compareThreadHistories(<THREAD_ID>, copiedThread.thread_id);
+    ```
+
+=== "CURL"
+
+    ```bash
+    if diff <(
+        curl --request GET --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/history | jq -S 'map(del(.metadata.thread_id))'
+    ) <(
+        curl --request GET --url <DEPLOYMENT_URL>/threads/<COPIED_THREAD_ID>/history | jq -S 'map(del(.metadata.thread_id))'
+    ) >/dev/null; then
+        echo "The histories are the same."
+    else
+        echo "The histories are different."
+    fi
+    ```
+
+Output:
+
+    The histories are the same.

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.
 
@@ -31,7 +55,8 @@ Then, let's import our required packages and instantiate our client, assistant,
     from langchain_core.messages import convert_to_messages
     from langgraph_sdk import get_client
 
-    client = get_client(url="whatever-your-deployment-url-is")
+    client = get_client(url=<DEPLOYMENT_URL>)
+    # Using the graph deployed with the name "agent"
     assistant_id = "agent"
     thread = await client.threads.create()
     ```
@@ -42,10 +67,19 @@ Then, let's import our required packages and instantiate our client, assistant,
     import { Client } from "@langchain/langgraph-sdk";
     
 
-    const client = new Client({ apiUrl:"whatever-your-deployment-url-is" });
+    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

@@ -21,7 +21,8 @@ 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="whatever-your-deployment-url-is")
+    client = get_client(url=<DEPLOYMENT_URL>)
+    # Using the graph deployed with the name "agent"
     assistant_id = "agent"
     thread = await client.threads.create()
     ```
@@ -31,11 +32,20 @@ In this how-to we use a simple ReAct style hosted graph (you can see the full co
     ```js
     import { Client } from "@langchain/langgraph-sdk";
 
-    const client = new Client({ apiUrl:"whatever-your-deployment-url-is" });
-    const assistantId = "agent"
+    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'
+    ```
+
 ## Adding a breakpoint
 
 We now want to add a breakpoint in our graph run, which we will do before a tool is called.
@@ -65,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"],
@@ -73,15 +83,52 @@ 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);
       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\": \"agent\",
+       \"input\": {\"messages\": [{\"role\": \"human\", \"content\": \"what's the weather in sf\"}]},
+       \"interrupt_before\": [\"action\"],
+       \"stream_mode\": [
+         \"messages\"
+       ]
+     }" | \
+     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"
+         }
+     }
+     '
+    ```
 
 Output:
 

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

@@ -17,7 +17,8 @@ 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="whatever-your-deployment-url-is")
+    client = get_client(url=<DEPLOYMENT_URL>)
+    # Using the graph deployed with the name "agent"
     assistant_id = "agent"
     thread = await client.threads.create()
     ```
@@ -27,11 +28,20 @@ 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:"whatever-your-deployment-url-is" });
+    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'
+    ```
+
 ## Editing state
 
 ### Initial invocation
@@ -57,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"],
@@ -68,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);
@@ -75,6 +86,42 @@ Now let's invoke our graph, making sure to interrupt before the `action` node.
     }
     ```
 
+=== "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\": \"search for weather in SF\"}]},
+       \"interrupt_before\": [\"action\"],
+       \"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:
 
     {'agent': {'messages': [{'content': [{'text': "Certainly! I'll search for the current weather in San Francisco for you using the search function. Here's how I'll do that:", 'type': 'text'}, {'id': 'toolu_01KEJMBFozSiZoS4mAcPZeqQ', 'input': {'query': 'current weather in San Francisco'}, 'name': 'search', 'type': 'tool_use'}], 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-6dbb0167-f8f6-4e2a-ab68-229b2d1fbb64', 'example': False, 'tool_calls': [{'name': 'search', 'args': {'query': 'current weather in San Francisco'}, 'id': 'toolu_01KEJMBFozSiZoS4mAcPZeqQ'}], 'invalid_tool_calls': [], 'usage_metadata': None}]}}
@@ -110,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
@@ -126,13 +173,25 @@ 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"
+
+    ```bash
+    curl --request GET --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/state | \                                                                                      
+    jq '.values.messages[-1] | (.tool_calls[0].args = {"query": "current weather in Sidi Frej"})' | \
+    curl --request POST \
+      --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/state \
+      --header 'Content-Type: application/json' \
+      --data @-
     ```
 
 Output:
 
-    {'configurable': {'thread_id': '88d58d3f-4151-47a9-a8e0-e42fdd3527b8',
-      'thread_ts': '1ef3274b-a809-6913-8002-91536ce6554d'}}
+    {'configurable': {'thread_id': '9c8f1a43-9dd8-4017-9271-2c53e57cf66a',
+      'checkpoint_ns': '',
+      'checkpoint_id': '1ef58e7e-3641-649f-8002-8b4305a64858'}}
 
 
 
@@ -164,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);
@@ -171,6 +231,40 @@ Now we can resume our graph run but with the updated state:
     }
     ```
 
+=== "CURL"
+
+    ```bash
+    curl --request POST \                                                                             
+     --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
+     --header 'Content-Type: application/json' \
+     --data "{
+       \"assistant_id\": \"agent\",
+       \"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:
 
     {'action': {'messages': [{'content': '["I looked up: current weather in Sidi Frej. Result: It\'s sunny in San Francisco, but you better look out if you\'re a Gemini 😈."]', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': 'search', 'id': '1161b8d1-bee4-4188-9be8-698aecb69f10', 'tool_call_id': 'toolu_01KEJMBFozSiZoS4mAcPZeqQ'}]}}

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

@@ -0,0 +1,889 @@
+# Review Tool Calls
+
+Human-in-the-loop (HIL) interactions are crucial for [agentic systems](https://langchain-ai.github.io/langgraph/concepts/agentic_concepts/#human-in-the-loop). A common pattern is to add some human in the loop step after certain tool calls. These tool calls often lead to either a function call or saving of some information. Examples include:
+
+- A tool call to execute SQL, which will then be run by the tool
+- A tool call to generate a summary, which will then be saved to the State of the graph
+
+Note that using tool calls is common **whether actually calling tools or not**.
+
+There are typically a few different interactions you may want to do here:
+
+1. Approve the tool call and continue
+2. Modify the tool call manually and then continue
+3. Give natural language feedback, and then pass that back to the agent instead of continuing
+
+We can implement this in LangGraph using a [breakpoint](https://langchain-ai.github.io/langgraph/how-tos/human_in_the_loop/breakpoints/): breakpoints allow us to interrupt graph execution before a specific step. At this breakpoint, we can manually update the graph state taking one of the three options above
+
+## Setup
+
+We are not going to show the full code for the graph we are hosting, but you can see it [here](../../how-tos/human_in_the_loop/review-tool-calls.ipynb#simple-usage) if you want to. Once this graph is hosted, we are ready to invoke it and wait for user input. 
+
+### SDK initialization
+
+First, we need to setup our client so that we can communicate with our hosted graph:
+
+
+=== "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"
+    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";
+    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)
+
+=== "Python"
+
+    ```python
+    input = { 'messages':[{ "role":"user", "content":"hi!" }] }
+
+    async for chunk in client.runs.stream(
+        thread["thread_id"],
+        assistant_id,
+        input=input,
+        stream_mode="updates",
+        interrupt_before=["action"],
+    ):
+        if chunk.data and chunk.event != "metadata": 
+            print(chunk.data)
+    ```
+
+=== "Javascript"
+
+    ```js
+    const input = { "messages": [{ "role": "human", "content": "hi!" }] };
+
+    const streamResponse = client.runs.stream(
+      thread["thread_id"],
+      assistantId,
+      {
+        input: input,
+        streamMode: "updates",
+        interruptBefore: ["action"],
+      }
+    );
+
+    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\": \"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}]}
+    {'messages': [{'content': 'hi!', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '39c51f14-2d5c-4690-883a-d940854b1845', 'example': False}, {'content': [{'text': "Hello! Welcome. How can I assist you today? Is there anything specific you'd like to know or any information you're looking for?", 'type': 'text', 'index': 0}], 'additional_kwargs': {}, 'response_metadata': {'stop_reason': 'end_turn', 'stop_sequence': None}, 'type': 'ai', 'name': None, 'id': 'run-d65e07fb-43ff-4d98-ab6b-6316191b9c8b', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': {'input_tokens': 355, 'output_tokens': 31, 'total_tokens': 386}}]}
+
+
+If we check the state, we can see that it is finished
+
+=== "Python"
+
+    ```python
+    state = await client.threads.get_state(thread["thread_id"])
+
+    print(state['next'])
+    ```
+
+=== "Javascript"
+
+    ```js
+    const state = await client.threads.getState(thread["thread_id"]);
+
+    console.log(state.next);
+    ```
+
+=== "CURL"
+
+    ```bash
+    curl --request GET \
+        --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/state | jq -c '.next'
+    ```
+
+Output:
+
+    []
+
+## Example of approving tool
+
+Let's now look at what it looks like to approve a tool call. Note that we don't need to pass an interrupt to our streaming calls because the graph (defined [here](../../how-tos/human_in_the_loop/review-tool-calls.ipynb#simple-usage)) was already compiled with an interrupt before the `human_review_node`.
+
+=== "Python"
+
+    ```python
+    input = {"messages": [{"role": "user", "content": "what's the weather in sf?"}]}
+
+    async for chunk in client.runs.stream(
+        thread["thread_id"],
+        "agent",
+        input=input,
+    ):
+        if chunk.data and chunk.event != "metadata": 
+            print(chunk.data)
+    ```
+
+=== "Javascript"
+
+    ```js
+    const input = { "messages": [{ "role": "user", "content": "what's the weather in sf?" }] };
+
+    const streamResponse = client.runs.stream(
+      thread["thread_id"],
+      assistantId,
+      {
+        input: 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\": \"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}]}
+    {'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}}]}
+
+
+If we now check, we can see that it is waiting on human review:
+
+=== "Python"
+
+    ```python
+    state = await client.threads.get_state(thread["thread_id"])
+
+    print(state['next'])
+    ```
+
+=== "Javascript"
+
+    ```js
+    const state = await client.threads.getState(thread["thread_id"]);
+
+    console.log(state.next);
+    ```
+
+=== "CURL"
+
+    ```bash
+    curl --request GET \
+        --url <DELPOYMENT_URL>/threads/<THREAD_ID>/state | jq -c '.next'
+    ```
+
+Output:
+
+    ['human_review_node']
+
+To approve the tool call, we can just continue the thread with no edits. To do this, we just create a new run with no inputs.
+
+=== "Python"
+
+    ```python
+    async for chunk in client.runs.stream(
+        thread["thread_id"],
+        "agent",
+        input=None,
+        stream_mode="values",
+    ):
+        if chunk.data and chunk.event != "metadata": 
+            print(chunk.data)
+    ```
+
+=== "Javascript"
+
+    ```js
+    const streamResponse = client.runs.stream(
+      thread["thread_id"],
+      assistantId,
+      {
+        input: null,
+        streamMode: "values",
+      }
+    );
+
+    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\": \"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'}]}
+    {'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'}, {'content': [{'text': "\n\nGreat news! The weather in San Francisco is sunny today. It's a beautiful day in the city by the bay. Is there anything else you'd like to know about the weather or any other information I can help you with?", 'type': 'text', 'index': 0}], 'additional_kwargs': {}, 'response_metadata': {'stop_reason': 'end_turn', 'stop_sequence': None}, 'type': 'ai', 'name': None, 'id': 'run-5d5fd0f1-a939-447e-801a-9aaa812322d3', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': {'input_tokens': 464, 'output_tokens': 50, 'total_tokens': 514}}]}
+
+## Edit Tool Call
+
+Let's now say we want to edit the tool call. E.g. change some of the parameters (or even the tool called!) but then execute that tool.
+
+=== "Python"
+
+    ```python
+    input = {"messages": [{"role": "user", "content": "what's the weather in sf?"}]}
+
+    async for chunk in client.runs.stream(
+        thread["thread_id"],
+        "agent",
+        input=input,
+        stream_mode="values",
+    ):
+        if chunk.data and chunk.event != "metadata": 
+            print(chunk.data)
+    ```
+
+=== "Javascript"
+
+    ```js
+    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);
+      }
+    }
+    ```
+
+=== "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}]}
+    {'messages': [{'content': "what's the weather in sf?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': 'cec11391-84da-464b-bd2a-bd4f0d93b9ee', '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_01SunSpDurNfcnXppWLPrtjC', '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-6326da9f-6061-4e12-8586-482e32ab4cab', 'example': False, 'tool_calls': [{'name': 'weather_search', 'args': {'city': 'San Francisco'}, 'id': 'toolu_01SunSpDurNfcnXppWLPrtjC', 'type': 'tool_call'}], 'invalid_tool_calls': [], 'usage_metadata': {'input_tokens': 360, 'output_tokens': 80, 'total_tokens': 440}}]}
+
+
+To do this, we first need to update the state. We can do this by passing a message in with the **same** id of the message we want to overwrite. This will have the effect of **replacing** that old message. Note that this is only possible because of the **reducer** we are using that replaces messages with the same ID - read more about that [here](https://langchain-ai.github.io/langgraph/concepts/low_level/#working-with-messages-in-graph-state).
+
+
+=== "Python"
+
+    ```python
+    # To get the ID of the message we want to replace, we need to fetch the current state and find it there.
+    state = await client.threads.get_state(thread['thread_id'])
+    print("Current State:")
+    print(state['values'])
+    print("\nCurrent Tool Call ID:")
+    current_content = state['values']['messages'][-1]['content']
+    current_id = state['values']['messages'][-1]['id']
+    tool_call_id = state['values']['messages'][-1]['tool_calls'][0]['id']
+    print(tool_call_id)
+
+    # We now need to construct a replacement tool call.
+    # We will change the argument to be `San Francisco, USA`
+    # Note that we could change any number of arguments or tool names - it just has to be a valid one
+    new_message = {
+        "role": "assistant", 
+        "content": current_content,
+        "tool_calls": [
+            {
+                "id": tool_call_id,
+                "name": "weather_search",
+                "args": {"city": "San Francisco, USA"}
+            }
+        ],
+        # This is important - this needs to be the same as the message you replacing!
+        # Otherwise, it will show up as a separate message
+        "id": current_id
+    }
+    await client.threads.update_state(
+        # This is the config which represents this thread
+        thread['thread_id'], 
+        # This is the updated value we want to push
+        {"messages": [new_message]}, 
+        # We push this update acting as our human_review_node
+        as_node="human_review_node"
+    )
+
+    print("\nResuming Execution")
+    # Let's now continue executing from here
+    async for chunk in client.runs.stream(
+        thread["thread_id"],
+        "agent",
+        input=None,
+    ):
+        if chunk.data and chunk.event != "metadata": 
+            print(chunk.data)
+    ```
+
+=== "Javascript"
+
+    ```js
+    const state = await client.threads.getState(thread.thread_id);
+    console.log("Current State:");
+    console.log(state.values);
+
+    console.log("\nCurrent Tool Call ID:");
+    const lastMessage = state.values.messages[state.values.messages.length - 1];
+    const currentContent = lastMessage.content;
+    const currentId = lastMessage.id;
+    const toolCallId = lastMessage.tool_calls[0].id;
+    console.log(toolCallId);
+
+    // 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
+    };
+
+    await client.threads.updateState(
+      thread.thread_id,  // Thread ID
+      {
+        values: { "messages": [newMessage] },  // Updated message
+        asNode: "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: null,
+      }
+    );
+
+    for await (const chunk of streamResponseResumed) {
+      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:
+
+    Current State:
+    {'messages': [{'content': "what's the weather in sf?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '8713d1fa-9b26-4eab-b768-dafdaac70590', '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_01VzagzsUGZsNMwW1wHkcw7h', '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-ede13f26-daf5-4d8f-817a-7611075bbcf1', 'example': False, 'tool_calls': [{'name': 'weather_search', 'args': {'city': 'San Francisco'}, 'id': 'toolu_01VzagzsUGZsNMwW1wHkcw7h', 'type': 'tool_call'}], 'invalid_tool_calls': [], 'usage_metadata': {'input_tokens': 360, 'output_tokens': 80, 'total_tokens': 440}}]}
+
+    Current Tool Call ID:
+    toolu_01VzagzsUGZsNMwW1wHkcw7h
+
+    Resuming Execution
+    {'messages': [{'content': "what's the weather in sf?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '8713d1fa-9b26-4eab-b768-dafdaac70590', '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_01VzagzsUGZsNMwW1wHkcw7h', 'input': {}, 'name': 'weather_search', 'type': 'tool_use', 'index': 1, 'partial_json': '{"city": "San Francisco"}'}], 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-ede13f26-daf5-4d8f-817a-7611075bbcf1', 'example': False, 'tool_calls': [{'name': 'weather_search', 'args': {'city': 'San Francisco, USA'}, 'id': 'toolu_01VzagzsUGZsNMwW1wHkcw7h', 'type': 'tool_call'}], 'invalid_tool_calls': [], 'usage_metadata': None}, {'content': 'Sunny!', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': 'weather_search', 'id': '7fc7d463-66bf-4555-9929-6af483de169b', 'tool_call_id': 'toolu_01VzagzsUGZsNMwW1wHkcw7h', 'artifact': None, 'status': 'success'}]}
+    {'messages': [{'content': "what's the weather in sf?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '8713d1fa-9b26-4eab-b768-dafdaac70590', '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_01VzagzsUGZsNMwW1wHkcw7h', 'input': {}, 'name': 'weather_search', 'type': 'tool_use', 'index': 1, 'partial_json': '{"city": "San Francisco"}'}], 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-ede13f26-daf5-4d8f-817a-7611075bbcf1', 'example': False, 'tool_calls': [{'name': 'weather_search', 'args': {'city': 'San Francisco, USA'}, 'id': 'toolu_01VzagzsUGZsNMwW1wHkcw7h', 'type': 'tool_call'}], 'invalid_tool_calls': [], 'usage_metadata': None}, {'content': 'Sunny!', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': 'weather_search', 'id': '7fc7d463-66bf-4555-9929-6af483de169b', 'tool_call_id': 'toolu_01VzagzsUGZsNMwW1wHkcw7h', 'artifact': None, 'status': 'success'}, {'content': [{'text': "\n\nBased on the search result, the weather in San Francisco is sunny! It's a beautiful day in the city by the bay. Is there anything else you'd like to know about the weather or any other information I can help you with?", 'type': 'text', 'index': 0}], 'additional_kwargs': {}, 'response_metadata': {'stop_reason': 'end_turn', 'stop_sequence': None}, 'type': 'ai', 'name': None, 'id': 'run-d90ce97a-39f9-4330-985e-67c5f351a0c5', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': {'input_tokens': 455, 'output_tokens': 52, 'total_tokens': 507}}]}
+
+## Give feedback to a tool call
+
+Sometimes, you may not want to execute a tool call, but you also may not want to ask the user to manually modify the tool call. In that case it may be better to get natural language feedback from the user. You can then insert these feedback as a mock **RESULT** of the tool call.
+
+There are multiple ways to do this:
+
+You could add a new message to the state (representing the "result" of a tool call)
+You could add TWO new messages to the state - one representing an "error" from the tool call, other HumanMessage representing the feedback
+Both are similar in that they involve adding messages to the state. The main difference lies in the logic AFTER the `human_node` and how it handles different types of messages.
+
+For this example we will just add a single tool call representing the feedback. Let's see this in action!
+
+=== "Python"
+
+    ```python
+    input = {"messages": [{"role": "user", "content": "what's the weather in sf?"}]}
+
+    async for chunk in client.runs.stream(
+        thread["thread_id"],
+        "agent",
+        input=input,
+    ):
+        if chunk.data and chunk.event != "metadata": 
+            print(chunk.data)
+    ```
+
+=== "Javascript"
+
+    ```js
+    const input = { "messages": [{ "role": "user", "content": "what's the weather in sf?" }] };
+
+    const streamResponse = client.runs.stream(
+      thread["thread_id"],
+      assistantId,
+      {
+        input: 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\": \"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}]}
+    {'messages': [{'content': "what's the weather in sf?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': 'c80f13d0-674d-4233-b6a0-3940509d3cf3', '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_016XyTdFA8NuPWeLyZPSzoM3', '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-4911ac27-3d7c-4edf-a3ca-c2908e3922eb', 'example': False, 'tool_calls': [{'name': 'weather_search', 'args': {'city': 'San Francisco'}, 'id': 'toolu_016XyTdFA8NuPWeLyZPSzoM3', 'type': 'tool_call'}], 'invalid_tool_calls': [], 'usage_metadata': {'input_tokens': 360, 'output_tokens': 80, 'total_tokens': 440}}]}
+
+To do this, we first need to update the state. We can do this by passing a message in with the same **tool call id** of the tool call we want to respond to. Note that this is a **different*** ID from above
+
+=== "Python"
+
+    ```python
+    # To get the ID of the message we want to replace, we need to fetch the current state and find it there.
+    state = await client.threads.get_state(thread['thread_id'])
+    print("Current State:")
+    print(state['values'])
+    print("\nCurrent Tool Call ID:")
+    tool_call_id = state['values']['messages'][-1]['tool_calls'][0]['id']
+    print(tool_call_id)
+
+    # We now need to construct a replacement tool call.
+    # We will change the argument to be `San Francisco, USA`
+    # Note that we could change any number of arguments or tool names - it just has to be a valid one
+    new_message = {
+        "role": "tool", 
+        # This is our natural language feedback
+        "content": "User requested changes: pass in the country as well",
+        "name": "weather_search",
+        "tool_call_id": tool_call_id
+    }
+    await client.threads.update_state(
+        # This is the config which represents this thread
+        thread['thread_id'], 
+        # This is the updated value we want to push
+        {"messages": [new_message]}, 
+        # We push this update acting as our human_review_node
+        as_node="human_review_node"
+    )
+
+    print("\nResuming execution")
+    # Let's now continue executing from here
+    async for chunk in client.runs.stream(
+        thread["thread_id"],
+        "agent",
+        input=None,
+        stream_mode="values",
+    ):
+        if chunk.data and chunk.event != "metadata": 
+            print(chunk.data)
+    ```
+
+=== "Javascript"
+
+    ```js
+    const state = await client.threads.getState(thread.thread_id);
+    console.log("Current State:");
+    console.log(state.values);
+
+    console.log("\nCurrent Tool Call ID:");
+    const lastMessage = state.values.messages[state.values.messages.length - 1];
+    const toolCallId = lastMessage.tool_calls[0].id;
+    console.log(toolCallId);
+
+    // 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,
+    };
+
+    await client.threads.updateState(
+      thread.thread_id,  // Thread ID
+      {
+        values: { "messages": [newMessage] },  // Updated message
+        asNode: "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: null,
+        streamMode: "values",
+        interruptBefore: ["action"],
+      }
+    );
+
+    for await (const chunk of streamResponseEdited) {
+      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:
+    {'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}}]}
+
+    Current Tool Call ID:
+    toolu_01NNw18j57GEGPZvsa9f1wvX
+
+    Resuming execution
+    {'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}}]}
+
+We can see that we now get to another breakpoint - because it went back to the model and got an entirely new prediction of what to call. Let's now approve this one and continue
+
+=== "Python"
+
+    ```python
+    async for chunk in client.runs.stream(
+        thread["thread_id"],
+        "agent",
+        input=None,
+    ):
+        if chunk.data and chunk.event != "metadata": 
+            print(chunk.data)
+    ```
+
+=== "Javascript"
+
+    ```js
+    const streamResponseResumed = client.runs.stream(
+      thread["thread_id"],
+      assistantId,
+      {
+        input: null,
+      }
+    );
+
+    for await (const chunk of streamResponseResumed) {
+      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\": \"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'}]}
+    {'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'}, {'content': [{'text': "\n\nGreat news! The weather in San Francisco is sunny today. Is there anything else you'd like to know about the weather or any other information I can help you with?", 'type': 'text', 'index': 0}], 'additional_kwargs': {}, 'response_metadata': {'stop_reason': 'end_turn', 'stop_sequence': None}, 'type': 'ai', 'name': None, 'id': 'run-6a857bb1-f65b-4b86-93d6-c025e003c777', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': {'input_tokens': 557, 'output_tokens': 38, 'total_tokens': 595}}]}

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

@@ -14,7 +14,8 @@ 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="whatever-your-deployment-url-is")
+    client = get_client(url=<DEPLOYMENT_URL>)
+    # Using the graph deployed with the name "agent"
     assistant_id = "agent"
     thread = await client.threads.create()
     ```
@@ -24,11 +25,20 @@ 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:"whatever-your-deployment-url-is" });
-    const assistantId = agent;
+    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'
+    ```
+
 ## Replay a state
 
 ### Initial invocation
@@ -38,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",
     ):
@@ -53,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"],
@@ -69,6 +79,41 @@ Before replaying a state - we need to create states to replay from! In order to
       }
     }
     ```
+
+=== "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\": \"Please search the weather in SF\"}]},
+       \"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:
 
@@ -100,23 +145,35 @@ Now let's get our list of states, and invoke from the third state (right before
     console.log(stateToReplay['next']);
     ```
 
+=== "CURL"
+
+    ```bash
+    curl --request GET --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/history | jq -r '.[2].next'
+    ```
+
 Output:
 
     ['action']
 
 
 
-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": {"thread_ts": state_to_replay['checkpoint_id']}}
+        checkpoint_id=updated_config["checkpoint_id"]
     ):
         if chunk.data and chunk.event != "metadata": 
             print(chunk.data)
@@ -125,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": {"thread_ts": stateToReplay['checkpoint_id']}},
+        checkpointId: config["checkpoint_id"]
       }
     );
     for await (const chunk of streamResponse) {
@@ -141,6 +200,51 @@ 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 -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:
 
     {'action': {'messages': [{'content': '["I looked up: current weather in San Francisco. Result: It\'s sunny in San Francisco, but you better look out if you\'re a Gemini 😈."]', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': 'search', 'id': 'eba650e5-400e-4938-8508-f878dcbcc532', 'tool_call_id': 'toolu_011vroKUtWU7SBdrngpgpFMn'}]}}
@@ -165,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"
@@ -176,9 +280,26 @@ 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"
+
+    ```bash
+    curl -s --request GET --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/history | \
+    jq -c '
+        .[2] as $state_to_replay |
+        .[2].values.messages[-1].tool_calls[0].args.query = "current weather in SF" |
+        {
+            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 @-
     ```
 
 Now we can rerun our graph with this new config, starting from the `new_state`, which is a branch of our `state_to_replay`:
@@ -188,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": {"thread_ts": new_state['configurable']['thread_ts']}}
+        checkpoint_id=config['checkpoint_id']
     ):
         if chunk.data and chunk.event != "metadata": 
             print(chunk.data)
@@ -202,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": {"thread_ts": newState['configurable']['thread_ts']}},
+        checkpointId: config['checkpoint_id'],
       }
     );
     for await (const chunk of streamResponse) {
@@ -216,6 +337,43 @@ Now we can rerun our graph with this new config, starting from the `new_state`,
     }
     ```
 
+=== "CURL"
+
+    ```bash
+    curl -s --request GET --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/state | \
+    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

@@ -24,7 +24,8 @@ 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="whatever-your-deployment-url-is")
+    client = get_client(url=<DEPLOYMENT_URL>)
+    # Using the graph deployed with the name "agent"
     assistant_id = "agent"
     thread = await client.threads.create()
     ```
@@ -34,11 +35,20 @@ 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:"whatever-your-deployment-url-is" });
+    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'
+    ```
+
 ## Waiting for user input
 
 ### Initial invocation
@@ -48,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"],
@@ -63,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"],
@@ -71,15 +95,52 @@ 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);
       }
     }
     ```
+
+=== "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\": \"Use the search tool to ask the user where they are, then look up the weather there\"}]},
+       \"interrupt_before\": [\"ask_human\"],
+       \"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:
 
@@ -108,20 +169,50 @@ 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"
+
+    ```bash
+    curl --request GET \
+     --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/state \
+     | jq -r '.values.messages[-1].tool_calls[0].id' \
+     | sh -c '
+         TOOL_CALL_ID="$1"
+         
+         # Construct the JSON payload
+         JSON_PAYLOAD=$(printf "{\"messages\": [{\"tool_call_id\": \"%s\", \"type\": \"tool\", \"content\": \"san francisco\"}], \"as_node\": \"ask_human\"}" "$TOOL_CALL_ID")
+         
+         # Send the updated state
+         curl --request POST \
+              --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/state \
+              --header "Content-Type: application/json" \
+              --data "${JSON_PAYLOAD}"
+     ' _ 
     ```
 
 Output:
 
-    {'configurable': {'thread_id': '10d0ee61-db47-48fc-a58c-109a1e68cd73',
-      'thread_ts': '1ef32729-3cc3-6647-8002-14dcb621b46e'}}
-
+    {'configurable': {'thread_id': 'a9f322ae-4ed1-41ec-942b-38cb3d342c3a',
+    'checkpoint_ns': '',
+    'checkpoint_id': '1ef58e97-a623-63dd-8002-39a9a9b20be3'}}
 
 
 ### Invoking after receiving human input
@@ -133,7 +224,7 @@ We can now tell the agent to continue. We can just pass in None as the input to
     ```python
     async for chunk in client.runs.stream(
         thread["thread_id"],
-        assistant_id, # graph_id
+        assistant_id,
         input=None,
         stream_mode="updates",
     ):
@@ -148,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);
@@ -158,6 +250,40 @@ We can now tell the agent to continue. We can just pass in None as the input to
     }
     ```
 
+=== "CURL"
+
+    ```bash
+    curl --request POST \                                                                             
+     --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
+     --header 'Content-Type: application/json' \
+     --data "{
+       \"assistant_id\": \"agent\",
+       \"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:
 
     {'agent': {'messages': [{'content': [{'text': "Thank you for letting me know that you're in San Francisco. Now, I'll use the search function to look up the weather in San Francisco.", 'type': 'text'}, {'id': 'toolu_01K57ofmgG2wyJ8tYJjbq5k7', 'input': {'query': 'current weather in San Francisco'}, 'name': 'search', 'type': 'tool_use'}], 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-241baed7-db5e-44ce-ac3c-56431705c22b', 'example': False, 'tool_calls': [{'name': 'search', 'args': {'query': 'current weather in San Francisco'}, 'id': 'toolu_01K57ofmgG2wyJ8tYJjbq5k7'}], 'invalid_tool_calls': [], 'usage_metadata': None}]}}

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
@@ -46,6 +46,7 @@ When creating complex graphs, leaving every decision up to the LLM can be danger
 - [How to wait for user input](./human_in_the_loop_user_input.md)
 - [How to edit graph state](./human_in_the_loop_edit_state.md)
 - [How to replay and branch from prior states](./human_in_the_loop_time_travel.md)
+- [How to review tool calls](./human_in_the_loop_review_tool_calls.md)
 
 ## LangGraph Studio
 
@@ -60,15 +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.
 
@@ -29,7 +53,8 @@ Now, let's import our required packages and instantiate our client, assistant, a
     from langchain_core.messages import convert_to_messages
     from langgraph_sdk import get_client
 
-    client = get_client(url="whatever-your-deployment-url-is")
+    client = get_client(url=<DEPLOYMENT_URL>)
+    # Using the graph deployed with the name "agent"
     assistant_id = "agent"
     thread = await client.threads.create()
     ```
@@ -39,11 +64,20 @@ Now, let's import our required packages and instantiate our client, assistant, a
     ```js
     import { Client } from "@langchain/langgraph-sdk";
 
-    const client = new Client({ apiUrl:"whatever-your-deployment-url-is" });
+    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/invoke_studio.md

@@ -1,13 +1,15 @@
 # Invoke Assistant
 
-The LangGraph Studio lets you test different configurations and inputs to your graph. The UI allows you to see exactly how your 
+The LangGraph Studio lets you test different configurations and inputs to your graph. It also provides a nice visualization of your graph during execution so it is easy to see which nodes are being run and what the outputs of each individual node are.
 
 1. The LangGraph Studio UI displays a visualization of the selected assistant.
-    1. In the top-right dropdown menu of the left-hand pane, select an assistant.
+    1. In the top-left dropdown menu of the left-hand pane, select an assistant.
     1. In the bottom of the left-hand pane, edit the `Input` and `Configure` the assistant.
     1. Select `Submit` to invoke the selected assistant.
 1. View output of the invocation in the right-hand pane.
 
-The following GIF shows these exact steps being carried out:
+The following video shows these exact steps being carried out:
 
-![Using LangGraph Studio](./img/studio_input.gif)
+<video controls allowfullscreen="true" poster="../img/studio_input_poster.png">
+    <source src="../img/studio_input.mp4" type="video/mp4">
+</video>

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.
 
@@ -28,7 +52,8 @@ Now, let's import our required packages and instantiate our client, assistant, a
     from langchain_core.messages import convert_to_messages
     from langgraph_sdk import get_client
 
-    client = get_client(url="whatever-your-deployment-url-is")
+    client = get_client(url=<DEPLOYMENT_URL>)
+    # Using the graph deployed with the name "agent"
     assistant_id = "agent"
     thread = await client.threads.create()
     ```
@@ -38,11 +63,20 @@ Now, let's import our required packages and instantiate our client, assistant, a
     ```js
     import { Client } from "@langchain/langgraph-sdk";
 
-    const client = new Client({ apiUrl:"whatever-your-deployment-url-is" });
+    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.
 
@@ -30,7 +54,8 @@ Now, let's import our required packages and instantiate our client, assistant, a
     from langchain_core.messages import convert_to_messages
     from langgraph_sdk import get_client
 
-    client = get_client(url="whatever-your-deployment-url-is")
+    client = get_client(url=<DEPLOYMENT_URL>)
+    # Using the graph deployed with the name "agent"
     assistant_id = "agent"
     thread = await client.threads.create()
     ```
@@ -40,11 +65,20 @@ Now, let's import our required packages and instantiate our client, assistant, a
     ```js
     import { Client } from "@langchain/langgraph-sdk";
 
-    const client = new Client({ apiUrl:"whatever-your-deployment-url-is" });
+    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,12 +1,15 @@
 # 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"
 
     ```python
     from langgraph_sdk import get_client
 
-    client = get_client(url="whatever-your-deployment-url-is")
+    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)
@@ -17,20 +20,34 @@ This guide covers how to stream events from your graph (`stream_mode="events"`).
     ```js
     import { Client } from "@langchain/langgraph-sdk";
 
-    const client = new Client({ apiUrl:"whatever-your-deployment-url-is" });
+    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"
+
+    ```bash
+    curl --request POST \
+      --url <DEPLOYMENT_URL>/threads \
+      --header 'Content-Type: application/json'
+    ```
 
 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': {}}
+    {
+        '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
+    }
 
 
 
@@ -53,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",
     ):
@@ -67,30 +84,65 @@ 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");
     }
     ```
 
+=== "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\"}]},
+       \"stream_mode\": [
+         \"events\"
+       ]
+     }" | \
+     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"
+         }
+     }
+     ' 
+    ```
+
 Output:
 
     Receiving new event of type: metadata...
@@ -235,9 +287,6 @@ Output:
     
     Receiving new event of type: end...
     None
-    
-    
-    
 
 
 ## Token-by-Token Streaming
@@ -252,15 +301,17 @@ 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",
     ):
         if (
             chunk.event == "events" and
-            chunk.data["event"] == "on_chat_model_stream"
+            chunk.data["event"] == "on_chat_model_stream" and
+            len(chunk.data["data"]["chunk"]["content"]) > 0 and
+            'text' in chunk.data["data"]["chunk"]["content"][0]
         ):
-            llm_response += chunk.data["data"]["chunk"]["content"]
+            llm_response += chunk.data["data"]["chunk"]["content"][0]['text']
             print(llm_response)
     ```
 
@@ -271,28 +322,95 @@ 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"
       }
     );
     for await (const chunk of streamResponse) {
-      if (chunk.event === "events" && chunk.data.event === "on_chat_model_stream") {
-        llmResponse += chunk.data.data.chunk.content;
+      if (chunk.event === "events" && chunk.data.event === "on_chat_model_stream" && chunk.data.chunk.content.length > 0 && 'text' in chunk.data.chunk.content[0]) {
+        llmResponse += chunk.data.data.chunk.content[0].text;
         console.log(llmResponse);
       }
     }
     ```
 
+=== "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\"}]},
+       \"stream_mode\": [
+         \"events\"
+       ]
+     }" | sed 's/\r$//' | awk '
+    /^event:/ { event = $2 }
+    /^data:/ {
+        json_data = substr($0, index($0, $2))
+
+        if (event == "events") {
+        print json_data
+        }
+    }' | jq -r '
+        select(.event == "on_chat_model_stream") |
+        .data.chunk.content[] | .text // empty
+    ' | awk '
+    BEGIN { llm_response="" }
+    $0 != "" && $0 != "null" {
+        llm_response = llm_response $0
+        print llm_response
+    }'
+    ```
+
 Output:
 
-    b
-    be
-    beg
-    begi
-    begin
-    begine
-    beginen
-    beginend
+    The
+    The search
+    The search results provide
+    The search results provide the current weather conditions
+    The search results provide the current weather conditions in San Francisco.
+    The search results provide the current weather conditions in San Francisco. According
+    The search results provide the current weather conditions in San Francisco. According to the data,
+    The search results provide the current weather conditions in San Francisco. According to the data, as
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12,
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024,
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C).
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The win
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is bl
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-southwest at 13
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-southwest at 13.4 mph
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-southwest at 13.4 mph (21.6
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-southwest at 13.4 mph (21.6 k
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-southwest at 13.4 mph (21.6 kph).
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-southwest at 13.4 mph (21.6 kph). The humidity is 
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-southwest at 13.4 mph (21.6 kph). The humidity is 70%
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-southwest at 13.4 mph (21.6 kph). The humidity is 70% and visibility
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-southwest at 13.4 mph (21.6 kph). The humidity is 70% and visibility is 6
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-southwest at 13.4 mph (21.6 kph). The humidity is 70% and visibility is 6 miles
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-southwest at 13.4 mph (21.6 kph). The humidity is 70% and visibility is 6 miles (10 km
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-southwest at 13.4 mph (21.6 kph). The humidity is 70% and visibility is 6 miles (10 km).
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-southwest at 13.4 mph (21.6 kph). The humidity is 70% and visibility is 6 miles (10 km). Overall
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-southwest at 13.4 mph (21.6 kph). The humidity is 70% and visibility is 6 miles (10 km). Overall, it appears
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-southwest at 13.4 mph (21.6 kph). The humidity is 70% and visibility is 6 miles (10 km). Overall, it appears to be a nice
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-southwest at 13.4 mph (21.6 kph). The humidity is 70% and visibility is 6 miles (10 km). Overall, it appears to be a nice sunny day in San
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-southwest at 13.4 mph (21.6 kph). The humidity is 70% and visibility is 6 miles (10 km). Overall, it appears to be a nice sunny day in San Francisco.
+
 

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:
 
@@ -41,7 +45,9 @@ First let's set up our client and thread:
     ```python
     from langgraph_sdk import get_client
 
-    client = get_client(url="whatever-your-deployment-url-is")
+    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)
@@ -52,20 +58,35 @@ First let's set up our client and thread:
     ```js
     import { Client } from "@langchain/langgraph-sdk";
 
-    const client = new Client({ apiUrl:"whatever-your-deployment-url-is" });
+    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"
+
+    ```bash
+    curl --request POST \
+      --url <DEPLOYMENT_URL>/threads \
+      --header 'Content-Type: application/json'
     ```
 
 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': {}}
+    {
+        '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
+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`)
 
 === "Python"
 
@@ -95,6 +116,69 @@ Let's also define a helper function for better formatting of the tool calls in m
     }
     ```
 
+=== "CURL"
+
+    ```bash
+    # process_stream.sh
+
+    format_tool_calls() {
+        echo "$1" | jq -r 'map("Tool Call ID: \(.id), Function: \(.name), Arguments: \(.args)") | join("\n")'
+    }
+
+    process_data_item() {
+        local data_item="$1"
+
+        if echo "$data_item" | jq -e '.role == "user"' > /dev/null; then
+            echo "Human: $(echo "$data_item" | jq -r '.content')"
+        else
+            local tool_calls=$(echo "$data_item" | jq -r '.tool_calls // []')
+            local invalid_tool_calls=$(echo "$data_item" | jq -r '.invalid_tool_calls // []')
+            local content=$(echo "$data_item" | jq -r '.content // ""')
+            local response_metadata=$(echo "$data_item" | jq -r '.response_metadata // {}')
+
+            if [ -n "$content" ] && [ "$content" != "null" ]; then
+                echo "AI: $content"
+            fi
+
+            if [ "$tool_calls" != "[]" ]; then
+                echo "Tool Calls:"
+                format_tool_calls "$tool_calls"
+            fi
+
+            if [ "$invalid_tool_calls" != "[]" ]; then
+                echo "Invalid Tool Calls:"
+                format_tool_calls "$invalid_tool_calls"
+            fi
+
+            if [ "$response_metadata" != "{}" ]; then
+                local finish_reason=$(echo "$response_metadata" | jq -r '.finish_reason // "N/A"')
+                echo "Response Metadata: Finish Reason - $finish_reason"
+            fi
+        fi
+    }
+
+    while IFS=': ' read -r key value; do
+        case "$key" in
+            event)
+                event="$value"
+                ;;
+            data)
+                if [ "$event" = "metadata" ]; then
+                    run_id=$(echo "$value" | jq -r '.run_id')
+                    echo "Metadata: Run ID - $run_id"
+                    echo "------------------------------------------------"
+                elif [ "$event" = "messages/partial" ]; then
+                    echo "$value" | jq -c '.[]' | while read -r data_item; do
+                        process_data_item "$data_item"
+                    done
+                    echo "------------------------------------------------"
+                fi
+                ;;
+        esac
+    done
+    ```
+
+
 Now we can stream by messages, which will return complete messages (at the end of node execution) as well as tokens for any messages generated inside a node:
 
 === "Python"
@@ -105,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",
@@ -144,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}`);
@@ -201,6 +286,23 @@ Now we can stream by messages, which will return complete messages (at the end o
     }
     ```
 
+=== "CURL"
+
+    ```bash
+    curl --request POST \
+    --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
+    --header 'Content-Type: application/json' \
+    --data "{
+    \"assistant_id\": \"agent\",
+    \"config\":{\"configurable\":{\"model_name\":\"openai\"}},
+    \"input\": {\"messages\": [{\"role\": \"human\", \"content\": \"What's the weather in sf\"}]},
+    \"stream_mode\": [
+    \"messages\"
+    ]
+    }" | sed 's/\r$//' | ./process_stream.sh
+    ```
+
+
 Output:
 
     Metadata: Run ID - 1ef2fe5c-6a1d-6575-bc09-d7832711c17e

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

@@ -9,7 +9,9 @@ First let's set up our client and thread:
     ```python
     from langgraph_sdk import get_client
 
-    client = get_client(url="whatever-your-deployment-url-is")
+    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)
@@ -20,19 +22,33 @@ First let's set up our client and thread:
     ```js
     import { Client } from "@langchain/langgraph-sdk";
 
-    const client = new Client({ apiUrl:"whatever-your-deployment-url-is" });
+    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"
+
+    ```bash
+    curl --request POST \
+      --url <DEPLOYMENT_URL>/threads \
+      --header 'Content-Type: application/json'
+    ```
 
 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': {}}
+    {
+        '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.
 
@@ -52,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"],
     ):
@@ -66,30 +82,67 @@ 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");
     }
     ```
 
+=== "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?\"}]},
+       \"stream_mode\": [
+         \"messages\",
+         \"events\",
+         \"debug\"
+       ]
+     }" | \
+     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"
+         }
+     }
+     '
+    ```
+
 Output:
 
     Receiving new event of type: metadata...
@@ -436,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:
 
@@ -16,7 +9,7 @@ First let's set up our client and thread:
     ```python
     from langgraph_sdk import get_client
 
-    client = get_client(url="whatever-your-deployment-url-is")
+    client = get_client(url=<DEPLOYMENT_URL>)
     # create thread
     thread = await client.threads.create()
     print(thread)
@@ -27,19 +20,31 @@ First let's set up our client and thread:
     ```js
     import { Client } from "@langchain/langgraph-sdk";
 
-    const client = new Client({ apiUrl:"whatever-your-deployment-url-is" });
+    const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
     // create thread
     const thread = await client.threads.create();
-    console.log(thread)
+    console.log(thread);
     ```
 
+=== "CURL"
+
+    ```bash
+    curl --request POST \
+      --url <DEPLOYMENT_URL>/threads \
+      --header 'Content-Type: application/json'
+    ```
 
 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': {}}
+    {
+      '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:
 
@@ -70,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"],
@@ -86,13 +91,49 @@ 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");
     }
     ```
 
+=== "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 la\"}]},
+       \"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"
+         }
+     }
+     '
+    ```
+
 Output:
 
     Receiving new event of type: metadata...

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:
 
@@ -16,7 +9,7 @@ First let's set up our client and thread:
     ```python
     from langgraph_sdk import get_client
 
-    client = get_client(url="whatever-your-deployment-url-is")
+    client = get_client(url=<DEPLOYMENT_URL>)
     # create thread
     thread = await client.threads.create()
     print(thread)
@@ -27,18 +20,31 @@ First let's set up our client and thread:
     ```js
     import { Client } from "@langchain/langgraph-sdk";
 
-    const client = new Client({ apiUrl: "whatever-your-deployment-url-is" });
+    const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
     // create thread
     const thread = await client.threads.create();
-    console.log(thread)
+    console.log(thread);
+    ```
+
+=== "CURL"
+
+    ```bash
+    curl --request POST \
+      --url <DEPLOYMENT_URL>/threads \
+      --header 'Content-Type: application/json'
     ```
 
 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': {}}
+    {
+      '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:
 
@@ -60,7 +66,6 @@ Now we can stream by values, which streams the full state of the graph after eac
     ```
 
 === "Javascript"
-    
 
     ```js
     const input = {"messages": [{"role": "human", "content": "what's the weather in la"}]}
@@ -74,12 +79,47 @@ 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");
     }
     ```
 
+=== "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 la\"}]},
+       \"stream_mode\": [
+         \"values\"
+       ]
+     }" | \
+     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"
+         }
+     }
+     ' 
+    ```
+
 
 Output:
 
@@ -149,6 +189,34 @@ If we want to just get the final result, we can use this endpoint and just keep
     }
     ```
 
+=== "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 la\"}]},
+       \"stream_mode\": [
+         \"values\"
+       ]
+     }" | \
+     sed 's/\r$//' | \
+     awk '
+     /^data:/ { 
+         sub(/^data: /, "", $0)   
+         data_content = $0          
+     }    
+     END {                                               
+         if (data_content != "") {
+             print data_content
+         }
+     }         
+     '
+    ```
+
+
 Output:
 
     {'messages': [{'content': 'what's the weather in la',

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

@@ -9,6 +9,8 @@ Starting from the <a href="https://smith.langchain.com/" target="_blank">LangSmi
 1. In the top-right corner, select `Open LangGraph Studio`.
 1. [Invoke an assistant](./invoke_studio.md) or [view an existing thread](./threads_studio.md).
 
-The following GIF shows these exact steps being carried out:
+The following video shows these exact steps being carried out:
 
-![Using LangGraph Studio](./img/studio_usage.gif)
+<video controls allowfullscreen="true" poster="../img/studio_usage_poster.png">
+    <source src="../img/studio_usage.mp4" type="video/mp4">
+</video>

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

@@ -6,14 +6,18 @@
 1. View the state of the thread (i.e. the output) in the right-hand pane.
 1. To create a new thread, select `+ New Thread`.
 
-The following GIF shows these exact steps being carried out:
+The following video shows these exact steps being carried out:
 
-![Using LangGraph Studio](./img/studio_threads.gif)
+<video controls="true" allowfullscreen="true" poster="../img/studio_threads_poster.png">
+    <source src="../img/studio_threads.mp4" type="video/mp4">
+</video>
 
 ## Edit Thread State
 
 The LangGraph Studio UI contains features for editing thread state. Explore these features in the right-hand pane. Select the `Edit` icon, modify the desired state, and then select `Fork` to invoke the assistant with the updated state.
 
-The following GIF shows how to edit a thread in the studio:
+The following video shows how to edit a thread in the studio:
 
-![Using LangGraph Studio](./img/studio_forks.gif)
+<video controls allowfullscreen="true" poster="../img/studio_forks_poster.png">
+    <source src="../img/studio_forks.mp4" type="video/mp4">
+</video>

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/index.md

@@ -6,13 +6,14 @@
     - We are actively contributing improvements back to LangGraph informed by our work on LangGraph Cloud.
     - You can always deploy LangGraph applications on your own infrastructure using the open-source LangGraph project.
 
-!!! danger "Important"
-    LangGraph Cloud is a closed source, paid product in an invite-only stage. We are currently focused on providing high bandwidth support to make our select early customers successful. If you are interested in applying for access, please fill out [this form](https://www.langchain.com/langgraph-cloud-beta).
-
 !!! warning "Under Construction"
     LangGraph Cloud documentation is under construction. Contents may change until general availability.
 
-![GIF](./how-tos/img/studio_input.gif)
+
+<video controls preload="auto" allowfullscreen="true" poster="how-tos/img/studio_forks_poster.png">
+    <source src="how-tos/img/studio_forks.mp4" type="video/mp4">
+</video>
+
 
 ## Overview
 
@@ -22,6 +23,8 @@ The LangGraph Cloud API exposes functionality of your LangGraph application thro
 
 LangGraph Cloud is seamlessly integrated with [LangSmith](https://www.langchain.com/langsmith) and is accessible from within the LangSmith UI.
 
+LangGraph Cloud applications can be tested and debugged using the [LangGraph Studio Desktop](https://github.com/langchain-ai/langgraph-studio). 
+
 ## Key Features
 
 The LangGraph Cloud API supports key LangGraph features in addition to new functionality for enabling complex, agentic workflows.

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:
 
@@ -66,6 +131,16 @@ Now that we have set everything up on our local file system, we are ready to hos
 
 ## Test the graph build locally
 
+### Using LangGraph Studio Desktop (recommended)
+
+![LangGraph Studio Desktop](./img/graph_video_poster.png)
+
+Testing your graph locally is easy with LangGraph Studio Desktop. LangGraph Studio offers a new way to develop LLM applications by providing a specialized agent IDE that enables visualization, interaction, and debugging of complex agentic applications
+
+With visual graphs and the ability to edit state, you can better understand agent workflows and iterate faster. LangGraph Studio integrates with [LangSmith](https://smith.langchain.com) so you can collaborate with teammates to debug failure modes.
+
+### Using the LangGraph CLI
+
 Before deploying to the cloud, we probably want to test the building of our graph locally. This is useful to make sure we have configured our [CLI configuration file][langgraph.json] correctly and our graph runs.
 
 In order to do this we can first install the LangGraph CLI
@@ -196,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/cloud/reference/cli.md

@@ -13,7 +13,7 @@ The LangGraph CLI requires a JSON configuration file with the following keys:
 | Key | Description |
 | --- | ----------- |
 | `dependencies` | **Required**. Array of dependencies for LangGraph Cloud API server. Dependencies can be one of the following: (1) `"."`, which will look for local Python packages, (2) `pyproject.toml`, `setup.py` or `requirements.txt` in the app directory `"./local_package"`, or (3) a package name. |
-| `graphs` | **Required**. Mapping from graph ID to path where the compiled graph is defined. Example: `./your_package/your_file.py:variable`, where `variable` is an instance of `langgraph.graph.graph.CompiledGraph`. |
+| `graphs` | **Required**. Mapping from graph ID to path where the compiled graph or a function that makes a graph is defined. Example: <ul><li>`./your_package/your_file.py:variable`, where `variable` is an instance of `langgraph.graph.state.CompiledStateGraph`</li><li>`./your_package/your_file.py:make_graph`, where `make_graph` is a function that takes a config dictionary (`langchain_core.runnables.RunnableConfig`) and creates an instance of `langgraph.graph.state.StateGraph` / `langgraph.graph.state.CompiledStateGraph`.</li></ul> |
 | `env` | Path to `.env` file or a mapping from environment variable to its value. |
 | `python_version` | `3.11` or `3.12`. Defaults to `3.11`. |
 | `pip_config_file`| Path to `pip` config file. |
@@ -49,7 +49,7 @@ Example:
         "."
     ],
     "graphs": {
-        "my_graph_id": "./your_package/your_file.py:variable"
+        "my_graph_id": "./your_package/your_file.py:make_graph"
     },
     "env": {
         "OPENAI_API_KEY": "secret-key"

docs/docs/concepts/agentic_concepts.md

@@ -56,6 +56,25 @@ This is a pretty advanced interaction pattern. In this interaction pattern, the
 
 See [this guide](../how-tos/human_in_the_loop/time-travel.ipynb) for how to do this in LangGraph.
 
+## Review Tool Calls
+
+This is a specific type of human-in-the-loop interaction but it's worth calling out because it is so common. A lot of agent decisions are made via tool calling, so having a clear UX for reviewing tool calls is handy.
+
+A tool call consists of:
+- The name of the tool to call
+- Arguments to pass to the tool
+
+Note that these tool calls can obviously be used for actually calling functions, but they can also be used for other purposes, like to route the agent in a specific direction.
+You will want to review the tool call for both of these use cases.
+
+When reviewing tool calls, there are few actions you may want to take.
+
+1. Approve the tool call (and let the agent continue on its way)
+2. Manually change the tool call, either the tool name or the tool arguments (and let the agent continue on its way after that)
+3. Leave feedback on the tool call. This differs from (2) in that you are not changing the tool call directly, but rather leaving natural language feedback suggesting the LLM call it differently (or call a different tool). You could do this by either adding a `ToolMessage` and having the feedback be the result of the tool call, or by adding a `ToolMessage` (that simulates an error) and then a `HumanMessage` (with the feedback).
+
+See [this guide](../how-tos/human_in_the_loop/review-tool-calls.ipynb) for how to do this in LangGraph.
+
 ## Map-Reduce
 
 A common pattern in agents is to generate a list of objects, do some work on each of those objects, and then combine the results. This is very similar to the common [map-reduce](https://en.wikipedia.org/wiki/MapReduce) operation. This can be tricky for a few reasons. First, it can be tough to define a structured graph ahead of time because the length of the list of objects may be unknown. Second, in order to do this map-reduce you need multiple versions of the state to exist... but the graph shares a common shared state, so how can this be?

docs/docs/concepts/index.md

@@ -20,7 +20,7 @@ Low Level Concepts
 - [State](low_level.md#state)
     - [Schema](low_level.md#schema)
     - [Reducers](low_level.md#reducers)
-    - [MessageState](low_level.md#messagestate)
+    - [MessageState](low_level.md#working-with-messages-in-graph-state)
 - [Nodes](low_level.md#nodes)
     - [`START` node](low_level.md#start-node)
     - [`END` node](low_level.md#end-node)

docs/docs/concepts/low_level.md

@@ -49,9 +49,14 @@ The main documented way to specify the schema of a graph is by using `TypedDict`
 By default, the graph will have the same input and output schemas. If you want to change this, you can also specify explicit input and output schemas directly. This is useful when you have a lot of keys, and some are explicitly for input and others for output. See the [notebook here](../how-tos/input_output_schema.ipynb) for how to use.
 
 By default, all nodes in the graph will share the same state. This means that they will read and write to the same state channels. It is possible to have nodes write to private state channels inside the graph for internal node communication - see [this notebook](../how-tos/pass_private_state.ipynb) for how to do that.
+
 ### Reducers
 
-Reducers are key to understanding how updates from nodes are applied to the `State`. Each key in the `State` has its own independent reducer function. If no reducer function is explicitly specified then it is assumed that all updates to that key should override it. Let's take a look at a few examples to understand them better.
+Reducers are key to understanding how updates from nodes are applied to the `State`. Each key in the `State` has its own independent reducer function. If no reducer function is explicitly specified then it is assumed that all updates to that key should override it. There are a few different types of reducers, starting with the default type of reducer:
+
+#### Default Reducer
+
+These two examples show how to use the default reducer:
 
 **Example A:**
 
@@ -78,22 +83,48 @@ class State(TypedDict):
 
 In this example, we've used the `Annotated` type to specify a reducer function (`operator.add`) for the second key (`bar`). Note that the first key remains unchanged. Let's assume the input to the graph is `{"foo": 1, "bar": ["hi"]}`. Let's then assume the first `Node` returns `{"foo": 2}`. This is treated as an update to the state. Notice that the `Node` does not need to return the whole `State` schema - just an update. After applying this update, the `State` would then be `{"foo": 2, "bar": ["hi"]}`. If the second node returns `{"bar": ["bye"]}` then the `State` would then be `{"foo": 2, "bar": ["hi", "bye"]}`. Notice here that the `bar` key is updated by adding the two lists together.
 
-### MessageState
+#### Context Reducer
 
-`MessageState` is one of the few opinionated components in LangGraph. `MessageState` is a special state designed to make it easy to use a list of messages as a key in your state. Specifically, `MessageState` is defined as:
+You can use `Context` channels to define shared resources (such as database connections) that are managed outside of your graph's nodes and excluded from checkpointing. The context manager provided to the Context channel is entered before the first step of the graph execution and exited after the last step, allowing you to set up and clean up resources for the duration of the graph invocation. Read this [how to](https://langchain-ai.github.io/langgraph/how-tos/state-context-key) to see an example of using the `Context` channel in your graph.
+
+### Working with Messages in Graph State
+
+#### Why use messages?
+
+Most modern LLM providers have a chat model interface that accepts a list of messages as input. LangChain's [`ChatModel`](https://python.langchain.com/v0.2/docs/concepts/#chat-models) in particular accepts a list of `Message` objects as inputs. These messages come in a variety of forms such as `HumanMessage` (user input) or `AIMessage` (LLM response). To read more about what message objects are, please refer to [this](https://python.langchain.com/v0.2/docs/concepts/#messages) conceptual guide.
+
+#### Using Messages in your Graph
+
+In many cases, it is helpful to store prior conversation history as a list of messages in your graph state. To do so, we can add a key (channel) to the graph state that stores a list of `Message` objects and annotate it with a reducer function (see `messages` key in the example below). The reducer function is vital to telling the graph how to update the list of `Message` objects in the state with each state update (for example, when a node sends an update). If you don't specify a reducer, every state update will overwrite the list of messages with the most recently provided value. If you wanted to simply append messages to the existing list, you could use `operator.add` as a reducer.
+
+However, you might also want to manually update messages in your graph state (e.g. human-in-the-loop). If you were to use `operator.add`, the manual state updates you send to the graph would be appended to the existing list of messages, instead of updating existing messages. To avoid that, you need a reducer that can keep track of message IDs and overwrite existing messages, if updated. To achieve this, you can use the prebuilt `add_messages` function. For brand new messages, it will simply append to existing list, but it will also handle the updates for existing messages correctly.
+
+#### Serialization
+
+In addition to keeping track of message IDs, the `add_messages` function will also try to deserialize messages into LangChain `Message` objects whenever a state update is received on the `messages` channel. See more information on LangChain serialization/deserialization [here](https://python.langchain.com/v0.2/docs/how_to/serialization/). This allows sending graph inputs / state updates in the following format:
+
+```python
+# this is supported
+{"messages": [HumanMessage(content="message")]}
+
+# and this is also supported
+{"messages": [{"type": "human", "content": "message"}]}
+```
+
+Since the state updates are always deserialized into LangChain `Messages` when using `add_messages`, you should use dot notation to access message attributes, like `state["messages"][-1].content`. Below is an example of a graph that uses `add_messages` as it's reducer function.
 
 ```python
 from langchain_core.messages import AnyMessage
 from langgraph.graph.message import add_messages
 from typing import Annotated, TypedDict
 
-class MessagesState(TypedDict):
+class GraphState(TypedDict):
     messages: Annotated[list[AnyMessage], add_messages]
 ```
 
-What this is doing is creating a `TypedDict` with a single key: `messages`. This is a list of `Message` objects, with `add_messages` as a reducer. `add_messages` basically adds messages to the existing list (it also does some nice extra things, like convert from OpenAI message format to the standard LangChain message format, handle updates based on message IDs, etc).
+#### MessagesState
 
-We often see a list of messages being a key component of state, so this prebuilt state is intended to make it easy to use messages. Typically, there is more state to track than just messages, so we see people subclass this state and add more fields, like:
+Since having a list of messages in your state is so common, there exists a prebuilt state called `MessagesState` which makes it easy to use messages. `MessagesState` is defined with a single `messages` key which is a list of `AnyMessage` objects and uses the `add_messages` reducer. Typically, there is more state to track than just messages, so we see people subclass this state and add more fields, like:
 
 ```python
 from langgraph.graph import MessagesState
@@ -370,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
 
@@ -396,10 +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).
+
+#### 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
 
@@ -25,7 +24,7 @@ LangGraph makes it easy to persist state across graph runs. The guide below show
 - [How to manage conversation history](memory/manage-conversation-history.ipynb)
 - [How to delete messages](memory/delete-messages.ipynb)
 - [How to add summary conversation memory](memory/add-summary-conversation-history.ipynb)
-- [How to create a custom checkpointer using Postgres](persistence_postgres.ipynb)
+- [How to use Postgres checkpointer for persistence](persistence_postgres.ipynb)
 - [How to create a custom checkpointer using MongoDB](persistence_mongodb.ipynb)
 - [How to create a custom checkpointer using Redis](persistence_redis.ipynb)
 
@@ -35,9 +34,11 @@ 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)
+- [Review tool calls](human_in_the_loop/review-tool-calls.ipynb)
 
 ## Streaming
 
@@ -60,6 +61,20 @@ These guides show how to use different streaming modes.
 - [How to handle tool calling errors](tool-calling-errors.ipynb)
 - [How to pass graph state to tools](pass-run-time-values-to-tools.ipynb)
 - [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)
+- [Use a context object in state](state-context-key.ipynb)
+- [Have a separate input and output schema](input_output_schema.ipynb)
+- [Pass private state between nodes inside the graph](pass_private_state.ipynb)
 
 ## Other
 
@@ -69,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/docs/reference/checkpoints.md

@@ -7,6 +7,8 @@ You can [compile][langgraph.graph.MessageGraph.compile] any LangGraph workflow w
 - Resilience for long-running, error-prone agents
 - Time travel retry and branch from a previous checkpoint
 
+Key checkpointer interfaces and primitives are defined in [`langgraph_checkpoint`](https://github.com/langchain-ai/langgraph/tree/main/libs/checkpoint) library.
+
 ### Checkpoint
 
 ::: langgraph.checkpoint.base.Checkpoint
@@ -21,7 +23,7 @@ You can [compile][langgraph.graph.MessageGraph.compile] any LangGraph workflow w
 
 ### SerializerProtocol
 
-::: langgraph.checkpoint.SerializerProtocol
+::: langgraph.checkpoint.base.SerializerProtocol
 
 ## Implementations
 
@@ -33,9 +35,20 @@ LangGraph also natively provides the following checkpoint implementations.
 
 ### AsyncSqliteSaver
 
-::: langgraph.checkpoint.aiosqlite.AsyncSqliteSaver
+::: langgraph.checkpoint.sqlite.aio.AsyncSqliteSaver
 
 ### SqliteSaver
 
 ::: langgraph.checkpoint.sqlite.SqliteSaver
+
+### AsyncPostgresSaver
+
+::: langgraph.checkpoint.postgres.aio.AsyncPostgresSaver
+
+### PostgresSaver
+
+::: langgraph.checkpoint.postgres.PostgresSaver
+handler: python
+
+
 handler: python

docs/docs/tutorials/index.md

@@ -65,4 +65,3 @@ Learn from example implementations of graphs designed for specific scenarios and
 - [Web Navigation](web-navigation/web_voyager.ipynb): Build an agent that can navigate and interact with websites
 - [Competitive Programming](usaco/usaco.ipynb): Build an agent with few-shot "episodic memory" and human-in-the-loop collaboration to solve problems from the USA Computing Olympiad; adapted from the ["Can Language Models Solve Olympiad Programming?"](https://arxiv.org/abs/2404.10952v1) paper by Shi, Tang, Narasimhan, and Yao.
 - [Complex data extraction](extraction/retries.ipynb): Build an agent that can use function calling to do complex extraction tasks
-- 

docs/mkdocs.yml

@@ -126,22 +126,24 @@ 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
           - Delete messages: how-tos/memory/delete-messages.ipynb
           - Add summary of the conversation history: how-tos/memory/add-summary-conversation-history.ipynb
-          - Create custom checkpointer using Postgres: how-tos/persistence_postgres.ipynb
+          - Use Postgres checkpointer for persistence: how-tos/persistence_postgres.ipynb
           - Create custom checkpointer using MongoDB: how-tos/persistence_mongodb.ipynb
           - 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
+          - Review tool calls: how-tos/human_in_the_loop/review-tool-calls.ipynb
       - Streaming:
           - Stream full state: how-tos/stream-values.ipynb
           - Stream state updates: how-tos/stream-updates.ipynb
@@ -157,6 +159,11 @@ nav:
           - Handle tool calling errors: how-tos/tool-calling-errors.ipynb
           - 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
@@ -167,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
@@ -189,12 +197,14 @@ nav:
           - Quick Start: "cloud/quick_start.md"
       - How-to Guides: 
           - "cloud/how-tos/index.md"
-          - Deployment:
+          - 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"
@@ -212,20 +222,23 @@ nav:
               - Wait for User Input: "cloud/how-tos/human_in_the_loop_user_input.md"
               - Edit Graph State: "cloud/how-tos/human_in_the_loop_edit_state.md"
               - Replay and Branch from Prior States: "cloud/how-tos/human_in_the_loop_time_travel.md"
+              - Review Tool Calls: "cloud/how-tos/human_in_the_loop_review_tool_calls.md"
           - LangGraph Studio:
               - Test Cloud Deployment: "cloud/how-tos/test_deployment.md"
               - Test Local Deployment: "cloud/how-tos/test_local_deployment.md"
               - 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:
           - API Concepts: "cloud/concepts/api.md"
           - Cloud Concepts: "cloud/concepts/cloud.md"
@@ -236,6 +249,8 @@ nav:
               - JS/TS: "cloud/reference/sdk/js_ts_sdk_ref.md"
           - CLI: "cloud/reference/cli.md"
           - Environment Variables: "cloud/reference/env_var.md"
+      - FAQ:
+          - Studio: "cloud/faq/studio.md"
 
 markdown_extensions:
   - abbr

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

@@ -26,7 +26,10 @@
    "id": "0d30b6f7-3bec-4d9f-af50-43dfdc81ae6c",
    "metadata": {},
    "outputs": [],
-   "source": ["# %%capture --no-stderr\n# %pip install -U langgraph langchain langchain_openai"]
+   "source": [
+    "# %%capture --no-stderr\n",
+    "# %pip install -U langgraph langchain langchain_openai"
+   ]
   },
   {
    "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\n# Optional, add tracing in LangSmith.\n# This will help you visualize and debug the control flow\nos.environ[\"LANGCHAIN_TRACING_V2\"] = \"true\"\nos.environ[\"LANGCHAIN_PROJECT\"] = \"Agent Simulation Evaluation\""]
+   "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",
+    "\n",
+    "# Optional, add tracing in LangSmith.\n",
+    "# This will help you visualize and debug the control flow\n",
+    "os.environ[\"LANGCHAIN_TRACING_V2\"] = \"true\"\n",
+    "os.environ[\"LANGCHAIN_PROJECT\"] = \"Agent Simulation Evaluation\""
+   ]
   },
   {
    "cell_type": "markdown",
@@ -55,7 +75,24 @@
    "id": "828479af-cf9c-4888-a365-599643a96b55",
    "metadata": {},
    "outputs": [],
-   "source": ["from typing import List\n\nimport openai\n\n\n# This is flexible, but you can define your agent here, or call your agent API here.\ndef my_chat_bot(messages: List[dict]) -> dict:\n    system_message = {\n        \"role\": \"system\",\n        \"content\": \"You are a customer support agent for an airline.\",\n    }\n    messages = [system_message] + messages\n    completion = openai.chat.completions.create(\n        messages=messages, model=\"gpt-3.5-turbo\"\n    )\n    return completion.choices[0].message.model_dump()"]
+   "source": [
+    "from typing import List\n",
+    "\n",
+    "import openai\n",
+    "\n",
+    "\n",
+    "# This is flexible, but you can define your agent here, or call your agent API here.\n",
+    "def my_chat_bot(messages: List[dict]) -> dict:\n",
+    "    system_message = {\n",
+    "        \"role\": \"system\",\n",
+    "        \"content\": \"You are a customer support agent for an airline.\",\n",
+    "    }\n",
+    "    messages = [system_message] + messages\n",
+    "    completion = openai.chat.completions.create(\n",
+    "        messages=messages, model=\"gpt-3.5-turbo\"\n",
+    "    )\n",
+    "    return completion.choices[0].message.model_dump()"
+   ]
   },
   {
    "cell_type": "code",
@@ -77,7 +114,9 @@
      "output_type": "execute_result"
     }
    ],
-   "source": ["my_chat_bot([{\"role\": \"user\", \"content\": \"hi!\"}])"]
+   "source": [
+    "my_chat_bot([{\"role\": \"user\", \"content\": \"hi!\"}])"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -96,7 +135,33 @@
    "id": "32c147df-7f90-4b0d-9a6b-671677020353",
    "metadata": {},
    "outputs": [],
-   "source": ["from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder\nfrom langchain_openai import ChatOpenAI\n\nsystem_prompt_template = \"\"\"You are a customer of an airline company. \\\nYou are interacting with a user who is a customer support person. \\\n\n{instructions}\n\nWhen you are finished with the conversation, respond with a single word 'FINISHED'\"\"\"\n\nprompt = ChatPromptTemplate.from_messages(\n    [\n        (\"system\", system_prompt_template),\n        MessagesPlaceholder(variable_name=\"messages\"),\n    ]\n)\ninstructions = \"\"\"Your name is Harrison. You are trying to get a refund for the trip you took to Alaska. \\\nYou want them to give you ALL the money back. \\\nThis trip happened 5 years ago.\"\"\"\n\nprompt = prompt.partial(name=\"Harrison\", instructions=instructions)\n\nmodel = ChatOpenAI()\n\nsimulated_user = prompt | model"]
+   "source": [
+    "from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder\n",
+    "from langchain_openai import ChatOpenAI\n",
+    "\n",
+    "system_prompt_template = \"\"\"You are a customer of an airline company. \\\n",
+    "You are interacting with a user who is a customer support person. \\\n",
+    "\n",
+    "{instructions}\n",
+    "\n",
+    "When you are finished with the conversation, respond with a single word 'FINISHED'\"\"\"\n",
+    "\n",
+    "prompt = ChatPromptTemplate.from_messages(\n",
+    "    [\n",
+    "        (\"system\", system_prompt_template),\n",
+    "        MessagesPlaceholder(variable_name=\"messages\"),\n",
+    "    ]\n",
+    ")\n",
+    "instructions = \"\"\"Your name is Harrison. You are trying to get a refund for the trip you took to Alaska. \\\n",
+    "You want them to give you ALL the money back. \\\n",
+    "This trip happened 5 years ago.\"\"\"\n",
+    "\n",
+    "prompt = prompt.partial(name=\"Harrison\", instructions=instructions)\n",
+    "\n",
+    "model = ChatOpenAI()\n",
+    "\n",
+    "simulated_user = prompt | model"
+   ]
   },
   {
    "cell_type": "code",
@@ -115,7 +180,12 @@
      "output_type": "execute_result"
     }
    ],
-   "source": ["from langchain_core.messages import HumanMessage\n\nmessages = [HumanMessage(content=\"Hi! How can I help you?\")]\nsimulated_user.invoke({\"messages\": messages})"]
+   "source": [
+    "from langchain_core.messages import HumanMessage\n",
+    "\n",
+    "messages = [HumanMessage(content=\"Hi! How can I help you?\")]\n",
+    "simulated_user.invoke({\"messages\": messages})"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -153,7 +223,20 @@
    "id": "69e2a3a3-40f3-4223-9136-113738440be9",
    "metadata": {},
    "outputs": [],
-   "source": ["from langchain_community.adapters.openai import convert_message_to_dict\nfrom langchain_core.messages import AIMessage\n\n\ndef chat_bot_node(messages):\n    # Convert from LangChain format to the OpenAI format, which our chatbot function expects.\n    messages = [convert_message_to_dict(m) for m in messages]\n    # Call the chat bot\n    chat_bot_response = my_chat_bot(messages)\n    # Respond with an AI Message\n    return AIMessage(content=chat_bot_response[\"content\"])"]
+   "source": [
+    "from langchain_community.adapters.openai import convert_message_to_dict\n",
+    "from langchain_core.messages import AIMessage\n",
+    "\n",
+    "\n",
+    "def chat_bot_node(state):\n",
+    "    messages = state[\"messages\"]\n",
+    "    # Convert from LangChain format to the OpenAI format, which our chatbot function expects.\n",
+    "    messages = [convert_message_to_dict(m) for m in messages]\n",
+    "    # 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\"])]}"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -169,7 +252,26 @@
    "id": "7cad7527-ffa5-4c30-8585-b54a7a18bd98",
    "metadata": {},
    "outputs": [],
-   "source": ["def _swap_roles(messages):\n    new_messages = []\n    for m in messages:\n        if isinstance(m, AIMessage):\n            new_messages.append(HumanMessage(content=m.content))\n        else:\n            new_messages.append(AIMessage(content=m.content))\n    return new_messages\n\n\ndef simulated_user_node(messages):\n    # Swap roles of messages\n    new_messages = _swap_roles(messages)\n    # 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 HumanMessage(content=response.content)"]
+   "source": [
+    "def _swap_roles(messages):\n",
+    "    new_messages = []\n",
+    "    for m in messages:\n",
+    "        if isinstance(m, AIMessage):\n",
+    "            new_messages.append(HumanMessage(content=m.content))\n",
+    "        else:\n",
+    "            new_messages.append(AIMessage(content=m.content))\n",
+    "    return new_messages\n",
+    "\n",
+    "\n",
+    "def simulated_user_node(state):\n",
+    "    messages = state[\"messages\"]\n",
+    "    # Swap roles of messages\n",
+    "    new_messages = _swap_roles(messages)\n",
+    "    # 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)]}"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -192,7 +294,16 @@
    "id": "28004fbf-a2f3-46b7-bde7-46c7adaf97fb",
    "metadata": {},
    "outputs": [],
-   "source": ["def should_continue(messages):\n    if len(messages) > 6:\n        return \"end\"\n    elif messages[-1].content == \"FINISHED\":\n        return \"end\"\n    else:\n        return \"continue\""]
+   "source": [
+    "def should_continue(state):\n",
+    "    messages = state[\"messages\"]\n",
+    "    if len(messages) > 6:\n",
+    "        return \"end\"\n",
+    "    elif messages[-1].content == \"FINISHED\":\n",
+    "        return \"end\"\n",
+    "    else:\n",
+    "        return \"continue\""
+   ]
   },
   {
    "cell_type": "markdown",
@@ -210,7 +321,37 @@
    "id": "0b597e4b-4cbb-4bbc-82e5-f7e31275964c",
    "metadata": {},
    "outputs": [],
-   "source": ["from langgraph.graph import END, MessageGraph, START\n\ngraph_builder = MessageGraph()\ngraph_builder.add_node(\"user\", simulated_user_node)\ngraph_builder.add_node(\"chat_bot\", chat_bot_node)\n# Every response from  your chat bot will automatically go to the\n# simulated user\ngraph_builder.add_edge(\"chat_bot\", \"user\")\ngraph_builder.add_conditional_edges(\n    \"user\",\n    should_continue,\n    # If the finish criteria are met, we will stop the simulation,\n    # otherwise, the virtual user's message will be sent to your chat bot\n    {\n        \"end\": END,\n        \"continue\": \"chat_bot\",\n    },\n)\n# The input will first go to your chat bot\ngraph_builder.add_edge(START, \"chat_bot\")\nsimulation = graph_builder.compile()"]
+   "source": [
+    "from langgraph.graph import END, StateGraph, START\n",
+    "from langgraph.graph.message import add_messages\n",
+    "from typing import Annotated\n",
+    "from typing_extensions import TypedDict\n",
+    "\n",
+    "\n",
+    "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",
+    "# Every response from  your chat bot will automatically go to the\n",
+    "# simulated user\n",
+    "graph_builder.add_edge(\"chat_bot\", \"user\")\n",
+    "graph_builder.add_conditional_edges(\n",
+    "    \"user\",\n",
+    "    should_continue,\n",
+    "    # If the finish criteria are met, we will stop the simulation,\n",
+    "    # otherwise, the virtual user's message will be sent to your chat bot\n",
+    "    {\n",
+    "        \"end\": END,\n",
+    "        \"continue\": \"chat_bot\",\n",
+    "    },\n",
+    ")\n",
+    "# The input will first go to your chat bot\n",
+    "graph_builder.add_edge(START, \"chat_bot\")\n",
+    "simulation = graph_builder.compile()"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -251,15 +392,13 @@
      ]
     }
    ],
-   "source": ["for chunk in simulation.stream([]):\n    # Print out all events aside from the final end chunk\n    if END not in chunk:\n        print(chunk)\n        print(\"----\")"]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "dde4f2b5-cfe8-4ff0-99ea-fe2c5fed70c0",
-   "metadata": {},
-   "outputs": [],
-   "source": [""]
+   "source": [
+    "for chunk in simulation.stream({}):\n",
+    "    # Print out all events aside from the final end chunk\n",
+    "    if END not in chunk:\n",
+    "        print(chunk)\n",
+    "        print(\"----\")"
+   ]
   }
  ],
  "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/chatbots/customer-support.ipynb

@@ -32,7 +32,10 @@
     "scrolled": true
    },
    "outputs": [],
-   "source": ["%%capture --no-stderr\n%pip install -U langgraph langchain-community langchain-openai scikit-learn"]
+   "source": [
+    "%%capture --no-stderr\n",
+    "%pip install -U langgraph langchain-community langchain-openai scikit-learn"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -48,7 +51,15 @@
    "id": "3d1ef253-6b0c-4481-868c-e1fe84f2c8ff",
    "metadata": {},
    "outputs": [],
-   "source": ["import requests\n\nurl = \"https://storage.googleapis.com/benchmarks-artifacts/chinook/Chinook.db\"\nresponse = requests.get(url)\n\nwith open(\"Chinook.db\", \"wb\") as file:\n    file.write(response.content)"]
+   "source": [
+    "import requests\n",
+    "\n",
+    "url = \"https://storage.googleapis.com/benchmarks-artifacts/chinook/Chinook.db\"\n",
+    "response = requests.get(url)\n",
+    "\n",
+    "with open(\"Chinook.db\", \"wb\") as file:\n",
+    "    file.write(response.content)"
+   ]
   },
   {
    "cell_type": "code",
@@ -77,7 +88,12 @@
      "output_type": "execute_result"
     }
    ],
-   "source": ["from langchain_community.utilities import SQLDatabase\n\ndb = SQLDatabase.from_uri(\"sqlite:///Chinook.db\")\ndb.get_usable_table_names()"]
+   "source": [
+    "from langchain_community.utilities import SQLDatabase\n",
+    "\n",
+    "db = SQLDatabase.from_uri(\"sqlite:///Chinook.db\")\n",
+    "db.get_usable_table_names()"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -96,7 +112,11 @@
    "id": "d9ea4e80-30e6-4d46-b480-35f0be2fb055",
    "metadata": {},
    "outputs": [],
-   "source": ["from langchain_openai import ChatOpenAI\n\nmodel = ChatOpenAI(temperature=0, streaming=True, model=\"gpt-4o\")"]
+   "source": [
+    "from langchain_openai import ChatOpenAI\n",
+    "\n",
+    "model = ChatOpenAI(temperature=0, streaming=True, model=\"gpt-4o\")"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -118,7 +138,9 @@
    "id": "ea958e9f-ab1f-49b5-bd85-16332055297c",
    "metadata": {},
    "outputs": [],
-   "source": ["from langchain_core.messages import HumanMessage, SystemMessage"]
+   "source": [
+    "from langchain_core.messages import HumanMessage, SystemMessage"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -137,7 +159,12 @@
    "id": "975b039a",
    "metadata": {},
    "outputs": [],
-   "source": ["# This tool is given to the agent to look up information about a customer\ndef get_customer_info(customer_id: int):\n    \"\"\"Look up customer info given their ID. ALWAYS make sure you have the customer ID before invoking this.\"\"\"\n    return db.run(f\"SELECT * FROM Customer WHERE CustomerID = {customer_id};\")"]
+   "source": [
+    "# This tool is given to the agent to look up information about a customer\n",
+    "def get_customer_info(customer_id: int):\n",
+    "    \"\"\"Look up customer info given their ID. ALWAYS make sure you have the customer ID before invoking this.\"\"\"\n",
+    "    return db.run(f\"SELECT * FROM Customer WHERE CustomerID = {customer_id};\")"
+   ]
   },
   {
    "cell_type": "code",
@@ -145,7 +172,20 @@
    "id": "1d5fa446",
    "metadata": {},
    "outputs": [],
-   "source": ["customer_prompt = \"\"\"Your job is to help a user update their profile.\n\nYou only have certain tools you can use. These tools require specific input. If you don't know the required input, then ask the user for it.\n\nIf you are unable to help the user, you can \"\"\"\n\n\ndef get_customer_messages(messages):\n    return [SystemMessage(content=customer_prompt)] + messages\n\n\ncustomer_chain = get_customer_messages | model.bind_tools([get_customer_info])"]
+   "source": [
+    "customer_prompt = \"\"\"Your job is to help a user update their profile.\n",
+    "\n",
+    "You only have certain tools you can use. These tools require specific input. If you don't know the required input, then ask the user for it.\n",
+    "\n",
+    "If you are unable to help the user, you can \"\"\"\n",
+    "\n",
+    "\n",
+    "def get_customer_messages(messages):\n",
+    "    return [SystemMessage(content=customer_prompt)] + messages\n",
+    "\n",
+    "\n",
+    "customer_chain = get_customer_messages | model.bind_tools([get_customer_info])"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -166,7 +206,19 @@
    "id": "a8604a3b-b484-4b2b-a914-4236cb98c524",
    "metadata": {},
    "outputs": [],
-   "source": ["from langchain_community.vectorstores import SKLearnVectorStore\nfrom langchain_openai import OpenAIEmbeddings\n\nartists = db._execute(\"select * from Artist\")\nsongs = db._execute(\"select * from Track\")\nartist_retriever = SKLearnVectorStore.from_texts(\n    [a[\"Name\"] for a in artists], OpenAIEmbeddings(), metadatas=artists\n).as_retriever()\nsong_retriever = SKLearnVectorStore.from_texts(\n    [a[\"Name\"] for a in songs], OpenAIEmbeddings(), metadatas=songs\n).as_retriever()"]
+   "source": [
+    "from langchain_community.vectorstores import SKLearnVectorStore\n",
+    "from langchain_openai import OpenAIEmbeddings\n",
+    "\n",
+    "artists = db._execute(\"select * from Artist\")\n",
+    "songs = db._execute(\"select * from Track\")\n",
+    "artist_retriever = SKLearnVectorStore.from_texts(\n",
+    "    [a[\"Name\"] for a in artists], OpenAIEmbeddings(), metadatas=artists\n",
+    ").as_retriever()\n",
+    "song_retriever = SKLearnVectorStore.from_texts(\n",
+    "    [a[\"Name\"] for a in songs], OpenAIEmbeddings(), metadatas=songs\n",
+    ").as_retriever()"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -182,7 +234,16 @@
    "id": "0a2a2b74",
    "metadata": {},
    "outputs": [],
-   "source": ["def get_albums_by_artist(artist):\n    \"\"\"Get albums by an artist (or similar artists).\"\"\"\n    docs = artist_retriever.get_relevant_documents(artist)\n    artist_ids = \", \".join([str(d.metadata[\"ArtistId\"]) for d in docs])\n    return db.run(\n        f\"SELECT Title, Name FROM Album LEFT JOIN Artist ON Album.ArtistId = Artist.ArtistId WHERE Album.ArtistId in ({artist_ids});\",\n        include_columns=True,\n    )"]
+   "source": [
+    "def get_albums_by_artist(artist):\n",
+    "    \"\"\"Get albums by an artist (or similar artists).\"\"\"\n",
+    "    docs = artist_retriever.get_relevant_documents(artist)\n",
+    "    artist_ids = \", \".join([str(d.metadata[\"ArtistId\"]) for d in docs])\n",
+    "    return db.run(\n",
+    "        f\"SELECT Title, Name FROM Album LEFT JOIN Artist ON Album.ArtistId = Artist.ArtistId WHERE Album.ArtistId in ({artist_ids});\",\n",
+    "        include_columns=True,\n",
+    "    )"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -198,7 +259,16 @@
    "id": "da533f50",
    "metadata": {},
    "outputs": [],
-   "source": ["def get_tracks_by_artist(artist):\n    \"\"\"Get songs by an artist (or similar artists).\"\"\"\n    docs = artist_retriever.invoke(artist)\n    artist_ids = \", \".join([str(d.metadata[\"ArtistId\"]) for d in docs])\n    return db.run(\n        f\"SELECT Track.Name as SongName, Artist.Name as ArtistName FROM Album LEFT JOIN Artist ON Album.ArtistId = Artist.ArtistId LEFT JOIN Track ON Track.AlbumId = Album.AlbumId WHERE Album.ArtistId in ({artist_ids});\",\n        include_columns=True,\n    )"]
+   "source": [
+    "def get_tracks_by_artist(artist):\n",
+    "    \"\"\"Get songs by an artist (or similar artists).\"\"\"\n",
+    "    docs = artist_retriever.invoke(artist)\n",
+    "    artist_ids = \", \".join([str(d.metadata[\"ArtistId\"]) for d in docs])\n",
+    "    return db.run(\n",
+    "        f\"SELECT Track.Name as SongName, Artist.Name as ArtistName FROM Album LEFT JOIN Artist ON Album.ArtistId = Artist.ArtistId LEFT JOIN Track ON Track.AlbumId = Album.AlbumId WHERE Album.ArtistId in ({artist_ids});\",\n",
+    "        include_columns=True,\n",
+    "    )"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -214,7 +284,11 @@
    "id": "b3c07010",
    "metadata": {},
    "outputs": [],
-   "source": ["def check_for_songs(song_title):\n    \"\"\"Check if a song exists by its name.\"\"\"\n    return song_retriever.invoke(song_title)"]
+   "source": [
+    "def check_for_songs(song_title):\n",
+    "    \"\"\"Check if a song exists by its name.\"\"\"\n",
+    "    return song_retriever.invoke(song_title)"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -230,7 +304,23 @@
    "id": "72a14d5c",
    "metadata": {},
    "outputs": [],
-   "source": ["song_system_message = \"\"\"Your job is to help a customer find any songs they are looking for. \n\nYou only have certain tools you can use. If a customer asks you to look something up that you don't know how, politely tell them what you can help with.\n\nWhen looking up artists and songs, sometimes the artist/song will not be found. In that case, the tools will return information \\\non similar songs and artists. This is intentional, it is not the tool messing up.\"\"\"\n\n\ndef get_song_messages(messages):\n    return [SystemMessage(content=song_system_message)] + messages\n\n\nsong_recc_chain = get_song_messages | model.bind_tools(\n    [get_albums_by_artist, get_tracks_by_artist, check_for_songs]\n)"]
+   "source": [
+    "song_system_message = \"\"\"Your job is to help a customer find any songs they are looking for. \n",
+    "\n",
+    "You only have certain tools you can use. If a customer asks you to look something up that you don't know how, politely tell them what you can help with.\n",
+    "\n",
+    "When looking up artists and songs, sometimes the artist/song will not be found. In that case, the tools will return information \\\n",
+    "on similar songs and artists. This is intentional, it is not the tool messing up.\"\"\"\n",
+    "\n",
+    "\n",
+    "def get_song_messages(messages):\n",
+    "    return [SystemMessage(content=song_system_message)] + messages\n",
+    "\n",
+    "\n",
+    "song_recc_chain = get_song_messages | model.bind_tools(\n",
+    "    [get_albums_by_artist, get_tracks_by_artist, check_for_songs]\n",
+    ")"
+   ]
   },
   {
    "cell_type": "code",
@@ -249,7 +339,10 @@
      "output_type": "execute_result"
     }
    ],
-   "source": ["msgs = [HumanMessage(content=\"hi! can you help me find songs by amy whinehouse?\")]\nsong_recc_chain.invoke(msgs)"]
+   "source": [
+    "msgs = [HumanMessage(content=\"hi! can you help me find songs by amy whinehouse?\")]\n",
+    "song_recc_chain.invoke(msgs)"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -267,7 +360,32 @@
    "id": "73e74268",
    "metadata": {},
    "outputs": [],
-   "source": ["from langchain_core.messages import AIMessage, HumanMessage, SystemMessage\nfrom langchain_core.pydantic_v1 import BaseModel, Field\n\n\nclass Router(BaseModel):\n    \"\"\"Call this if you are able to route the user to the appropriate representative.\"\"\"\n\n    choice: str = Field(description=\"should be one of: music, customer\")\n\n\nsystem_message = \"\"\"Your job is to help as a customer service representative for a music store.\n\nYou should interact politely with customers to try to figure out how you can help. You can help in a few ways:\n\n- Updating user information: if a customer wants to update the information in the user database. Call the router with `customer`\n- Recommending music: if a customer wants to find some music or information about music. Call the router with `music`\n\nIf the user is asking or wants to ask about updating or accessing their information, send them to that route.\nIf the user is asking or wants to ask about music, send them to that route.\nOtherwise, respond.\"\"\"\n\n\ndef get_messages(messages):\n    return [SystemMessage(content=system_message)] + messages"]
+   "source": [
+    "from langchain_core.messages import AIMessage, HumanMessage, SystemMessage\n",
+    "from langchain_core.pydantic_v1 import BaseModel, Field\n",
+    "\n",
+    "\n",
+    "class Router(BaseModel):\n",
+    "    \"\"\"Call this if you are able to route the user to the appropriate representative.\"\"\"\n",
+    "\n",
+    "    choice: str = Field(description=\"should be one of: music, customer\")\n",
+    "\n",
+    "\n",
+    "system_message = \"\"\"Your job is to help as a customer service representative for a music store.\n",
+    "\n",
+    "You should interact politely with customers to try to figure out how you can help. You can help in a few ways:\n",
+    "\n",
+    "- Updating user information: if a customer wants to update the information in the user database. Call the router with `customer`\n",
+    "- Recommending music: if a customer wants to find some music or information about music. Call the router with `music`\n",
+    "\n",
+    "If the user is asking or wants to ask about updating or accessing their information, send them to that route.\n",
+    "If the user is asking or wants to ask about music, send them to that route.\n",
+    "Otherwise, respond.\"\"\"\n",
+    "\n",
+    "\n",
+    "def get_messages(messages):\n",
+    "    return [SystemMessage(content=system_message)] + messages"
+   ]
   },
   {
    "cell_type": "code",
@@ -275,7 +393,9 @@
    "id": "ddf27314",
    "metadata": {},
    "outputs": [],
-   "source": ["chain = get_messages | model.bind_tools([Router])"]
+   "source": [
+    "chain = get_messages | model.bind_tools([Router])"
+   ]
   },
   {
    "cell_type": "code",
@@ -294,7 +414,10 @@
      "output_type": "execute_result"
     }
    ],
-   "source": ["msgs = [HumanMessage(content=\"hi! can you help me find a good song?\")]\nchain.invoke(msgs)"]
+   "source": [
+    "msgs = [HumanMessage(content=\"hi! can you help me find a good song?\")]\n",
+    "chain.invoke(msgs)"
+   ]
   },
   {
    "cell_type": "code",
@@ -313,7 +436,10 @@
      "output_type": "execute_result"
     }
    ],
-   "source": ["msgs = [HumanMessage(content=\"hi! what's the email you have for me?\")]\nchain.invoke(msgs)"]
+   "source": [
+    "msgs = [HumanMessage(content=\"hi! what's the email you have for me?\")]\n",
+    "chain.invoke(msgs)"
+   ]
   },
   {
    "cell_type": "code",
@@ -321,7 +447,15 @@
    "id": "bd6ddd8b-7500-46a7-811d-3bcb937bda51",
    "metadata": {},
    "outputs": [],
-   "source": ["from langchain_core.messages import AIMessage\n\n\ndef add_name(message, name):\n    _dict = message.dict()\n    _dict[\"name\"] = name\n    return AIMessage(**_dict)"]
+   "source": [
+    "from langchain_core.messages import AIMessage\n",
+    "\n",
+    "\n",
+    "def add_name(message, name):\n",
+    "    _dict = message.dict()\n",
+    "    _dict[\"name\"] = name\n",
+    "    return AIMessage(**_dict)"
+   ]
   },
   {
    "cell_type": "code",
@@ -329,7 +463,45 @@
    "id": "27494de5-8345-4c23-bc0e-81e0dd5d47d8",
    "metadata": {},
    "outputs": [],
-   "source": ["import json\n\nfrom langgraph.graph import END, START\n\n\ndef _get_last_ai_message(messages):\n    for m in messages[::-1]:\n        if isinstance(m, AIMessage):\n            return m\n    return None\n\n\ndef _is_tool_call(msg):\n    return hasattr(msg, \"additional_kwargs\") and \"tool_calls\" in msg.additional_kwargs\n\n\ndef _route(messages):\n    last_message = messages[-1]\n    if isinstance(last_message, AIMessage):\n        if not last_message.tool_calls:\n            return END\n        else:\n            if last_message.name == \"general\":\n                if len(last_message.tool_calls) > 1:\n                    raise ValueError(\"Too many tools\")\n                return last_message.tool_calls[0][\"args\"][\"choice\"]\n            else:\n                return \"tools\"\n    last_m = _get_last_ai_message(messages)\n    if last_m is None:\n        return \"general\"\n    if last_m.name == \"music\":\n        return \"music\"\n    elif last_m.name == \"customer\":\n        return \"customer\"\n    else:\n        return \"general\""]
+   "source": [
+    "import json\n",
+    "\n",
+    "from langgraph.graph import END, START\n",
+    "\n",
+    "\n",
+    "def _get_last_ai_message(messages):\n",
+    "    for m in messages[::-1]:\n",
+    "        if isinstance(m, AIMessage):\n",
+    "            return m\n",
+    "    return None\n",
+    "\n",
+    "\n",
+    "def _is_tool_call(msg):\n",
+    "    return hasattr(msg, \"additional_kwargs\") and \"tool_calls\" in msg.additional_kwargs\n",
+    "\n",
+    "\n",
+    "def _route(messages):\n",
+    "    last_message = messages[-1]\n",
+    "    if isinstance(last_message, AIMessage):\n",
+    "        if not last_message.tool_calls:\n",
+    "            return END\n",
+    "        else:\n",
+    "            if last_message.name == \"general\":\n",
+    "                if len(last_message.tool_calls) > 1:\n",
+    "                    raise ValueError(\"Too many tools\")\n",
+    "                return last_message.tool_calls[0][\"args\"][\"choice\"]\n",
+    "            else:\n",
+    "                return \"tools\"\n",
+    "    last_m = _get_last_ai_message(messages)\n",
+    "    if last_m is None:\n",
+    "        return \"general\"\n",
+    "    if last_m.name == \"music\":\n",
+    "        return \"music\"\n",
+    "    elif last_m.name == \"customer\":\n",
+    "        return \"customer\"\n",
+    "    else:\n",
+    "        return \"general\""
+   ]
   },
   {
    "cell_type": "code",
@@ -337,7 +509,12 @@
    "id": "8aec704a-46fe-4fb3-bdee-11c3bbffc370",
    "metadata": {},
    "outputs": [],
-   "source": ["from langgraph.prebuilt import ToolNode\n\ntools = [get_albums_by_artist, get_tracks_by_artist, check_for_songs, get_customer_info]\ntool_node = ToolNode(tools)"]
+   "source": [
+    "from langgraph.prebuilt import ToolNode\n",
+    "\n",
+    "tools = [get_albums_by_artist, get_tracks_by_artist, check_for_songs, get_customer_info]\n",
+    "tool_node = ToolNode(tools)"
+   ]
   },
   {
    "cell_type": "code",
@@ -345,7 +522,16 @@
    "id": "4d5b75c6-73e0-4922-a765-a15be63f869e",
    "metadata": {},
    "outputs": [],
-   "source": ["def _filter_out_routes(messages):\n    ms = []\n    for m in messages:\n        if _is_tool_call(m):\n            if m.name == \"general\":\n                continue\n        ms.append(m)\n    return ms"]
+   "source": [
+    "def _filter_out_routes(messages):\n",
+    "    ms = []\n",
+    "    for m in messages:\n",
+    "        if _is_tool_call(m):\n",
+    "            if m.name == \"general\":\n",
+    "                continue\n",
+    "        ms.append(m)\n",
+    "    return ms"
+   ]
   },
   {
    "cell_type": "code",
@@ -353,7 +539,13 @@
    "id": "fd4dbf98-dbb3-411a-bad6-2bb334072aaf",
    "metadata": {},
    "outputs": [],
-   "source": ["from functools import partial\n\ngeneral_node = _filter_out_routes | chain | partial(add_name, name=\"general\")\nmusic_node = _filter_out_routes | song_recc_chain | partial(add_name, name=\"music\")\ncustomer_node = _filter_out_routes | customer_chain | partial(add_name, name=\"customer\")"]
+   "source": [
+    "from functools import partial\n",
+    "\n",
+    "general_node = _filter_out_routes | chain | partial(add_name, name=\"general\")\n",
+    "music_node = _filter_out_routes | song_recc_chain | partial(add_name, name=\"music\")\n",
+    "customer_node = _filter_out_routes | customer_chain | partial(add_name, name=\"customer\")"
+   ]
   },
   {
    "cell_type": "code",
@@ -361,7 +553,33 @@
    "id": "dcade924",
    "metadata": {},
    "outputs": [],
-   "source": ["from langgraph.checkpoint.sqlite import SqliteSaver\n\nfrom langgraph.graph import MessageGraph\n\nmemory = SqliteSaver.from_conn_string(\":memory:\")\ngraph = MessageGraph()\nnodes = {\n    \"general\": \"general\",\n    \"music\": \"music\",\n    END: END,\n    \"tools\": \"tools\",\n    \"customer\": \"customer\",\n}\n# Define a new graph\nworkflow = MessageGraph()\nworkflow.add_node(\"general\", general_node)\nworkflow.add_node(\"music\", music_node)\nworkflow.add_node(\"customer\", customer_node)\nworkflow.add_node(\"tools\", tool_node)\nworkflow.add_conditional_edges(\"general\", _route, nodes)\nworkflow.add_conditional_edges(\"tools\", _route, nodes)\nworkflow.add_conditional_edges(\"music\", _route, nodes)\nworkflow.add_conditional_edges(\"customer\", _route, nodes)\nworkflow.add_conditional_edges(START, _route, nodes)\ngraph = workflow.compile()"]
+   "source": [
+    "from langgraph.checkpoint.memory import MemorySaver\n",
+    "\n",
+    "from langgraph.graph import MessageGraph\n",
+    "\n",
+    "memory = MemorySaver()\n",
+    "graph = MessageGraph()\n",
+    "nodes = {\n",
+    "    \"general\": \"general\",\n",
+    "    \"music\": \"music\",\n",
+    "    END: END,\n",
+    "    \"tools\": \"tools\",\n",
+    "    \"customer\": \"customer\",\n",
+    "}\n",
+    "# Define a new graph\n",
+    "workflow = MessageGraph()\n",
+    "workflow.add_node(\"general\", general_node)\n",
+    "workflow.add_node(\"music\", music_node)\n",
+    "workflow.add_node(\"customer\", customer_node)\n",
+    "workflow.add_node(\"tools\", tool_node)\n",
+    "workflow.add_conditional_edges(\"general\", _route, nodes)\n",
+    "workflow.add_conditional_edges(\"tools\", _route, nodes)\n",
+    "workflow.add_conditional_edges(\"music\", _route, nodes)\n",
+    "workflow.add_conditional_edges(\"customer\", _route, nodes)\n",
+    "workflow.add_conditional_edges(START, _route, nodes)\n",
+    "graph = workflow.compile()"
+   ]
   },
   {
    "cell_type": "code",
@@ -370,7 +588,7 @@
    "metadata": {},
    "outputs": [
     {
-     "name": "stdin",
+     "name": "stdout",
      "output_type": "stream",
      "text": [
       "User (q/Q to quit):  what music do you have?\n"
@@ -395,7 +613,7 @@
      ]
     },
     {
-     "name": "stdin",
+     "name": "stdout",
      "output_type": "stream",
      "text": [
       "User (q/Q to quit):  how about shakira?\n"
@@ -446,7 +664,7 @@
      ]
     },
     {
-     "name": "stdin",
+     "name": "stdout",
      "output_type": "stream",
      "text": [
       "User (q/Q to quit):  hm cool\n"
@@ -483,7 +701,7 @@
      ]
     },
     {
-     "name": "stdin",
+     "name": "stdout",
      "output_type": "stream",
      "text": [
       "User (q/Q to quit):  q\n"
@@ -497,7 +715,27 @@
      ]
     }
    ],
-   "source": ["import uuid\n\nfrom langchain_core.messages import HumanMessage\n\nfrom langgraph.graph.graph import START\n\nhistory = []\nwhile True:\n    user = input(\"User (q/Q to quit): \")\n    if user in {\"q\", \"Q\"}:\n        print(\"AI: Byebye\")\n        break\n    history.append(HumanMessage(content=user))\n    async for output in graph.astream(history):\n        for key, value in output.items():\n            print(f\"Output from node '{key}':\")\n            print(\"---\")\n            print(value)\n        print(\"\\n---\\n\")"]
+   "source": [
+    "import uuid\n",
+    "\n",
+    "from langchain_core.messages import HumanMessage\n",
+    "\n",
+    "from langgraph.graph.graph import START\n",
+    "\n",
+    "history = []\n",
+    "while True:\n",
+    "    user = input(\"User (q/Q to quit): \")\n",
+    "    if user in {\"q\", \"Q\"}:\n",
+    "        print(\"AI: Byebye\")\n",
+    "        break\n",
+    "    history.append(HumanMessage(content=user))\n",
+    "    async for output in graph.astream(history):\n",
+    "        for key, value in output.items():\n",
+    "            print(f\"Output from node '{key}':\")\n",
+    "            print(\"---\")\n",
+    "            print(value)\n",
+    "        print(\"\\n---\\n\")"
+   ]
   }
  ],
  "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/code_assistant/langgraph_code_assistant_mistral.ipynb

@@ -154,7 +154,7 @@
    "id": "2dff2209-44c7-4e2c-b607-ba6675f9e45f",
    "metadata": {},
    "outputs": [],
-   "source": ["from langgraph.checkpoint.sqlite import SqliteSaver\nfrom langgraph.graph import END, StateGraph, START\n\nbuilder = StateGraph(GraphState)\n\n# Define the nodes\nbuilder.add_node(\"generate\", generate)  # generation solution\nbuilder.add_node(\"check_code\", code_check)  # check code\n\n# Build graph\nbuilder.add_edge(START, \"generate\")\nbuilder.add_edge(\"generate\", \"check_code\")\nbuilder.add_conditional_edges(\n    \"check_code\",\n    decide_to_finish,\n    {\n        \"end\": END,\n        \"generate\": \"generate\",\n    },\n)\n\nmemory = SqliteSaver.from_conn_string(\":memory:\")\ngraph = builder.compile(checkpointer=memory)"]
+   "source": ["from langgraph.checkpoint.memory import MemorySaver\nfrom langgraph.graph import END, StateGraph, START\n\nbuilder = StateGraph(GraphState)\n\n# Define the nodes\nbuilder.add_node(\"generate\", generate)  # generation solution\nbuilder.add_node(\"check_code\", code_check)  # check code\n\n# Build graph\nbuilder.add_edge(START, \"generate\")\nbuilder.add_edge(\"generate\", \"check_code\")\nbuilder.add_conditional_edges(\n    \"check_code\",\n    decide_to_finish,\n    {\n        \"end\": END,\n        \"generate\": \"generate\",\n    },\n)\n\nmemory = MemorySaver()\ngraph = builder.compile(checkpointer=memory)"]
   },
   {
    "cell_type": "code",

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

@@ -1,247 +1,334 @@
 {
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "992c4695-ec4f-428d-bd05-fb3b5fbd70f4",
-   "metadata": {},
-   "source": [
-    "# How to add human-in-the-loop processes to the prebuilt ReAct agent\n",
-    "\n",
-    "This tutorial will show how to add human-in-the-loop processes to the prebuilt ReAct agent. Please see [this tutorial](./create-react-agent.ipynb) for how to get started with the prebuilt ReAct agent\n",
-    "\n",
-    "You can add a a breakpoint before tools are called by passing `interrupt_before=[\"tools\"]` to `create_react_agent`. Note that you need to be using a checkpointer for this to work."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "7be3889f-3c17-4fa1-bd2b-84114a2c7247",
-   "metadata": {},
-   "source": [
-    "## Setup"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "a213e11a-5c62-4ddb-a707-490d91add383",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%%capture --no-stderr\n",
-    "%pip install -U langgraph langchain-openai"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "23a1885c-04ab-4750-aefa-105891fddf3e",
-   "metadata": {},
-   "outputs": [
+  "cells": [
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "OPENAI_API_KEY:  ········\n"
-     ]
-    }
-   ],
-   "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\")\n",
-    "\n",
-    "# Recommended\n",
-    "_set_env(\"LANGCHAIN_API_KEY\")\n",
-    "os.environ[\"LANGCHAIN_TRACING_V2\"] = \"true\"\n",
-    "os.environ[\"LANGCHAIN_PROJECT\"] = \"Create ReAct Agent Tutorial\""
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "03c0f089-070c-4cd4-87e0-6c51f2477b82",
-   "metadata": {},
-   "source": [
-    "## Code"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "7a154152-973e-4b5d-aa13-48c617744a4c",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# First we initialize the model we want to use.\n",
-    "from langchain_openai import ChatOpenAI\n",
-    "\n",
-    "model = ChatOpenAI(model=\"gpt-4o\", temperature=0)\n",
-    "\n",
-    "\n",
-    "# For this tutorial we will use custom tool that returns pre-defined values for weather in two cities (NYC & SF)\n",
-    "\n",
-    "from typing import Literal\n",
-    "\n",
-    "from langchain_core.tools import tool\n",
-    "\n",
-    "\n",
-    "@tool\n",
-    "def get_weather(city: Literal[\"nyc\", \"sf\"]):\n",
-    "    \"\"\"Use this to get weather information.\"\"\"\n",
-    "    if city == \"nyc\":\n",
-    "        return \"It might be cloudy in nyc\"\n",
-    "    elif city == \"sf\":\n",
-    "        return \"It's always sunny in sf\"\n",
-    "    else:\n",
-    "        raise AssertionError(\"Unknown city\")\n",
-    "\n",
-    "\n",
-    "tools = [get_weather]\n",
-    "\n",
-    "# We need a checkpointer to enable human-in-the-loop patterns\n",
-    "from langgraph.checkpoint import MemorySaver\n",
-    "\n",
-    "memory = MemorySaver()\n",
-    "\n",
-    "# Define the graph\n",
-    "\n",
-    "from langgraph.prebuilt import create_react_agent\n",
-    "\n",
-    "graph = create_react_agent(\n",
-    "    model, tools=tools, interrupt_before=[\"tools\"], checkpointer=memory\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "00407425-506d-4ffd-9c86-987921d8c844",
-   "metadata": {},
-   "source": [
-    "## Usage\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "16636975-5f2d-4dc7-ab8e-d0bea0830a28",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def print_stream(stream):\n",
-    "    for s in stream:\n",
-    "        message = s[\"messages\"][-1]\n",
-    "        if isinstance(message, tuple):\n",
-    "            print(message)\n",
-    "        else:\n",
-    "            message.pretty_print()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "9ffff6c3-a4f5-47c9-b51d-97caaee85cd6",
-   "metadata": {},
-   "outputs": [
+      "cell_type": "markdown",
+      "id": "992c4695-ec4f-428d-bd05-fb3b5fbd70f4",
+      "metadata": {},
+      "source": [
+        "# How to add human-in-the-loop processes to the prebuilt ReAct agent\n",
+        "\n",
+        "This tutorial will show how to add human-in-the-loop processes to the prebuilt ReAct agent. Please see [this tutorial](./create-react-agent.ipynb) for how to get started with the prebuilt ReAct agent\n",
+        "\n",
+        "You can add a a breakpoint before tools are called by passing `interrupt_before=[\"tools\"]` to `create_react_agent`. Note that you need to be using a checkpointer for this to work."
+      ]
+    },
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "================================\u001b[1m Human Message \u001b[0m=================================\n",
-      "\n",
-      "What's 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",
-      "  Args:\n",
-      "    city: sf\n"
-     ]
-    }
-   ],
-   "source": [
-    "config = {\"configurable\": {\"thread_id\": \"42\"}}\n",
-    "inputs = {\"messages\": [(\"user\", \"What's the weather in SF?\")]}\n",
-    "\n",
-    "print_stream(graph.stream(inputs, config, stream_mode=\"values\"))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "3decf001-7228-4ed5-8779-2b9ed98a74ea",
-   "metadata": {},
-   "outputs": [
+      "cell_type": "markdown",
+      "id": "7be3889f-3c17-4fa1-bd2b-84114a2c7247",
+      "metadata": {},
+      "source": [
+        "## Setup"
+      ]
+    },
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Next step:  ('tools',)\n"
-     ]
-    }
-   ],
-   "source": [
-    "snapshot = graph.get_state(config)\n",
-    "print(\"Next step: \", snapshot.next)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "83148e08-63e8-49e5-a08b-02dc907bed1d",
-   "metadata": {},
-   "outputs": [
+      "cell_type": "code",
+      "execution_count": 1,
+      "id": "a213e11a-5c62-4ddb-a707-490d91add383",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "%%capture --no-stderr\n",
+        "%pip install -U langgraph langchain-openai"
+      ]
+    },
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "=================================\u001b[1m Tool Message \u001b[0m=================================\n",
-      "Name: get_weather\n",
-      "\n",
-      "It's always sunny in sf\n",
-      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
-      "\n",
-      "The weather in San Francisco is currently sunny.\n"
-     ]
+      "cell_type": "code",
+      "execution_count": 2,
+      "id": "23a1885c-04ab-4750-aefa-105891fddf3e",
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "OPENAI_API_KEY:  ········\n"
+          ]
+        }
+      ],
+      "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\")\n",
+        "\n",
+        "# Recommended\n",
+        "_set_env(\"LANGCHAIN_API_KEY\")\n",
+        "os.environ[\"LANGCHAIN_TRACING_V2\"] = \"true\"\n",
+        "os.environ[\"LANGCHAIN_PROJECT\"] = \"Create ReAct Agent Tutorial\""
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "03c0f089-070c-4cd4-87e0-6c51f2477b82",
+      "metadata": {},
+      "source": [
+        "## Code"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "id": "7a154152-973e-4b5d-aa13-48c617744a4c",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# First we initialize the model we want to use.\n",
+        "from langchain_openai import ChatOpenAI\n",
+        "\n",
+        "model = ChatOpenAI(model=\"gpt-4o\", temperature=0)\n",
+        "\n",
+        "\n",
+        "# For this tutorial we will use custom tool that returns pre-defined values for weather in two cities (NYC & SF)\n",
+        "\n",
+        "from typing import Literal\n",
+        "\n",
+        "from langchain_core.tools import tool\n",
+        "\n",
+        "\n",
+        "@tool\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 location.lower() in [\"sf\", \"san francisco\"]:\n",
+        "        return \"It's always sunny in sf\"\n",
+        "    else:\n",
+        "        raise AssertionError(\"Unknown Location\")\n",
+        "\n",
+        "\n",
+        "tools = [get_weather]\n",
+        "\n",
+        "# We need a checkpointer to enable human-in-the-loop patterns\n",
+        "from langgraph.checkpoint.memory import MemorySaver\n",
+        "\n",
+        "memory = MemorySaver()\n",
+        "\n",
+        "# Define the graph\n",
+        "\n",
+        "from langgraph.prebuilt import create_react_agent\n",
+        "\n",
+        "graph = create_react_agent(\n",
+        "    model, tools=tools, interrupt_before=[\"tools\"], checkpointer=memory\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "00407425-506d-4ffd-9c86-987921d8c844",
+      "metadata": {},
+      "source": [
+        "## Usage\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 2,
+      "id": "16636975-5f2d-4dc7-ab8e-d0bea0830a28",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "def print_stream(stream):\n",
+        "    for s in stream:\n",
+        "        message = s[\"messages\"][-1]\n",
+        "        if isinstance(message, tuple):\n",
+        "            print(message)\n",
+        "        else:\n",
+        "            message.pretty_print()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 3,
+      "id": "9ffff6c3-a4f5-47c9-b51d-97caaee85cd6",
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "================================\u001b[1m Human Message \u001b[0m=================================\n",
+            "\n",
+            "what is the weather in SF?\n",
+            "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+            "Tool Calls:\n",
+            "  get_weather (call_TcDfLuoCKLmQ7eG71SedxLZ6)\n",
+            " Call ID: call_TcDfLuoCKLmQ7eG71SedxLZ6\n",
+            "  Args:\n",
+            "    location: San Francisco, CA\n"
+          ]
+        }
+      ],
+      "source": [
+        "from langchain_core.messages import HumanMessage\n",
+        "config = {\"configurable\": {\"thread_id\": \"42\"}}\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": 4,
+      "id": "3decf001-7228-4ed5-8779-2b9ed98a74ea",
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Next step:  ('tools',)\n"
+          ]
+        }
+      ],
+      "source": [
+        "snapshot = graph.get_state(config)\n",
+        "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": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "=================================\u001b[1m Tool Message \u001b[0m=================================\n",
+            "Name: get_weather\n",
+            "\n",
+            "It's always sunny in sf\n",
+            "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+            "\n",
+            "The weather in San Francisco is currently sunny. Enjoy the sunshine!\n"
+          ]
+        }
+      ],
+      "source": [
+        "print_stream(graph.stream(None, config, stream_mode=\"values\"))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "8202a5f9",
+      "metadata": {},
+      "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": {
+    "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"
     }
-   ],
-   "source": [
-    "print_stream(graph.stream(None, config, stream_mode=\"values\"))"
-   ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "6f6f8965-b016-4e25-be63-31c00fc0a6de",
-   "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
+  "nbformat": 4,
+  "nbformat_minor": 5
 }

examples/create-react-agent-memory.ipynb

@@ -1,255 +1,247 @@
 {
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "992c4695-ec4f-428d-bd05-fb3b5fbd70f4",
-   "metadata": {},
-   "source": [
-    "# How to add memory to the prebuilt ReAct agent\n",
-    "\n",
-    "This tutorial will show how to add memory to the prebuilt ReAct agent. Please see [this tutorial](./create-react-agent.ipynb) for how to get started with the prebuilt ReAct agent\n",
-    "\n",
-    "All we need to do to enable memory is pass in a checkpointer to `create_react_agents`"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "7be3889f-3c17-4fa1-bd2b-84114a2c7247",
-   "metadata": {},
-   "source": [
-    "## Setup"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "a213e11a-5c62-4ddb-a707-490d91add383",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%%capture --no-stderr\n",
-    "%pip install -U langgraph langchain-openai"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "23a1885c-04ab-4750-aefa-105891fddf3e",
-   "metadata": {},
-   "outputs": [
+  "cells": [
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "OPENAI_API_KEY:  ········\n"
-     ]
-    }
-   ],
-   "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\")\n",
-    "\n",
-    "# Recommended\n",
-    "_set_env(\"LANGCHAIN_API_KEY\")\n",
-    "os.environ[\"LANGCHAIN_TRACING_V2\"] = \"true\"\n",
-    "os.environ[\"LANGCHAIN_PROJECT\"] = \"Create ReAct Agent Tutorial\""
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "03c0f089-070c-4cd4-87e0-6c51f2477b82",
-   "metadata": {},
-   "source": [
-    "## Code"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "7a154152-973e-4b5d-aa13-48c617744a4c",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# First we initialize the model we want to use.\n",
-    "from langchain_openai import ChatOpenAI\n",
-    "\n",
-    "model = ChatOpenAI(model=\"gpt-4o\", temperature=0)\n",
-    "\n",
-    "\n",
-    "# For this tutorial we will use custom tool that returns pre-defined values for weather in two cities (NYC & SF)\n",
-    "\n",
-    "from typing import Literal\n",
-    "\n",
-    "from langchain_core.tools import tool\n",
-    "\n",
-    "\n",
-    "@tool\n",
-    "def get_weather(city: Literal[\"nyc\", \"sf\"]):\n",
-    "    \"\"\"Use this to get weather information.\"\"\"\n",
-    "    if city == \"nyc\":\n",
-    "        return \"It might be cloudy in nyc\"\n",
-    "    elif city == \"sf\":\n",
-    "        return \"It's always sunny in sf\"\n",
-    "    else:\n",
-    "        raise AssertionError(\"Unknown city\")\n",
-    "\n",
-    "\n",
-    "tools = [get_weather]\n",
-    "\n",
-    "# We can add \"chat memory\" to the graph with LangGraph's checkpointer\n",
-    "# to retain the chat context between interactions\n",
-    "from langgraph.checkpoint import MemorySaver\n",
-    "\n",
-    "memory = MemorySaver()\n",
-    "\n",
-    "# Define the graph\n",
-    "\n",
-    "from langgraph.prebuilt import create_react_agent\n",
-    "\n",
-    "graph = create_react_agent(model, tools=tools, checkpointer=memory)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "00407425-506d-4ffd-9c86-987921d8c844",
-   "metadata": {},
-   "source": [
-    "## Usage\n",
-    "\n",
-    "Let's interact with it multiple times to show that it can remember"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "16636975-5f2d-4dc7-ab8e-d0bea0830a28",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def print_stream(stream):\n",
-    "    for s in stream:\n",
-    "        message = s[\"messages\"][-1]\n",
-    "        if isinstance(message, tuple):\n",
-    "            print(message)\n",
-    "        else:\n",
-    "            message.pretty_print()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "9ffff6c3-a4f5-47c9-b51d-97caaee85cd6",
-   "metadata": {},
-   "outputs": [
+      "cell_type": "markdown",
+      "id": "992c4695-ec4f-428d-bd05-fb3b5fbd70f4",
+      "metadata": {},
+      "source": [
+        "# How to add memory to the prebuilt ReAct agent\n",
+        "\n",
+        "This tutorial will show how to add memory to the prebuilt ReAct agent. Please see [this tutorial](./create-react-agent.ipynb) for how to get started with the prebuilt ReAct agent\n",
+        "\n",
+        "All we need to do to enable memory is pass in a checkpointer to `create_react_agents`"
+      ]
+    },
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "================================\u001b[1m Human Message \u001b[0m=================================\n",
-      "\n",
-      "What's the weather in NYC?\n",
-      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
-      "Tool Calls:\n",
-      "  get_weather (call_mdovy4yXSSYrmSlnlVSUacVn)\n",
-      " Call ID: call_mdovy4yXSSYrmSlnlVSUacVn\n",
-      "  Args:\n",
-      "    city: nyc\n",
-      "=================================\u001b[1m Tool Message \u001b[0m=================================\n",
-      "Name: get_weather\n",
-      "\n",
-      "It might be cloudy in nyc\n",
-      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
-      "\n",
-      "The weather in NYC might be cloudy.\n"
-     ]
-    }
-   ],
-   "source": [
-    "config = {\"configurable\": {\"thread_id\": \"1\"}}\n",
-    "inputs = {\"messages\": [(\"user\", \"What's the weather in NYC?\")]}\n",
-    "\n",
-    "print_stream(graph.stream(inputs, config=config, stream_mode=\"values\"))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "838a043f-90ad-4e69-9d1d-6e22db2c346c",
-   "metadata": {},
-   "source": [
-    "Notice that when we pass the same the same thread ID, the chat history is preserved"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "187479f9-32fa-4611-9487-cf816ba2e147",
-   "metadata": {},
-   "outputs": [
+      "cell_type": "markdown",
+      "id": "7be3889f-3c17-4fa1-bd2b-84114a2c7247",
+      "metadata": {},
+      "source": [
+        "## Setup"
+      ]
+    },
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "================================\u001b[1m Human Message \u001b[0m=================================\n",
-      "\n",
-      "What's it known for?\n",
-      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
-      "\n",
-      "New York City (NYC) is known for many things, including:\n",
-      "\n",
-      "1. **Landmarks and Attractions**: The Statue of Liberty, Times Square, Central Park, Empire State Building, and Brooklyn Bridge.\n",
-      "2. **Cultural Institutions**: Broadway theaters, Metropolitan Museum of Art, Museum of Modern Art (MoMA), and the American Museum of Natural History.\n",
-      "3. **Diverse Neighborhoods**: Areas like Chinatown, Little Italy, Harlem, and Greenwich Village.\n",
-      "4. **Financial Hub**: Wall Street and the New York Stock Exchange.\n",
-      "5. **Cuisine**: A melting pot of global cuisines, famous for its pizza, bagels, and street food.\n",
-      "6. **Media and Entertainment**: Home to major media companies, TV networks, and film studios.\n",
-      "7. **Fashion**: A global fashion capital, hosting New York Fashion Week.\n",
-      "8. **Sports**: Teams like the New York Yankees, New York Mets, New York Knicks, and New York Rangers.\n",
-      "9. **Public Transportation**: An extensive subway system and iconic yellow taxis.\n",
-      "10. **Events**: New Year's Eve celebration in Times Square, Macy's Thanksgiving Day Parade, and various cultural festivals.\n"
-     ]
+      "cell_type": "code",
+      "execution_count": 1,
+      "id": "a213e11a-5c62-4ddb-a707-490d91add383",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "%%capture --no-stderr\n",
+        "%pip install -U langgraph langchain-openai"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 2,
+      "id": "23a1885c-04ab-4750-aefa-105891fddf3e",
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "OPENAI_API_KEY:  ········\n"
+          ]
+        }
+      ],
+      "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\")\n",
+        "\n",
+        "# Recommended\n",
+        "_set_env(\"LANGCHAIN_API_KEY\")\n",
+        "os.environ[\"LANGCHAIN_TRACING_V2\"] = \"true\"\n",
+        "os.environ[\"LANGCHAIN_PROJECT\"] = \"Create ReAct Agent Tutorial\""
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "03c0f089-070c-4cd4-87e0-6c51f2477b82",
+      "metadata": {},
+      "source": [
+        "## Code"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 3,
+      "id": "7a154152-973e-4b5d-aa13-48c617744a4c",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# First we initialize the model we want to use.\n",
+        "from langchain_openai import ChatOpenAI\n",
+        "\n",
+        "model = ChatOpenAI(model=\"gpt-4o\", temperature=0)\n",
+        "\n",
+        "\n",
+        "# For this tutorial we will use custom tool that returns pre-defined values for weather in two cities (NYC & SF)\n",
+        "\n",
+        "from typing import Literal\n",
+        "\n",
+        "from langchain_core.tools import tool\n",
+        "\n",
+        "\n",
+        "@tool\n",
+        "def get_weather(city: Literal[\"nyc\", \"sf\"]):\n",
+        "    \"\"\"Use this to get weather information.\"\"\"\n",
+        "    if city == \"nyc\":\n",
+        "        return \"It might be cloudy in nyc\"\n",
+        "    elif city == \"sf\":\n",
+        "        return \"It's always sunny in sf\"\n",
+        "    else:\n",
+        "        raise AssertionError(\"Unknown city\")\n",
+        "\n",
+        "\n",
+        "tools = [get_weather]\n",
+        "\n",
+        "# We can add \"chat memory\" to the graph with LangGraph's checkpointer\n",
+        "# to retain the chat context between interactions\n",
+        "from langgraph.checkpoint.memory import MemorySaver\n",
+        "\n",
+        "memory = MemorySaver()\n",
+        "\n",
+        "# Define the graph\n",
+        "\n",
+        "from langgraph.prebuilt import create_react_agent\n",
+        "\n",
+        "graph = create_react_agent(model, tools=tools, checkpointer=memory)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "00407425-506d-4ffd-9c86-987921d8c844",
+      "metadata": {},
+      "source": [
+        "## Usage\n",
+        "\n",
+        "Let's interact with it multiple times to show that it can remember"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 4,
+      "id": "16636975-5f2d-4dc7-ab8e-d0bea0830a28",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "def print_stream(stream):\n",
+        "    for s in stream:\n",
+        "        message = s[\"messages\"][-1]\n",
+        "        if isinstance(message, tuple):\n",
+        "            print(message)\n",
+        "        else:\n",
+        "            message.pretty_print()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 5,
+      "id": "9ffff6c3-a4f5-47c9-b51d-97caaee85cd6",
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "================================\u001b[1m Human Message \u001b[0m=================================\n",
+            "\n",
+            "What's the weather in NYC?\n",
+            "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+            "Tool Calls:\n",
+            "  get_weather (call_mdovy4yXSSYrmSlnlVSUacVn)\n",
+            " Call ID: call_mdovy4yXSSYrmSlnlVSUacVn\n",
+            "  Args:\n",
+            "    city: nyc\n",
+            "=================================\u001b[1m Tool Message \u001b[0m=================================\n",
+            "Name: get_weather\n",
+            "\n",
+            "It might be cloudy in nyc\n",
+            "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+            "\n",
+            "The weather in NYC might be cloudy.\n"
+          ]
+        }
+      ],
+      "source": [
+        "config = {\"configurable\": {\"thread_id\": \"1\"}}\n",
+        "inputs = {\"messages\": [(\"user\", \"What's the weather in NYC?\")]}\n",
+        "\n",
+        "print_stream(graph.stream(inputs, config=config, stream_mode=\"values\"))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "838a043f-90ad-4e69-9d1d-6e22db2c346c",
+      "metadata": {},
+      "source": [
+        "Notice that when we pass the same the same thread ID, the chat history is preserved"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 6,
+      "id": "187479f9-32fa-4611-9487-cf816ba2e147",
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "================================\u001b[1m Human Message \u001b[0m=================================\n",
+            "\n",
+            "What's it known for?\n",
+            "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+            "\n",
+            "New York City (NYC) is known for many things, including:\n",
+            "\n",
+            "1. **Landmarks and Attractions**: The Statue of Liberty, Times Square, Central Park, Empire State Building, and Brooklyn Bridge.\n",
+            "2. **Cultural Institutions**: Broadway theaters, Metropolitan Museum of Art, Museum of Modern Art (MoMA), and the American Museum of Natural History.\n",
+            "3. **Diverse Neighborhoods**: Areas like Chinatown, Little Italy, Harlem, and Greenwich Village.\n",
+            "4. **Financial Hub**: Wall Street and the New York Stock Exchange.\n",
+            "5. **Cuisine**: A melting pot of global cuisines, famous for its pizza, bagels, and street food.\n",
+            "6. **Media and Entertainment**: Home to major media companies, TV networks, and film studios.\n",
+            "7. **Fashion**: A global fashion capital, hosting New York Fashion Week.\n",
+            "8. **Sports**: Teams like the New York Yankees, New York Mets, New York Knicks, and New York Rangers.\n",
+            "9. **Public Transportation**: An extensive subway system and iconic yellow taxis.\n",
+            "10. **Events**: New Year's Eve celebration in Times Square, Macy's Thanksgiving Day Parade, and various cultural festivals.\n"
+          ]
+        }
+      ],
+      "source": [
+        "inputs = {\"messages\": [(\"user\", \"What's it known for?\")]}\n",
+        "print_stream(graph.stream(inputs, config=config, stream_mode=\"values\"))"
+      ]
+    }
+  ],
+  "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"
     }
-   ],
-   "source": [
-    "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": {
-  "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
+  "nbformat": 4,
+  "nbformat_minor": 5
 }

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/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.ipynb

@@ -39,7 +39,10 @@
    "id": "af4ce0ba-7596-4e5f-8bf8-0b0bd6e62833",
    "metadata": {},
    "outputs": [],
-   "source": ["%%capture --no-stderr\n%pip install --quiet -U langgraph langchain_openai"]
+   "source": [
+    "%%capture --no-stderr\n",
+    "%pip install --quiet -U langgraph langchain_openai"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -55,7 +58,18 @@
    "id": "c903a1cf-2977-4e2d-ad7d-8b3946821d89",
    "metadata": {},
    "outputs": [],
-   "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\")"]
+   "source": [
+    "import getpass\n",
+    "import os\n",
+    "\n",
+    "\n",
+    "def _set_env(var: str):\n",
+    "    if not os.environ.get(var):\n",
+    "        os.environ[var] = getpass.getpass(f\"{var}: \")\n",
+    "\n",
+    "\n",
+    "_set_env(\"OPENAI_API_KEY\")"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -71,7 +85,10 @@
    "id": "95e25aec-7c9f-4a63-b143-225d0e9a79c3",
    "metadata": {},
    "outputs": [],
-   "source": ["os.environ[\"LANGCHAIN_TRACING_V2\"] = \"true\"\n_set_env(\"LANGCHAIN_API_KEY\")"]
+   "source": [
+    "os.environ[\"LANGCHAIN_TRACING_V2\"] = \"true\"\n",
+    "_set_env(\"LANGCHAIN_API_KEY\")"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -89,7 +106,22 @@
    "id": "6098e5cb",
    "metadata": {},
    "outputs": [],
-   "source": ["from typing import Annotated\n\nfrom typing_extensions import TypedDict\n\nfrom langgraph.graph.message import add_messages\n\n# `add_messages`` essentially does this\n# (with more robust handling)\n# def add_messages(left: list, right: list):\n#     return left + right\n\n\nclass State(TypedDict):\n    messages: Annotated[list, add_messages]"]
+   "source": [
+    "from typing import Annotated\n",
+    "\n",
+    "from typing_extensions import TypedDict\n",
+    "\n",
+    "from langgraph.graph.message import add_messages\n",
+    "\n",
+    "# `add_messages`` essentially does this\n",
+    "# (with more robust handling)\n",
+    "# def add_messages(left: list, right: list):\n",
+    "#     return left + right\n",
+    "\n",
+    "\n",
+    "class State(TypedDict):\n",
+    "    messages: Annotated[list, add_messages]"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -109,7 +141,22 @@
    "id": "d7ef57dd-5d6e-4ad3-9377-a92201c1310e",
    "metadata": {},
    "outputs": [],
-   "source": ["from langchain_core.tools import tool\n\n\n@tool\ndef search(query: str):\n    \"\"\"Call to surf the web.\"\"\"\n    # This is a placeholder for the actual implementation\n    # Don't let the LLM know this though 😊\n    return [\n        \"It's sunny in San Francisco, but you better look out if you're a Gemini 😈.\"\n    ]\n\n\ntools = [search]"]
+   "source": [
+    "from langchain_core.tools import tool\n",
+    "\n",
+    "\n",
+    "@tool\n",
+    "def search(query: str):\n",
+    "    \"\"\"Call to surf the web.\"\"\"\n",
+    "    # This is a placeholder for the actual implementation\n",
+    "    # Don't let the LLM know this though 😊\n",
+    "    return [\n",
+    "        \"It's sunny in San Francisco, but you better look out if you're a Gemini 😈.\"\n",
+    "    ]\n",
+    "\n",
+    "\n",
+    "tools = [search]"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -127,7 +174,11 @@
    "id": "5cf3331e-ccb3-41c8-aeb9-a840a94d41e7",
    "metadata": {},
    "outputs": [],
-   "source": ["from langgraph.prebuilt import ToolExecutor\n\ntool_executor = ToolExecutor(tools)"]
+   "source": [
+    "from langgraph.prebuilt import ToolExecutor\n",
+    "\n",
+    "tool_executor = ToolExecutor(tools)"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -148,7 +199,11 @@
    "id": "892b54b9-75f0-4804-9ed0-88b5e5532989",
    "metadata": {},
    "outputs": [],
-   "source": ["from langchain_openai import ChatOpenAI\n\nmodel = ChatOpenAI(temperature=0)"]
+   "source": [
+    "from langchain_openai import ChatOpenAI\n",
+    "\n",
+    "model = ChatOpenAI(temperature=0)"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -166,7 +221,9 @@
    "id": "cd3cbae5-d92c-4559-a4aa-44721b80d107",
    "metadata": {},
    "outputs": [],
-   "source": ["model = model.bind_tools(tools)"]
+   "source": [
+    "model = model.bind_tools(tools)"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -201,7 +258,53 @@
    "id": "3b541bb9-900c-40d0-964d-7b5dfee30667",
    "metadata": {},
    "outputs": [],
-   "source": ["from langchain_core.messages import ToolMessage\n\nfrom langgraph.prebuilt import ToolInvocation\n\n\n# Define the function that determines whether to continue or not\ndef should_continue(state):\n    messages = state[\"messages\"]\n    last_message = messages[-1]\n    # If there is no function call, then we finish\n    if not last_message.tool_calls:\n        return \"end\"\n    # Otherwise if there is, we continue\n    else:\n        return \"continue\"\n\n\n# Define the function that calls the model\ndef call_model(state):\n    messages = state[\"messages\"]\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# Define the function to execute tools\ndef call_tool(state):\n    messages = state[\"messages\"]\n    # Based on the continue condition\n    # we know the last message involves a function call\n    last_message = messages[-1]\n    # We construct an ToolInvocation from the function_call\n    tool_call = last_message.tool_calls[0]\n    action = ToolInvocation(\n        tool=tool_call[\"name\"],\n        tool_input=tool_call[\"args\"],\n    )\n    # We call the tool_executor and get back a response\n    response = tool_executor.invoke(action)\n    # We use the response to create a ToolMessage\n    tool_message = ToolMessage(\n        content=str(response), name=action.tool, tool_call_id=tool_call[\"id\"]\n    )\n    # We return a list, because this will get added to the existing list\n    return {\"messages\": [tool_message]}"]
+   "source": [
+    "from langchain_core.messages import ToolMessage\n",
+    "\n",
+    "from langgraph.prebuilt import ToolInvocation\n",
+    "\n",
+    "\n",
+    "# Define the function that determines whether to continue or not\n",
+    "def should_continue(state):\n",
+    "    messages = state[\"messages\"]\n",
+    "    last_message = messages[-1]\n",
+    "    # If there is no function call, then we finish\n",
+    "    if not last_message.tool_calls:\n",
+    "        return \"end\"\n",
+    "    # Otherwise if there is, we continue\n",
+    "    else:\n",
+    "        return \"continue\"\n",
+    "\n",
+    "\n",
+    "# Define the function that calls the model\n",
+    "def call_model(state):\n",
+    "    messages = state[\"messages\"]\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",
+    "# Define the function to execute tools\n",
+    "def call_tool(state):\n",
+    "    messages = state[\"messages\"]\n",
+    "    # Based on the continue condition\n",
+    "    # we know the last message involves a function call\n",
+    "    last_message = messages[-1]\n",
+    "    # We construct an ToolInvocation from the function_call\n",
+    "    tool_call = last_message.tool_calls[0]\n",
+    "    action = ToolInvocation(\n",
+    "        tool=tool_call[\"name\"],\n",
+    "        tool_input=tool_call[\"args\"],\n",
+    "    )\n",
+    "    # We call the tool_executor and get back a response\n",
+    "    response = tool_executor.invoke(action)\n",
+    "    # We use the response to create a ToolMessage\n",
+    "    tool_message = ToolMessage(\n",
+    "        content=str(response), name=action.tool, tool_call_id=tool_call[\"id\"]\n",
+    "    )\n",
+    "    # We return a list, because this will get added to the existing list\n",
+    "    return {\"messages\": [tool_message]}"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -219,7 +322,45 @@
    "id": "812b4e70-4956-4415-8880-db48b3dcbad2",
    "metadata": {},
    "outputs": [],
-   "source": ["from langgraph.graph import END, StateGraph, START\n\n# Define a new graph\nworkflow = StateGraph(State)\n\n# Define the two nodes we will cycle between\nworkflow.add_node(\"agent\", call_model)\nworkflow.add_node(\"action\", call_tool)\n\n# Set the entrypoint as `agent`\n# This means that this node is the first one called\nworkflow.add_edge(START, \"agent\")\n\n# We now add a conditional edge\nworkflow.add_conditional_edges(\n    # First, we define the start node. We use `agent`.\n    # This means these are the edges taken after the `agent` node is called.\n    \"agent\",\n    # Next, we pass in the function that will determine which node is called next.\n    should_continue,\n    # Finally we pass in a mapping.\n    # The keys are strings, and the values are other nodes.\n    # END is a special node marking that the graph should finish.\n    # What will happen is we will call `should_continue`, and then the output of that\n    # will be matched against the keys in this mapping.\n    # Based on which one it matches, that node will then be called.\n    {\n        # If `tools`, then we call the tool node.\n        \"continue\": \"action\",\n        # Otherwise we finish.\n        \"end\": END,\n    },\n)\n\n# We now add a normal edge from `tools` to `agent`.\n# This means that after `tools` is called, `agent` node is called next.\nworkflow.add_edge(\"action\", \"agent\")"]
+   "source": [
+    "from langgraph.graph import END, StateGraph, START\n",
+    "\n",
+    "# Define a new graph\n",
+    "workflow = StateGraph(State)\n",
+    "\n",
+    "# Define the two nodes we will cycle between\n",
+    "workflow.add_node(\"agent\", call_model)\n",
+    "workflow.add_node(\"action\", call_tool)\n",
+    "\n",
+    "# Set the entrypoint as `agent`\n",
+    "# This means that this node is the first one called\n",
+    "workflow.add_edge(START, \"agent\")\n",
+    "\n",
+    "# We now add a conditional edge\n",
+    "workflow.add_conditional_edges(\n",
+    "    # First, we define the start node. We use `agent`.\n",
+    "    # This means these are the edges taken after the `agent` node is called.\n",
+    "    \"agent\",\n",
+    "    # Next, we pass in the function that will determine which node is called next.\n",
+    "    should_continue,\n",
+    "    # Finally we pass in a mapping.\n",
+    "    # The keys are strings, and the values are other nodes.\n",
+    "    # END is a special node marking that the graph should finish.\n",
+    "    # What will happen is we will call `should_continue`, and then the output of that\n",
+    "    # will be matched against the keys in this mapping.\n",
+    "    # Based on which one it matches, that node will then be called.\n",
+    "    {\n",
+    "        # If `tools`, then we call the tool node.\n",
+    "        \"continue\": \"action\",\n",
+    "        # Otherwise we finish.\n",
+    "        \"end\": END,\n",
+    "    },\n",
+    ")\n",
+    "\n",
+    "# We now add a normal edge from `tools` to `agent`.\n",
+    "# This means that after `tools` is called, `agent` node is called next.\n",
+    "workflow.add_edge(\"action\", \"agent\")"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -237,7 +378,11 @@
    "id": "6845ed6a-d155-4105-9160-28849877248b",
    "metadata": {},
    "outputs": [],
-   "source": ["from langgraph.checkpoint.sqlite import SqliteSaver\n\nmemory = SqliteSaver.from_conn_string(\":memory:\")"]
+   "source": [
+    "from langgraph.checkpoint.memory import MemorySaver\n",
+    "\n",
+    "memory = MemorySaver()"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -255,7 +400,12 @@
    "id": "79d29875-8aa8-434c-9f20-1c58346a6249",
    "metadata": {},
    "outputs": [],
-   "source": ["# Finally, we compile it!\n# This compiles it into a LangChain Runnable,\n# meaning you can use it as you would any other runnable\napp = workflow.compile(checkpointer=memory, interrupt_before=[\"action\"])"]
+   "source": [
+    "# Finally, we compile it!\n",
+    "# This compiles it into a LangChain Runnable,\n",
+    "# meaning you can use it as you would any other runnable\n",
+    "app = workflow.compile(checkpointer=memory, interrupt_before=[\"action\"])"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -282,7 +432,11 @@
      "output_type": "display_data"
     }
    ],
-   "source": ["from IPython.display import Image, display\n\ndisplay(Image(app.get_graph().draw_mermaid_png()))"]
+   "source": [
+    "from IPython.display import Image, display\n",
+    "\n",
+    "display(Image(app.get_graph().draw_mermaid_png()))"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -313,7 +467,14 @@
      ]
     }
    ],
-   "source": ["from langchain_core.messages import HumanMessage\n\nthread = {\"configurable\": {\"thread_id\": \"2\"}}\ninputs = [HumanMessage(content=\"hi! I'm bob\")]\nfor event in app.stream({\"messages\": inputs}, thread, stream_mode=\"values\"):\n    event[\"messages\"][-1].pretty_print()"]
+   "source": [
+    "from langchain_core.messages import HumanMessage\n",
+    "\n",
+    "thread = {\"configurable\": {\"thread_id\": \"2\"}}\n",
+    "inputs = [HumanMessage(content=\"hi! I'm bob\")]\n",
+    "for event in app.stream({\"messages\": inputs}, thread, stream_mode=\"values\"):\n",
+    "    event[\"messages\"][-1].pretty_print()"
+   ]
   },
   {
    "cell_type": "code",
@@ -334,7 +495,11 @@
      ]
     }
    ],
-   "source": ["inputs = [HumanMessage(content=\"What did I tell you my name was?\")]\nfor event in app.stream({\"messages\": inputs}, thread, stream_mode=\"values\"):\n    event[\"messages\"][-1].pretty_print()"]
+   "source": [
+    "inputs = [HumanMessage(content=\"What did I tell you my name was?\")]\n",
+    "for event in app.stream({\"messages\": inputs}, thread, stream_mode=\"values\"):\n",
+    "    event[\"messages\"][-1].pretty_print()"
+   ]
   },
   {
    "cell_type": "code",
@@ -358,7 +523,11 @@
      ]
     }
    ],
-   "source": ["inputs = [HumanMessage(content=\"what's the weather in sf now?\")]\nfor event in app.stream({\"messages\": inputs}, thread, stream_mode=\"values\"):\n    event[\"messages\"][-1].pretty_print()"]
+   "source": [
+    "inputs = [HumanMessage(content=\"what's the weather in sf now?\")]\n",
+    "for event in app.stream({\"messages\": inputs}, thread, stream_mode=\"values\"):\n",
+    "    event[\"messages\"][-1].pretty_print()"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -392,7 +561,10 @@
      ]
     }
    ],
-   "source": ["for event in app.stream(None, thread, stream_mode=\"values\"):\n    event[\"messages\"][-1].pretty_print()"]
+   "source": [
+    "for event in app.stream(None, thread, stream_mode=\"values\"):\n",
+    "    event[\"messages\"][-1].pretty_print()"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -427,7 +599,43 @@
    "id": "5454f436-d56e-4499-9381-06192aca1b56",
    "metadata": {},
    "outputs": [],
-   "source": ["import json\nfrom typing import Optional\n\nfrom langchain_core.messages import AIMessage\n\n\n# Helper function to construct message asking for verification\ndef generate_verification_message(message: AIMessage) -> None:\n    \"\"\"Generate \"verification message\" from message with tool calls.\"\"\"\n    serialized_tool_calls = json.dumps(\n        message.tool_calls,\n        indent=2,\n    )\n    return AIMessage(\n        content=(\n            \"I plan to invoke the following tools, do you approve?\\n\\n\"\n            \"Type 'y' if you do, anything else to stop.\\n\\n\"\n            f\"{serialized_tool_calls}\"\n        ),\n        id=message.id,\n    )\n\n\n# Helper function to stream output from the graph\ndef stream_app_catch_tool_calls(inputs, thread) -> Optional[AIMessage]:\n    \"\"\"Stream app, catching tool calls.\"\"\"\n    tool_call_message = None\n    for event in app.stream(inputs, thread, stream_mode=\"values\"):\n        message = event[\"messages\"][-1]\n        if isinstance(message, AIMessage) and message.tool_calls:\n            tool_call_message = message\n        else:\n            message.pretty_print()\n\n    return tool_call_message"]
+   "source": [
+    "import json\n",
+    "from typing import Optional\n",
+    "\n",
+    "from langchain_core.messages import AIMessage\n",
+    "\n",
+    "\n",
+    "# Helper function to construct message asking for verification\n",
+    "def generate_verification_message(message: AIMessage) -> None:\n",
+    "    \"\"\"Generate \"verification message\" from message with tool calls.\"\"\"\n",
+    "    serialized_tool_calls = json.dumps(\n",
+    "        message.tool_calls,\n",
+    "        indent=2,\n",
+    "    )\n",
+    "    return AIMessage(\n",
+    "        content=(\n",
+    "            \"I plan to invoke the following tools, do you approve?\\n\\n\"\n",
+    "            \"Type 'y' if you do, anything else to stop.\\n\\n\"\n",
+    "            f\"{serialized_tool_calls}\"\n",
+    "        ),\n",
+    "        id=message.id,\n",
+    "    )\n",
+    "\n",
+    "\n",
+    "# Helper function to stream output from the graph\n",
+    "def stream_app_catch_tool_calls(inputs, thread) -> Optional[AIMessage]:\n",
+    "    \"\"\"Stream app, catching tool calls.\"\"\"\n",
+    "    tool_call_message = None\n",
+    "    for event in app.stream(inputs, thread, stream_mode=\"values\"):\n",
+    "        message = event[\"messages\"][-1]\n",
+    "        if isinstance(message, AIMessage) and message.tool_calls:\n",
+    "            tool_call_message = message\n",
+    "        else:\n",
+    "            message.pretty_print()\n",
+    "\n",
+    "    return tool_call_message"
+   ]
   },
   {
    "cell_type": "code",
@@ -514,7 +722,43 @@
      ]
     }
    ],
-   "source": ["import uuid\n\nthread = {\"configurable\": {\"thread_id\": \"3\"}}\n\ntool_call_message = stream_app_catch_tool_calls(\n    {\"messages\": [HumanMessage(\"what's the weather in sf now?\")]},\n    thread,\n)\n\nwhile tool_call_message:\n    verification_message = generate_verification_message(tool_call_message)\n    verification_message.pretty_print()\n    input_message = HumanMessage(input())\n    if input_message.content == \"exit\":\n        break\n    input_message.pretty_print()\n\n    # First we update the state with the verification message and the input message.\n    # note that `generate_verification_message` sets the message ID to be the same\n    # as the ID from the original tool call message. Updating the state with this\n    # message will overwrite the previous tool call.\n    snapshot = app.get_state(thread)\n    snapshot.values[\"messages\"] += [verification_message, input_message]\n\n    if input_message.content == \"y\":\n        tool_call_message.id = str(uuid.uuid4())\n        # If verified, we append the tool call message to the state\n        # and resume execution.\n        snapshot.values[\"messages\"] += [tool_call_message]\n        app.update_state(thread, snapshot.values, as_node=\"agent\")\n    else:\n        # Otherwise, resume execution from the input message.\n        app.update_state(thread, snapshot.values, as_node=\"__start__\")\n\n    tool_call_message = stream_app_catch_tool_calls(None, thread)"]
+   "source": [
+    "import uuid\n",
+    "\n",
+    "thread = {\"configurable\": {\"thread_id\": \"3\"}}\n",
+    "\n",
+    "tool_call_message = stream_app_catch_tool_calls(\n",
+    "    {\"messages\": [HumanMessage(\"what's the weather in sf now?\")]},\n",
+    "    thread,\n",
+    ")\n",
+    "\n",
+    "while tool_call_message:\n",
+    "    verification_message = generate_verification_message(tool_call_message)\n",
+    "    verification_message.pretty_print()\n",
+    "    input_message = HumanMessage(input())\n",
+    "    if input_message.content == \"exit\":\n",
+    "        break\n",
+    "    input_message.pretty_print()\n",
+    "\n",
+    "    # First we update the state with the verification message and the input message.\n",
+    "    # note that `generate_verification_message` sets the message ID to be the same\n",
+    "    # as the ID from the original tool call message. Updating the state with this\n",
+    "    # message will overwrite the previous tool call.\n",
+    "    snapshot = app.get_state(thread)\n",
+    "    snapshot.values[\"messages\"] += [verification_message, input_message]\n",
+    "\n",
+    "    if input_message.content == \"y\":\n",
+    "        tool_call_message.id = str(uuid.uuid4())\n",
+    "        # If verified, we append the tool call message to the state\n",
+    "        # and resume execution.\n",
+    "        snapshot.values[\"messages\"] += [tool_call_message]\n",
+    "        app.update_state(thread, snapshot.values, as_node=\"agent\")\n",
+    "    else:\n",
+    "        # Otherwise, resume execution from the input message.\n",
+    "        app.update_state(thread, snapshot.values, as_node=\"__start__\")\n",
+    "\n",
+    "    tool_call_message = stream_app_catch_tool_calls(None, thread)"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -535,7 +779,34 @@
    "id": "03232f16-d6fe-46d0-afa0-a6f0d0bf16de",
    "metadata": {},
    "outputs": [],
-   "source": ["class State(TypedDict):\n    messages: Annotated[list, add_messages]\n    tool_call_message: Optional[AIMessage]\n\n\ndef call_model(state):\n    messages = state[\"messages\"]\n    if messages[-1].content == \"y\":\n        return {\n            \"messages\": [state[\"tool_call_message\"]],\n            \"tool_call_message\": None,\n        }\n    else:\n        response = model.invoke(messages)\n        if response.tool_calls:\n            verification_message = generate_verification_message(response)\n            response.id = str(uuid.uuid4())\n            return {\n                \"messages\": [verification_message],\n                \"tool_call_message\": response,\n            }\n        else:\n            return {\n                \"messages\": [response],\n                \"tool_call_message\": None,\n            }"]
+   "source": [
+    "class State(TypedDict):\n",
+    "    messages: Annotated[list, add_messages]\n",
+    "    tool_call_message: Optional[AIMessage]\n",
+    "\n",
+    "\n",
+    "def call_model(state):\n",
+    "    messages = state[\"messages\"]\n",
+    "    if messages[-1].content == \"y\":\n",
+    "        return {\n",
+    "            \"messages\": [state[\"tool_call_message\"]],\n",
+    "            \"tool_call_message\": None,\n",
+    "        }\n",
+    "    else:\n",
+    "        response = model.invoke(messages)\n",
+    "        if response.tool_calls:\n",
+    "            verification_message = generate_verification_message(response)\n",
+    "            response.id = str(uuid.uuid4())\n",
+    "            return {\n",
+    "                \"messages\": [verification_message],\n",
+    "                \"tool_call_message\": response,\n",
+    "            }\n",
+    "        else:\n",
+    "            return {\n",
+    "                \"messages\": [response],\n",
+    "                \"tool_call_message\": None,\n",
+    "            }"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -551,7 +822,27 @@
    "id": "502dc688-c926-407e-8759-8c9e39eb4257",
    "metadata": {},
    "outputs": [],
-   "source": ["workflow = StateGraph(State)\n\nworkflow.add_node(\"agent\", call_model)\nworkflow.add_node(\"action\", call_tool)\n\nworkflow.add_edge(START, \"agent\")\n\nworkflow.add_conditional_edges(\n    \"agent\",\n    should_continue,\n    {\n        \"continue\": \"action\",\n        \"end\": END,\n    },\n)\n\nworkflow.add_edge(\"action\", \"agent\")\n\napp = workflow.compile(checkpointer=memory)"]
+   "source": [
+    "workflow = StateGraph(State)\n",
+    "\n",
+    "workflow.add_node(\"agent\", call_model)\n",
+    "workflow.add_node(\"action\", call_tool)\n",
+    "\n",
+    "workflow.add_edge(START, \"agent\")\n",
+    "\n",
+    "workflow.add_conditional_edges(\n",
+    "    \"agent\",\n",
+    "    should_continue,\n",
+    "    {\n",
+    "        \"continue\": \"action\",\n",
+    "        \"end\": END,\n",
+    "    },\n",
+    ")\n",
+    "\n",
+    "workflow.add_edge(\"action\", \"agent\")\n",
+    "\n",
+    "app = workflow.compile(checkpointer=memory)"
+   ]
   },
   {
    "cell_type": "code",
@@ -584,7 +875,13 @@
      ]
     }
    ],
-   "source": ["thread = {\"configurable\": {\"thread_id\": \"4\"}}\n\ninputs = [HumanMessage(content=\"what's the weather in sf?\")]\nfor event in app.stream({\"messages\": inputs}, thread, stream_mode=\"values\"):\n    event[\"messages\"][-1].pretty_print()"]
+   "source": [
+    "thread = {\"configurable\": {\"thread_id\": \"4\"}}\n",
+    "\n",
+    "inputs = [HumanMessage(content=\"what's the weather in sf?\")]\n",
+    "for event in app.stream({\"messages\": inputs}, thread, stream_mode=\"values\"):\n",
+    "    event[\"messages\"][-1].pretty_print()"
+   ]
   },
   {
    "cell_type": "code",
@@ -617,7 +914,11 @@
      ]
     }
    ],
-   "source": ["inputs = [HumanMessage(content=\"can you specify sf in CA?\")]\nfor event in app.stream({\"messages\": inputs}, thread, stream_mode=\"values\"):\n    event[\"messages\"][-1].pretty_print()"]
+   "source": [
+    "inputs = [HumanMessage(content=\"can you specify sf in CA?\")]\n",
+    "for event in app.stream({\"messages\": inputs}, thread, stream_mode=\"values\"):\n",
+    "    event[\"messages\"][-1].pretty_print()"
+   ]
   },
   {
    "cell_type": "code",
@@ -648,7 +949,11 @@
      ]
     }
    ],
-   "source": ["inputs = [HumanMessage(content=\"y\")]\nfor event in app.stream({\"messages\": inputs}, thread, stream_mode=\"values\"):\n    event[\"messages\"][-1].pretty_print()"]
+   "source": [
+    "inputs = [HumanMessage(content=\"y\")]\n",
+    "for event in app.stream({\"messages\": inputs}, thread, stream_mode=\"values\"):\n",
+    "    event[\"messages\"][-1].pretty_print()"
+   ]
   }
  ],
  "metadata": {