cli: release 0.1.52 (#1516)

feat(cli): add building support for JS

.github/ISSUE_TEMPLATE/bug-report.yml

@@ -1,5 +1,5 @@
 name: "\U0001F41B Bug Report"
-description: Report a bug in LangChain. To report a security issue, please instead use the security option below. For questions, please use the GitHub Discussions.
+description: Report a bug in LangGraph. To report a security issue, please instead use the security option below. For questions, please use the GitHub Discussions.
 labels: ["02 Bug Report"]
 body:
   - type: markdown
@@ -15,11 +15,11 @@ body:
         Relevant links to check before filing a bug report to see if your issue has already been reported, fixed or
         if there's another way to solve your problem:
         
+        [LangGraph documentation](https://langchain-ai.github.io/langgraph/).
         [LangChain documentation with the integrated search](https://python.langchain.com/docs/get_started/introduction),
-        [API Reference](https://api.python.langchain.com/en/stable/),
-        [GitHub search](https://github.com/langchain-ai/langchain),
-        [LangChain Github Discussions](https://github.com/langchain-ai/langchain/discussions),
-        [LangChain Github Issues](https://github.com/langchain-ai/langchain/issues?q=is%3Aissue),
+        [GitHub search](https://github.com/langchain-ai/langgraph),
+        [LangChain Github Discussions](https://github.com/langchain-ai/langgraph/discussions),
+        [LangChain Github Issues](https://github.com/langchain-ai/langgraph/issues),
         [LangChain ChatBot](https://chat.langchain.com/)
   - type: checkboxes
     id: checks
@@ -54,13 +54,13 @@ body:
         * Avoid screenshots when possible, as they are hard to read and (more importantly) don't allow others to copy-and-paste your code.
 
       placeholder: |
-        from langchain_core.runnables import RunnableLambda
+        from langgraph.graph import StateGraph
 
         def bad_code(inputs) -> int:
           raise NotImplementedError('For demo purpose')
           
-          chain = RunnableLambda(bad_code)
-          chain.invoke('Hello!')
+        chain = StateGraph(list)
+        chain.invoke('Hello!')
       render: python
   - type: textarea
     id: error
@@ -82,7 +82,7 @@ body:
 
         Write a short description telling what you are doing, what you expect to happen, and what is currently happening.
       placeholder: |
-        * I'm trying to use the `langchain` library to do X.
+        * I'm trying to use the `langgraph` library to do X.
         * I expect to see Y.
         * Instead, it does Z.
     validations:
@@ -102,7 +102,7 @@ body:
         
         python -m langchain_core.sys_info
       placeholder: |
-        "pip freeze | grep langchain"
+        "pip freeze | grep langgraph"
         platform
         python version
         

.github/ISSUE_TEMPLATE/config.yml

@@ -3,13 +3,13 @@ version: 2.1
 contact_links:
   - name: 🤔 Question or Problem
     about: Ask a question or ask about a problem in GitHub Discussions.
-    url: https://www.github.com/langchain-ai/langchain/discussions/categories/q-a
-  - name: Discord
-    url: https://discord.gg/6adMQxSpJS
-    about: General community discussions
+    url: https://github.com/langchain-ai/langgraph/discussions/categories/q-a
   - name: Feature Request
-    url: https://www.github.com/langchain-ai/langchain/discussions/categories/ideas
+    url: https://github.com/langchain-ai/langgraph/discussions/categories/ideas
     about: Suggest a feature or an idea
   - name: Show and tell
     about: Show what you built with LangChain
-    url: https://www.github.com/langchain-ai/langchain/discussions/categories/show-and-tell
+    url: https://github.com/langchain-ai/langgraph/discussions/categories/show-and-tell
+  - name: Slack
+    url:  https://www.langchain.com/join-community
+    about: General community discussions

.github/ISSUE_TEMPLATE/documentation.yml

@@ -1,5 +1,5 @@
 name: Documentation
-description: Report an issue related to the LangChain documentation.
+description: Report an issue related to the LangGraph documentation.
 title: "DOC: <Please write a comprehensive title after the 'DOC: ' prefix>"
 labels: [03 - Documentation]
 

.github/workflows/_test.yml

@@ -24,13 +24,7 @@ jobs:
     name: "test #${{ matrix.python-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 +33,17 @@ 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
 
       - 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

Makefile

@@ -1,6 +1,14 @@
-.PHONY: build-docs serve-docs serve-clean-docs clean-docs codespell
+.PHONY: build-docs serve-docs serve-clean-docs clean-docs codespell build-typedoc
 
-build-docs:
+build-typedoc:
+	cd libs/sdk-js && yarn install --include-dev && yarn typedoc
+	cd libs/sdk-js && yarn --silent concat-md --decrease-title-levels --ignore=js_ts_sdk_ref.md --start-title-level-at 2 docs > ../../docs/docs/cloud/reference/sdk/js_ts_sdk_ref.md 2>/dev/null
+	#  Add links to the monorepo
+	sed -e '1,10s|@langchain/langgraph-sdk|[@langchain/langgraph-sdk](https://github.com/langchain-ai/langgraph/tree/main/libs/sdk-js)|g' docs/docs/cloud/reference/sdk/js_ts_sdk_ref.md > temp_file && mv temp_file docs/docs/cloud/reference/sdk/js_ts_sdk_ref.md
+
+
+
+build-docs: build-typedoc
 	poetry run python docs/_scripts/copy_notebooks.py
 	poetry run python -m mkdocs build --clean -f docs/mkdocs.yml --strict
 
@@ -8,7 +16,7 @@ serve-clean-docs: clean-docs
 	poetry run python docs/_scripts/copy_notebooks.py
 	poetry run python -m mkdocs serve -c -f docs/mkdocs.yml --strict -w ./libs/langgraph
 
-serve-docs:
+serve-docs: build-typedoc
 	poetry run python docs/_scripts/copy_notebooks.py
 	poetry run python -m mkdocs serve -f docs/mkdocs.yml -w ./libs/langgraph --dirty
 

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
 
 
@@ -73,8 +69,8 @@ def search(query: str):
     """Call to surf the web."""
     # This is a placeholder, but don't tell the LLM that...
     if "sf" in query.lower() or "san francisco" in query.lower():
-        return ["It's 60 degrees and foggy."]
-    return ["It's 90 degrees and sunny."]
+        return "It's 60 degrees and foggy."
+    return "It's 90 degrees and sunny."
 
 
 tools = [search]
@@ -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/.gitignore

@@ -1,2 +1,4 @@
 *.ipynb
 site/
+docs/tutorials/**/*.png
+docs/cloud/reference/sdk/js_ts_sdk_ref.md

docs/_scripts/copy_notebooks.py

@@ -21,17 +21,30 @@ _MANUAL = {
         "stream-updates.ipynb",
         "stream-multiple.ipynb",
         "streaming-tokens.ipynb",
+        "streaming-tokens-without-langchain.ipynb",
         "streaming-content.ipynb",
         "streaming-events-from-within-tools.ipynb",
+        "streaming-events-from-within-tools-without-langchain.ipynb",
         "streaming-from-final-node.ipynb",
         "persistence.ipynb",
-        "managing-conversation-history.ipynb",
+        "input_output_schema.ipynb",
+        "pass_private_state.ipynb",
+        "memory/manage-conversation-history.ipynb",
+        "memory/delete-messages.ipynb",
+        "memory/add-summary-conversation-history.ipynb",
         "persistence_postgres.ipynb",
+        "persistence_mongodb.ipynb",
+        "persistence_redis.ipynb",
         "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",
@@ -44,9 +57,13 @@ _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-agent-structured-output.ipynb",
     ],
     "tutorials": [
         "introduction.ipynb",
@@ -82,13 +99,14 @@ _HIDE = set(
         "dynamically-returning-directly.ipynb",
         "force-calling-a-tool-first.ipynb",
         "managing-agent-steps.ipynb",
-        "pass-run-time-values-to-tools.ipynb",
         "respond-in-format.ipynb",
         "quickstart.ipynb",
         "human-in-the-loop.ipynb",
         "learning.ipynb",
         "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
 
@@ -37,7 +41,7 @@ It's often useful to run graphs on some schedule. LangGraph Cloud supports cron
 
 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.
 
-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
 
@@ -55,7 +59,7 @@ Streaming is critical for making LLM applications feel responsive to end users.
 
 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.
 
 ### Human-in-the-Loop
 
@@ -63,7 +67,7 @@ There are many occasions where the graph cannot run completely autonomously. For
 
 ### Double Texting
 
-Many times users might interact with your graph in unintended ways. For instance, a user may send one message and before the graph has finished running send a second message. To solve this issue of "double-texting" (i.e. prompting the graph a second time before the first run has finished), Langgraph has provided four different solutions, all of which are covered in the [Double Texting how-tos](../how-tos/index.md#double-texting). These options are:
+Many times users might interact with your graph in unintended ways. For instance, a user may send one message and before the graph has finished running send a second message. To solve this issue of "double-texting" (i.e. prompting the graph a second time before the first run has finished), LangGraph has provided four different solutions, all of which are covered in the [Double Texting how-tos](../how-tos/index.md#double-texting). These options are:
 
 - `reject`: This is the simplest option, this just rejects any follow up runs and does not allow double texting. See the [how-to guide](../how-tos/reject_concurrent.md) for configuring the reject double text option.
 - `enqueue`: This is a relatively simple option which continues the first run until it completes the whole run, then sends the new input as a separate run. See the [how-to guide](../how-tos/enqueue_concurrent.md) for configuring the enqueue double text option.
@@ -101,3 +105,7 @@ The LangGraph Cloud offers several features to support secure and robost deploym
 ### Authentication
 
 LangGraph applications deployed to LangGraph Cloud are automatically configured with LangSmith authentication. In order to call the API, a valid <a href="https://docs.smith.langchain.com/how_to_guides/setup/create_account_api_key#api-keys" target="_blank">LangSmith API key</a> is required.
+
+### Local Testing
+
+Before deploying your app in production to LangGraph Cloud, you may wish to test out your graph locally in order to ensure that everything is running as expected. Luckily, LangGraph makes this easy for you through use of the LangGraph CLI. Read more in this [how-to guide](../deployment/test_locally.md) or look at the [CLI reference](../reference/cli.md) to learn more.

docs/docs/cloud/concepts/cloud.md

@@ -0,0 +1,28 @@
+# Cloud Concepts
+
+This page describes the high-level concepts of the LangGraph Cloud deployment.
+
+## Deployment
+
+A deployment is an instance of a LangGraph API. A single deployment can have many [revisions](#revision). When a deployment is created, all of the necessary infrastructure (e.g. database, containers, secrets store) are automatically provisioned. See the [architecture diagram](#architecture) below for more details.
+
+See the [how-to guide](../deployment/cloud.md#create-new-deployment) for creating a new deployment.
+
+## Revision
+
+A revision is an iteration of a [deployment](#deployment). When a new deployment is created, an initial revision is automatically created. To deploy new code changes or update environment variable configurations for a deployment, a new revision must be created. When a revision is created, a new container image is built automatically.
+
+See the [how-to guide](../deployment/cloud.md#create-new-revision) for creating a new revision.
+
+## Asynchronous Deployment
+
+Infrastructure for [deployments](#deployment) and [revisions](#revision) are provisioned and deployed asynchronously. They are not deployed immediately after submission. Currently, deployment can take up to several minutes.
+
+## Architecture
+
+!!! warning "Subject to Change"
+    The LangGraph Cloud deployment architecture may change in the future.
+
+A high-level diagram of a LangGraph Cloud deployment.
+
+![diagram](langgraph_cloud_architecture.png)

docs/docs/cloud/deployment/cloud.md

@@ -2,9 +2,10 @@
 
 LangGraph Cloud is available within <a href="https://www.langchain.com/langsmith" target="_blank">LangSmith</a>. To deploy a LangGraph Cloud API, navigate to the <a href="https://smith.langchain.com/" target="_blank">LangSmith UI</a>.
 
-## Setup GitHub Repository
+## Prerequisites
 
-LangGraph Cloud applications are deployed from GitHub repositories. Configure and upload a LangGraph Cloud application to a GitHub repository in order to deploy it to LangGraph Cloud.
+1. LangGraph Cloud applications are deployed from GitHub repositories. Configure and upload a LangGraph Cloud application to a GitHub repository in order to deploy it to LangGraph Cloud.
+1. [Verify that the LangGraph API runs locally](test_locally.md). If the API does not build and run successfully (i.e. `langgraph up`), deploying to LangGraph Cloud will fail as well.
 
 ## Create New Deployment
 
@@ -45,8 +46,33 @@ Starting from the <a href="https://smith.langchain.com/" target="_blank">LangSmi
         1. Update the value of existing secrets or environment variables.
 1. Select `Submit`. After a few seconds, the `New Revision` modal will close and the new revision will be queued for deployment.
 
-## Asynchronous Deployment
+## View Build and Deployment Logs
 
-New [deployments](#create-new-deployment) and [revisions](#create-new-revision) are provisioned and deployed asynchronously. They are not deployed immediately after submission. Currently, deployment can take up to several minutes.
+Build and deployment logs are available for each revision.
 
-The `Deployment` view continually updates the status of pending revisions.
+Starting from the `Deployment` view...
+
+1. Select the desired revision from the `Revisions` table. A panel slides open from the right-hand side and the `Build` tab is selected by default, which displays build logs for the revision.
+1. In the panel, select the `Deploy` tab to view deployment logs for the revision.
+1. Within the `Deploy` tab, adjust the date/time range picker as needed. By default, the date/time range picker is set to the `Last 15 minutes`.
+
+## Interrupt Revision
+
+Interrupting a revision will stop deployment of the revision.
+
+!!! warning "Undefined Behavior"
+    Interrupted revisions have undefined behavior. This is only useful if you need to deploy a new revision and you already have a revision "stuck" in progress. In the future, this feature may be removed.
+
+Starting from the `Deployment` view...
+
+1. Select the menu icon (three dots) on the right-hand side of the row for the desired revision from the `Revisions` table.
+1. Select `Interrupt` from the menu.
+1. A modal will appear. Review the confirmation message. Select `Interrupt revision`.
+
+## Delete Deployment
+
+Starting from the <a href="https://smith.langchain.com/" target="_blank">LangSmith UI</a>...
+
+1. In the left-hand navigation panel, select `Deployments`. The `Deployments` view contains a list of existing LangGraph Cloud deployments.
+1. Select the menu icon (three dots) on the right-hand side of the row for the desired deployment and select `Delete`.
+1. A `Confirmation` modal will appear. Select `Delete`.

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/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.
@@ -19,16 +33,43 @@ After each step, an example file directory is provided to demonstrate how code c
 
 Dependencies can optionally be specified in one of the following files: `pyproject.toml`, `setup.py`, or `requirements.txt`. If none of these files is created, then dependencies can be specified later in the [LangGraph API configuration file](#create-langgraph-api-config).
 
+The dependencies below will be included in the image, you can also use them in your code, as long as with a compatible version range:
+
+```
+langgraph>=0.2.7,<0.3.0
+langgraph-checkpoint>=1.0.4
+langchain-core>=0.2.27,<0.3.0
+langsmith>=0.1.63
+orjson>=3.9.7
+httpx>=0.25.0
+tenacity>=8.0.0
+uvicorn>=0.26.0
+sse-starlette>=2.1.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
@@ -36,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
@@ -43,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
@@ -86,36 +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.
+
 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_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), 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
 ```
 
@@ -20,6 +33,25 @@ After each step, an example file directory is provided to demonstrate how code c
 
 Dependencies can optionally be specified in one of the following files: `pyproject.toml`, `setup.py`, or `requirements.txt`. If none of these files is created, then dependencies can be specified later in the [LangGraph API configuration file](#create-langgraph-api-config).
 
+The dependencies below will be included in the image, you can also use them in your code, as long as with a compatible version range:
+```
+langgraph>=0.2.7,<0.3.0
+langgraph-checkpoint>=1.0.4
+langchain-core>=0.2.27,<0.3.0
+langsmith>=0.1.63
+orjson>=3.9.7
+httpx>=0.25.0
+tenacity>=8.0.0
+uvicorn>=0.26.0
+sse-starlette>=2.1.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:
 
 ```toml
@@ -33,7 +65,7 @@ readme = "README.md"
 
 [tool.poetry.dependencies]
 python = ">=3.9.0,<3.13"
-langgraph = "^0.1.0"
+langgraph = "^0.2.0"
 langchain-fireworks = "^0.1.3"
 
 
@@ -46,9 +78,6 @@ Example file directory:
 
 ```bash
 my-app/
-├── my_agent
-│   ├── __init__.py
-│   └── agent.py
 └── pyproject.toml   # Python packages required for your graph
 ```
 
@@ -68,10 +97,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
 ```
 
@@ -79,39 +105,53 @@ 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"
-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.
 
 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
 ```
 
@@ -125,30 +165,34 @@ Example `langgraph.json` file:
 {
   "dependencies": ["."],
   "graphs": {
-    "my_fantastic_agent": "./my_agent/agent.py:agent"
+    "agent": "./my_agent/agent.py:graph"
   },
-  "env": "./.env"
+  "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.
+
 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

@@ -0,0 +1,182 @@
+# How to test a LangGraph app locally
+
+This guide assumes you have a LangGraph app correctly set up with a proper configuration file and a corresponding compiled graph, and that you have a proper LangChain API key.
+
+Testing locally ensures that there are no errors or conflicts with Python dependencies and confirms that the configuration file is specified correctly.
+
+## Setup
+
+Install the proper packages:
+
+```shell
+pip install langgraph-cli
+```
+
+Ensure you have an API key, which you can create from the LangSmith UI (Settings > API Keys). This is required to authenticate that you have LangGraph Cloud access. After you have saved the key to a safe place, place the following line in your `.env` file:
+
+```python
+LANGCHAIN_API_KEY = *********
+```
+
+## Start the API server
+
+Once you have downloaded the CLI, you can run the following command to start the API server for local testing:
+
+```shell
+langgraph up
+```
+
+This will start up the LangGraph API server locally. If this runs successfully, you should see something like:
+
+```shell
+Ready!
+- API: http://localhost:8123
+2024-06-26 19:20:41,056:INFO:uvicorn.access 127.0.0.1:44138 - "GET /ok HTTP/1.1" 200
+```
+
+### Interact with the server
+
+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>)
+    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> });
+    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
+    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()
+    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();
+    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"
+
+    ```python
+    input = {"messages": [{"role": "human", "content": "what's the weather in sf"}]}
+    async for chunk in client.runs.stream(
+        thread["thread_id"],
+        assistant_id,
+        input=input,
+        stream_mode="updates",
+    ):
+        print(f"Receiving new event of type: {chunk.event}...")
+        print(chunk.data)
+        print("\n\n")
+    ```
+=== "Javascript"
+
+    ```js
+    const input = { "messages": [{ "role": "human", "content": "what's the weather in sf"}] }
+
+    const streamResponse = client.runs.stream(
+      thread["thread_id"],
+      assistantId,
+      {
+        input: input,
+        streamMode: "updates",
+      }
+    );
+    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\"}]},
+       \"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,65 @@
+# 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 that maps the possible outputs of your router function with the names of the nodes that each output corresponds to. The path map is passed as the third argument to the `add_conditional_edges` function like so:
+
+```python
+graph.add_conditional_edges("node_a", routing_function, {True: "node_b", False: "node_c"})
+```
+
+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
+
+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/check_thread_status.md

@@ -0,0 +1,200 @@
+# 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>)
+    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'
+    ```
+
+## 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/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/enqueue_concurrent.md

@@ -1,6 +1,6 @@
 ## Enqueue
 
-This guide assumes knowledge of what double-texting is, which you can learn about in the [double-texting conceptual guide](../concepts/index.md#double-texting).
+This guide assumes knowledge of what double-texting is, which you can learn about in the [double-texting conceptual guide](../concepts/api.md#double-texting).
 
 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.
 
@@ -31,7 +31,7 @@ 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>)
     assistant_id = "agent"
     thread = await client.threads.create()
     ```
@@ -42,7 +42,7 @@ 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> });
     const assistantId = "agent";
     const thread = await client.threads.create();
     ```

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

@@ -21,7 +21,7 @@ In this how-to we use a simple ReAct style hosted graph (you can see the full co
 
     ```python
     from langgraph_sdk import get_client
-    client = get_client(url="whatever-your-deployment-url-is")
+    client = get_client(url=<DEPLOYMENT_URL>)
     assistant_id = "agent"
     thread = await client.threads.create()
     ```
@@ -31,11 +31,19 @@ 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 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'
+    ```
+
 ## Adding a breakpoint
 
 We now want to add a breakpoint in our graph run, which we will do before a tool is called.
@@ -43,7 +51,7 @@ We can do this by adding `interrupt_before=["action"]`, which tells us to interr
 We can do this either when compiling the graph or when kicking off a run.
 Here we will do it when kicking of a run, if you would like to to do it at compile time you need to edit the python file where your graph is defined and add the `interrupt_before` parameter when you call `.compile`.
 
-First let's access our hosted Langgraph instance through the SDK:
+First let's access our hosted LangGraph instance through the SDK:
 
 And, now let's compile it with a breakpoint before the tool node:
 
@@ -82,6 +90,42 @@ And, now let's compile it with a breakpoint before the tool node:
       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,7 @@ First, we need to setup our client so that we can communicate with our hosted gr
 
     ```python
     from langgraph_sdk import get_client
-    client = get_client(url="whatever-your-deployment-url-is")
+    client = get_client(url=<DEPLOYMENT_URL>)
     assistant_id = "agent"
     thread = await client.threads.create()
     ```
@@ -27,11 +27,19 @@ 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> });
     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
@@ -75,6 +83,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}]}}
@@ -129,10 +173,22 @@ Now, let's assume we actually meant to search for the weather in Sidi Frej (anot
     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'}}
 
 
 
@@ -171,6 +227,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,575 @@
+# 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>)
+    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();
+    ```
+
+## 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);
+      }
+    }
+    ```
+
+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);
+    ```
+
+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,
+        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);
+      }
+    }
+    ```
+
+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);
+    ```
+
+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: undefined,
+        streamMode: "values",
+      }
+    );
+    for await (const chunk of streamResponse) {
+      if (chunk.data && chunk.event !== "metadata") {
+        console.log(chunk.data);
+      }
+    }
+    ```
+
+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);
+      }
+    }
+    ```
+
+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,
+        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 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: undefined,
+        streamMode: "values",
+        interruptBefore: ["action"],
+    }
+    );
+    for await (const chunk of streamResponseResumed) {
+    if (chunk.data && chunk.event !== "metadata") {
+        console.log(chunk.data);
+    }
+    }
+    ```
+
+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,
+        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);
+      }
+    }
+    ```
+
+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: undefined,
+        streamMode: "values",
+        interruptBefore: ["action"],
+    }
+    );
+    for await (const chunk of streamResponseEdited) {
+    if (chunk.data && chunk.event !== "metadata") {
+        console.log(chunk.data);
+    }
+    }
+    ```
+
+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,
+        stream_mode="values",
+    ):
+        if chunk.data and chunk.event != "metadata": 
+            print(chunk.data)
+    ```
+
+=== "Javascript"
+
+    ```js
+    const streamResponseResumed = client.runs.stream(
+      thread["thread_id"],
+      assistantId,
+      {
+        input: undefined,
+        streamMode: "values",
+      }
+    );
+    for await (const chunk of streamResponseResumed) {
+      if (chunk.data && chunk.event !== "metadata") {
+        console.log(chunk.data);
+      }
+    }
+    ```
+
+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

@@ -1,6 +1,6 @@
 # How to Replay and Branch from Prior States
 
-With Langgraph Cloud you have the ability to return to any of your prior states and either re-run the graph to reproduce issues noticed during testing, or branch out in a different way from what was originally done in the prior states. In this guide we will show a quick example of how to rerun past states and how to branch off from previous states as well.
+With LangGraph Cloud you have the ability to return to any of your prior states and either re-run the graph to reproduce issues noticed during testing, or branch out in a different way from what was originally done in the prior states. In this guide we will show a quick example of how to rerun past states and how to branch off from previous states as well.
 
 ## Setup
 
@@ -14,7 +14,7 @@ First, we need to setup our client so that we can communicate with our hosted gr
 
     ```python
     from langgraph_sdk import get_client
-    client = get_client(url="whatever-your-deployment-url-is")
+    client = get_client(url=<DEPLOYMENT_URL>)
     assistant_id = "agent"
     thread = await client.threads.create()
     ```
@@ -24,11 +24,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> });
     const assistantId = agent;
     const thread = await client.threads.create();
     ```
 
+=== "CURL"
+
+    ```bash
+    curl --request POST \
+      --url <DEPLOYMENT_URL>/threads \
+      --header 'Content-Type: application/json' \
+      --data {}
+    ```
+
 ## Replay a state
 
 ### Initial invocation
@@ -38,7 +47,7 @@ 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"],
@@ -53,7 +62,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 +78,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 +144,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 +181,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 +199,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 +268,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 +279,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`:
@@ -191,7 +311,7 @@ Now we can rerun our graph with this new config, starting from the `new_state`,
         assistant["assistant_id"], # graph_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)
@@ -206,7 +326,7 @@ Now we can rerun our graph with this new config, starting from the `new_state`,
       {
         input: null,
         streamMode: "updates",
-        config: {"configurable": {"thread_ts": newState['configurable']['thread_ts']}},
+        checkpointId: config['checkpoint_id'],
       }
     );
     for await (const chunk of streamResponse) {
@@ -216,6 +336,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,7 @@ First, we need to setup our client so that we can communicate with our hosted gr
 
     ```python
     from langgraph_sdk import get_client
-    client = get_client(url="whatever-your-deployment-url-is")
+    client = get_client(url=<DEPLOYMENT_URL>)
     assistant_id = "agent"
     thread = await client.threads.create()
     ```
@@ -34,11 +34,19 @@ 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> });
     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
@@ -80,6 +88,42 @@ Now, let's invoke our graph by interrupting before `ask_human` 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\": \"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:
 
@@ -117,11 +161,31 @@ Because we are treating this as a tool call, we will need to update the state as
     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 +197,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",
     ):
@@ -158,6 +222,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

@@ -11,10 +11,13 @@ Welcome to the LangGraph Cloud how-to guides! These guides provide practical, st
 
 LangGraph Cloud gives you best in class observability, testing, and hosting services. Read more about them in these how to guides:
 
-- [How to set up app for deployment](../deployment/setup.md)
+- [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 test locally](../deployment/test_locally.md)
 - [How to deploy to LangGraph cloud](../deployment/cloud.md)
 - [How to self-host](../deployment/self_hosted.md)
 
+
 ## Streaming
 
 Streaming the results of your LLM application is vital for ensuring a good user experience, especially when your graph may call multiple models and take a long time to fully complete a run. Read about how to stream values from your graph in these how to guides:
@@ -43,12 +46,14 @@ 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
 
 LangGraph Studio is a built-in UI for visualizing, testing, and debugging your agents.
 
 - [How to enter LangGraph Studio](./test_deployment.md)
+- [How to enter LangGraph Studio for local deployment](./test_local_deployment.md)
 - [How to test your graph in LangGraph Studio](./invoke_studio.md)
 - [Interact with threads in LangGraph Studio](./threads_studio.md)
 
@@ -68,3 +73,5 @@ Other guides that may prove helpful!
 - [How to configure agents](cloud_examples/configuration_cloud.ipynb)
 - [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 copy threads](./copy_threads.md)
+- [How to check status of your threads](./check_thread_status.md)

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

@@ -1,6 +1,6 @@
 ## Interrupt
 
-This guide assumes knowledge of what double-texting is, which you can learn about in the [double-texting conceptual guide](../concepts/index.md#double-texting).
+This guide assumes knowledge of what double-texting is, which you can learn about in the [double-texting conceptual guide](../concepts/api.md#double-texting).
 
 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.
 
@@ -29,7 +29,7 @@ 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>)
     assistant_id = "agent"
     thread = await client.threads.create()
     ```
@@ -39,7 +39,7 @@ 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> });
     const assistantId = "agent";
     const thread = await client.threads.create();
     ```

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

@@ -28,7 +28,7 @@ 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>)
     assistant_id = "agent"
     thread = await client.threads.create()
     ```
@@ -38,7 +38,7 @@ 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> });
     const assistantId = "agent";
     const thread = await client.threads.create();
     ```

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

@@ -30,7 +30,7 @@ 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>)
     assistant_id = "agent"
     thread = await client.threads.create()
     ```
@@ -40,7 +40,7 @@ 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> });
     const assistantId = "agent";
     const thread = await client.threads.create();
     ```

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

@@ -9,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)
@@ -20,7 +20,7 @@ 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)

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

@@ -6,7 +6,7 @@ This guide covers how to stream events from your graph (`stream_mode="events"`).
     ```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)
@@ -17,12 +17,19 @@ 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> });
     // 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:
 
@@ -30,7 +37,9 @@ 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': {}}
+     'metadata': {},
+     'status': 'idle',
+     'config': {}}
 
 
 
@@ -91,6 +100,41 @@ Streaming events produces responses containing an `event` key (in addition to ot
     }
     ```
 
+=== "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...
@@ -258,9 +302,11 @@ Token-by-token streaming can be implemented with the `events` streaming mode. Th
     ):
         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)
     ```
 
@@ -278,21 +324,88 @@ Token-by-token streaming can be implemented with the `events` streaming mode. Th
       }
     );
     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

@@ -41,7 +41,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)
@@ -52,20 +52,30 @@ 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)
     ```
 
+=== "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': {}}
+     'metadata': {},
+     'status': 'idle',
+     'config': {}}
 
-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 +105,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"
@@ -201,6 +274,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,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)
@@ -20,19 +20,28 @@ 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)
     ```
 
+=== "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': {}}
+     'metadata': {},
+     'status': 'idle',
+     'config': {}}
 
 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.
 
@@ -90,6 +99,43 @@ When configuring multiple streaming modes for a run, responses for each respecti
     }
     ```
 
+=== "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...

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

@@ -16,7 +16,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 +27,28 @@ 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)
     ```
 
+=== "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': {}}
+     'metadata': {},
+     'status': 'idle',
+     'config': {}}
 
 Now we can stream by updates, which outputs updates made to the state by each node after it has executed:
 
@@ -93,6 +102,41 @@ Now we can stream by updates, which outputs updates made to the state by each no
     }
     ```
 
+=== "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

@@ -16,7 +16,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 +27,28 @@ 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)
     ```
 
+=== "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': {}}
+     'metadata': {},
+     'status': 'idle',
+     'config': {}}
 
 Now we can stream by values, which streams the full state of the graph after each node has finished executing:
 
@@ -60,7 +70,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"}]}
@@ -80,6 +89,41 @@ Now we can stream by values, which streams the full state of the graph after eac
     }
     ```
 
+=== "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 +193,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/test_local_deployment.md

@@ -0,0 +1,28 @@
+# LangGraph Studio With Local Deployment
+
+!!! warning "Browser Compatibility"
+    Viewing the studio page of a local LangGraph deployment does not work in Safari. Use Chrome instead.
+
+## Setup
+
+Make sure you have setup your app correctly, by creating a compiled graph, a `.env` file with any environment variables, and a `langgraph.json` config file that points to your environment file and compiled graph. See [here](https://langchain-ai.github.io/langgraph/cloud/deployment/setup/) for more detailed instructions.
+
+After you have your app setup, head into the directory with your `langgraph.json` file and call `langgraph up -c langgraph.json --watch` to start the API server in watch mode which means it will restart on code changes, which is ideal for local testing. If the API server start correctly you should see logs that look something like this:
+
+    Ready!
+    - API: http://localhost:8123
+    2024-06-26 19:20:41,056:INFO:uvicorn.access 127.0.0.1:44138 - "GET /ok HTTP/1.1" 200
+
+Read this [reference](https://langchain-ai.github.io/langgraph/cloud/reference/cli/#up) to learn about all the options for starting the API server.
+
+## Access Studio
+
+Once you have successfully started the API server, you can access the studio by going to the following URL: `https://smith.langchain.com/studio/?baseUrl=http://127.0.0.1:8123` (see warning above if using Safari).
+
+If everything is working correctly you should see the studio show up looking something like this (with your graph diagram on the left hand side):
+
+![LangGraph Studio](./img/studio_screenshot.png)
+
+## Use the Studio for Testing
+
+To learn about how to use the studio for testing, read the [LangGraph Studio how-tos](https://langchain-ai.github.io/langgraph/cloud/how-tos/#langgraph-studio).

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

@@ -1,21 +1,30 @@
 # LangGraph Cloud (beta)
 
-!!! 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).
+!!! tip
+    - LangGraph is an MIT-licensed open-source library, which we are committed to maintaining and growing for the community.
+    - LangGraph Cloud is an optional managed hosting service for LangGraph, which provides additional features geared towards production deployments.
+    - 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.
 
 !!! 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
 
 LangGraph Cloud is a managed service for deploying and hosting LangGraph applications. Deploying applications with LangGraph Cloud shortens the time-to-market for developers. With one click, deploy a production-ready API with built-in persistence for your LangGraph application. LangGraph Cloud APIs are horizontally scalable and deployed with durable storage.
 
-The LangGraph Cloud API exposes functionality of your LangGraph application through [Assistants](./concepts/index.md#assistants). An assistant abstracts the cognitive architecture of your graph. Invoke an assistant by calling the pre-built [API endpoints](./reference/api/api_ref.md).
+The LangGraph Cloud API exposes functionality of your LangGraph application through [Assistants](./concepts/api.md#assistants). An assistant abstracts the cognitive architecture of your graph. Invoke an assistant by calling the pre-built [API endpoints](./reference/api/api_ref.md).
 
 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.
@@ -31,5 +40,5 @@ The LangGraph Cloud API supports key LangGraph features in addition to new funct
 
 - [Tutorials](./quick_start.md): Learn to build and deploy applications for LangGraph Cloud.
 - [How-to Guides](./how-tos/index.md): Learn how to set up a LangGraph application for deployment and implement features of the LangGraph Cloud API such as streaming tokens, configuring double texting, and creating cron jobs. Go here if you want to copy and run a specific code snippet.
-- [Conceptual Guides](./concepts/index.md): In-depth explanations of the core data models (e.g. assistants) and key features (e.g. double texting) of the LangGraph Cloud API.
+- [Conceptual Guides](./concepts/api.md): In-depth explanations of the core data models (e.g. assistants), key features of the LangGraph Cloud API (e.g. double texting), and the architecture of a LangGraph Cloud deployment.
 - [Reference](./reference/api/api_ref.md): References for the LangGraph Cloud API, the corresponding Python and JS/TS SDKs, the LangGraph CLI, and deployment environment variables.

docs/docs/cloud/quick_start.md

@@ -66,6 +66,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
@@ -74,13 +84,13 @@ In order to do this we can first install the LangGraph CLI
 pip install langgraph-cli
 ```
 
-We can then stand up a simple test server. The server this stands up is INCREDIBLY simple - it is just a single endpoint and has no persistence. **This should not be used for hosting your application, only for testing the build and basic functionality.**
+We can then test our API server locally. This requires access to LangGraph closed beta. In order to run the server locally, you will need to add your `LANGSMITH_API_KEY` to the .env file so we can validate you have access to LangGraph closed beta.
 
 ```shell
-langgraph test
+langgraph up
 ```
 
-This will test building of the agent server. If this runs successfully, you should see something like:
+This will start up the LangGraph API server locally. If this runs successfully, you should see something like:
 
 ```shell
 Ready!
@@ -88,7 +98,7 @@ Ready!
 2024-06-26 19:20:41,056:INFO:uvicorn.access 127.0.0.1:44138 - "GET /ok HTTP/1.1" 200
 ```
 
-You can now test this out! Again, we only expose a single simple endpoint (for streaming stateless runs). This is intended to allow you to test that the agent is properly set up, but should **NOT** but used for production purposes. To test it out, you can go to another terminal window and run:
+You can now test this out! **Note: this local server is intended SOLELY for local testing purposes and is not performant enough for production applications, so please do not use it as such.** To test it out, you can go to another terminal window and run:
 
 ```shell
 curl --request POST \
@@ -186,14 +196,12 @@ Once you have tested that your hosted graph works as expected using LangGraph St
 
 First, make sure you have the SDK installed by calling `pip install langgraph_sdk`.
 
-Before using, you need to get the URL of your LangGraph deployment. You can find this on the auto generated documentation page here:
-
-![Base URL of LangGraph deployment](./deployment/img/base_url.png)
+Before using, you need to get the URL of your LangGraph deployment. You can find this in the `Deployment` view. Click the URL to copy it to the clipboard.
 
 You also need to make sure you have set up your API key properly so you can authenticate with LangGraph Cloud.
 
 ```shell
-export LANGCHAIN_API_KEY=...
+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:

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"
@@ -83,6 +83,31 @@ langgraph build [OPTIONS]
 | `-c, --config FILE` | `langgraph.json` | Path to configuration file declaring dependencies, graphs and environment variables. |
 | `--help` | | Display command documentation. |
 
+### `up`
+Start langgraph API server. For local testing, requires a LangSmith API key with access to LangGraph Cloud closed beta. Requires a license key for production use.
+
+**Usage**
+```
+langgraph up [OPTIONS]
+```
+
+**Options**
+
+| Option | Default | Description |
+| ------ | ------- | ----------- |
+| `--wait` | | Wait for services to start before returning. Implies --detach |
+| `--postgres-uri TEXT` | Local database | Postgres URI to use for the database. |
+| `--watch` | | Restart on file changes |
+| `--debugger-base-url TEXT` | `http://127.0.0.1:[PORT]` | URL used by the debugger to access LangGraph API. |
+| `--debugger-port INTEGER` | | Pull the debugger image locally and serve the UI on specified port |
+| `--verbose` | | Show more output from the server logs. |
+| `-c, --config FILE` | `langgraph.json` | Path to configuration file declaring dependencies, graphs and environment variables. |
+| `-d, --docker-compose FILE` | | Path to docker-compose.yml file with additional services to launch. |
+| `-p, --port INTEGER` | `8123` | Port to expose. Example: `langgraph test --port 8000` |
+| `--pull / --no-pull` | `pull` | Pull latest images. Use --no-pull for running the server with locally-built images. Example: `langgraph up --no-pull` |
+| `--recreate / --no-recreate` | `no-recreate` | Recreate containers even if their configuration and image haven't changed |
+| `--help` | | Display command documentation. | 
+
 ### `test`
 Test your LangGraph in the cloud. The only function you can call from the SDK after testing your graph is `client.runs.stream(thread_id=None, ...)`
 

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

@@ -14,7 +14,9 @@ By composing `Nodes` and `Edges`, you can create complex, looping workflows that
 
 In short: _nodes do the work. edges tell what to do next_.
 
-LangGraph's underlying graph algorithm uses [message passing](https://en.wikipedia.org/wiki/Message_passing) to define a general program. When a `Node` completes, it sends a message along one or more edges to other node(s). These nodes run their functions, pass the resulting messages to the next set of nodes, and on and on it goes. Inspired by [Pregel](https://research.google/pubs/pregel-a-system-for-large-scale-graph-processing/), the program proceeds in discrete "super-steps" that are all executed conceptually in parallel. Whenever the graph is run, all the nodes start in an `inactive` state. Whenever an incoming edge (or "channel") receives a new message (state), the node becomes `active`, runs the function, and responds with updates. At the end of each superstep, each node votes to `halt` by marking itself as `inactive` if it has no more incoming messages. The graph terminates when all nodes are `inactive` and when no messages are in transit.
+LangGraph's underlying graph algorithm uses [message passing](https://en.wikipedia.org/wiki/Message_passing) to define a general program. When a Node completes its operation, it sends messages along one or more edges to other node(s). These recipient nodes then execute their functions, pass the resulting messages to the next set of nodes, and the process continues. Inspired by Google's [Pregel](https://research.google/pubs/pregel-a-system-for-large-scale-graph-processing/) system, the program proceeds in discrete "super-steps."
+
+A super-step can be considered a single iteration over the graph nodes. Nodes that run in parallel are part of the same super-step, while nodes that run sequentially belong to separate super-steps. At the start of graph execution, all nodes begin in an `inactive` state. A node becomes `active` when it receives a new message (state) on any of its incoming edges (or "channels"). The active node then runs its function and responds with updates. At the end of each super-step, nodes with no incoming messages vote to `halt` by marking themselves as `inactive`. The graph execution terminates when all nodes are `inactive` and no messages are in transit.
 
 ### StateGraph
 
@@ -44,9 +46,17 @@ The first thing you do when you define a graph is define the `State` of the grap
 
 The main documented way to specify the schema of a graph is by using `TypedDict`. However, we also support [using a Pydantic BaseModel](../how-tos/state-model.ipynb) as your graph state to add **default values** and additional data validation.
 
+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:**
 
@@ -73,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
@@ -178,7 +214,7 @@ graph.add_edge("node_a", "node_b")
 If you want to **optionally** route to 1 or more edges (or optionally terminate), you can use the [add_conditional_edges][langgraph.graph.StateGraph.add_conditional_edges] method. This method accepts the name of a node and a "routing function" to call after that node is executed:
 
 ```python
-graph.add_edge("node_a", routing_function)
+graph.add_conditional_edges("node_a", routing_function)
 ```
 
 Similar to nodes, the `routing_function` accept the current `state` of the graph and return a value.
@@ -188,7 +224,7 @@ By default, the return value `routing_function` is used as the name of the node
 You can optionally provide a dictionary that maps the `routing_function`'s output to the name of the next node.
 
 ```python
-graph.add_edge("node_a", routing_function, {True: "node_b", False: "node_c"})
+graph.add_conditional_edges("node_a", routing_function, {True: "node_b", False: "node_c"})
 ```
 
 ### Entry Point
@@ -232,11 +268,9 @@ graph.add_conditional_edges("node_a", continue_to_jokes)
 
 ## Checkpointer
 
-One of the main benefits of LangGraph is that it comes backed by a persistence layer. This is accomplished via [checkpointers][basecheckpointsaver].
+LangGraph has a built-in persistence layer, implemented through [checkpointers][basecheckpointsaver]. When you use a checkpointer with a graph, you can interact with the state of that graph. When you use a checkpointer with a graph, you can interact with and manage the graph's state. The checkpointer saves a _checkpoint_ of the graph state at every super-step, enabling several powerful capabilities:
 
-Checkpointers can be used to save a _checkpoint_ of the state of a graph after all steps of the graph. This allows for several things.
-
-First, it allows for [human-in-the-loop workflows](agentic_concepts.md#human-in-the-loop), as it allows humans to inspect, interrupt, and approve steps. Checkpointers are needed for these workflows as the human has to be able to view the state of a graph at any point in time, and the graph has to be to resume execution after the human has made any updates to the state.
+First, checkpointers facilitate [human-in-the-loop workflows](agentic_concepts.md#human-in-the-loop) workflows by allowing humans to inspect, interrupt, and approve steps.Checkpointers are needed for these workflows as the human has to be able to view the state of a graph at any point in time, and the graph has to be to resume execution after the human has made any updates to the state.
 
 Second, it allows for ["memory"](agentic_concepts.md#memory) between interactions. You can use checkpointers to create threads and save the state of a thread after a graph executes. In the case of repeated human interactions (like conversations) any follow up messages can be sent to that checkpoint, which will retain its memory of previous ones.
 
@@ -244,8 +278,7 @@ See [this guide](../how-tos/persistence.ipynb) for how to add a checkpointer to
 
 ## Threads
 
-When using a checkpointer, you must specify a `thread_id` or `thread_ts` when running the graph.
-Threads are used to checkpoint multiple different runs. This can be used to enable a multi-tenant chat applications.
+Threads enable the checkpointing of multiple different runs, making them essential for multi-tenant chat applications and other scenarios where maintaining separate states is necessary. A thread is a unique ID assigned to a series of checkpoints saved by a checkpointer. When using a checkpointer, you must specify a `thread_id` or `thread_ts` when running the graph.
 
 `thread_id` is simply the ID of a thread. This is always required
 
@@ -262,14 +295,7 @@ See [this guide](../how-tos/persistence.ipynb) for how to use threads.
 
 ## Checkpointer state
 
-When you use a checkpointer with a graph, you can interact with the state of that graph.
-This usually done when enabling different human-in-the-loop interaction patterns.
-Each time you run the graph, the checkpointer creates several checkpoints every time a
-node or set of nodes finishes running.
-The most recent checkpoint is the current state of the thread.
-When interacting with the checkpointer state, you must specify a [thread identifier](#threads).
-
-Each checkpoint has two properties:
+ When interacting with the checkpointer state, you must specify a [thread identifier](#threads).Each checkpoint saved by the checkpointer has two properties:
 
 - **values**: This is the value of the state at this point in time.
 - **next**: This is a tuple of the nodes to execute next in the graph.
@@ -335,6 +361,16 @@ The final thing you specify when calling `update_state` is `as_node`. This updat
 
 The reason this matters is that the next steps in the graph to execute depend on the last node to have given an update, so this can be used to control which node executes next.
 
+## Graph Migrations
+
+LangGraph can easily handle migrations of graph definitions (nodes, edges, and state) even when using a checkpointer to track state.
+
+- For threads at the end of the graph (i.e. not interrupted) you can change the entire topology of the graph (i.e. all nodes and edges, remove, add, rename, etc)
+- For threads currently interrupted, we support all topology changes other than renaming / removing nodes (as that thread could now be about to enter a node that no longer exists) -- if this is a blocker please reach out and we can prioritize a solution.
+- For modifying state, we have full backwards and forwards compatibility for adding and removing keys
+- State keys that are renamed lose their saved state in existing threads
+- State keys whose types change in incompatible ways could currently cause issues in threads with state from before the change -- if this is a blocker please reach out and we can prioritize a solution.
+
 ## Configuration
 
 When creating a graph, you can also mark that certain parts of the graph are configurable. This is commonly done to enable easily switching between models or system prompts. This allows you to create a single "cognitive architecture" (the graph) but have multiple different instance of it.
@@ -365,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] to learn more about how the recursion limit works.
 
 ## Breakpoints
 
@@ -397,4 +443,17 @@ LangGraph is built with first class support for streaming. There are several dif
 - [`"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.
 
-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).
+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) among other things.
+
+Under the hood, the compiled graph and each of its nodes are turned into [runnables](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`:
+
+* 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` during each node execution and `on_chain_end` when the graph finishes. Graph events will have the `LangGraph` in the event's `name` field
+* LangGraph writes to state channels 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`.
+ 
+You can find a detailed table of all callback events and triggers [here](https://python.langchain.com/v0.2/docs/concepts/#callback-events).
+
+!!! 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).

docs/docs/how-tos/index.md

@@ -15,15 +15,19 @@ 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
 
 LangGraph makes it easy to persist state across graph runs. The guide below shows how to add persistence to your graph.
 
 - [How to add persistence ("memory") to your graph](persistence.ipynb)
-- [How to manage conversation history](managing-conversation-history.ipynb)
-- [How to create a custom checkpointer using Postgres](persistence_postgres.ipynb)
+- [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 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)
 
 ## Human in the Loop
 
@@ -31,9 +35,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
 
@@ -43,17 +49,37 @@ These guides show how to use different streaming modes.
 - [How to stream full state of your graph](stream-values.ipynb)
 - [How to stream state updates of your graph](stream-updates.ipynb)
 - [How to stream LLM tokens](streaming-tokens.ipynb)
+- [How to stream LLM tokens without LangChain models](streaming-tokens-without-langchain.ipynb)
 - [How to stream arbitrarily nested content](streaming-content.ipynb)
 - [How to configure multiple streaming modes at the same time](stream-multiple.ipynb)
 - [How to stream events from within a tool](streaming-events-from-within-tools.ipynb)
+- [How to stream events from within a tool without LangChain models](streaming-events-from-within-tools-without-langchain.ipynb)
 - [How to stream events from the final node](streaming-from-final-node.ipynb)
 
+## Tool calling
+
+- [How to call tools using ToolNode](tool-calling.ipynb)
+- [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)
+
+## 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
+
 - [How to run graph asynchronously](async.ipynb)
 - [How to visualize your graph](visualization.ipynb)
 - [How to add runtime configuration to your graph](configuration.ipynb)
 - [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,19 +7,23 @@ 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.Checkpoint
+::: langgraph.checkpoint.base.Checkpoint
+
+### CheckpointMetadata
+
+::: langgraph.checkpoint.base.CheckpointMetadata
 
 ### BaseCheckpointSaver
 
 ::: langgraph.checkpoint.base.BaseCheckpointSaver
-handler: python
 
 ### SerializerProtocol
 
-::: langgraph.checkpoint.SerializerProtocol
-handler: python
+::: langgraph.checkpoint.base.SerializerProtocol
 
 ## Implementations
 
@@ -28,14 +32,23 @@ LangGraph also natively provides the following checkpoint implementations.
 ### MemorySaver
 
 ::: langgraph.checkpoint.memory.MemorySaver
-handler: python
 
 ### AsyncSqliteSaver
 
-::: langgraph.checkpoint.aiosqlite.AsyncSqliteSaver
-handler: python
+::: 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/reference/graphs.md

@@ -65,4 +65,8 @@ builder.add_conditional_edges("my_node", my_condition)
 
 ## Send
 
-::: langgraph.constants.Send
+::: langgraph.constants.Send
+
+## RetryPolicy
+
+::: langgraph.pregel.types.RetryPolicy

docs/docs/reference/prebuilt.md

@@ -55,4 +55,13 @@ from langgraph.prebuilt import tools_condition
 from langgraph.prebuilt import ValidationNode
 ```
 
-::: langgraph.prebuilt.ValidationNode
+::: langgraph.prebuilt.ValidationNode
+
+## InjectedState
+
+```python
+from langgraph.prebuilt import InjectedState
+```
+
+::: langgraph.prebuilt.InjectedState
+    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

@@ -12,8 +12,6 @@ theme:
     repo: fontawesome/brands/git-alt
   features:
     - announce.dismiss
-    - content.action.edit
-    - content.action.view
     - content.code.annotate
     - content.code.copy
     - content.code.select
@@ -131,29 +129,49 @@ nav:
           - 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/managing-conversation-history.ipynb
-          - Create custom checkpointer using Postgres: how-tos/persistence_postgres.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
+          - 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
           - Stream LLM tokens: how-tos/streaming-tokens.ipynb
+          - Stream LLM tokens without LangChain models: how-tos/streaming-tokens-without-langchain.ipynb
           - Stream arbitrarily nested content: how-tos/streaming-content.ipynb
           - Configure multiple streaming modes: how-tos/stream-multiple.ipynb
           - Stream events from within tools: how-tos/streaming-events-from-within-tools.ipynb
+          - Stream events from within tools without LangChain models: how-tos/streaming-events-from-within-tools-without-langchain.ipynb
           - Stream events from the final node: how-tos/streaming-from-final-node.ipynb
+      - Tool calling:
+          - Call tools using ToolNode: how-tos/tool-calling.ipynb
+          - Handle tool calling errors: how-tos/tool-calling-errors.ipynb
+          - 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
+      - State Management:
+          - Use Pydantic model as state: how-tos/state-model.ipynb
+          - Use a context object in state: how-tos/state-context-key.ipynb
+          - Have a separate input and output schema: how-tos/input_output_schema.ipynb
+          - Pass private state between nodes inside the graph: how-tos/pass_private_state.ipynb
       - Other:
           - Run graph asynchronously: how-tos/async.ipynb
           - Visualize your graph: how-tos/visualization.ipynb
           - Add runtime configuration: how-tos/configuration.ipynb
-          - Use Pydantic model as state: how-tos/state-model.ipynb
-          - Use a context object in state: how-tos/state-context-key.ipynb
+          - Add node retries: how-tos/node-retries.ipynb
+          - How to force function calling agent to structure output: 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
@@ -176,9 +194,12 @@ 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"
+              - 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:
@@ -198,8 +219,10 @@ 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:
@@ -211,7 +234,11 @@ nav:
               - Configure Agents: "cloud/how-tos/cloud_examples/configuration_cloud.ipynb"
               - 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'
-      - Conceptual Guides: "cloud/concepts/index.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"
       - Reference:
           - API: "cloud/reference/api/api_ref.md"
           - SDK:
@@ -219,6 +246,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

docs/overrides/main.html

@@ -146,6 +146,13 @@
       display: none !important;
     }
 
+    .jupyter-wrapper .jp-CodeCell .jp-Cell-inputWrapper .jp-InputPrompt.jp-InputArea-prompt {
+      display: none !important;
+    }
+
+    .jupyter-wrapper .jp-Notebook .jp-Cell .jp-OutputPrompt {
+      display: none !important;
+    }
   </style>
 {% endblock %}
 

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,7 +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(\"----\")"]
+   "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",
@@ -259,7 +406,7 @@
    "id": "dde4f2b5-cfe8-4ff0-99ea-fe2c5fed70c0",
    "metadata": {},
    "outputs": [],
-   "source": [""]
+   "source": []
   }
  ],
  "metadata": {

examples/chatbots/customer-support.ipynb

@@ -2,10 +2,739 @@
  "cells": [
   {
    "cell_type": "markdown",
-   "id": "4c37bb65-6e2c-42e4-bfa7-9df10e2652a0",
+   "id": "d9d1a28b-c2a1-4246-b1c2-c58d6938f798",
    "metadata": {},
    "source": [
-    "This example has moved! Check out the [Customer Support Tutorial](../customer-support/customer-support.ipynb) for more information."
+    "# Customer Support\n",
+    "\n",
+    "Here, we show an example of building a customer support chatbot.\n",
+    "\n",
+    "This customer support chatbot interacts with SQL database to answer questions.\n",
+    "We will use a mock SQL database to get started: the [Chinook](https://www.sqlitetutorial.net/sqlite-sample-database/) database.\n",
+    "This database is about sales from a music store: what songs and album exists, customer orders, things like that.\n",
+    "\n",
+    "This chatbot has two different states: \n",
+    "1. Music: the user can inquire about different songs and albums present in the store\n",
+    "2. Account: the user can ask questions about their account\n",
+    "\n",
+    "Under the hood, this is handled by two separate agents. \n",
+    "Each has a specific prompt and tools related to their objective. \n",
+    "There is also a generic agent who is responsible for routing between these two agents as needed.\n",
+    "\n",
+    "Note: This is a very simple example! For a more complete tutorial on building a customer support bot, check out the [Customer Support Tutorial](../customer-support/customer-support.ipynb) for more information."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "35abc013-2613-4a49-a806-939dcf13ccf3",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "%%capture --no-stderr\n",
+    "%pip install -U langgraph langchain-community langchain-openai scikit-learn"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9431e7f1-07fa-49d9-ac45-29613703dcc1",
+   "metadata": {},
+   "source": [
+    "## Load the data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "3d1ef253-6b0c-4481-868c-e1fe84f2c8ff",
+   "metadata": {},
+   "outputs": [],
+   "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",
+   "execution_count": 2,
+   "id": "61f7ef9c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['Album',\n",
+       " 'Artist',\n",
+       " 'Customer',\n",
+       " 'Employee',\n",
+       " 'Genre',\n",
+       " 'Invoice',\n",
+       " 'InvoiceLine',\n",
+       " 'MediaType',\n",
+       " 'Playlist',\n",
+       " 'PlaylistTrack',\n",
+       " 'Track']"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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",
+   "id": "1cf668e4-8cb4-4de1-bc5e-c90284bf74bc",
+   "metadata": {},
+   "source": [
+    "## Load an LLM\n",
+    "\n",
+    "We will load a language model to use.\n",
+    "For this demo we will use OpenAI."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "d9ea4e80-30e6-4d46-b480-35f0be2fb055",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_openai import ChatOpenAI\n",
+    "\n",
+    "model = ChatOpenAI(temperature=0, streaming=True, model=\"gpt-4o\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "73907422-7e05-431e-b06d-256c9ec1f6f6",
+   "metadata": {},
+   "source": [
+    "## Load Other Modules\n",
+    "\n",
+    "Load other modules we will use.\n",
+    "\n",
+    "All of the tools our agents will use will be custom tools. As such, we will use the `@tool` decorator to create custom tools.\n",
+    "\n",
+    "We will pass in messages to the agent, so we load `HumanMessage` and `SystemMessage`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "ea958e9f-ab1f-49b5-bd85-16332055297c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_core.messages import HumanMessage, SystemMessage"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "35271d4d-2a1c-41be-9359-a3a7c3fed3d9",
+   "metadata": {},
+   "source": [
+    "## Define the Customer Agent\n",
+    "\n",
+    "This agent is responsible for looking up customer information.\n",
+    "It will have a specific prompt as well a specific tool to look up information about that customer (after asking for their user id)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "975b039a",
+   "metadata": {},
+   "outputs": [],
+   "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",
+   "execution_count": 6,
+   "id": "1d5fa446",
+   "metadata": {},
+   "outputs": [],
+   "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",
+   "id": "904a9485-3857-458e-8b9d-33bc33842bc9",
+   "metadata": {},
+   "source": [
+    "## Define the Music Agent\n",
+    "\n",
+    "This agent is responsible for figuring out information about music. To do that, we will create a prompt and various tools for looking up information about music\n",
+    "\n",
+    "First, we will create indexes for looking up artists and track names.\n",
+    "This will allow us to look up artists and tracks without having to spell their names exactly right."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "a8604a3b-b484-4b2b-a914-4236cb98c524",
+   "metadata": {},
+   "outputs": [],
+   "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",
+   "id": "ac7eb264-c572-4925-ad55-a1d52a18b1c0",
+   "metadata": {},
+   "source": [
+    "First, let's create a tool for getting albums by artist."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "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",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "45e85066-f2fc-490e-992d-cd66c9cd6486",
+   "metadata": {},
+   "source": [
+    "Next, lets create a tool for getting tracks by an artist"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "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",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bb0e50ab-b059-427c-924b-f8072d8db23c",
+   "metadata": {},
+   "source": [
+    "Finally, let's create a tool for looking up songs by their name."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "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)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "88388ff8-38b5-4e4e-a24d-de8c3670bd2b",
+   "metadata": {},
+   "source": [
+    "Create the chain to call the relevant tools"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "72a14d5c",
+   "metadata": {},
+   "outputs": [],
+   "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",
+   "execution_count": 12,
+   "id": "cff15eb0-62c7-451d-a5f9-4576b24c879e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content='', additional_kwargs={'tool_calls': [{'index': 0, 'id': 'call_aXa9rSRXvTCJabrMY6AqkSV8', 'function': {'arguments': '{\"artist\":\"Amy Winehouse\"}', 'name': 'get_tracks_by_artist'}, 'type': 'function'}]}, response_metadata={'finish_reason': 'tool_calls', 'model_name': 'gpt-4o-2024-05-13', 'system_fingerprint': 'fp_ce0793330f'}, id='run-60633269-fd02-43e8-b434-28e3b8b69fb1-0', tool_calls=[{'name': 'get_tracks_by_artist', 'args': {'artist': 'Amy Winehouse'}, 'id': 'call_aXa9rSRXvTCJabrMY6AqkSV8'}])"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "msgs = [HumanMessage(content=\"hi! can you help me find songs by amy whinehouse?\")]\n",
+    "song_recc_chain.invoke(msgs)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0a42c293-0816-4f3c-b4a3-5b9f3a0665d1",
+   "metadata": {},
+   "source": [
+    "## Define the Generic Agent\n",
+    "\n",
+    "We now define a generic agent that is responsible for handling initial inquiries and routing to the right sub agent."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "73e74268",
+   "metadata": {},
+   "outputs": [],
+   "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",
+   "execution_count": 14,
+   "id": "ddf27314",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain = get_messages | model.bind_tools([Router])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "3c896f34",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content='', additional_kwargs={'tool_calls': [{'index': 0, 'id': 'call_0aaFPPCWDiAoPyXQX2PS8TcJ', 'function': {'arguments': '{\"choice\":\"music\"}', 'name': 'Router'}, 'type': 'function'}]}, response_metadata={'finish_reason': 'tool_calls', 'model_name': 'gpt-4o-2024-05-13', 'system_fingerprint': 'fp_ce0793330f'}, id='run-73d51d75-b7c5-49fe-b558-105ede7c75d1-0', tool_calls=[{'name': 'Router', 'args': {'choice': 'music'}, 'id': 'call_0aaFPPCWDiAoPyXQX2PS8TcJ'}])"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "msgs = [HumanMessage(content=\"hi! can you help me find a good song?\")]\n",
+    "chain.invoke(msgs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "40d86f59",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content='', additional_kwargs={'tool_calls': [{'index': 0, 'id': 'call_Okla9DfMHIPs5TslS6KPaoBA', 'function': {'arguments': '{\"choice\":\"customer\"}', 'name': 'Router'}, 'type': 'function'}]}, response_metadata={'finish_reason': 'tool_calls', 'model_name': 'gpt-4o-2024-05-13', 'system_fingerprint': 'fp_4008e3b719'}, id='run-0d82d4f8-f4eb-4b16-add8-3e7fdffd6332-0', tool_calls=[{'name': 'Router', 'args': {'choice': 'customer'}, 'id': 'call_Okla9DfMHIPs5TslS6KPaoBA'}])"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "msgs = [HumanMessage(content=\"hi! what's the email you have for me?\")]\n",
+    "chain.invoke(msgs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "bd6ddd8b-7500-46a7-811d-3bcb937bda51",
+   "metadata": {},
+   "outputs": [],
+   "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",
+   "execution_count": 18,
+   "id": "27494de5-8345-4c23-bc0e-81e0dd5d47d8",
+   "metadata": {},
+   "outputs": [],
+   "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",
+   "execution_count": 19,
+   "id": "8aec704a-46fe-4fb3-bdee-11c3bbffc370",
+   "metadata": {},
+   "outputs": [],
+   "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",
+   "execution_count": 20,
+   "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"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "fd4dbf98-dbb3-411a-bad6-2bb334072aaf",
+   "metadata": {},
+   "outputs": [],
+   "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",
+   "execution_count": 22,
+   "id": "dcade924",
+   "metadata": {},
+   "outputs": [],
+   "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",
+   "execution_count": 23,
+   "id": "ac65d6d2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "User (q/Q to quit):  what music do you have?\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Output from node 'general':\n",
+      "---\n",
+      "content='' additional_kwargs={'tool_calls': [{'index': 0, 'id': 'call_iste6NuKvZou8O9QudOectOU', 'function': {'arguments': '{\"choice\":\"music\"}', 'name': 'Router'}, 'type': 'function'}]} response_metadata={'finish_reason': 'tool_calls', 'model_name': 'gpt-4o-2024-05-13', 'system_fingerprint': 'fp_4008e3b719'} name='general' id='run-9eb940ff-6592-43ae-aa34-22c3d630ac65-0' tool_calls=[{'name': 'Router', 'args': {'choice': 'music'}, 'id': 'call_iste6NuKvZou8O9QudOectOU'}]\n",
+      "\n",
+      "---\n",
+      "\n",
+      "Output from node 'music':\n",
+      "---\n",
+      "content=\"I can help you find songs and albums by specific artists, or check if a particular song exists. Just let me know the name of the artist or song you're interested in!\" response_metadata={'finish_reason': 'stop', 'model_name': 'gpt-4o-2024-05-13', 'system_fingerprint': 'fp_4008e3b719'} name='music' id='run-91f560e7-ffa5-437f-afda-27490cbd1efe-0'\n",
+      "\n",
+      "---\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "User (q/Q to quit):  how about shakira?\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Output from node 'general':\n",
+      "---\n",
+      "content='' additional_kwargs={'tool_calls': [{'index': 0, 'id': 'call_fH4oKyA3U9aQy3p31MYXv2VP', 'function': {'arguments': '{\"choice\":\"music\"}', 'name': 'Router'}, 'type': 'function'}]} response_metadata={'finish_reason': 'tool_calls', 'model_name': 'gpt-4o-2024-05-13', 'system_fingerprint': 'fp_d576307f90'} name='general' id='run-6f2eee09-9e3e-4011-a045-196cc5baa1ee-0' tool_calls=[{'name': 'Router', 'args': {'choice': 'music'}, 'id': 'call_fH4oKyA3U9aQy3p31MYXv2VP'}]\n",
+      "\n",
+      "---\n",
+      "\n",
+      "Output from node 'music':\n",
+      "---\n",
+      "content='' additional_kwargs={'tool_calls': [{'index': 0, 'id': 'call_qivZqsI8zQAqSDP2jsvHyR7T', 'function': {'arguments': '{\"artist\": \"Shakira\"}', 'name': 'get_albums_by_artist'}, 'type': 'function'}, {'index': 1, 'id': 'call_GER0B3vlAjxcvYOYq1NGlV4r', 'function': {'arguments': '{\"artist\": \"Shakira\"}', 'name': 'get_tracks_by_artist'}, 'type': 'function'}]} response_metadata={'finish_reason': 'tool_calls', 'model_name': 'gpt-4o-2024-05-13', 'system_fingerprint': 'fp_ce0793330f'} name='music' id='run-38e2eca8-771c-48a2-83be-023fd17fc6f6-0' tool_calls=[{'name': 'get_albums_by_artist', 'args': {'artist': 'Shakira'}, 'id': 'call_qivZqsI8zQAqSDP2jsvHyR7T'}, {'name': 'get_tracks_by_artist', 'args': {'artist': 'Shakira'}, 'id': 'call_GER0B3vlAjxcvYOYq1NGlV4r'}]\n",
+      "\n",
+      "---\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/wfh/code/lc/langchain/libs/core/langchain_core/_api/deprecation.py:139: LangChainDeprecationWarning: The method `BaseRetriever.get_relevant_documents` was deprecated in langchain-core 0.1.46 and will be removed in 0.3.0. Use invoke instead.\n",
+      "  warn_deprecated(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Output from node 'tools':\n",
+      "---\n",
+      "[ToolMessage(content=\"[{'Title': 'Supernatural', 'Name': 'Santana'}, {'Title': 'Santana - As Years Go By', 'Name': 'Santana'}, {'Title': 'Santana Live', 'Name': 'Santana'}, {'Title': 'Lulu Santos - RCA 100 Anos De Música - Álbum 01', 'Name': 'Lulu Santos'}, {'Title': 'Lulu Santos - RCA 100 Anos De Música - Álbum 02', 'Name': 'Lulu Santos'}]\", name='get_albums_by_artist', id='14ad12f3-afa1-4375-a89d-e878babf2d95', tool_call_id='call_qivZqsI8zQAqSDP2jsvHyR7T'), ToolMessage(content='[{\\'SongName\\': \\'(Da Le) Yaleo\\', \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \\'Love Of My Life\\', \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \\'Put Your Lights On\\', \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \\'Africa Bamba\\', \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \\'Smooth\\', \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \\'Do You Like The Way\\', \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \\'Maria Maria\\', \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \\'Migra\\', \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \\'Corazon Espinado\\', \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \\'Wishing It Was\\', \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \\'El Farol\\', \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \\'Primavera\\', \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \\'The Calling\\', \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \\'Jingo\\', \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \\'El Corazon Manda\\', \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \\'La Puesta Del Sol\\', \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \\'Persuasion\\', \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \\'As The Years Go by\\', \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \\'Soul Sacrifice\\', \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \\'Fried Neckbones And Home Fries\\', \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \\'Santana Jam\\', \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \\'Evil Ways\\', \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \"We\\'ve Got To Get Together/Jingo\", \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \\'Rock Me\\', \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \"Just Ain\\'t Good Enough\", \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \\'Funky Piano\\', \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \\'The Way You Do To Mer\\', \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \\'Assim Caminha A Humanidade\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'Um Pro Outro\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'Casa\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'Condição\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'Satisfação\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'Brumário\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'Sábado À Noite\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'A Cura\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'Atrás Do Trio Elétrico\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'Tudo Bem\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'Toda Forma De Amor\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'Sereia\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'Se Você Pensa\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'Lá Vem O Sol (Here Comes The Sun)\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'Honolulu\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'Dancin´Days\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'Aviso Aos Navegantes\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'Hyperconectividade\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'O Descobridor Dos Sete Mares\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'Um Certo Alguém\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'Fullgás\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'Aquilo\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'Senta A Pua\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'Ro-Que-Se-Da-Ne\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'Tudo Igual\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'Fogo De Palha\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'Assaltaram A Gramática\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'O Último Romântico (Ao Vivo)\\', \\'ArtistName\\': \\'Lulu Santos\\'}]', name='get_tracks_by_artist', id='4ddcebc3-8e4e-42d4-8ae4-3ce3a62b548c', tool_call_id='call_GER0B3vlAjxcvYOYq1NGlV4r')]\n",
+      "\n",
+      "---\n",
+      "\n",
+      "Output from node 'music':\n",
+      "---\n",
+      "content=\"It seems I couldn't find specific albums or songs by Shakira, but I did find some related artists and their works. Here are some albums and songs by Santana and Lulu Santos:\\n\\n### Albums:\\n- **Santana:**\\n  - Supernatural\\n  - Santana - As Years Go By\\n  - Santana Live\\n\\n- **Lulu Santos:**\\n  - Lulu Santos - RCA 100 Anos De Música - Álbum 01\\n  - Lulu Santos - RCA 100 Anos De Música - Álbum 02\\n\\n### Songs:\\n- **Santana:**\\n  - (Da Le) Yaleo\\n  - Love Of My Life\\n  - Put Your Lights On\\n  - Africa Bamba\\n  - Smooth\\n  - Maria Maria\\n  - Corazon Espinado\\n  - Jingo\\n  - Evil Ways\\n\\n- **Lulu Santos:**\\n  - Assim Caminha A Humanidade\\n  - Um Pro Outro\\n  - Casa\\n  - Condição\\n  - Satisfação\\n  - A Cura\\n  - Atrás Do Trio Elétrico\\n  - Toda Forma De Amor\\n  - Sereia\\n  - Se Você Pensa\\n\\nIf you have any other specific artists or songs in mind, feel free to let me know!\" response_metadata={'finish_reason': 'stop', 'model_name': 'gpt-4o-2024-05-13', 'system_fingerprint': 'fp_d576307f90'} name='music' id='run-3d90d7cc-e7f7-48dc-bffd-00765c3f5d13-0'\n",
+      "\n",
+      "---\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "User (q/Q to quit):  hm cool\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Output from node 'general':\n",
+      "---\n",
+      "content='' additional_kwargs={'tool_calls': [{'index': 0, 'id': 'call_Nc5d0TWNbpnVJFeYJdQFuFGd', 'function': {'arguments': '{\"choice\":\"music\"}', 'name': 'Router'}, 'type': 'function'}]} response_metadata={'finish_reason': 'tool_calls', 'model_name': 'gpt-4o-2024-05-13', 'system_fingerprint': 'fp_4008e3b719'} name='general' id='run-19a3588e-f04c-48db-a54f-95d6b930ee3e-0' tool_calls=[{'name': 'Router', 'args': {'choice': 'music'}, 'id': 'call_Nc5d0TWNbpnVJFeYJdQFuFGd'}]\n",
+      "\n",
+      "---\n",
+      "\n",
+      "Output from node 'music':\n",
+      "---\n",
+      "content='' additional_kwargs={'tool_calls': [{'index': 0, 'id': 'call_weMHkgu3GYaMwXZM6hnCZd0z', 'function': {'arguments': '{\"artist\": \"Shakira\"}', 'name': 'get_albums_by_artist'}, 'type': 'function'}, {'index': 1, 'id': 'call_rXlVbPiEHbt10CNDUJ5GA2ZQ', 'function': {'arguments': '{\"artist\": \"Shakira\"}', 'name': 'get_tracks_by_artist'}, 'type': 'function'}]} response_metadata={'finish_reason': 'tool_calls', 'model_name': 'gpt-4o-2024-05-13', 'system_fingerprint': 'fp_ce0793330f'} name='music' id='run-71bf8550-b5a8-423f-b463-83d9ff51391b-0' tool_calls=[{'name': 'get_albums_by_artist', 'args': {'artist': 'Shakira'}, 'id': 'call_weMHkgu3GYaMwXZM6hnCZd0z'}, {'name': 'get_tracks_by_artist', 'args': {'artist': 'Shakira'}, 'id': 'call_rXlVbPiEHbt10CNDUJ5GA2ZQ'}]\n",
+      "\n",
+      "---\n",
+      "\n",
+      "Output from node 'tools':\n",
+      "---\n",
+      "[ToolMessage(content=\"[{'Title': 'Supernatural', 'Name': 'Santana'}, {'Title': 'Santana - As Years Go By', 'Name': 'Santana'}, {'Title': 'Santana Live', 'Name': 'Santana'}, {'Title': 'Lulu Santos - RCA 100 Anos De Música - Álbum 01', 'Name': 'Lulu Santos'}, {'Title': 'Lulu Santos - RCA 100 Anos De Música - Álbum 02', 'Name': 'Lulu Santos'}]\", name='get_albums_by_artist', id='52ada997-83f6-4500-b0a7-1104d4d38eb9', tool_call_id='call_weMHkgu3GYaMwXZM6hnCZd0z'), ToolMessage(content='[{\\'SongName\\': \\'(Da Le) Yaleo\\', \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \\'Love Of My Life\\', \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \\'Put Your Lights On\\', \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \\'Africa Bamba\\', \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \\'Smooth\\', \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \\'Do You Like The Way\\', \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \\'Maria Maria\\', \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \\'Migra\\', \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \\'Corazon Espinado\\', \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \\'Wishing It Was\\', \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \\'El Farol\\', \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \\'Primavera\\', \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \\'The Calling\\', \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \\'Jingo\\', \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \\'El Corazon Manda\\', \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \\'La Puesta Del Sol\\', \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \\'Persuasion\\', \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \\'As The Years Go by\\', \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \\'Soul Sacrifice\\', \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \\'Fried Neckbones And Home Fries\\', \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \\'Santana Jam\\', \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \\'Evil Ways\\', \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \"We\\'ve Got To Get Together/Jingo\", \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \\'Rock Me\\', \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \"Just Ain\\'t Good Enough\", \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \\'Funky Piano\\', \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \\'The Way You Do To Mer\\', \\'ArtistName\\': \\'Santana\\'}, {\\'SongName\\': \\'Assim Caminha A Humanidade\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'Um Pro Outro\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'Casa\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'Condição\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'Satisfação\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'Brumário\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'Sábado À Noite\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'A Cura\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'Atrás Do Trio Elétrico\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'Tudo Bem\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'Toda Forma De Amor\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'Sereia\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'Se Você Pensa\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'Lá Vem O Sol (Here Comes The Sun)\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'Honolulu\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'Dancin´Days\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'Aviso Aos Navegantes\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'Hyperconectividade\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'O Descobridor Dos Sete Mares\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'Um Certo Alguém\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'Fullgás\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'Aquilo\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'Senta A Pua\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'Ro-Que-Se-Da-Ne\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'Tudo Igual\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'Fogo De Palha\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'Assaltaram A Gramática\\', \\'ArtistName\\': \\'Lulu Santos\\'}, {\\'SongName\\': \\'O Último Romântico (Ao Vivo)\\', \\'ArtistName\\': \\'Lulu Santos\\'}]', name='get_tracks_by_artist', id='7583e077-2fb4-44bf-bb00-b89d599ae84d', tool_call_id='call_rXlVbPiEHbt10CNDUJ5GA2ZQ')]\n",
+      "\n",
+      "---\n",
+      "\n",
+      "Output from node 'music':\n",
+      "---\n",
+      "content=\"It seems like I couldn't find specific albums or songs by Shakira. However, I did find some related artists and their works. Here are some albums and songs by Santana and Lulu Santos:\\n\\n### Albums:\\n1. **Santana**\\n   - Supernatural\\n   - Santana - As Years Go By\\n   - Santana Live\\n\\n2. **Lulu Santos**\\n   - RCA 100 Anos De Música - Álbum 01\\n   - RCA 100 Anos De Música - Álbum 02\\n\\n### Songs:\\n1. **Santana**\\n   - (Da Le) Yaleo\\n   - Love Of My Life\\n   - Put Your Lights On\\n   - Africa Bamba\\n   - Smooth\\n   - Maria Maria\\n   - Corazon Espinado\\n   - Jingo\\n   - Evil Ways\\n\\n2. **Lulu Santos**\\n   - Assim Caminha A Humanidade\\n   - Um Pro Outro\\n   - Casa\\n   - Condição\\n   - Satisfação\\n   - A Cura\\n   - Atrás Do Trio Elétrico\\n   - Toda Forma De Amor\\n   - Sereia\\n\\nIf you have any other artists or songs in mind, feel free to let me know!\" response_metadata={'finish_reason': 'stop', 'model_name': 'gpt-4o-2024-05-13', 'system_fingerprint': 'fp_d576307f90'} name='music' id='run-2418b45b-2762-49ca-b166-a0fee309ed9e-0'\n",
+      "\n",
+      "---\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "User (q/Q to quit):  q\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "AI: Byebye\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\")"
    ]
   }
  ],

examples/cloud_examples/webhooks.ipynb

@@ -6,7 +6,7 @@
    "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",
+    "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",

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/create-react-agent-hitl.ipynb

@@ -1,247 +1,247 @@
 {
- "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": 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.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": 4,
+      "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 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": [
+        {
+          "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": [
+        {
+          "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"
+          ]
+        }
+      ],
+      "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.12.2"
     }
-   ],
-   "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,255 @@
 {
- "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\"))"
+      ]
+    },
+    {
+      "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"
     }
-   ],
-   "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

@@ -9,7 +9,7 @@
     "\n",
     "This tutorial will show how to add a custom system prompt 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 custom system prompt by passing a string to the `messages_modifier` param."
+    "You can add a custom system prompt by passing a string to the `state_modifier` param."
    ]
   },
   {
@@ -112,7 +112,7 @@
     "\n",
     "from langgraph.prebuilt import create_react_agent\n",
     "\n",
-    "graph = create_react_agent(model, tools=tools, messages_modifier=prompt)"
+    "graph = create_react_agent(model, tools=tools, state_modifier=prompt)"
    ]
   },
   {

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": {