Merge branch 'main' into wfh/cli_from_module

This PR only allows this in the HTTP client. 

I can follow up with a PR to allow throughout the entire API.

The use case is to allow instantiating the client once (w/ a single connection pool), but allowing changing api keys and any other headers at run time

.github/workflows/_lint.yml

@@ -54,7 +54,7 @@ jobs:
         if: steps.changed-files.outputs.all
         shell: bash
         working-directory: ${{ inputs.working-directory }}
-        run: poetry lock --check
+        run: poetry check --lock
 
       - name: Install dependencies
         if: steps.changed-files.outputs.all

.github/workflows/_test.yml

@@ -39,6 +39,12 @@ jobs:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_RO_TOKEN }}
 
+      - name: Check Lock
+        shell: bash
+        working-directory: ${{ inputs.working-directory }}
+        run: |
+          poetry check --lock
+
       - name: Install dependencies
         shell: bash
         working-directory: ${{ inputs.working-directory }}

.github/workflows/ci.yml

@@ -20,7 +20,31 @@ env:
   POETRY_VERSION: "1.7.1"
 
 jobs:
+  changes:
+    runs-on: ubuntu-latest
+    outputs:
+      python: ${{ steps.filter.outputs.python }}
+      sdk-js: ${{ steps.filter.outputs.sdk-js }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dorny/paths-filter@v3
+        id: filter
+        with:
+          filters: |
+            python:
+              - 'libs/langgraph/**'
+              - 'libs/sdk-py/**'
+              - 'libs/cli/**'
+              - 'libs/checkpoint/**'
+              - 'libs/checkpoint-sqlite/**'
+              - 'libs/checkpoint-postgres/**'
+              - 'libs/scheduler-kafka/**'
+              - 'libs/prebuilt/**'
+            sdk-js:
+              - 'libs/sdk-js/**'
+
   lint:
+    needs: changes
     name: cd ${{ matrix.working-directory }}
     strategy:
       matrix:
@@ -33,13 +57,16 @@ jobs:
             "libs/checkpoint-sqlite",
             "libs/checkpoint-postgres",
             "libs/scheduler-kafka",
+            "libs/prebuilt",
           ]
+    if: needs.changes.outputs.python == 'true'
     uses: ./.github/workflows/_lint.yml
     with:
       working-directory: ${{ matrix.working-directory }}
     secrets: inherit
 
   test:
+    needs: changes
     name: cd ${{ matrix.working-directory }}
     strategy:
       matrix:
@@ -49,7 +76,9 @@ jobs:
             "libs/checkpoint",
             "libs/checkpoint-sqlite",
             "libs/checkpoint-postgres",
+            "libs/prebuilt",
           ]
+    if: needs.changes.outputs.python == 'true'
     uses: ./.github/workflows/_test.yml
     with:
       working-directory: ${{ matrix.working-directory }}
@@ -57,17 +86,23 @@ jobs:
 
   # NOTE: we're testing langgraph separately because it requires a different matrix
   test-langgraph:
+    needs: changes
+    if: needs.changes.outputs.python == 'true'
     name: "cd libs/langgraph"
     uses: ./.github/workflows/_test_langgraph.yml
     secrets: inherit
 
   # NOTE: we're testing scheduler-kafka separately because it requires a different matrix
   test-scheduler-kafka:
+    needs: changes
+    if: needs.changes.outputs.python == 'true'
     name: "cd libs/scheduler-kafka"
     uses: ./.github/workflows/_test_scheduler_kafka.yml
     secrets: inherit
 
   check-sdk-methods:
+    needs: changes
+    if: needs.changes.outputs.python == 'true'
     name: "Check SDK methods matching"
     runs-on: ubuntu-latest
     steps:
@@ -79,12 +114,52 @@ jobs:
       - name: Run check_sdk_methods script
         run: python .github/scripts/check_sdk_methods.py
 
+  check-schema:
+    needs: changes
+    if: needs.changes.outputs.python == 'true'
+    name: "Check CLI schema hasn't changed #${{ matrix.python-version }}"
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version:
+          - "3.11"
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Python ${{ matrix.python-version }} + Poetry ${{ env.POETRY_VERSION }}
+        uses: "./.github/actions/poetry_setup"
+        with:
+          python-version: "3.11"
+          poetry-version: ${{ env.POETRY_VERSION }}
+          cache-key: schema-check-cli
+      - name: Install CLI dependencies
+        run: |
+          cd libs/cli
+          poetry install
+      - name: Generate schema and check for changes
+        run: |
+          cd libs/cli
+          # Create a temporary copy of the current schema
+          cp schemas/schema.json schemas/schema.current.json
+          # Generate new schema
+          poetry run python generate_schema.py
+          # Compare the new schema with the original
+          if ! diff -q schemas/schema.json schemas/schema.current.json > /dev/null; then
+            echo "Error: Langgraph.json configuration schema has changed. Please run 'poetry run python generate_schema.py' in the libs/cli directory and commit the changes."
+            diff schemas/schema.json schemas/schema.current.json
+            exit 1
+          fi
+          echo "Schema check passed - no changes detected"
+
   integration-test:
+    needs: changes
+    if: needs.changes.outputs.python == 'true'
     name: CLI integration test
     uses: ./.github/workflows/_integration_test.yml
     secrets: inherit
 
   lint-js:
+    needs: changes
+    if: needs.changes.outputs.sdk-js == 'true'
     runs-on: ubuntu-latest
     strategy:
       matrix:
@@ -109,6 +184,8 @@ jobs:
         run: yarn build
 
   test-js:
+    needs: changes
+    if: needs.changes.outputs.sdk-js == 'true'
     runs-on: ubuntu-latest
     strategy:
       matrix:
@@ -139,6 +216,8 @@ jobs:
         test,
         test-langgraph,
         test-scheduler-kafka,
+        check-sdk-methods,
+        check-schema,
         integration-test,
         test-js,
       ]

.github/workflows/deploy_docs.yml

@@ -78,15 +78,23 @@ jobs:
             pytest \
             pytest-check-links \
             GitPython \
-            "git+https://${GITHUB_TOKEN}@github.com/langchain-ai/mkdocs-material-insiders.git" \
             "git+https://github.com/benjamincburns/markdown-exec.git@cc0d39d737e5ffd4b83d23cd8729d7ea16e363c8"
 
+          # we run this installation only for internal PRs
+          # as GITHUB_TOKEN is not available for PRs from outside contributors
+          if [ -n "${GITHUB_TOKEN}" ]; then
+            poetry run pip install "git+https://${GITHUB_TOKEN}@github.com/langchain-ai/mkdocs-material-insiders.git"
+          fi
+
           poetry run jupyter kernelspec list
           poetry run python3 -m ipykernel install --user --name=python3
           npm install -g tslab
           poetry run tslab install --python=python3
           poetry run jupyter kernelspec list
 
+      - name: Run unit tests
+        # Run unit tests on the docs build pipeline
+        run: make tests
       - name: Lint Docs
         # This step lints the docs using the existing linting set up.
         # It should be very fast and should not require any external services.
@@ -94,7 +102,14 @@ jobs:
       - name: Build llms-text
         run: make llms-text
       - name: Build site
-        run: make build-docs
+        run: |
+          # If this is main branch, then we want to download stats. we do this 
+          # with the env variable DOWNLOAD_STATS=true
+          if [ "${{ github.ref }}" == "refs/heads/main" ]; then
+            DOWNLOAD_STATS=true make build-docs
+          else
+            make build-docs
+          fi
         env:
           MKDOCS_GIT_COMMITTERS_APIKEY: ${{ secrets.MKDOCS_GIT_COMMITTERS_APIKEY }}
           OPENAI_API_KEY: sf-proj-1234567890 # fake placeholder, shouldn't actually be used
@@ -109,6 +124,7 @@ jobs:
               --check-links-ignore "https://(api|web|docs)\.smith\.langchain\.com/.*" \
               --check-links-ignore "https://academy\.langchain\.com/.*" \
               --check-links-ignore "https://x.com/.*" \
+              --check-links-ignore "https://twitter.com/.*" \
               --check-links-ignore "https://github\.com/.*" \
               --check-links-ignore "http://localhost:8123/.*" \
               --check-links-ignore "http://localhost:2024.*" \
@@ -118,6 +134,7 @@ jobs:
               --check-links-ignore "https://openai\.com/.*" \
               --check-links-ignore "https://www\.uber\.com/.*" \
               --check-links-ignore "https://pepy\.tech/.*" \
+              --check-links-ignore "docs/docs/static/wordmark_*" \
               --check-links $(find site -name "index.html" | grep -v 'storm/index.html')
               
           else
@@ -135,8 +152,10 @@ jobs:
                 --check-links-ignore "http://localhost:2024.*" \
                 --check-links-ignore "http://127.0.0.1:.*" \
                 --check-links-ignore "https://x.com/.*" \
+                --check-links-ignore "https://twitter.com/.*" \
                 --check-links-ignore "https://github\.com/.*" \
                 --check-links-ignore "/.*\.(ipynb|html)$" \
+                --check-links-ignore "docs/docs/static/wordmark_*" \
                 --check-links ${CHANGED_FILES} \
                 || ([ $? = 5 ] && exit 0 || exit $?)
             else

.github/workflows/release.yml

@@ -195,7 +195,11 @@ jobs:
               "$PKG_NAME==$VERSION" \
           )
 
-          if [[ "$PKG_NAME" == *checkpoint* ]]; then
+          if [[ "$PKG_NAME" == *prebuilt* ]]; then
+            poetry run pip install langgraph
+          fi
+
+          if [[ "$PKG_NAME" == *checkpoint* || "$PKG_NAME" == *prebuilt* ]]; 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)"

.github/workflows/run_notebooks.yml

@@ -57,13 +57,13 @@ jobs:
         env:
           # these won't actually be used because of the VCR cassettes
           # but need to set them to avoid triggering getpass()
-          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
-          TAVILY_API_KEY: ${{ secrets.TAVILY_API_KEY }}
-          LANGSMITH_API_KEY: ${{ secrets.LANGSMITH_API_KEY }}
-          NOMIC_API_KEY: ${{ secrets.NOMIC_API_KEY }}
-          COHERE_API_KEY: ${{ secrets.COHERE_API_KEY }}
-          FIREWORKS_API_KEY: ${{ secrets.FIREWORKS_API_KEY }}
+          OPENAI_API_KEY: "very-secret-key"
+          ANTHROPIC_API_KEY: "very-secret-key"
+          TAVILY_API_KEY: "very-secret-key"
+          LANGSMITH_API_KEY: "very-secret-key"
+          NOMIC_API_KEY: "very-secret-key"
+          COHERE_API_KEY: "very-secret-key"
+          FIREWORKS_API_KEY: "very-secret-key"
         run: |
           if [ "${{ github.event_name }}" = "workflow_dispatch" ] || [ "${{ github.event_name }}" = "schedule" ]; then
             echo "Running all notebooks"

.github/workflows/size.yml

@@ -1,29 +0,0 @@
-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
-        # TODO: roll back the web voyager hack
-        run: |
-          large_added_files=$(find ${{ steps.changed-files.outputs.added_files }} -maxdepth 0 -size +1M | grep -v "web_voyager" || true)
-          if [ -n "$large_added_files" ]; then
-            echo "Large files added: $large_added_files"
-            echo "# Large files added:" >> $GITHUB_STEP_SUMMARY
-            echo "$large_added_files" >> $GITHUB_STEP_SUMMARY
-            exit 1
-          fi

README.md

@@ -1,339 +1,87 @@
-# 🦜🕸️LangGraph
+<picture class="github-only">
+  <source media="(prefers-color-scheme: light)" srcset="https://langchain-ai.github.io/langgraph/static/wordmark_dark.svg">
+  <source media="(prefers-color-scheme: dark)" srcset="https://langchain-ai.github.io/langgraph/static/wordmark_light.svg">
+  <img alt="LangGraph Logo" src="https://langchain-ai.github.io/langgraph/static/wordmark_dark.svg" width="80%">
+</picture>
 
-![Version](https://img.shields.io/pypi/v/langgraph)
+<div>
+<br>
+</div>
+
+[![Version](https://img.shields.io/pypi/v/langgraph.svg)](https://pypi.org/project/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)
 [![Docs](https://img.shields.io/badge/docs-latest-blue)](https://langchain-ai.github.io/langgraph/)
 
-⚡ Building language agents as graphs ⚡
-
 > [!NOTE]
 > Looking for the JS version? See the [JS repo](https://github.com/langchain-ai/langgraphjs) and the [JS docs](https://langchain-ai.github.io/langgraphjs/).
 
-## Overview
+LangGraph — used by Replit, Uber, LinkedIn, GitLab and more — is a low-level orchestration framework for building controllable agents. While langchain provides integrations and composable components to streamline LLM application development, the LangGraph library enables agent orchestration — offering customizable architectures, long-term memory, and human-in-the-loop to reliably handle complex tasks.
 
-[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. Check out an introductory tutorial [here](https://langchain-ai.github.io/langgraph/tutorials/introduction/).
-
-
-LangGraph is inspired by [Pregel](https://research.google/pubs/pub37252/) and [Apache Beam](https://beam.apache.org/). The public interface draws inspiration from [NetworkX](https://networkx.org/documentation/latest/). LangGraph is built by LangChain Inc, the creators of LangChain, but can be used without LangChain.
-
-### Why use LangGraph?
-
-LangGraph powers [production-grade agents](https://www.langchain.com/built-with-langgraph), trusted by Linkedin, Uber, Klarna, GitLab, and many more. LangGraph provides fine-grained control over both the flow and state of your agent applications. It implements a central [persistence layer](https://langchain-ai.github.io/langgraph/concepts/persistence/), enabling features that are common to most agent architectures:
-
-- **Memory**: LangGraph persists arbitrary aspects of your application's state,
-supporting memory of conversations and other updates within and across user
-interactions;
-- **Human-in-the-loop**: Because state is checkpointed, execution can be interrupted
-and resumed, allowing for decisions, validation, and corrections at key stages via
-human input.
-
-Standardizing these components allows individuals and teams to focus on the behavior
-of their agent, instead of its supporting infrastructure.
-
-Through [LangGraph Platform](#langgraph-platform), LangGraph also provides tooling for
-the development, deployment, debugging, and monitoring of your applications.
-
-LangGraph integrates seamlessly with
-[LangChain](https://python.langchain.com/docs/introduction/) and
-[LangSmith](https://docs.smith.langchain.com/) (but does not require them).
-
-To learn more about LangGraph, check out our first LangChain Academy
-course, *Introduction to LangGraph*, available for free
-[here](https://academy.langchain.com/courses/intro-to-langgraph).
-
-### LangGraph Platform
-
-[LangGraph Platform](https://langchain-ai.github.io/langgraph/concepts/langgraph_platform) is infrastructure for deploying LangGraph agents. It is a commercial solution for deploying agentic applications to production, built on the open-source LangGraph framework. The LangGraph Platform consists of several components that work together to support the development, deployment, debugging, and monitoring of LangGraph applications: [LangGraph Server](https://langchain-ai.github.io/langgraph/concepts/langgraph_server) (APIs), [LangGraph SDKs](https://langchain-ai.github.io/langgraph/concepts/sdk) (clients for the APIs), [LangGraph CLI](https://langchain-ai.github.io/langgraph/concepts/langgraph_cli) (command line tool for building the server), and [LangGraph Studio](https://langchain-ai.github.io/langgraph/concepts/langgraph_studio) (UI/debugger).
-
-See deployment options [here](https://langchain-ai.github.io/langgraph/concepts/deployment_options/)
-(includes a free tier).
-
-Here are some common issues that arise in complex deployments, which LangGraph Platform addresses:
-
-- **Streaming support**: LangGraph Server provides [multiple streaming modes](https://langchain-ai.github.io/langgraph/concepts/streaming) optimized for various application needs
-- **Background runs**: Runs agents asynchronously in the background
-- **Support for long running agents**: Infrastructure that can handle long running processes
-- **[Double texting](https://langchain-ai.github.io/langgraph/concepts/double_texting)**: Handle the case where you get two messages from the user before the agent can respond
-- **Handle burstiness**: Task queue for ensuring requests are handled consistently without loss, even under heavy loads
-
-## Installation
-
-```shell
+```bash
 pip install -U langgraph
 ```
 
-## Example
-
-Let's build a tool-calling [ReAct-style](https://langchain-ai.github.io/langgraph/concepts/agentic_concepts/#react-implementation) agent that uses a search tool!
-
-```shell
-pip install langchain-anthropic
-```
-
-```shell
-export ANTHROPIC_API_KEY=sk-...
-```
-
-Optionally, we can set up [LangSmith](https://docs.smith.langchain.com/) for best-in-class observability.
-
-```shell
-export LANGSMITH_TRACING=true
-export LANGSMITH_API_KEY=lsv2_sk_...
-```
-
-The simplest way to create a tool-calling agent in LangGraph is to use `create_react_agent`:
-
-<details open>
-  <summary>High-level implementation</summary>
+To learn more about how to use LangGraph, check out [the docs](https://langchain-ai.github.io/langgraph/). We show a simple example below of how to create a ReAct agent.
 
 ```python
+# This code depends on pip install langchain[anthropic]
 from langgraph.prebuilt import create_react_agent
-from langgraph.checkpoint.memory import MemorySaver
-from langchain_anthropic import ChatAnthropic
-from langchain_core.tools import tool
 
-# Define the tools for the agent to use
-@tool
 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."
 
-
-tools = [search]
-model = ChatAnthropic(model="claude-3-5-sonnet-latest", temperature=0)
-
-# Initialize memory to persist state between graph runs
-checkpointer = MemorySaver()
-
-app = create_react_agent(model, tools, checkpointer=checkpointer)
-
-# Use the agent
-final_state = app.invoke(
-    {"messages": [{"role": "user", "content": "what is the weather in sf"}]},
-    config={"configurable": {"thread_id": 42}}
+agent = create_react_agent("anthropic:claude-3-7-sonnet-latest", tools=[search])
+agent.invoke(
+    {"messages": [{"role": "user", "content": "what is the weather in sf"}]}
 )
-final_state["messages"][-1].content
-```
-```
-"Based on the search results, I can tell you that the current weather in San Francisco is:\n\nTemperature: 60 degrees Fahrenheit\nConditions: Foggy\n\nSan Francisco is known for its microclimates and frequent fog, especially during the summer months. The temperature of 60°F (about 15.5°C) is quite typical for the city, which tends to have mild temperatures year-round. The fog, often referred to as "Karl the Fog" by locals, is a characteristic feature of San Francisco\'s weather, particularly in the mornings and evenings.\n\nIs there anything else you\'d like to know about the weather in San Francisco or any other location?"
 ```
 
-Now when we pass the same <code>"thread_id"</code>, the conversation context is retained via the saved state (i.e. stored list of messages)
+## Why use LangGraph?
 
-```python
-final_state = app.invoke(
-    {"messages": [{"role": "user", "content": "what about ny"}]},
-    config={"configurable": {"thread_id": 42}}
-)
-final_state["messages"][-1].content
-```
+LangGraph is built for developers who want to build powerful, adaptable AI agents. Developers choose LangGraph for:
 
-```
-"Based on the search results, I can tell you that the current weather in New York City is:\n\nTemperature: 90 degrees Fahrenheit (approximately 32.2 degrees Celsius)\nConditions: Sunny\n\nThis weather is quite different from what we just saw in San Francisco. New York is experiencing much warmer temperatures right now. Here are a few points to note:\n\n1. The temperature of 90°F is quite hot, typical of summer weather in New York City.\n2. The sunny conditions suggest clear skies, which is great for outdoor activities but also means it might feel even hotter due to direct sunlight.\n3. This kind of weather in New York often comes with high humidity, which can make it feel even warmer than the actual temperature suggests.\n\nIt's interesting to see the stark contrast between San Francisco's mild, foggy weather and New York's hot, sunny conditions. This difference illustrates how varied weather can be across different parts of the United States, even on the same day.\n\nIs there anything else you'd like to know about the weather in New York or any other location?"
-```
-</details>
+- **Reliability and controllability.** Steer agent actions with moderation checks and human-in-the-loop approvals. LangGraph persists context for long-running workflows, keeping your agents on course.
+- **Low-level and extensible.** Build custom agents with fully descriptive, low-level primitives – free from rigid abstractions that limit customization. Design scalable multi-agent systems, with each agent serving a specific role tailored to your use case.
+- **First-class streaming support.** With token-by-token streaming and streaming of intermediate steps, LangGraph gives users clear visibility into agent reasoning and actions as they unfold in real time.
 
-> [!TIP]
-> LangGraph is a **low-level** framework that allows you to implement any custom agent
-architectures. Click on the low-level implementation below to see how to implement a
-tool-calling agent from scratch.
+LangGraph is trusted in production and powering agents for companies like:
 
-<details>
-<summary>Low-level implementation</summary>
+- [Klarna](https://blog.langchain.dev/customers-klarna/): Customer support bot for 85 million active users
+- [Elastic](https://www.elastic.co/blog/elastic-security-generative-ai-features): Security AI assistant for threat detection
+- [Uber](https://dpe.org/sessions/ty-smith-adam-huda/this-year-in-ubers-ai-driven-developer-productivity-revolution/): Automated unit test generation
+- [Replit](https://www.langchain.com/breakoutagents/replit): Code generation
+- And many more ([see list here](https://www.langchain.com/built-with-langgraph))
 
-```python
-from typing import Literal
+## LangGraph’s ecosystem
 
-from langchain_anthropic import ChatAnthropic
-from langchain_core.tools import tool
-from langgraph.checkpoint.memory import MemorySaver
-from langgraph.graph import END, START, StateGraph, MessagesState
-from langgraph.prebuilt import ToolNode
+While LangGraph can be used standalone, it also integrates seamlessly with any LangChain product, giving developers a full suite of tools for building agents. To improve your LLM application development, pair LangGraph with:
 
+- [LangSmith](http://www.langchain.com/langsmith) — Helpful for agent evals and observability. Debug poor-performing LLM app runs, evaluate agent trajectories, gain visibility in production, and improve performance over time.
+- [LangGraph Platform](https://langchain-ai.github.io/langgraph/concepts/#langgraph-platform) — Deploy and scale agents effortlessly with a purpose-built deployment platform for long running, stateful workflows. Discover, reuse, configure, and share agents across teams — and iterate quickly with visual prototyping in [LangGraph Studio](https://langchain-ai.github.io/langgraph/concepts/langgraph_studio/).
 
-# Define the tools for the agent to use
-@tool
-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."
+## Pairing with LangGraph Platform
 
+While LangGraph is our open-source agent orchestration framework, enterprises that need scalable agent deployment can benefit from [LangGraph Platform](https://langchain-ai.github.io/langgraph/concepts/langgraph_platform/).
 
-tools = [search]
+LangGraph Platform can help engineering teams:
 
-tool_node = ToolNode(tools)
+- **Accelerate agent development**: Quickly create agent UXs with configurable templates and [LangGraph Studio](https://langchain-ai.github.io/langgraph/concepts/langgraph_studio/) for visualizing and debugging agent interactions.
+- **Deploy seamlessly**: We handle the complexity of deploying your agent. LangGraph Platform includes robust APIs for memory, threads, and cron jobs plus auto-scaling task queues & servers.
+- **Centralize agent management & reusability**: Discover, reuse, and manage agents across the organization. Business users can also modify agents without coding.
 
-model = ChatAnthropic(model="claude-3-5-sonnet-latest", temperature=0).bind_tools(tools)
+## Additional resources
 
-# Define the function that determines whether to continue or not
-def should_continue(state: MessagesState) -> Literal["tools", END]:
-    messages = state['messages']
-    last_message = messages[-1]
-    # If the LLM makes a tool call, then we route to the "tools" node
-    if last_message.tool_calls:
-        return "tools"
-    # Otherwise, we stop (reply to the user)
-    return END
+- [LangChain Academy](https://academy.langchain.com/courses/intro-to-langgraph): Learn the basics of LangGraph in our free, structured course.
+- [Tutorials](https://langchain-ai.github.io/langgraph/tutorials/): Simple walkthroughs with guided examples on getting started with LangGraph.
+- [Templates](https://langchain-ai.github.io/langgraph/concepts/template_applications/): Pre-built reference apps for common agentic workflows (e.g. ReAct agent, memory, retrieval etc.) that can be cloned and adapted.
+- [How-to Guides](https://langchain-ai.github.io/langgraph/how-tos/): Quick, actionable code snippets for topics such as streaming, adding memory & persistence, and design patterns (e.g. branching, subgraphs, etc.).
+- [API Reference](https://langchain-ai.github.io/langgraph/reference/graphs/): Detailed reference on core classes, methods, how to use the graph and checkpointing APIs, and higher-level prebuilt components.
+- [Built with LangGraph](https://www.langchain.com/built-with-langgraph): Hear how industry leaders use LangGraph to ship powerful, production-ready AI applications.
 
+## Acknowledgements
 
-# Define the function that calls the model
-def call_model(state: MessagesState):
-    messages = state['messages']
-    response = model.invoke(messages)
-    # We return a list, because this will get added to the existing list
-    return {"messages": [response]}
-
-
-# Define a new graph
-workflow = StateGraph(MessagesState)
-
-# Define the two nodes we will cycle between
-workflow.add_node("agent", call_model)
-workflow.add_node("tools", tool_node)
-
-# Set the entrypoint as `agent`
-# This means that this node is the first one called
-workflow.add_edge(START, "agent")
-
-# We now add a conditional edge
-workflow.add_conditional_edges(
-    # First, we define the start node. We use `agent`.
-    # This means these are the edges taken after the `agent` node is called.
-    "agent",
-    # Next, we pass in the function that will determine which node is called next.
-    should_continue,
-)
-
-# We now add a normal edge from `tools` to `agent`.
-# This means that after `tools` is called, `agent` node is called next.
-workflow.add_edge("tools", 'agent')
-
-# Initialize memory to persist state between graph runs
-checkpointer = MemorySaver()
-
-# Finally, we compile it!
-# This compiles it into a LangChain Runnable,
-# meaning you can use it as you would any other runnable.
-# Note that we're (optionally) passing the memory when compiling the graph
-app = workflow.compile(checkpointer=checkpointer)
-
-# Use the agent
-final_state = app.invoke(
-    {"messages": [{"role": "user", "content": "what is the weather in sf"}]},
-    config={"configurable": {"thread_id": 42}}
-)
-final_state["messages"][-1].content
-```
-
-<b>Step-by-step Breakdown</b>:
-
-<details>
-<summary>Initialize the model and tools.</summary>
-<ul>
-  <li>
-    We use <code>ChatAnthropic</code> as our LLM. <strong>NOTE:</strong> we need to make sure the model knows that it has these tools available to call. We can do this by converting the LangChain tools into the format for OpenAI tool calling using the <code>.bind_tools()</code> method.
-  </li>
-  <li>
-    We define the tools we want to use - a search tool in our case. It is really easy to create your own tools - see documentation here on how to do that <a href="https://python.langchain.com/docs/how_to/custom_tools/">here</a>.
-  </li>
-</ul>
-</details>
-
-<details>
-<summary>Initialize graph with state.</summary>
-
-<ul>
-    <li>We initialize graph (<code>StateGraph</code>) by passing state schema (in our case <code>MessagesState</code>)</li>
-    <li><code>MessagesState</code> is a prebuilt state schema that has one attribute -- a list of LangChain <code>Message</code> objects, as well as logic for merging the updates from each node into the state.</li>
-</ul>
-</details>
-
-<details>
-<summary>Define graph nodes.</summary>
-
-There are two main nodes we need:
-
-<ul>
-    <li>The <code>agent</code> node: responsible for deciding what (if any) actions to take.</li>
-    <li>The <code>tools</code> node that invokes tools: if the agent decides to take an action, this node will then execute that action.</li>
-</ul>
-</details>
-
-<details>
-<summary>Define entry point and graph edges.</summary>
-
-First, we need to set the entry point for graph execution - <code>agent</code> node.
-
-Then we define one normal and one conditional edge. Conditional edge means that the destination depends on the contents of the graph's state (<code>MessagesState</code>). In our case, the destination is not known until the agent (LLM) decides.
-
-<ul>
-  <li>Conditional edge: after the agent is called, we should either:
-    <ul>
-      <li>a. Run tools if the agent said to take an action, OR</li>
-      <li>b. Finish (respond to the user) if the agent did not ask to run tools</li>
-    </ul>
-  </li>
-  <li>Normal edge: after the tools are invoked, the graph should always return to the agent to decide what to do next</li>
-</ul>
-</details>
-
-<details>
-<summary>Compile the graph.</summary>
-
-<ul>
-  <li>
-    When we compile the graph, we turn it into a LangChain 
-    <a href="https://python.langchain.com/docs/concepts/runnables/">Runnable</a>, 
-    which automatically enables calling <code>.invoke()</code>, <code>.stream()</code> and <code>.batch()</code> 
-    with your inputs
-  </li>
-  <li>
-    We can also optionally pass checkpointer object for persisting state between graph runs, and enabling memory, 
-    human-in-the-loop workflows, time travel and more. In our case we use <code>MemorySaver</code> - 
-    a simple in-memory checkpointer
-  </li>
-</ul>
-</details>
-
-<details>
-<summary>Execute the graph.</summary>
-
-<ol>
-  <li>LangGraph adds the input message to the internal state, then passes the state to the entrypoint node, <code>"agent"</code>.</li>
-  <li>The <code>"agent"</code> node executes, invoking the chat model.</li>
-  <li>The chat model returns an <code>AIMessage</code>. LangGraph adds this to the state.</li>
-  <li>Graph cycles the following steps until there are no more <code>tool_calls</code> on <code>AIMessage</code>:
-    <ul>
-      <li>If <code>AIMessage</code> has <code>tool_calls</code>, <code>"tools"</code> node executes</li>
-      <li>The <code>"agent"</code> node executes again and returns <code>AIMessage</code></li>
-    </ul>
-  </li>
-  <li>Execution progresses to the special <code>END</code> value and outputs the final state. And as a result, we get a list of all our chat messages as output.</li>
-</ol>
-</details>
-
-</details>
-
-## Documentation
-
-* [Tutorials](https://langchain-ai.github.io/langgraph/tutorials/): Learn to build with LangGraph through guided examples.
-* [How-to Guides](https://langchain-ai.github.io/langgraph/how-tos/): Accomplish specific things within LangGraph, from streaming, to adding memory & persistence, to common design patterns (branching, subgraphs, etc.), these are the place to go if you want to copy and run a specific code snippet.
-* [Conceptual Guides](https://langchain-ai.github.io/langgraph/concepts/high_level/): In-depth explanations of the key concepts and principles behind LangGraph, such as nodes, edges, state and more.
-* [API Reference](https://langchain-ai.github.io/langgraph/reference/graphs/): Review important classes and methods, simple examples of how to use the graph and checkpointing APIs, higher-level prebuilt components and more.
-* [LangGraph Platform](https://langchain-ai.github.io/langgraph/concepts/#langgraph-platform): LangGraph Platform is a commercial solution for deploying agentic applications in production, built on the open-source LangGraph framework.
-
-## Resources
-
-* [Built with LangGraph](https://www.langchain.com/built-with-langgraph): Hear how industry leaders use LangGraph to ship powerful, production-ready AI applications.
-
-## Contributing
-
-For more information on how to contribute, see [here](https://github.com/langchain-ai/langgraph/blob/main/CONTRIBUTING.md).
+LangGraph is inspired by [Pregel](https://research.google/pubs/pub37252/) and [Apache Beam](https://beam.apache.org/). The public interface draws inspiration from [NetworkX](https://networkx.org/documentation/latest/). LangGraph is built by LangChain Inc, the creators of LangChain, but can be used without LangChain.

docs/Makefile

@@ -1,4 +1,4 @@
-.PHONY: lint-docs format-docs build-docs serve-docs serve-clean-docs clean-docs codespell build-typedoc llms-text build-prebuilt
+.PHONY: lint-docs format-docs build-docs serve-docs serve-clean-docs clean-docs codespell build-typedoc llms-text build-prebuilt tests
 
 build-typedoc:
 	cd ../libs/sdk-js && yarn install --include-dev && yarn typedoc
@@ -10,14 +10,22 @@ build-prebuilt:
 	# Use to create an update to date prebuilt page.
 	# Looks up download stats for each of the prebuilt packages and
 	# generates the final prebuilt page.
-	poetry run python -m _scripts.third_party_page.get_download_stats stats.yml
+	@if [ "$(DOWNLOAD_STATS)" = "true" ]; then \
+		set -x; \
+		poetry run python -m _scripts.third_party_page.get_download_stats stats.yml; \
+		set +x; \
+	else \
+		set -x; \
+		poetry run python -m _scripts.third_party_page.get_download_stats --fake stats.yml; \
+		set +x; \
+	fi
 	poetry run python -m _scripts.third_party_page.create_third_party_page stats.yml docs/prebuilt.md --language python
 
 build-docs: build-typedoc build-prebuilt
 	poetry run python -m mkdocs build --clean -f mkdocs.yml --strict
 
 llms-text:
-	poetry run python _scripts/generate_llms_text.py docs/llms-full.txt
+	poetry run python -m _scripts.generate_llms_text docs/llms-full.txt
 
 install-vercel-deps:
 	dnf install -y python3.11
@@ -26,11 +34,10 @@ install-vercel-deps:
 	# don't use vercel's python - it wasn't compiled with sqlite support, and it fails when installing ipython's kernel
 	poetry env use /usr/bin/python3.11
 	poetry install --with docs --with test --no-root
-	poetry run pip install "git+https://github.com/benjamincburns/markdown-exec.git@cc0d39d737e5ffd4b83d23cd8729d7ea16e363c8"
-	poetry run python3 -m ipykernel install --name=python3
-	npm install -g tslab
-	poetry run tslab install --python=python3
-	poetry run jupyter kernelspec list
+
+tests:
+	# Run unit tests
+	poetry run pytest tests/unit_tests
 
 
 vercel-build-docs: install-vercel-deps

docs/README.md

@@ -14,6 +14,8 @@ To run the documentation server locally you can run:
 make serve-docs
 ```
 
+This will start the documentation server on [http://127.0.0.1:8000/langgraph/](http://127.0.0.1:8000/langgraph/).
+
 ## Execute notebooks
 
 If you would like to automatically execute all of the notebooks, to mimic the "Run notebooks" GHA, you can run:

docs/_scripts/assets/nock_setup_preamble.ts

@@ -1,75 +0,0 @@
-import nock, { Definition } from "nock";
-import msgpack from "msgpack-lite";
-import zlib from "node:zlib";
-import fs from "node:fs/promises";
-import { Buffer } from "node:buffer";
-
-// deno style imports here because we're running this in the deno jupyter kernel
-
-interface NockCassetteData {
-  hash: string;
-  entries: Definition[];
-}
-
-// Utility functions for compression & serialization
-function compressData(data: NockCassetteData, compressionLevel = 9): string {
-  const packed = msgpack.encode(data);
-  const compressed = zlib.deflateSync(packed, { level: compressionLevel });
-  return compressed.toString("base64");
-}
-
-function decompressData(compressedString: string): NockCassetteData {
-  const decoded = Buffer.from(compressedString, "base64");
-  const decompressed = zlib.inflateSync(decoded);
-  return msgpack.decode(decompressed) as NockCassetteData;
-}
-
-// deno-lint-ignore no-unused-vars
-class HashedCassette {
-  private recording = true;
-
-  constructor(
-    private readonly cassettePath: string,
-    private readonly hash: string
-  ) {}
-
-  async enter() {
-    try {
-      const rawCassette = await fs.readFile(this.cassettePath, "utf-8");
-      const data = decompressData(rawCassette);
-      if (data.hash === this.hash) {
-        this.recording = false;
-        nock.disableNetConnect();
-        nock.define(data.entries);
-        return;
-      }
-    } catch (error) {
-      if (error instanceof Error && error.message.includes("ENOENT")) {
-        this.recording = true;
-      } else {
-        throw error;
-      }
-    }
-
-    nock.recorder.rec({
-      dont_print: true,
-      output_objects: true,
-    });
-  }
-
-  async exit() {
-    if (this.recording) {
-      const entries = nock.recorder.play() as Definition[];
-      const data = {
-        hash: this.hash,
-        entries,
-      };
-      const compressed = compressData(data);
-      await fs.writeFile(this.cassettePath, compressed);
-    } else {
-      nock.enableNetConnect();
-      nock.restore();
-      nock.cleanAll();
-    }
-  }
-}

docs/_scripts/assets/vcr_setup_preamble.py

@@ -1,107 +0,0 @@
-import base64
-import os
-import zlib
-from types import TracebackType
-from typing import Optional, Any, Type
-
-import msgpack
-import vcr
-
-os.environ.pop("LANGCHAIN_TRACING_V2", None)
-custom_vcr = vcr.VCR()
-
-
-def compress_data(data: Any, compression_level: int = 9) -> str:
-    packed = msgpack.packb(data, use_bin_type=True)
-    compressed = zlib.compress(packed, level=compression_level)
-    return base64.b64encode(compressed).decode("utf-8")
-
-
-def decompress_data(compressed_string: str) -> Any:
-    decoded = base64.b64decode(compressed_string)
-    decompressed = zlib.decompress(decoded)
-    return msgpack.unpackb(decompressed, raw=False)
-
-
-class AdvancedCompressedSerializer:
-    def serialize(self, cassette_dict: Any) -> str:
-        return compress_data(cassette_dict)
-
-    def deserialize(self, cassette_string: str) -> Any:
-        return decompress_data(cassette_string)
-
-
-custom_vcr.register_serializer("advanced_compressed", AdvancedCompressedSerializer())
-custom_vcr.serializer = "advanced_compressed"
-
-
-class HashedCassette:
-    def __init__(self, cassette_path: str, hash_value: str) -> None:
-        """A context manager for using VCR cassettes with an embedded hash value.
-
-        Args:
-            cassette_path (str): The file path of the cassette (independent of hash).
-            hash_value (str): The expected hash value (e.g. a uuid string).
-
-        This class provides a context manager for using VCR cassettes with an embedded hash value.
-        The hash value is used to ensure that the cassette matches the expected state, and if not,
-        the cassette is removed or updated with the new hash value.
-        """
-        self.cassette_path: str = cassette_path
-        self.hash_value: str = hash_value
-        self.vcr: vcr.VCR = custom_vcr
-        self.cassette_context: Optional[Any] = None
-        self.exited: bool = False
-
-    def __enter__(self) -> Any:
-        self.exited: bool = False
-        # Get the serializer instance from the VCR instance.
-        serializer = self.vcr.serializers[self.vcr.serializer]
-        # If the cassette file exists, check its embedded hash.
-        if os.path.exists(self.cassette_path):
-            with open(self.cassette_path, "r") as f:
-                content = f.read()
-            try:
-                cassette_data = serializer.deserialize(content)
-            except Exception as e:
-                os.remove(self.cassette_path)
-            else:
-                existing_hash = cassette_data.get("cassette_hash")
-                if existing_hash != self.hash_value:
-                    os.remove(self.cassette_path)
-        # Now enter the VCR cassette context.
-        self.cassette_context = custom_vcr.use_cassette(
-            self.cassette_path,
-            filter_headers=["x-api-key", "authorization"],
-            record_mode="once",
-            serializer="advanced_compressed",
-        )
-        return self.cassette_context.__enter__()
-
-    def __exit__(
-        self,
-        exc_type: Optional[Type[BaseException]] = None,
-        exc_val: Optional[BaseException] = None,
-        exc_tb: Optional[TracebackType] = None,
-    ) -> Optional[bool]:
-        if self.exited:
-            return
-        self.exited = True
-        # Exit the VCR cassette context.
-        result = self.cassette_context.__exit__(exc_type, exc_val, exc_tb)
-        serializer = self.vcr.serializers[self.vcr.serializer]
-        # If a cassette was recorded (or updated), open and update its hash.
-        if os.path.exists(self.cassette_path):
-            with open(self.cassette_path, "r") as f:
-                content = f.read()
-            try:
-                cassette_data = serializer.deserialize(content)
-            except Exception as e:
-                return result
-            # Update the cassette data with the expected hash.
-            if cassette_data.get("cassette_hash") != self.hash_value:
-                cassette_data["cassette_hash"] = self.hash_value
-                serialized_data = serializer.serialize(cassette_data)
-                with open(self.cassette_path, "w") as f:
-                    f.write(serialized_data)
-        return result

docs/_scripts/generate_api_reference_links.py

@@ -1,9 +1,9 @@
+import ast
 import importlib
-import inspect
 import logging
 import re
 from functools import lru_cache
-from typing import List, Literal, Optional
+from typing import List, Optional
 
 from typing_extensions import TypedDict
 
@@ -39,7 +39,6 @@ MANUAL_API_REFERENCES_LANGGRAPH = [
     (["langgraph.graph"], "langgraph.graph.message", "add_messages", "graphs"),
     (["langgraph.graph"], "langgraph.graph.state", "StateGraph", "graphs"),
     (["langgraph.graph"], "langgraph.graph.state", "CompiledStateGraph", "graphs"),
-    ([], "langgraph.types", "StreamMode", "types"),
     (["langgraph.graph"], "langgraph.constants", "START", "constants"),
     (["langgraph.graph"], "langgraph.constants", "END", "constants"),
     (["langgraph.constants"], "langgraph.types", "Send", "types"),
@@ -48,7 +47,9 @@ MANUAL_API_REFERENCES_LANGGRAPH = [
     (["langgraph.constants"], "langgraph.types", "Command", "types"),
     (["langgraph.func"], "langgraph.func", "entrypoint", "func"),
     (["langgraph.func"], "langgraph.func", "task", "func"),
-    ([], "langgraph.types", "RetryPolicy", "types"),
+    (["langgraph.types"], "langgraph.types", "RetryPolicy", "types"),
+    (["langgraph.types"], "langgraph.types", "StreamMode", "types"),
+    (["langgraph.types"], "langgraph.types", "StreamWriter", "types"),
     ([], "langgraph.checkpoint.base", "Checkpoint", "checkpoints"),
     ([], "langgraph.checkpoint.base", "CheckpointMetadata", "checkpoints"),
     ([], "langgraph.checkpoint.base", "BaseCheckpointSaver", "checkpoints"),
@@ -68,34 +69,19 @@ WELL_KNOWN_LANGGRAPH_OBJECTS = {
 }
 
 
-def _make_regular_expression(pkg_prefix: str) -> re.Pattern:
-    if not pkg_prefix.isidentifier():
-        raise ValueError(f"Invalid package prefix: {pkg_prefix}")
-    return re.compile(
-        r"from\s+(" + pkg_prefix + "(?:_\w+)?(?:\.\w+)*?)\s+import\s+"
-        r"((?:\w+(?:,\s*)?)*"  # Match zero or more words separated by a comma+optional ws
-        r"(?:\s*\(.*?\))?)",  # Match optional parentheses block
-        re.DOTALL,  # Match newlines as well
-    )
-
-
-# Regular expression to match langchain import lines
-_IMPORT_LANGCHAIN_RE = _make_regular_expression("langchain")
-_IMPORT_LANGGRAPH_RE = _make_regular_expression("langgraph")
-
-
 @lru_cache(maxsize=10_000)
 def _get_full_module_name(module_path: str, class_name: str) -> Optional[str]:
     """Get full module name using inspect, with LRU cache to memoize results."""
     try:
         module = importlib.import_module(module_path)
-        class_ = getattr(module, class_name)
-        module = inspect.getmodule(class_)
-        if module is None:
-            # For constants, inspect.getmodule() might return None
-            # In this case, we'll return the original module_path
+        symbol = getattr(module, class_name)
+        # First check the __module__ attribute on the symbol.
+        mod_name = getattr(symbol, "__module__", None)
+        # If __module__ is not set or comes from typing,
+        # assume the definition is in module_path.
+        if mod_name is None or mod_name.startswith("typing"):
             return module_path
-        return module.__name__
+        return mod_name
     except AttributeError as e:
         logger.warning(f"API Reference: Could not find module for {class_name}, {e}")
         return None
@@ -104,139 +90,128 @@ def _get_full_module_name(module_path: str, class_name: str) -> Optional[str]:
         return None
 
 
-def _get_doc_title(data: str, file_name: str) -> str:
-    try:
-        return re.findall(r"^#\s*(.*)", data, re.MULTILINE)[0]
-    except IndexError:
-        pass
-    # Parse the rst-style titles
-    try:
-        return re.findall(r"^(.*)\n=+\n", data, re.MULTILINE)[0]
-    except IndexError:
-        return file_name
-
-
 class ImportInformation(TypedDict):
     imported: str  # The name of the class that was imported.
     source: str  # The full module path from which the class was imported.
     docs: str  # The URL pointing to the class's documentation.
-    title: str  # The title of the document where the import is used.
+    path: str  # The path of the file where the markdown content originated.
 
 
-def _get_imports(
-    code: str, doc_title: str, package_ecosystem: Literal["langchain", "langgraph"]
-) -> List[ImportInformation]:
-    """Get imports from the given code block.
-
-    Args:
-        code: Python code block from which to extract imports
-        doc_title: Title of the document
-        package_ecosystem: "langchain" or "langgraph". The two live in different
-            repositories and have separate documentation sites.
-
-    Returns:
-        List of import information for the given code block
-    """
-    imports = []
-
-    if package_ecosystem == "langchain":
-        pattern = _IMPORT_LANGCHAIN_RE
-    elif package_ecosystem == "langgraph":
-        pattern = _IMPORT_LANGGRAPH_RE
-    else:
-        raise ValueError(f"Invalid package ecosystem: {package_ecosystem}")
-
-    for import_match in pattern.finditer(code):
-        module = import_match.group(1)
-        if "pydantic_v1" in module:
-            continue
-        imports_str = (
-            import_match.group(2).replace("(\n", "").replace("\n)", "")
-        )  # Handle newlines within parentheses
-        # remove any newline and spaces, then split by comma
-        imported_classes = [
-            imp.strip()
-            for imp in re.split(r",\s*", imports_str.replace("\n", ""))
-            if imp.strip()
-        ]
-        for class_name in imported_classes:
-            module_path = _get_full_module_name(module, class_name)
-            if not module_path:
-                continue
-            if len(module_path.split(".")) < 2:
-                continue
-
-            if package_ecosystem == "langchain":
-                pkg = module_path.split(".")[0].replace("langchain_", "")
-                top_level_mod = module_path.split(".")[1]
-
-                url = (
-                    _LANGCHAIN_API_REFERENCE
-                    + pkg
-                    + "/"
-                    + top_level_mod
-                    + "/"
-                    + module_path
-                    + "."
-                    + class_name
-                    + ".html"
-                )
-            elif package_ecosystem == "langgraph":
-                if (module, class_name) not in WELL_KNOWN_LANGGRAPH_OBJECTS:
-                    # Likely not documented yet
-                    continue
-
-                source_module, namespace = WELL_KNOWN_LANGGRAPH_OBJECTS[
-                    (module, class_name)
-                ]
-                url = (
-                    _LANGGRAPH_API_REFERENCE
-                    + namespace
-                    + "/#"
-                    + source_module
-                    + "."
-                    + class_name
-                )
-            else:
-                raise ValueError(f"Invalid package ecosystem: {package_ecosystem}")
-
-            # Add the import information to our list
-            imports.append(
-                {
-                    "imported": class_name,
-                    "source": module,
-                    "docs": url,
-                    "title": doc_title,
-                }
-            )
-
-    return imports
-
-
-def get_imports(code: str, doc_title: str) -> List[ImportInformation]:
+def get_imports(code: str, path: str) -> List[ImportInformation]:
     """Retrieve all import references from the given code for specified ecosystems.
 
     Args:
         code: The source code from which to extract import references.
-        doc_title: The documentation title associated with the code.
+        path: The path of the file where the markdown content originated.
 
     Returns:
         A list of import information for each import found.
     """
-    ecosystems = ["langchain", "langgraph"]
-    all_imports = []
-    for package_ecosystem in ecosystems:
-        all_imports.extend(_get_imports(code, doc_title, package_ecosystem))
-    return all_imports
+    # Parse the code into an AST.
+    try:
+        tree = ast.parse(code)
+    except SyntaxError:
+        return []
+
+    found_imports = []
+
+    # Walk through the AST and process ImportFrom nodes.
+    for node in ast.walk(tree):
+        if isinstance(node, ast.ImportFrom):
+            # node.module is the source module.
+            if node.module is None:
+                continue
+            for alias in node.names:
+                if not (
+                    node.module.startswith("langchain")
+                    or node.module.startswith("langgraph")
+                ):
+                    continue
+
+                found_imports.append(
+                    {
+                        "source": node.module,
+                        # alias.name is the original name even if an alias exists.
+                        "imported": alias.name,
+                    }
+                )
+
+    imports: list[ImportInformation] = []
+
+    for found_import in found_imports:
+        module = found_import["source"]
+
+        if module.startswith("langchain"):
+            # Handles things like `langchain` or `langchain_anthropic`
+            package_ecosystem = "langchain"
+        elif module.startswith("langgraph"):
+            package_ecosystem = "langgraph"
+        else:
+            continue
+
+        class_name = found_import["imported"]
+        module_path = _get_full_module_name(module, class_name)
+        if not module_path:
+            continue
+        if len(module_path.split(".")) < 2:
+            continue
+
+        if package_ecosystem == "langchain":
+            pkg = module_path.split(".")[0].replace("langchain_", "")
+            top_level_mod = module_path.split(".")[1]
+
+            url = (
+                _LANGCHAIN_API_REFERENCE
+                + pkg
+                + "/"
+                + top_level_mod
+                + "/"
+                + module_path
+                + "."
+                + class_name
+                + ".html"
+            )
+        elif package_ecosystem == "langgraph":
+            if (module, class_name) not in WELL_KNOWN_LANGGRAPH_OBJECTS:
+                # Likely not documented yet
+                continue
+
+            source_module, namespace = WELL_KNOWN_LANGGRAPH_OBJECTS[
+                (module, class_name)
+            ]
+            url = (
+                _LANGGRAPH_API_REFERENCE
+                + namespace
+                + "/#"
+                + source_module
+                + "."
+                + class_name
+            )
+        else:
+            raise ValueError(f"Invalid package ecosystem: {package_ecosystem}")
+
+        # Add the import information to our list
+        imports.append(
+            {
+                "imported": class_name,
+                "source": module,
+                "docs": url,
+                "path": path,
+            }
+        )
+
+    return imports
 
 
-def update_markdown_with_imports(markdown: str) -> str:
+def update_markdown_with_imports(markdown: str, path: str) -> str:
     """Update markdown to include API reference links for imports in Python code blocks.
 
-    This function scans the markdown content for Python code blocks, extracts any imports, and appends links to their API documentation.
+    This function scans the markdown content for Python code blocks, extracts any
+    imports, and appends links to their API documentation.
 
     Args:
         markdown: The markdown content to process.
+        path: The path of the file where the markdown content originated.
 
     Returns:
         Updated markdown with API reference links appended to Python code blocks.
@@ -247,10 +222,12 @@ def update_markdown_with_imports(markdown: str) -> str:
         ```python
         from langchain.nlp import TextGenerator
         ```
-        This function will append an API reference link to the `TextGenerator` class from the `langchain.nlp` module if it's recognized.
+        This function will append an API reference link to the `TextGenerator` class
+        from the `langchain.nlp` module if it's recognized.
     """
     code_block_pattern = re.compile(
-        r'(?P<indent>[ \t]*)```(?P<language>python|py)\n(?P<code>.*?)\n(?P=indent)```', re.DOTALL
+        r"(?P<indent>[ \t]*)```(?P<language>python|py)\n(?P<code>.*?)\n(?P=indent)```",
+        re.DOTALL,
     )
 
     def replace_code_block(match: re.Match) -> str:
@@ -262,9 +239,8 @@ def update_markdown_with_imports(markdown: str) -> str:
         Returns:
             str: The modified code block with API reference links appended if applicable.
         """
-        indent = match.group('indent')
-        code_block = match.group('code')
-        language = match.group('language')  # Preserve the language from the regex match
+        indent = match.group("indent")
+        code_block = match.group("code")
         # Retrieve import information from the code block
         imports = get_imports(code_block, "__unused__")
 
@@ -274,11 +250,11 @@ def update_markdown_with_imports(markdown: str) -> str:
             return original_code_block
 
         # Generate API reference links for each import
-        api_links = ' | '.join(
+        api_links = " | ".join(
             f'<a href="{imp["docs"]}">{imp["imported"]}</a>' for imp in imports
         )
         # Return the code block with appended API reference links
-        return f'{original_code_block}\n\n{indent}API Reference: {api_links}'
+        return f"{original_code_block}\n\n{indent}API Reference: {api_links}"
 
     # Apply the replace_code_block function to all matches in the markdown
     updated_markdown = code_block_pattern.sub(replace_code_block, markdown)

docs/_scripts/generate_llms_text.py

@@ -2,12 +2,11 @@
 
 import glob
 import os
-import pathlib
 
 from mkdocs.structure.files import File
 from mkdocs.structure.pages import Page
 
-from notebook_hooks import _on_page_markdown_with_config
+from _scripts.notebook_hooks import _on_page_markdown_with_config
 
 HERE = os.path.dirname(os.path.abspath(__file__))
 # Get source directory (parent of HERE / docs)

docs/_scripts/notebook_convert.py

@@ -1,36 +1,238 @@
-import argparse
+import ast
 import os
 import re
 from pathlib import Path
-from typing import Literal, Optional
+from typing import Literal
 
 import nbformat
 from nbconvert.exporters import MarkdownExporter
 from nbconvert.preprocessors import Preprocessor
 
 
+def _uses_input(source: str) -> bool:
+    """Parse the source code to determine if it uses the input() function."""
+    try:
+        tree = ast.parse(source)
+    except SyntaxError:
+        # If there's a syntax error, assume input() might be present to be safe.
+        return False
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Call):
+            # Check if the function called is named 'input'
+            if isinstance(node.func, ast.Name) and node.func.id == "input":
+                return True
+    return False
+
+
+def _rewrite_cell_magic(code: str) -> str:
+    """Process a code block that uses cell magic.:w
+
+    - Lines starting with "%%capture" are ignored.
+    - Lines starting with "%pip" are rewritten by removing the leading "%" character.
+    - Any other non-empty line causes a NotImplementedError.
+
+    Args:
+        code (str): The original code block.
+
+    Returns:
+        str: The transformed code block.
+
+    Raises:
+        NotImplementedError: If a line doesn't start with either "%%capture" or "%pip".
+    """
+    rewritten_lines = []
+
+    for line in code.splitlines():
+        stripped = line.strip()
+        # Skip empty lines
+        if not stripped:
+            continue
+        # Ignore %%capture lines
+        if stripped.startswith("%%capture"):
+            continue
+        # Rewrite %pip lines by dropping the '%'
+        elif stripped.startswith("%pip"):
+            # Drop the leading '%' character
+            rewritten_lines.append(stripped[1:])
+        # Anything else is not supported
+        else:
+            raise NotImplementedError(f"Unhandled line: {line}")
+
+    return "\n".join(rewritten_lines)
+
+
+class PrintCallVisitor(ast.NodeVisitor):
+    """
+    This visitor sets self.has_print to True if it encounters a call
+    to a print within the global scope.
+
+    This should catch calls to print(), print_stream(), etc. (Prefixed with "print").
+
+    May have some false positives, but it's not meant to be perfect.
+
+    Temporary code for notebook conversion.
+    """
+
+    def __init__(self):
+        self.has_print = False
+        self.scope_level = 0  # counter to track whether we're inside a def/lambda
+
+    def visit_FunctionDef(self, node):
+        self.scope_level += 1
+        self.generic_visit(node)
+        self.scope_level -= 1
+
+    def visit_AsyncFunctionDef(self, node):
+        self.scope_level += 1
+        self.generic_visit(node)
+        self.scope_level -= 1
+
+    def visit_Lambda(self, node):
+        self.scope_level += 1
+        self.generic_visit(node)
+        self.scope_level -= 1
+
+    def visit_ClassDef(self, node):
+        self.scope_level += 1
+        self.generic_visit(node)
+        self.scope_level -= 1
+
+    def visit_Call(self, node):
+        # Only consider calls when not inside a function definition.
+        if self.scope_level == 0:
+            if isinstance(node.func, ast.Name) and node.func.id.startswith("print"):
+                self.has_print = True
+        self.generic_visit(node)
+
+
+def _has_output(source: str) -> bool:
+    """Determine if the code block is expected to produce output.
+
+    Args:
+        source (str): The source code of the code block.
+
+    Returns:
+        True if the code block is expected to produce output, False otherwise.
+
+        Must meet the following conditions:
+
+        1. There is a call to a printing function (name starts with "print")
+           that is not inside a function definition.
+        2. The last top-level statement is an expression that is valid if:
+         - It is any expression (including calls) AND
+         - It is NOT a call to `display(...)`.
+
+        `display` isn't handled currently by markdown-exec
+    """
+    try:
+        tree = ast.parse(source)
+    except SyntaxError:
+        return False
+
+    # Condition (1): Check for a global print-like call.
+    visitor = PrintCallVisitor()
+    visitor.visit(tree)
+    condition_a = visitor.has_print
+
+    # Condition (2): Check the last top-level statement.
+    condition_b = False
+    if tree.body:
+        last_stmt = tree.body[-1]
+        if isinstance(last_stmt, ast.Expr):
+            # If the expression is a call, ensure it's not a call to "display"
+            if isinstance(last_stmt.value, ast.Call):
+                if (
+                    isinstance(last_stmt.value.func, ast.Name)
+                    and last_stmt.value.func.id == "display"
+                ):
+                    condition_b = False  # exclude display-wrapped expressions
+                else:
+                    condition_b = True
+            else:
+                # Any other expression qualifies.
+                condition_b = True
+
+    return condition_a or condition_b
+
+
+def _convert_links_in_markdown(markdown: str) -> str:
+    """Convert links present in notebook markdown cells to standardized format.
+
+    We want to update markdown links code cells by linking to markdown
+    files rather than assuming that the link is to the finalized HTML.
+
+    This code is needed temporarily since the markdown links that are present
+    in ipython notebooks do not follow the same conventions as regular markdown
+    files in mkdocs (which should link to a .md file).
+    """
+
+    # Define the regex pattern in parts for clarity:
+    pattern = (
+        r"(?<!!)"  # Negative lookbehind: ensure the link is not an image (i.e., doesn't start with "!")
+        r"\["  # Literal '[' indicating the start of the link text.
+        r"(?P<text>[^\]]*)"  # Named group 'text': match any characters except ']', representing the link text.
+        r"\]"  # Literal ']' indicating the end of the link text.
+        r"\("  # Literal '(' indicating the start of the URL.
+        r"(?![^\)]*//)"  # Negative lookahead: ensure that the URL does not contain '//' (skip absolute URLs).
+        r"(?P<url>[^)]*)"  # Named group 'url': match any characters except ')', representing the URL.
+        r"\)"  # Literal ')' indicating the end of the URL.
+    )
+
+    def custom_replacement(match):
+        """logic will correct the link format used in ipython notebooks
+
+        Ipython notebooks were being converted directly into HTML links
+        instead of markdown links that retain the markdown extension.
+
+        It needs to handle the following cases:
+        - optional fragments (e.g., `#section`)
+            e.g., `[text](url/#section)` -> `[text](url.md#section)`
+            e.g., `[text](url#section)` -> `[text](url.md#section)`
+        - relative paths (e.g., `../path/to/file`) need to be denested by 1 level
+        """
+        text = match.group("text")
+        url = match.group("url")
+
+        if url.startswith("../"):
+            # we strip the "../" from the start of the URL
+            # We only need to denest one level.
+            url = url[3:]
+
+        url = url.rstrip("/")  # Strip `/` from the end of the URL
+
+        # if url has a fragment
+        if "#" in url:
+            url, fragment = url.split("#")
+            url = url.rstrip("/")
+            # Strip `/` from the end of the URL
+            return f"[{text}]({url}.md#{fragment})"
+        # Otherwise add the .md extension
+        return f"[{text}]({url}.md)"
+
+    return re.sub(
+        pattern,
+        custom_replacement,
+        markdown,
+    )
+
+
 class EscapePreprocessor(Preprocessor):
-    def __init__(self, rewrite_links: bool = True, **kwargs) -> None:
+    def __init__(self, markdown_exec_migration: bool = False, **kwargs) -> None:
         super().__init__(**kwargs)
-        self.rewrite_links = rewrite_links
+        self.markdown_exec_migration = markdown_exec_migration
 
     def preprocess_cell(self, cell, resources, cell_index):
         if cell.cell_type == "markdown":
-            if self.rewrite_links:
-                # We'll need to adjust the logic for this to keep markdown format
-                # but link to markdown files rather than ipynb files.
+            if not self.markdown_exec_migration:
+                # Old logic is to convert ipynb links to HTML links
                 cell.source = re.sub(
                     r"(?<!!)\[([^\]]*)\]\((?![^\)]*//)([^)]*)(?:\.ipynb)?\)",
                     r'<a href="\2">\1</a>',
                     cell.source,
                 )
             else:
-                # Keep format but replace the .ipynb extension with .md
-                cell.source = re.sub(
-                    r"(?<!!)\[([^\]]*)\]\((?![^\)]*//)([^)]*)(?:\.ipynb)?\)",
-                    r"[\1](\2.md)",
-                    cell.source,
-                )
+                cell.source = _convert_links_in_markdown(cell.source)
 
             # Fix image paths in <img> tags
             cell.source = re.sub(
@@ -39,9 +241,19 @@ class EscapePreprocessor(Preprocessor):
 
         elif cell.cell_type == "code":
             # Determine if the cell has bash or cell magic
-            if cell.source.startswith("%") or cell.source.startswith("!"):
-                # update metadata to denote that it's not a python cell
-                cell.metadata["language_info"] = {"name": "unknown"}
+            source = cell.source
+            is_exec = not (
+                source.startswith("%") or source.startswith("!") or _uses_input(source)
+            )
+            cell.metadata["exec"] = is_exec
+
+            if self.markdown_exec_migration:
+                # For markdown exec migration we'll re-write cell magic as bash commands
+                if source.startswith("%%"):
+                    cell.source = _rewrite_cell_magic(source)
+                    cell.metadata["language"] = "shell"
+
+                cell.metadata["has_output"] = _has_output(source)
 
             # Remove noqa comments
             cell.source = re.sub(r"#\s*noqa.*$", "", cell.source, flags=re.MULTILINE)
@@ -138,17 +350,6 @@ exporter = MarkdownExporter(
     ],
 )
 
-md_executable = MarkdownExporter(
-    preprocessors=[
-        ExtractAttachmentsPreprocessor,
-        EscapePreprocessor(rewrite_links=False),
-    ],
-    template_name="md_executable",
-    extra_template_basedirs=[
-        os.path.join(os.path.dirname(__file__), "notebook_convert_templates")
-    ],
-)
-
 
 def convert_notebook(
     notebook_path: Path,
@@ -158,91 +359,5 @@ def convert_notebook(
         nb = nbformat.read(f, as_version=4)
 
     nb.metadata.mode = mode
-    if mode == "markdown":
-        body, _ = exporter.from_notebook_node(nb)
-    else:
-        body, _ = md_executable.from_notebook_node(nb)
+    body, _ = exporter.from_notebook_node(nb)
     return body
-
-
-HERE = Path(__file__).parent
-DOCS = HERE.parent / "docs"
-
-
-# Convert notebooks to markdown
-def _convert_notebooks(
-    *,
-    output_dir: Optional[Path] = None,
-    replace: bool = False,
-    pattern: str = "*.ipynb",
-) -> None:
-    """Converting notebooks."""
-    if not output_dir and not replace:
-        raise ValueError("Either --output_dir or --replace must be specified")
-
-    output_dir_path = DOCS if replace else Path(output_dir)
-    notebooks = list(DOCS.rglob(pattern))
-
-    file_names = [notebook.name for notebook in notebooks]
-
-    for notebook in notebooks:
-        markdown = convert_notebook(notebook, mode="exec")
-        markdown_path = output_dir_path / notebook.relative_to(DOCS).with_suffix(".md")
-        markdown_path.parent.mkdir(parents=True, exist_ok=True)
-        with open(markdown_path, "w") as f:
-            f.write(markdown)
-        if replace:
-            notebook.unlink(missing_ok=False)
-
-    if replace:
-        # The regex will match markdown links that point to *.ipynb files.
-        # It captures:
-        #   group(1): the link text (inside the square brackets)
-        #   group(2): the file path (without the trailing .ipynb)
-        link_pattern = r"(?<!!)\[([^\]]+)\]\((?![^)]*//)([^)]+)\.ipynb\)"
-
-        def replace_link(match: re.Match) -> str:
-            link_text = match.group(1)
-            link_target = match.group(2)
-            # Reconstruct the file name with the .ipynb extension.
-            # For example, if link_target is "foo/bar", then linked_file becomes "bar.ipynb".
-            linked_file = Path(link_target).name + ".ipynb"
-            # Only update if the notebook was among those converted.
-            if linked_file in file_names:
-                # Change the extension from .ipynb to .md
-                return f"[{link_text}]({link_target}.md)"
-            # Otherwise, leave the original link intact.
-            return match.group(0)
-
-        # Process all markdown files in the output directory.
-        for path in output_dir_path.rglob("*.md"):
-            with open(path, "r", encoding="utf-8") as f:
-                content = f.read()
-            new_content = re.sub(link_pattern, replace_link, content)
-            with open(path, "w", encoding="utf-8") as f:
-                f.write(new_content)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser(description="Convert notebooks to markdown")
-    parser.add_argument(
-        "--output_dir",
-        default=None,
-        help="Directory to output markdown files",
-    )
-    parser.add_argument(
-        "--replace",
-        action="store_true",
-        help="Replace original notebooks with markdown files",
-    )
-    parser.add_argument(
-        "--pattern",
-        default="*.ipynb",
-        help="Glob pattern to match notebooks to convert",
-    )
-    args = parser.parse_args()
-    _convert_notebooks(
-        replace=args.replace,
-        output_dir=args.output_dir,
-        pattern=args.pattern,
-    )

docs/_scripts/notebook_convert_templates/md_executable/conf.json

@@ -1,5 +0,0 @@
-{
-  "mimetypes": {
-    "text/markdown": true
-  }
-}

docs/_scripts/notebook_convert_templates/md_executable/index.md.j2

@@ -1,36 +0,0 @@
-{#https://github.com/rdbisme/nbconvert/blob/master/share/jupyter/nbconvert/templates/markdown/index.md.j2#}
-{% extends 'markdown/index.md.j2' %}
-
-{% block input %}
-```
-{%- if 'magics_language' in cell.metadata  -%}
-    {{ cell.metadata.magics_language}}
-{%- elif 'name' in nb.metadata.get('language_info', {}) -%}
-    {{ nb.metadata.language_info.name }} exec="on" source="above" session="1"
-{%- endif %}
-{{ cell.source}}
-```
-{% endblock input %}
-
-{%- block traceback_line -%}
-{%- endblock traceback_line -%}
-
-{%- block stream -%}
-{%- endblock stream -%}
-
-{%- block data_text scoped -%}
-{%- endblock data_text -%}
-
-{%- block data_html scoped -%}
-```html
-{{ output.data['text/html'] | safe }} 
-```
-{%- endblock data_html -%}
-
-{%- block data_jpg scoped -%}
-![](data:image/jpg;base64,{{ output.data['image/jpeg'] }})
-{%- endblock data_jpg -%}
-
-{%- block data_png scoped -%}
-![](data:image/png;base64,{{ output.data['image/png'] }})
-{%- endblock data_png -%}

docs/_scripts/notebook_hooks.py

@@ -1,21 +1,14 @@
 import logging
 import os
+import posixpath
 import re
-import traceback
-from typing import Any, Callable, Dict
+from typing import Any, Dict
 
-from markdown import Markdown
-from pymdownx.superfences import SuperFencesException
 from mkdocs.structure.files import Files, File
 from mkdocs.structure.pages import Page
-import posixpath
-
-from markdown_exec.hooks import SessionHistoryEntry
-
-from generate_api_reference_links import update_markdown_with_imports
-from notebook_convert import convert_notebook
-from setup_vcr import load_postamble, load_preamble, _hash_string
 
+from _scripts.generate_api_reference_links import update_markdown_with_imports
+from _scripts.notebook_convert import convert_notebook
 
 logger = logging.getLogger(__name__)
 logging.basicConfig()
@@ -101,7 +94,7 @@ def _highlight_code_blocks(markdown: str) -> str:
     # existing hl_lines for Python and JavaScript
     # Pattern to find code blocks with highlight comments, handling optional indentation
     code_block_pattern = re.compile(
-        r"(?P<indent>[ \t]*)```(?P<language>py|python|js|javascript)(?!\s+hl_lines=)\n"
+        r"(?P<indent>[ \t]*)```(?P<language>\w+)[ ]*(?P<attributes>[^\n]*)\n"
         r"(?P<code>((?:.*\n)*?))"  # Capture the code inside the block using named group
         r"(?P=indent)```"  # Match closing backticks with the same indentation
     )
@@ -110,6 +103,13 @@ def _highlight_code_blocks(markdown: str) -> str:
         indent = match.group("indent")
         language = match.group("language")
         code_block = match.group("code")
+        attributes = match.group("attributes").rstrip()
+
+        # Account for a case where hl_lines is manually specified
+        if "hl_lines" in attributes:
+            # Return original code block
+            return match.group(0)
+
         lines = code_block.split("\n")
         highlighted_lines = []
 
@@ -135,128 +135,29 @@ def _highlight_code_blocks(markdown: str) -> str:
         # Reconstruct the new code block
         new_code_block = "\n".join(lines_to_keep)
 
+        # Construct the full code block that also includes
+        # the fenced code block syntax.
+        opening_fence = f"```{language}"
+
+        if attributes:
+            opening_fence += f" {attributes}"
+
         if highlighted_lines:
-            return (
-                f'{indent}```{language} hl_lines="{" ".join(highlighted_lines)}"\n'
-                # The indent and terminating \n is already included in the code block
-                f"{new_code_block}"
-                f"{indent}```"
-            )
-        else:
-            return (
-                f"{indent}```{language}\n"
-                # The indent and terminating \n is already included in the code block
-                f"{new_code_block}"
-                f"{indent}```"
-            )
+            opening_fence += f" hl_lines=\"{' '.join(highlighted_lines)}\""
+
+        return (
+            # The indent and opening fence
+            f"{indent}{opening_fence}\n"
+            # The indent and terminating \n is already included in the code block
+            f"{new_code_block}"
+            f"{indent}```"
+        )
 
     # Replace all code blocks in the markdown
     markdown = code_block_pattern.sub(replace_highlight_comments, markdown)
     return markdown
 
 
-def handle_vcr_setup(
-    *,
-    formatter: Callable,
-    language: str,
-    code: str,
-    session: str,
-    id: str,
-    md: Markdown,
-    **kwargs: Dict[str, Any],
-) -> Dict[str, Any]:
-    """Handle VCR setup in markdown content if necessary."""
-    try:
-        if kwargs.get("extra", None) is None:
-            raise SuperFencesException(
-                f"error while processing {language} block: extra dict is required"
-            )
-
-        if kwargs["extra"].get("path", None) is None:
-            raise SuperFencesException(
-                f"error while processing {language} block: path is required"
-            )
-
-        document_filename = kwargs["extra"]["path"]
-
-        if session is None or session == "" and id is None or id == "":
-            id = _hash_string(code)
-
-        if session is not None and session != "":
-            logger.info(f"new session {session} on page {document_filename}")
-
-        cassette_prefix = document_filename.replace(".md", "").replace(os.path.sep, "_")
-
-        cassette_dir = os.path.abspath(
-            os.path.join(os.path.dirname(os.path.dirname(__file__)), "cassettes")
-        )
-        os.makedirs(cassette_dir, exist_ok=True)
-
-        # Build a unique cassette name.
-        cassette_name = os.path.join(
-            cassette_dir,
-            f"{cassette_prefix}_{session if session else id}_{language}.msgpack.zlib",
-        )
-
-        # Add context manager at start with explicit __enter__ and __exit__ calls
-
-        wrapped_lines = [
-            load_preamble(language, code, cassette_name),
-            code,
-        ]
-
-        if session is None or session == "":
-            logger.info(
-                f"no session, adding postamble for {language} in {document_filename}"
-            )
-            wrapped_lines.append(load_postamble(language))
-
-        transformed_source = "\n".join(wrapped_lines)
-        return dict(
-            transform_source=lambda code: (transformed_source, code),
-            id=id,
-            extra={},
-        )
-    except Exception as e:
-        raise SuperFencesException(traceback.format_exc()) from e
-
-
-def handle_vcr_teardown(
-    *,
-    formatter: Callable,
-    language: str,
-    session: str,
-    history: list[SessionHistoryEntry],
-):
-    last_inputs = dict(history[-1].inputs)
-    code = load_postamble(language)
-    md = last_inputs["md"]
-    html = False
-    update_toc = False
-
-    document_filename = last_inputs.get("extra", {}).get("path", None)
-
-    if document_filename is None:
-        logger.warning(f"no document filename found while tearing down {session}!")
-    else:
-        logger.info(f"tearing down {session} on {document_filename}")
-        logger.info(traceback.format_stack())
-
-    kwargs = dict(
-        code=code,
-        session=session,
-        id=f"{id}_vcr_end",
-        md=md,
-        html=html,
-        update_toc=update_toc,
-        extra={},
-    )
-
-    # This doesn't actually render anything, we just call the formatter so it
-    # executes in the same context as the session of which we're disposing.
-    formatter(**kwargs)
-
-
 def _on_page_markdown_with_config(
     markdown: str,
     page: Page,
@@ -274,7 +175,7 @@ def _on_page_markdown_with_config(
 
     # Append API reference links to code blocks
     if add_api_references:
-        markdown = update_markdown_with_imports(markdown)
+        markdown = update_markdown_with_imports(markdown, page.file.abs_src_path)
     # Apply highlight comments to code blocks
     markdown = _highlight_code_blocks(markdown)
 
@@ -285,7 +186,7 @@ def _on_page_markdown_with_config(
 
     if remove_base64_images:
         # Remove base64 encoded images from markdown
-        markdown = re.sub(r"!\[.*?\]\(data:image/+;base64,[^\)]+\)", "", markdown)
+        markdown = re.sub(r"!\[.*?\]\(data:image/[^;]+;base64,[^)]+\)", "", markdown)
 
     return markdown
 

docs/_scripts/setup_vcr.py

@@ -1,77 +0,0 @@
-# A list of patterns that, if found in a code block, will cause us to leave that block unchanged.
-import hashlib
-import os
-from textwrap import dedent
-
-preambles = {
-    "python": "vcr_setup_preamble.py",
-    "typescript": "nock_setup_preamble.ts",
-}
-
-
-def _get_python_cassette_init(cassette_name: str, hash_: str) -> str:
-    return dedent(
-        f"""
-        _cassette = HashedCassette('{cassette_name}', '{hash_}')
-        _cassette.__enter__()
-        """
-    )
-
-
-def _get_typescript_cassette_init(cassette_name: str, hash_: str) -> str:
-    return dedent(
-        f"""
-        const _cassette = new HashedCassette("{cassette_name}", "{hash_}");
-        await _cassette.enter();
-        """
-    )
-
-
-def _get_python_cassette_cleanup() -> str:
-    return "_cassette.__exit__()"
-
-
-def _get_typescript_cassette_cleanup() -> str:
-    return "await _cassette.exit();"
-
-
-preamble_inits = {
-    "python": _get_python_cassette_init,
-    "py": _get_python_cassette_init,
-    "typescript": _get_typescript_cassette_init,
-    "ts": _get_typescript_cassette_init,
-}
-
-preamble_cleanups = {
-    "python": _get_python_cassette_cleanup,
-    "py": _get_python_cassette_cleanup,
-    "typescript": _get_typescript_cassette_cleanup,
-    "ts": _get_typescript_cassette_cleanup,
-}
-
-
-def load_preamble(language: str, code: str, cassette_name: str) -> str:
-    """Load the source code for the preamble for a given language."""
-    _assets_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "assets")
-
-    preamble_path = os.path.join(_assets_dir, preambles[language])
-    with open(preamble_path, "r") as f:
-        lines = f.readlines()
-        hash_ = _hash_string(code)
-        lines.append(preamble_inits[language](cassette_name, hash_))
-        return "\n".join(lines).strip()
-
-
-def load_postamble(language: str) -> str:
-    """Load the source code for the postamble for a given language."""
-
-    return preamble_cleanups[language]()
-
-
-def _hash_string(input_string: str) -> str:
-    # Encode the input string to bytes
-    encoded_string = input_string.encode("utf-8")
-    # Create a SHA-256 hash object
-    sha256_hash = hashlib.sha256(encoded_string)
-    # Get the hexadecimal digest of the hash
-    return sha256_hash.hexdigest()

docs/_scripts/third_party_page/create_third_party_page.py

@@ -83,14 +83,18 @@ def generate_markdown(resolved_packages: List[ResolvedPackage], language: str) -
         resolved_packages, key=lambda p: p["weekly_downloads"] or 0, reverse=True
     )
     rows = [
-        "| Name | GitHub URL | Description | Weekly Downloads |",
-        "| --- | --- | --- | --- |",
+        "| Name | GitHub URL | Description | Weekly Downloads | Stars |",
+        "| --- | --- | --- | --- | --- |",
     ]
     for package in sorted_packages:
         name = f"**{package['name']}**"
         repo_url = f"[{package['repo']}](https://github.com/{package['repo']})"
-        downloads = package["weekly_downloads"] or 0
-        row = f"| {name} | {repo_url} | {package['description']} | {downloads} |"
+        stars_badge = (
+            f"https://img.shields.io/github/stars/{package['repo']}?style=social"
+        )
+        stars = f"![GitHub stars]({stars_badge})"
+        downloads = package["weekly_downloads"] or "-"
+        row = f"| {name} | {repo_url} | {package['description']} | {downloads} | {stars}"
         rows.append(row)
     markdown_content = MARKDOWN.format(
         library_list="\n".join(rows), langgraph_url=langgraph_url

docs/_scripts/third_party_page/get_download_stats.py

@@ -30,25 +30,63 @@ PACKAGES_FILE = HERE / "packages.yml"
 PACKAGES = yaml.safe_load(PACKAGES_FILE.read_text())['packages']
 
 
-def _get_weekly_downloads(packages: list[Package]) -> list[ResolvedPackage]:
+def _get_weekly_downloads(packages: list[Package], fake: bool) -> list[ResolvedPackage]:
     """Retrieve the monthly download count for a list of packages from PyPIStats."""
     resolved_packages: list[ResolvedPackage] = []
 
+    if fake:
+        # To avoid making network requests during testing, return fake download counts
+        for package in packages:
+            resolved_packages.append(
+                {
+                    "name": package["name"],
+                    "repo": package["repo"],
+                    "weekly_downloads": -12345,
+                    "description": package["description"],
+                }
+            )
+        return resolved_packages
+
     for package in packages:
-        url = f"https://pypistats.org/api/packages/{package['name']}/overall"
+        # First check if package exists on PyPI
+        pypi_url = f"https://pypi.org/pypi/{package['name']}/json"
+        try:
+            pypi_response = requests.get(pypi_url)
+            pypi_response.raise_for_status()
+        except requests.exceptions.HTTPError:
+            raise AssertionError(f"Package {package['name']} does not exist on PyPI")
 
-        response = requests.get(url)
-        response.raise_for_status()
-        data = response.json()
+        # Get first release date
+        pypi_data = pypi_response.json()
+        releases = pypi_data["releases"]
+        first_release_date = None
+        for version_releases in releases.values():
+            if version_releases:  # Some versions may be empty lists
+                upload_time = datetime.fromisoformat(version_releases[0]["upload_time"])
+                if first_release_date is None or upload_time < first_release_date:
+                    first_release_date = upload_time
 
-        sorted_data = sorted(
-            data["data"],
-            key=lambda x: datetime.strptime(x["date"], "%Y-%m-%d"),
-            reverse=True,
-        )
+        if first_release_date is None:
+            raise AssertionError(f"Package {package['name']} has no releases yet")
 
-        # Sum the last 7 days of downloads
-        num_downloads = sum(entry["downloads"] for entry in sorted_data[:7])
+        # If package was published in last 48 hours, skip download stats
+        if (datetime.now() - first_release_date).total_seconds() >= 48 * 3600:
+            url = f"https://pypistats.org/api/packages/{package['name']}/overall"
+
+            response = requests.get(url)
+            response.raise_for_status()
+            data = response.json()
+
+            sorted_data = sorted(
+                data["data"],
+                key=lambda x: datetime.strptime(x["date"], "%Y-%m-%d"),
+                reverse=True,
+            )
+
+            # Sum the last 7 days of downloads
+            num_downloads = sum(entry["downloads"] for entry in sorted_data[:7])
+        else:
+            num_downloads = None
 
         resolved_packages.append(
             {
@@ -63,13 +101,13 @@ def _get_weekly_downloads(packages: list[Package]) -> list[ResolvedPackage]:
 
 
 
-def main(output_file: str) -> None:
+def main(output_file: str, fake: bool) -> None:
     """Main function to generate package download information.
 
     Args:
         output_file: Path to the output YAML file.
     """
-    resolved_packages: list[ResolvedPackage] = _get_weekly_downloads(PACKAGES)
+    resolved_packages: list[ResolvedPackage] = _get_weekly_downloads(PACKAGES, fake)
 
     if not output_file.endswith(".yml"):
         raise ValueError("Output file must have a .yml extension")
@@ -90,6 +128,15 @@ if __name__ == "__main__":
             "downloads.yml"
         ),
     )
+    parser.add_argument(
+        "--fake",
+        default=False,
+        action="store_true",
+        help=(
+            "Generate fake download counts for testing purposes. "
+            "This option will not make any network requests."
+        ),
+    )
     args = parser.parse_args()
 
-    main(args.output_file)
+    main(args.output_file, args.fake)

docs/_scripts/third_party_page/packages.yml

@@ -2,10 +2,40 @@
 packages:
   - name: "trustcall"
     repo: "hinthornw/trustcall"
-    description: "Tenacious tool calling built on LangGraph"
+    description: "Tenacious tool calling built on LangGraph."
   - name: "breeze-agent"
     repo: "andrestorres123/breeze-agent"
-    description: "A streamlined research system built inspired on STORM and built on LangGraph"
+    description: "A streamlined research system built inspired on STORM and built on LangGraph."
   - name: "langgraph-supervisor"
-    repo: "langchain-ai/langgraph-supervisor"
-    description: "Build supervisor multi-agent systems with LangGraph"
+    repo: "langchain-ai/langgraph-supervisor-py"
+    description: "Build supervisor multi-agent systems with LangGraph."
+  - name: "langmem"
+    repo: "langchain-ai/langmem"
+    description: "Build agents that learn and adapt from interactions over time."
+  - name: "langchain-mcp-adapters"
+    repo: "langchain-ai/langchain-mcp-adapters"
+    description: "Make Anthropic Model Context Protocol (MCP) tools compatible with LangGraph agents."
+  - name: "open-deep-research"
+    repo: "langchain-ai/open_deep_research"
+    description: "Open source assistant for iterative web research and report writing."
+  - name: "langgraph-swarm"
+    repo: "langchain-ai/langgraph-swarm-py"
+    description: "Build swarm-style multi-agent systems using LangGraph."
+  - name: "delve-taxonomy-generator"
+    repo: "andrestorres123/delve"
+    description: "A taxonomy generator for unstructured data"
+  - name: "nodeology"
+    repo: "xyin-anl/Nodeology"
+    description: "Enable researcher to build scientific workflows easily with simplified interface."
+  - name: "langgraph-bigtool"
+    repo: "langchain-ai/langgraph-bigtool"
+    description: "Build LangGraph agents with large numbers of tools."
+  - name: "ai-data-science-team"
+    repo: "business-science/ai-data-science-team"
+    description: "An AI-powered data science team of agents to help you perform common data science tasks 10X faster."
+  - name: "langgraph-reflection"
+    repo: "langchain-ai/langgraph-reflection"
+    description: "LangGraph agent that runs a reflection step."
+  - name: "langmanus"
+    repo: "langmanus/langmanus"
+    description: "A community-driven AI automation framework that builds upon the incredible work of the open source community. Our goal is to combine language models with specialized tools for tasks like web search, crawling, and Python code execution, while giving back to the community that made this possible."

docs/docs/adopters.md

@@ -1,4 +1,4 @@
-# 🦜🕸️ LangGraph Adopters
+# 🦜🕸️ Companies using LangGraph
 
 This list of companies using LangGraph and their success stories is compiled from public sources. If your company uses LangGraph, we'd love for you to share your story and add it to the list. You’re also welcome to contribute updates based on publicly available information from other companies, such as blog posts or press releases.
 
@@ -9,9 +9,11 @@ This list of companies using LangGraph and their success stories is compiled fro
 | [AppFolio](https://www.appfolio.com/) | Real Estate | Copilot for domain-specific task | [Case study, 2024](https://blog.langchain.dev/customers-appfolio/) |
 | [Athena Intelligence](https://www.athenaintel.com/) | Software & Technology (GenAI Native) | Research & summarization | [Case study, 2024](https://blog.langchain.dev/customers-athena-intelligence/) |
 | [Captide](https://www.captide.co/) | Software & Technology (GenAI Native) | Data extraction | [Case study, 2025](https://blog.langchain.dev/how-captide-is-redefining-equity-research-with-agentic-workflows-built-on-langgraph-and-langsmith/) |
+| [Cisco Outshift](https://outshift.cisco.com/) | Software & Technology | DevOps | [Blog post, 2025](https://outshift.cisco.com/blog/build-react-agent-application-for-devops-tasks-using-rest-apis) |
 | [Elastic](https://www.elastic.co/) | Software & Technology | Copilot for domain-specific task | [Blog post, 2025](https://www.elastic.co/blog/elastic-security-generative-ai-features) |
 | [GitLab](https://about.gitlab.com/) | Software & Technology | Code generation | [Duo workflow docs](https://handbook.gitlab.com/handbook/engineering/architecture/design-documents/duo_workflow/) |
 | [Infor](https://infor.com/) | Software & Technology | GenAI embedded product experiences; customer support; copilot | [Case study, 2025](https://blog.langchain.dev/customers-infor/) |
+| [Klarna](https://www.klarna.com/) | Fintech | Copilot for domain-specific task | [Case study, 2025](https://blog.langchain.dev/customers-klarna/) |
 | [Komodo Health](https://www.komodohealth.com/) | Healthcare | Copilot for domain-specific task | [Blog post](https://www.komodohealth.com/perspectives/new-gen-ai-assistant-empowers-the-enterprise/) |
 | [LinkedIn](https://www.linkedin.com/) | Social Media | Code generation; Search & discovery | [Blog post, 2025](https://www.linkedin.com/blog/engineering/ai/practical-text-to-sql-for-data-analytics); [Blog post, 2024](https://www.linkedin.com/blog/engineering/generative-ai/behind-the-platform-the-journey-to-create-the-linkedin-genai-application-tech-stack) |
 | [Minimal](https://gominimal.ai/) | E-commerce | Customer support | [Case study, 2025](https://blog.langchain.dev/how-minimal-built-a-multi-agent-customer-support-system-with-langgraph-langsmith/) |
@@ -22,4 +24,4 @@ This list of companies using LangGraph and their success stories is compiled fro
 | [Tradestack](https://www.tradestack.uk/) | Software & Technology (GenAI Native) | Copilot for domain-specific task | [Case study, 2024](https://blog.langchain.dev/customers-tradestack/) |
 | [Uber](https://www.uber.com/) | Transportation | Developer productivity; Code generation | [Presentation, 2024](https://dpe.org/sessions/ty-smith-adam-huda/this-year-in-ubers-ai-driven-developer-productivity-revolution/); [Video, 2024](https://www.youtube.com/watch?v=8rkA5vWUE4Y) |
 | [Unify](https://www.unifygtm.com/) | Software & Technology (GenAI Native) | Copilot for domain-specific task | [Blog post, 2024](https://blog.langchain.dev/unify-launches-agents-for-account-qualification-using-langgraph-and-langsmith/) |
-| [Vizient](https://www.vizientinc.com/) | Healthcare | Copilot for domain-specific task | [Case study, 2025](https://blog.langchain.dev/p/3d2cd58c-13a5-4df9-bd84-7d54ed0ed82c/) |
+| [Vizient](https://www.vizientinc.com/) | Healthcare | Copilot for domain-specific task | [Case study, 2025](https://blog.langchain.dev/p/3d2cd58c-13a5-4df9-bd84-7d54ed0ed82c/) |

docs/docs/cloud/deployment/cloud.md

@@ -92,3 +92,28 @@ Starting from the `LangGraph Platform` view...
 1. Check/uncheck checkbox to `Automatically update deployment on push to branch`.
     1. Branch creation/deletion and tag creation/deletion events will not trigger an update. Only pushes to an existing branch will trigger an update.
     1. Pushes in quick succession to a branch will not trigger subsequent updates. In the future, this functionality may be changed/improved.
+
+## Add or Remove GitHub Repositories
+
+After installing and authorizing LangChain's `hosted-langserve` GitHub app, repository access for the app can be modified to add new repositories or remove existing repositories. If a new repository is created, it may need to be added explicitly.
+
+1. From the GitHub profile, navigate to `Settings` > `Applications` > `hosted-langserve` > click `Configure`.
+1. Under `Repository access`, select `All repositories` or `Only select repositories`. If `Only select repositories` is selected, new repositories must be explicitly added.
+1. Click `Save`.
+1. When creating a new deployment, the list of GitHub repositories in the dropdown menu will be updated to reflect the repository access changes.
+
+## Whitelisting IP Addresses
+
+All traffic from `LangGraph Platform` deployments created after January 6th 2025 will come through a NAT gateway.
+This NAT gateway will have several static ip addresses depending on the region you are deploying in. Refer to the table below for the list of IP addresses to whitelist:
+
+| US             | EU             |
+|----------------|----------------|
+| 35.197.29.146  | 34.13.192.67   |
+| 34.145.102.123 | 34.147.105.64  |
+| 34.169.45.153  | 34.90.22.166   |
+| 34.82.222.17   | 34.147.36.213  |
+| 35.227.171.135 | 34.32.137.113  | 
+| 34.169.88.30   | 34.91.238.184  |
+| 34.19.93.202   | 35.204.101.241 |
+| 34.19.34.50    | 35.204.48.32   |

docs/docs/cloud/deployment/semantic_search.md

@@ -17,7 +17,7 @@ This guide explains how to add semantic search to your LangGraph deployment's cr
     ...
     "store": {
         "index": {
-            "embed": "openai:text-embeddings-3-small",
+            "embed": "openai:text-embedding-3-small",
             "dims": 1536,
             "fields": ["$"]
         }
@@ -27,7 +27,7 @@ This guide explains how to add semantic search to your LangGraph deployment's cr
 
 This configuration:
 
-- Uses OpenAI's text-embeddings-3-small model for generating embeddings
+- Uses OpenAI's text-embedding-3-small model for generating embeddings
 - Sets the embedding dimension to 1536 (matching the model's output)
 - Indexes all fields in your stored data (`["$"]` means index everything, or specify specific fields like `["text", "metadata.title"]`)
 

docs/docs/cloud/deployment/setup.md

@@ -36,21 +36,20 @@ Dependencies can optionally be specified in one of the following files: `pyproje
 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.56,<0.3.0
-langgraph-checkpoint>=2.0.5,<3.0
+langgraph>=0.2.56,<0.4.0
+langgraph-sdk>=0.1.53
+langgraph-checkpoint>=2.0.15,<3.0
 langchain-core>=0.2.38,<0.4.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
+sse-starlette>=2.1.0,<2.2.0
 uvloop>=0.18.0
 httptools>=0.5.0
-jsonschema-rs>=0.16.3
-croniter>=1.0.1
+jsonschema-rs>=0.20.0
 structlog>=23.1.0
-redis>=5.0.0,<6.0.0
 ```
 
 Example `requirements.txt` file:

docs/docs/cloud/deployment/setup_pyproject.md

@@ -36,21 +36,20 @@ Dependencies can optionally be specified in one of the following files: `pyproje
 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.56,<0.3.0
-langgraph-checkpoint>=2.0.5,<3.0
+langgraph>=0.2.56,<0.4.0
+langgraph-sdk>=0.1.53
+langgraph-checkpoint>=2.0.15,<3.0
 langchain-core>=0.2.38,<0.4.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
+sse-starlette>=2.1.0,<2.2.0
 uvloop>=0.18.0
 httptools>=0.5.0
-jsonschema-rs>=0.16.3
-croniter>=1.0.1
+jsonschema-rs>=0.20.0
 structlog>=23.1.0
-redis>=5.0.0,<6.0.0
 ```
 
 Example `pyproject.toml` file:
@@ -65,7 +64,7 @@ license = "MIT"
 readme = "README.md"
 
 [tool.poetry.dependencies]
-python = ">=3.9.0,<3.13"
+python = ">=3.9"
 langgraph = "^0.2.0"
 langchain-fireworks = "^0.1.3"
 

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

@@ -0,0 +1,312 @@
+# How to implement Generative User Interfaces with LangGraph
+
+!!! info "Prerequisites"
+
+    - [LangGraph Platform](../../concepts/langgraph_platform.md)
+    - [LangGraph Server](../../concepts/langgraph_server.md)
+    - [`useStream()` React Hook](./use_stream_react.md)
+
+Generative user interfaces (Generative UI) allows agents to go beyond text and generate rich user interfaces. This enables creating more interactive and context-aware applications where the UI adapts based on the conversation flow and AI responses.
+
+![Generative UI Sample](./img/generative_ui_sample.jpg)
+
+LangGraph Platform supports colocating your React components with your graph code. This allows you to focus on building specific UI components for your graph while easily plugging into existing chat interfaces such as [Agent Chat](https://agentchat.vercel.app) and loading the code only when actually needed.
+
+!!! warning "LangGraph.js only"
+
+    Currently only LangGraph.js supports Generative UI. Support for Python is coming soon.
+
+## Tutorial
+
+### 1. Define and configure UI components
+
+First, create your first UI component. For each component you need to provide an unique identifier that will be used to reference the component in your graph code.
+
+```tsx title="src/agent/ui.tsx"
+const WeatherComponent = (props: { city: string }) => {
+  return <div>Weather for {props.city}</div>;
+};
+
+export default {
+  weather: WeatherComponent,
+};
+```
+
+Next, define your UI components in your `langgraph.json` configuration:
+
+```json
+{
+  "node_version": "20",
+  "graphs": {
+    "agent": "./src/agent/index.ts:graph"
+  },
+  "ui": {
+    "agent": "./src/agent/ui.tsx"
+  }
+}
+```
+
+The `ui` section points to the UI components that will be used by graphs. By default, we recommend using the same key as the graph name, but you can split out the components however you like, see [Customise the namespace of UI components](#customise-the-namespace-of-ui-components) for more details.
+
+LangGraph Platform will automatically bundle your UI components code and styles and serve them as external assets that can be loaded by the `LoadExternalComponent` component. Some dependencies such as `react` and `react-dom` will be automatically excluded from the bundle.
+
+CSS and Tailwind 4.x is also supported out of the box, so you can freely use Tailwind classes as well as `shadcn/ui` in your UI components.
+
+=== "`src/agent/ui.tsx`"
+
+    ```tsx
+    import "./styles.css";
+
+    const WeatherComponent = (props: { city: string }) => {
+      return <div className="bg-red-500">Weather for {props.city}</div>;
+    };
+
+    export default {
+      weather: WeatherComponent,
+    };
+    ```
+
+=== "`src/agent/styles.css`"
+
+    ```css
+    @import "tailwindcss";
+    ```
+
+### 2. Send the UI components in your graph
+
+Use the `typedUi` utility to emit UI elements from your agent nodes:
+
+```typescript title="src/agent/index.ts"
+import {
+  typedUi,
+  uiMessageReducer,
+} from "@langchain/langgraph-sdk/react-ui/server";
+
+import { ChatOpenAI } from "@langchain/openai";
+import { v4 as uuidv4 } from "uuid";
+import { z } from "zod";
+
+import type ComponentMap from "./ui.js";
+
+import {
+  Annotation,
+  MessagesAnnotation,
+  StateGraph,
+  type LangGraphRunnableConfig,
+} from "@langchain/langgraph";
+
+const AgentState = Annotation.Root({
+  ...MessagesAnnotation.spec,
+  ui: Annotation({ reducer: uiMessageReducer, default: () => [] }),
+});
+
+export const graph = new StateGraph(AgentState)
+  .addNode("weather", async (state, config) => {
+    // Provide the type of the component map to ensure
+    // type safety of `ui.push()` calls as well as
+    // pushing the messages to the `ui` and sending a custom event as well.
+    const ui = typedUi<typeof ComponentMap>(config);
+
+    const weather = await new ChatOpenAI({ model: "gpt-4o-mini" })
+      .withStructuredOutput(z.object({ city: z.string() }))
+      .withConfig({ tags: ["langsmith:nostream"] })
+      .invoke(state.messages);
+
+    const response = {
+      id: uuidv4(),
+      type: "ai",
+      content: `Here's the weather for ${weather.city}`,
+    };
+
+    // Emit UI elements with associated AI message
+    ui.push({ name: "weather", props: weather }, { message: response });
+
+    return { messages: [response] };
+  })
+  .addEdge("__start__", "weather")
+  .compile();
+```
+
+### 3. Handle UI elements in your React application
+
+On the client side, you can use `useStream()` and `LoadExternalComponent` to display the UI elements.
+
+```tsx title="src/app/page.tsx"
+"use client";
+
+import { useStream } from "@langchain/langgraph-sdk/react";
+import { LoadExternalComponent } from "@langchain/langgraph-sdk/react-ui";
+
+export default function Page() {
+  const { thread, values } = useStream({
+    apiUrl: "http://localhost:2024",
+    assistantId: "agent",
+  });
+
+  return (
+    <div>
+      {thread.messages.map((message) => (
+        <div key={message.id}>
+          {message.content}
+          {values.ui
+            ?.filter((ui) => ui.metadata?.message_id === message.id)
+            .map((ui) => (
+              <LoadExternalComponent key={ui.id} stream={thread} message={ui} />
+            ))}
+        </div>
+      ))}
+    </div>
+  );
+}
+```
+
+Behind the scenes, `LoadExternalComponent` will fetch the JS and CSS for the UI components from LangGraph Platform and render them in a shadow DOM, thus ensuring style isolation from the rest of your application.
+
+## How-to guides
+
+### Show loading UI when components are loading
+
+You can provide a fallback UI to be rendered when the components are loading.
+
+```tsx
+<LoadExternalComponent
+  stream={thread}
+  message={ui}
+  fallback={<div>Loading...</div>}
+/>
+```
+
+### Provide custom components on the client side
+
+If you already have the components loaded in your client application, you can provide a map of such components to be rendered directly without fetching the UI code from LangGraph Platform.
+
+```tsx
+const clientComponents = {
+  weather: WeatherComponent,
+};
+
+<LoadExternalComponent
+  stream={thread}
+  message={ui}
+  components={clientComponents}
+/>;
+```
+
+### Customise the namespace of UI components.
+
+By default `LoadExternalComponent` will use the `assistantId` from `useStream()` hook to fetch the code for UI components. You can customise this by providing a `namespace` prop to the `LoadExternalComponent` component.
+
+=== "`src/app/page.tsx`"
+
+    ```tsx
+    <LoadExternalComponent
+      stream={thread}
+      message={ui}
+      namespace="custom-namespace"
+    />
+    ```
+
+=== "`langgraph.json`"
+
+    ```json
+    {
+      "ui": {
+        "custom-namespace": "./src/agent/ui.tsx"
+      }
+    }
+    ```
+
+### Access and interact with the thread state from the UI component
+
+You can access the thread state inside the UI component by using the `useStreamContext` hook.
+
+```tsx
+import { useStreamContext } from "@langchain/langgraph-sdk/react-ui";
+
+const WeatherComponent = (props: { city: string }) => {
+  const { thread, submit } = useStreamContext();
+  return (
+    <>
+      <div>Weather for {props.city}</div>
+
+      <button
+        onClick={() => {
+          const newMessage = {
+            type: "human",
+            content: `What's the weather in ${props.city}?`,
+          };
+
+          submit({ messages: [newMessage] });
+        }}
+      >
+        Retry
+      </button>
+    </>
+  );
+};
+```
+
+### Pass additional context to the client components
+
+You can pass additional context to the client components by providing a `meta` prop to the `LoadExternalComponent` component.
+
+```tsx
+<LoadExternalComponent stream={thread} message={ui} meta={{ userId: "123" }} />
+```
+
+Then, you can access the `meta` prop in the UI component by using the `useStreamContext` hook.
+
+```tsx
+import { useStreamContext } from "@langchain/langgraph-sdk/react-ui";
+
+const WeatherComponent = (props: { city: string }) => {
+  const { meta } = useStreamContext<
+    { city: string },
+    { MetaType: { userId?: string } }
+  >();
+
+  return (
+    <div>
+      Weather for {props.city} (user: {meta?.userId})
+    </div>
+  );
+};
+```
+
+### Streaming UI updates before the node execution is finished
+
+You can stream UI updates before the node execution is finished by using the `onCustomEvent` callback of the `useStream()` hook.
+
+```tsx
+import { uiMessageReducer } from "@langchain/langgraph-sdk/react-ui";
+
+const { thread, submit } = useStream({
+  apiUrl: "http://localhost:2024",
+  assistantId: "agent",
+  onCustomEvent: (event, options) => {
+    options.mutate((prev) => {
+      const ui = uiMessageReducer(prev.ui ?? [], event);
+      return { ...prev, ui };
+    });
+  },
+});
+```
+
+### Remove UI messages from state
+
+Similar to how messages can be removed from the state by appending a RemoveMessage you can remove an UI message from the state by calling `ui.delete` with the ID of the UI message.
+
+```tsx
+// pushed message
+const message = ui.push({ name: "weather", props: { city: "London" } });
+
+// remove said message
+ui.delete(message.id);
+
+// return new state to persist changes
+return { ui: ui.items };
+```
+
+## Learn more
+
+- [JS/TS SDK Reference](../reference/sdk/js_ts_sdk_ref.md)

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

@@ -63,7 +63,7 @@ Now, let's invoke our graph by interrupting before `ask_human` node:
         "messages": [
             {
                 "role": "user",
-                "content": "Use the search tool to ask the user where they are, then look up the weather there",
+                "content": "Ask the user where they are, then look up the weather there",
             }
         ]
     }
@@ -85,8 +85,7 @@ Now, let's invoke our graph by interrupting before `ask_human` node:
       messages: [
         {
           role: "human",
-          content: "Use the search tool to ask the user where they are, then look up the weather there"
-        }
+          content: "Ask the user where they are, then look up the weather there" }
       ]
     };
 
@@ -115,7 +114,7 @@ Now, let's invoke our graph by interrupting before `ask_human` node:
      --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\"}]},
+       \"input\": {\"messages\": [{\"role\": \"human\", \"content\": \"Ask the user where they are, then look up the weather there\"}]},
        \"interrupt_before\": [\"ask_human\"],
        \"stream_mode\": [
          \"updates\"

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

@@ -0,0 +1,140 @@
+# Prompt Engineering in LangGraph Studio
+
+## Overview
+
+A central aspect of agent development is prompt engineering. LangGraph Studio makes it easy to iterate on the prompts used within your graph directly within the UI.
+
+## Setup
+
+The first step is to define your [configuration](https://langchain-ai.github.io/langgraph/how-tos/configuration/) such that LangGraph Studio is aware of the prompts you want to iterate on and which nodes they are associated with.
+
+### Reference
+
+When defining your configuration, you can use special metadata keys to instruct LangGraph Studio how to handle different fields. Here's a reference for the available configuration options:
+
+#### `langgraph_nodes`
+
+- **Description**: Specifies which graph nodes a configuration field is associated with.
+- **Value Type**: Array of strings, where each string is the name of a node in your graph.
+- **Usage Context**: Include in the `json_schema_extra` dictionary for Pydantic models or the `metadata["json_schema_extra"]` dictionary for dataclasses.
+- **Required**: No, but necessary if you want a field to be editable for specific nodes in the UI.
+- **Example**:
+  ```python
+  system_prompt: str = Field(
+      default="You are a helpful AI assistant.",
+      json_schema_extra={"langgraph_nodes": ["call_model", "other_node"]},
+  )
+  ```
+
+#### `langgraph_type`
+
+- **Description**: Specifies the type of configuration field, which determines how it's handled in the UI.
+- **Value Type**: String
+- **Supported Values**:
+  - `"prompt"`: Indicates the field contains prompt text that should be treated specially in the UI.
+- **Usage Context**: Include in the `json_schema_extra` dictionary for Pydantic models or the `metadata["json_schema_extra"]` dictionary for dataclasses.
+- **Required**: No, but helpful for prompt fields to enable special handling.
+- **Example**:
+  ```python
+  system_prompt: str = Field(
+      default="You are a helpful AI assistant.",
+      json_schema_extra={
+          "langgraph_nodes": ["call_model"],
+          "langgraph_type": "prompt",
+      },
+  )
+  ```
+
+### Example
+
+For example, if you have a node called `call_model` whose system prompt you want to iterate on, you can define a configuration like the following.
+
+```python
+## Using Pydantic
+from pydantic import BaseModel, Field
+from typing import Annotated, Literal
+
+class Configuration(BaseModel):
+    """The configuration for the agent."""
+
+    system_prompt: str = Field(
+        default="You are a helpful AI assistant.",
+        description="The system prompt to use for the agent's interactions. "
+        "This prompt sets the context and behavior for the agent.",
+        json_schema_extra={
+            "langgraph_nodes": ["call_model"],
+            "langgraph_type": "prompt",
+        },
+    )
+
+    model: Annotated[
+        Literal[
+            "anthropic/claude-3-7-sonnet-latest",
+            "anthropic/claude-3-5-haiku-latest",
+            "openai/o1",
+            "openai/gpt-4o-mini",
+            "openai/o1-mini",
+            "openai/o3-mini",
+        ],
+        {"__template_metadata__": {"kind": "llm"}},
+    ] = Field(
+        default="openai/gpt-4o-mini",
+        description="The name of the language model to use for the agent's main interactions. "
+        "Should be in the form: provider/model-name.",
+        json_schema_extra={"langgraph_nodes": ["call_model"]},
+    )
+
+## Using Dataclasses
+from dataclasses import dataclass, field
+
+@dataclass(kw_only=True)
+class Configuration:
+    """The configuration for the agent."""
+
+    system_prompt: str = field(
+        default="You are a helpful AI assistant.",
+        metadata={
+            "description": "The system prompt to use for the agent's interactions. "
+            "This prompt sets the context and behavior for the agent.",
+            "json_schema_extra": {"langgraph_nodes": ["call_model"]},
+        },
+    )
+
+    model: Annotated[str, {"__template_metadata__": {"kind": "llm"}}] = field(
+        default="anthropic/claude-3-5-sonnet-20240620",
+        metadata={
+            "description": "The name of the language model to use for the agent's main interactions. "
+            "Should be in the form: provider/model-name.",
+            "json_schema_extra": {"langgraph_nodes": ["call_model"]},
+        },
+    )
+
+```
+
+## Iterating on prompts
+
+### Node Configuration
+
+With this set up, running your graph and viewing in LangGraph Studio will result in the graph rendering like such.
+
+**Note the configuration icon in the top right corner of the `call_model` node**:
+
+![Graph in Studio](../img/studio_graph_with_configuration.png){width=1200}
+
+Clicking this icon will open a modal where you can edit the configuration for all of the fields associated with the `call_model` node. From here, you can save your changes and apply them to the graph. Note that these values reflect the currently active assistant, and saving will update the assistant with the new values.
+
+![Configuration modal](../img/studio_node_configuration.png){width=1200}
+
+### Playground
+
+LangGraph Studio also supports prompt engineering through an integration with the LangSmith Playground. To do so:
+
+1. Open an existing thread or create a new one.
+2. Within the thread log, any nodes that have made an LLM call will have a "View LLM Runs" button. Clicking this will open a popover with the LLM runs for that node.
+3. Select the LLM run you want to edit. This will open the LangSmith Playground with the selected LLM run.
+
+![Playground in Studio](../img/studio_playground.png){width=1200}
+
+From here you can edit the prompt, test different model configurations and re-run just this LLM call without having to re-run the entire graph. When you are happy with your changes, you can copy the updated prompt back into your graph.
+
+For more information on how to use the LangSmith Playground, see the [LangSmith Playground documentation](https://docs.smith.langchain.com/prompt_engineering/how_to_guides#playground).

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

@@ -99,7 +99,7 @@ We can stream the results of a stateless run in an almost identical fashion to h
 
     ```bash
     curl --request POST \
-        --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
+        --url <DEPLOYMENT_URL>/runs/stream \
         --header 'Content-Type: application/json' \
         --data "{
             \"assistant_id\": \"agent\",
@@ -144,7 +144,7 @@ In addition to streaming, you can also wait for a stateless result by using the
 
     ```bash
     curl --request POST \
-        --url <DEPLOYMENT_URL>/runs/runs/wait \
+        --url <DEPLOYMENT_URL>/runs/wait \
         --header 'Content-Type: application/json' \
         --data '{
             "assistant_id": <ASSISTANT_IDD>,

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

@@ -1,10 +1,10 @@
-# Test Cloud Deployment
+# Test LangGraph Platform Deployment
 
-The LangGraph Studio UI connects directly to LangGraph Cloud deployments.
+The LangGraph Studio UI connects directly to LangGraph Platform deployments.
 
 Starting from the <a href="https://smith.langchain.com/" target="_blank">LangSmith UI</a>...
 
-1. In the left-hand navigation panel, select `LangGraph Cloud`. The `LangGraph Cloud` view contains a list of existing LangGraph Cloud deployments.
+1. In the left-hand navigation panel, select `LangGraph Platform`. The `LangGraph Platform` view contains a list of existing LangGraph Platform deployments.
 1. Select an existing deployment to test with LangGraph Studio.
 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).

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

@@ -0,0 +1,458 @@
+# How to integrate LangGraph into your React application
+
+!!! info "Prerequisites"
+    - [LangGraph Platform](../../concepts/langgraph_platform.md)
+    - [LangGraph Server](../../concepts/langgraph_server.md)
+
+The `useStream()` React hook provides a seamless way to integrate LangGraph into your React applications. It handles all the complexities of streaming, state management, and branching logic, letting you focus on building great chat experiences.
+
+Key features:
+
+- Messages streaming: Handle a stream of message chunks to form a complete message
+- Automatic state management for messages, interrupts, loading states, and errors
+- Conversation branching: Create alternate conversation paths from any point in the chat history
+- UI-agnostic design: bring your own components and styling
+
+Let's explore how to use `useStream()` in your React application.
+
+The `useStream()` provides a solid foundation for creating bespoke chat experiences. For pre-built chat components and interfaces, we also recommend checking out [CopilotKit](https://docs.copilotkit.ai/coagents/quickstart/langgraph) and [assistant-ui](https://www.assistant-ui.com/docs/runtimes/langgraph).
+
+## Installation
+
+```bash
+npm install @langchain/langgraph-sdk @langchain/core
+```
+
+## Example
+
+```tsx
+"use client";
+
+import { useStream } from "@langchain/langgraph-sdk/react";
+import type { Message } from "@langchain/langgraph-sdk";
+
+export default function App() {
+  const thread = useStream<{ messages: Message[] }>({
+    apiUrl: "http://localhost:2024",
+    assistantId: "agent",
+    messagesKey: "messages",
+  });
+
+  return (
+    <div>
+      <div>
+        {thread.messages.map((message) => (
+          <div key={message.id}>{message.content as string}</div>
+        ))}
+      </div>
+
+      <form
+        onSubmit={(e) => {
+          e.preventDefault();
+
+          const form = e.target as HTMLFormElement;
+          const message = new FormData(form).get("message") as string;
+
+          form.reset();
+          thread.submit({ messages: [{ type: "human", content: message }] });
+        }}
+      >
+        <input type="text" name="message" />
+
+        {thread.isLoading ? (
+          <button key="stop" type="button" onClick={() => thread.stop()}>
+            Stop
+          </button>
+        ) : (
+          <button keytype="submit">Send</button>
+        )}
+      </form>
+    </div>
+  );
+}
+```
+
+## Customizing Your UI
+
+The `useStream()` hook takes care of all the complex state management behind the scenes, providing you with simple interfaces to build your UI. Here's what you get out of the box:
+
+- Thread state management
+- Loading and error states
+- Interrupts
+- Message handling and updates
+- Branching support
+
+Here are some examples on how to use these features effectively:
+
+### Loading States
+
+The `isLoading` property tells you when a stream is active, enabling you to:
+
+- Show a loading indicator
+- Disable input fields during processing
+- Display a cancel button
+
+```tsx
+export default function App() {
+  const { isLoading, stop } = useStream<{ messages: Message[] }>({
+    apiUrl: "http://localhost:2024",
+    assistantId: "agent",
+    messagesKey: "messages",
+  });
+
+  return (
+    <form>
+      {isLoading && (
+        <button key="stop" type="button" onClick={() => stop()}>
+          Stop
+        </button>
+      )}
+    </form>
+  );
+}
+```
+
+### Thread Management
+
+Keep track of conversations with built-in thread management. You can access the current thread ID and get notified when new threads are created:
+
+```tsx
+const [threadId, setThreadId] = useState<string | null>(null);
+
+const thread = useStream<{ messages: Message[] }>({
+  apiUrl: "http://localhost:2024",
+  assistantId: "agent",
+
+  threadId: threadId,
+  onThreadId: setThreadId,
+});
+```
+
+We recommend storing the `threadId` in your URL's query parameters to let users resume conversations after page refreshes.
+
+### Messages Handling
+
+The `useStream()` hook will keep track of the message chunks received from the server and concatenate them together to form a complete message. The completed message chunks can be retrieved via the `messages` property.
+
+By default, the `messagesKey` is set to `messages`, where it will append the new messages chunks to `values["messages"]`. If you store messages in a different key, you can change the value of `messagesKey`.
+
+```tsx
+import type { Message } from "@langchain/langgraph-sdk";
+import { useStream } from "@langchain/langgraph-sdk/react";
+
+export default function HomePage() {
+  const thread = useStream<{ messages: Message[] }>({
+    apiUrl: "http://localhost:2024",
+    assistantId: "agent",
+    messagesKey: "messages",
+  });
+
+  return (
+    <div>
+      {thread.messages.map((message) => (
+        <div key={message.id}>{message.content as string}</div>
+      ))}
+    </div>
+  );
+}
+```
+
+Under the hood, the `useStream()` hook will use the `streamMode: "messages-key"` to receive a stream of messages (i.e. individual LLM tokens) from any LangChain chat model invocations inside your graph nodes. Learn more about messages streaming in the [How to stream messages from your graph](./stream_messages.md) guide.
+
+### Interrupts
+
+The `useStream()` hook exposes the `interrupt` property, which will be filled with the last interrupt from the thread. You can use interrupts to:
+
+- Render a confirmation UI before executing a node
+- Wait for human input, allowing agent to ask the user with clarifying questions
+
+Learn more about interrupts in the [How to handle interrupts](../../how-tos/human_in_the_loop/wait-user-input.ipynb) guide.
+
+```tsx
+const thread = useStream<
+  { messages: Message[] },
+  { InterruptType: string }
+>({
+  apiUrl: "http://localhost:2024",
+  assistantId: "agent",
+  messagesKey: "messages",
+});
+
+if (thread.interrupt) {
+  return (
+    <div>
+      Interrupted! {thread.interrupt.value}
+
+      <button
+        type="button"
+        onClick={() => {
+          // `resume` can be any value that the agent accepts
+          thread.submit(undefined, { command: { resume: true } });
+        }}
+      >
+        Resume
+      </button>
+    </div>
+  );
+}
+```
+
+### Branching
+
+For each message, you can use `getMessagesMetadata()` to get the first checkpoint from which the message has been first seen. You can then create a new run from the checkpoint preceding the first seen checkpoint to create a new branch in a thread.
+
+A branch can be created in following ways:
+
+1. Edit a previous user message.
+2. Request a regeneration of a previous assistant message.
+
+```tsx
+"use client";
+
+import type { Message } from "@langchain/langgraph-sdk";
+import { useStream } from "@langchain/langgraph-sdk/react";
+import { useState } from "react";
+
+function BranchSwitcher({
+  branch,
+  branchOptions,
+  onSelect,
+}: {
+  branch: string | undefined;
+  branchOptions: string[] | undefined;
+  onSelect: (branch: string) => void;
+}) {
+  if (!branchOptions || !branch) return null;
+  const index = branchOptions.indexOf(branch);
+
+  return (
+    <div className="flex items-center gap-2">
+      <button
+        type="button"
+        onClick={() => {
+          const prevBranch = branchOptions[index - 1];
+          if (!prevBranch) return;
+          onSelect(prevBranch);
+        }}
+      >
+        Prev
+      </button>
+      <span>
+        {index + 1} / {branchOptions.length}
+      </span>
+      <button
+        type="button"
+        onClick={() => {
+          const nextBranch = branchOptions[index + 1];
+          if (!nextBranch) return;
+          onSelect(nextBranch);
+        }}
+      >
+        Next
+      </button>
+    </div>
+  );
+}
+
+function EditMessage({
+  message,
+  onEdit,
+}: {
+  message: Message;
+  onEdit: (message: Message) => void;
+}) {
+  const [editing, setEditing] = useState(false);
+
+  if (!editing) {
+    return (
+      <button type="button" onClick={() => setEditing(true)}>
+        Edit
+      </button>
+    );
+  }
+
+  return (
+    <form
+      onSubmit={(e) => {
+        e.preventDefault();
+        const form = e.target as HTMLFormElement;
+        const content = new FormData(form).get("content") as string;
+
+        form.reset();
+        onEdit({ type: "human", content });
+        setEditing(false);
+      }}
+    >
+      <input name="content" defaultValue={message.content as string} />
+      <button type="submit">Save</button>
+    </form>
+  );
+}
+
+export default function App() {
+  const thread = useStream({
+    apiUrl: "http://localhost:2024",
+    assistantId: "agent",
+    messagesKey: "messages",
+  });
+
+  return (
+    <div>
+      <div>
+        {thread.messages.map((message) => {
+          const meta = thread.getMessagesMetadata(message);
+          const parentCheckpoint = meta?.firstSeenState?.parent_checkpoint;
+
+          return (
+            <div key={message.id}>
+              <div>{message.content as string}</div>
+
+              {message.type === "human" && (
+                <EditMessage
+                  message={message}
+                  onEdit={(message) =>
+                    thread.submit(
+                      { messages: [message] },
+                      { checkpoint: parentCheckpoint },
+                    )
+                  }
+                />
+              )}
+
+              {message.type === "ai" && (
+                <button
+                  type="button"
+                  onClick={() =>
+                    thread.submit(undefined, { checkpoint: parentCheckpoint })
+                  }
+                >
+                  <span>Regenerate</span>
+                </button>
+              )}
+
+              <BranchSwitcher
+                branch={meta?.branch}
+                branchOptions={meta?.branchOptions}
+                onSelect={(branch) => thread.setBranch(branch)}
+              />
+            </div>
+          );
+        })}
+      </div>
+
+      <form
+        onSubmit={(e) => {
+          e.preventDefault();
+
+          const form = e.target as HTMLFormElement;
+          const message = new FormData(form).get("message") as string;
+
+          form.reset();
+          thread.submit({ messages: [message] });
+        }}
+      >
+        <input type="text" name="message" />
+
+        {thread.isLoading ? (
+          <button key="stop" type="button" onClick={() => thread.stop()}>
+            Stop
+          </button>
+        ) : (
+          <button key="submit" type="submit">
+            Send
+          </button>
+        )}
+      </form>
+    </div>
+  );
+}
+```
+
+For advanced use cases you can use the `experimental_branchTree` property to get the tree representation of the thread, which can be used to render branching controls for non-message based graphs.
+
+### TypeScript
+
+The `useStream()` hook is friendly for apps written in TypeScript and you can specify types for the state to get better type safety and IDE support.
+
+```tsx
+// Define your types
+type State = {
+  messages: Message[];
+  context?: Record<string, unknown>;
+};
+
+// Use them with the hook
+const thread = useStream<State>({
+  apiUrl: "http://localhost:2024",
+  assistantId: "agent",
+  messagesKey: "messages",
+});
+```
+
+You can also optionally specify types for different scenarios, such as:
+
+- `ConfigurableType`: Type for the `config.configurable` property (default: `Record<string, unknown>`)
+- `InterruptType`: Type for the interrupt value - i.e. contents of `interrupt(...)` function (default: `unknown`)
+- `CustomEventType`: Type for the custom events (default: `unknown`)
+- `UpdateType`: Type for the submit function (default: `Partial<State>`)
+
+```tsx
+
+const thread = useStream<State, {
+  UpdateType: {
+    messages: Message[] | Message;
+    context?: Record<string, unknown>;
+  };
+  InterruptType: string;
+  CustomEventType: {
+    type: "progress" | "debug";
+    payload: unknown;
+  };
+  ConfigurableType: {
+    model: string;
+  };
+}>({
+  apiUrl: "http://localhost:2024",
+  assistantId: "agent",
+  messagesKey: "messages",
+});
+```
+
+If you're using LangGraph.js, you can also reuse your graph's annotation types. However, make sure to only import the types of the annotation schema in order to avoid importing the entire LangGraph.js runtime (i.e. via `import type { ... }` directive).
+
+```tsx
+import {
+  Annotation,
+  MessagesAnnotation,
+  type StateType,
+  type UpdateType,
+} from "@langchain/langgraph/web";
+
+const AgentState = Annotation.Root({
+  ...MessagesAnnotation.spec,
+  context: Annotation<string>(),
+});
+
+const thread = useStream<
+  StateType<typeof AgentState.spec>,
+  { UpdateType: UpdateType<typeof AgentState.spec> }
+>({
+  apiUrl: "http://localhost:2024",
+  assistantId: "agent",
+  messagesKey: "messages",
+});
+```
+
+## Event Handling
+
+The `useStream()` hook provides several callback options to help you respond to different events:
+
+- `onError`: Called when an error occurs.
+- `onFinish`: Called when the stream is finished.
+- `onUpdateEvent`: Called when an update event is received.
+- `onCustomEvent`: Called when a custom event is received. See [Custom events](../../concepts/streaming.md#custom) to learn how to stream custom events.
+- `onMetadataEvent`: Called when a metadata event is received, which contains the Run ID and Thread ID.
+
+## Learn More
+
+- [JS/TS SDK Reference](../reference/sdk/js_ts_sdk_ref.md)

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

@@ -1,142 +1,147 @@
-# Use Webhooks
+# Using Webhooks
 
-You may wish to use webhooks in your client, especially when using async streams in case you want to update something in your service once the API call to LangGraph Cloud has finished running. To do so, you will need to expose an endpoint that can accept POST requests, and then pass it to your API request in the "webhook" parameter.
+When working with LangGraph Cloud, you may want to use webhooks to receive updates after an API call completes. Webhooks are useful for triggering actions in your service once a run has finished processing. To implement this, you need to expose an endpoint that can accept `POST` requests and pass this endpoint as a `webhook` parameter in your API request.
 
-Currently, the SDK has not exposed this endpoint but you can access it through curl commands as follows.
+Currently, the SDK does not provide built-in support for defining webhook endpoints, but you can specify them manually using API requests.
 
-The following endpoints accept `webhook` as a parameter: 
+## Supported Endpoints
 
-- Create Run -> POST /thread/{thread_id}/runs
-- Create Thread Cron -> POST /thread/{thread_id}/runs/crons
-- Stream Run -> POST /thread/{thread_id}/runs/stream
-- Wait Run -> POST /thread/{thread_id}/runs/wait
-- Create Cron -> POST /runs/crons
-- Stream Run Stateless -> POST /runs/stream
-- Wait Run Stateless -> POST /runs/wait
+The following API endpoints accept a `webhook` parameter:
 
-In this example, we will show calling a webhook after streaming a run. 
+| Operation | HTTP Method | Endpoint |
+|-----------|------------|----------|
+| Create Run | `POST` | `/thread/{thread_id}/runs` |
+| Create Thread Cron | `POST` | `/thread/{thread_id}/runs/crons` |
+| Stream Run | `POST` | `/thread/{thread_id}/runs/stream` |
+| Wait Run | `POST` | `/thread/{thread_id}/runs/wait` |
+| Create Cron | `POST` | `/runs/crons` |
+| Stream Run Stateless | `POST` | `/runs/stream` |
+| Wait Run Stateless | `POST` | `/runs/wait` |
 
-## Setup
+In this guide, we’ll show how to trigger a webhook after streaming a run.
 
-First, let's setup our assistant and thread:
+## Setting Up Your Assistant and Thread
+
+Before making API calls, set up your assistant and thread.
 
 === "Python"
+```python
+from langgraph_sdk import get_client
 
-    ```python
-    from langgraph_sdk import get_client
+client = get_client(url=<DEPLOYMENT_URL>)
+assistant_id = "agent"
+thread = await client.threads.create()
+print(thread)
+```
 
-    client = get_client(url=<DEPLOYMENT_URL>)
-    # Using the graph deployed with the name "agent"
-    assistant_id = "agent"
-    # create thread
-    thread = await client.threads.create()
-    print(thread)
-    ```
+=== "JavaScript"
+```js
+import { Client } from "@langchain/langgraph-sdk";
 
-=== "Javascript"
-
-    ```js
-    import { Client } from "@langchain/langgraph-sdk";
-
-    const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
-    // Using the graph deployed with the name "agent"
-    const assistantID = "agent";
-    // create thread
-    const thread = await client.threads.create();
-    console.log(thread);
-    ```
+const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
+const assistantID = "agent";
+const thread = await client.threads.create();
+console.log(thread);
+```
 
 === "CURL"
+```bash
+curl --request POST \
+    --url <DEPLOYMENT_URL>/assistants/search \
+    --header 'Content-Type: application/json' \
+    --data '{ "limit": 10, "offset": 0 }' | jq -c 'map(select(.config == null or .config == {})) | .[0]' && \
+curl --request POST \
+    --url <DEPLOYMENT_URL>/threads \
+    --header 'Content-Type: application/json' \
+    --data '{}'
+```
 
-    ```bash
-    curl --request POST \
-        --url <DEPLOYMENT_URL>/assistants/search \
-        --header 'Content-Type: application/json' \
-        --data '{
-            "limit": 10,
-            "offset": 0
-        }' | jq -c 'map(select(.config == null or .config == {})) | .[0]' && \
-    curl --request POST \
-        --url <DEPLOYMENT_URL>/threads \
-        --header 'Content-Type: application/json' \
-        --data '{}'
-    ```
+### Example Response
+```json
+{
+    "thread_id": "9dde5490-2b67-47c8-aa14-4bfec88af217",
+    "created_at": "2024-08-30T23:07:38.242730+00:00",
+    "updated_at": "2024-08-30T23:07:38.242730+00:00",
+    "metadata": {},
+    "status": "idle",
+    "config": {},
+    "values": null
+}
+```
 
-Output:
+## Using a Webhook with a Graph Run
 
-    {
-        'thread_id': '9dde5490-2b67-47c8-aa14-4bfec88af217', 
-        'created_at': '2024-08-30T23:07:38.242730+00:00', 
-        'updated_at': '2024-08-30T23:07:38.242730+00:00', 
-        'metadata': {}, 
-        'status': 'idle', 
-        'config': {}, 
-        'values': None
-    }
+To use a webhook, specify the `webhook` parameter in your API request. When the run completes, LangGraph Cloud sends a `POST` request to the specified webhook URL.
 
-## Use graph with a webhook
-
-To invoke a run with a webhook, we specify the `webhook` parameter with the desired endpoint when creating a run. Webhook requests are triggered by the end of a run.
-
-For example, if we can receive requests at `https://my-server.app/my-webhook-endpoint`, we can pass this to `stream`:
+For example, if your server listens for webhook events at `https://my-server.app/my-webhook-endpoint`, include this in your request:
 
 === "Python"
+```python
+input = { "messages": [{ "role": "user", "content": "Hello!" }] }
 
-    ```python
-    # create input
-    input = { "messages": [{ "role": "user", "content": "Hello!" }] }
+async for chunk in client.runs.stream(
+    thread_id=thread["thread_id"],
+    assistant_id=assistant_id,
+    input=input,
+    stream_mode="events",
+    webhook="https://my-server.app/my-webhook-endpoint"
+):
+    pass
+```
 
-    async for chunk in client.runs.stream(
-        thread_id=thread["thread_id"],
-        assistant_id=assistant_id,
-        input=input,
-        stream_mode="events",
-        webhook="https://my-server.app/my-webhook-endpoint"
-    ):
-        # Do something with the stream output
-        pass
-    ```
+=== "JavaScript"
+```js
+const input = { messages: [{ role: "human", content: "Hello!" }] };
 
-=== "Javascript"
+const streamResponse = client.runs.stream(
+  thread["thread_id"],
+  assistantID,
+  {
+    input: input,
+    webhook: "https://my-server.app/my-webhook-endpoint"
+  }
+);
 
-    ```js
-    // create input
-    const input = { messages: [{ role: "human", content: "Hello!" }] };
-
-    // stream events
-    const streamResponse = client.runs.stream(
-      thread["thread_id"],
-      assistantID,
-      {
-        input: input,
-        webhook: "https://my-server.app/my-webhook-endpoint"
-      }
-    );
-    for await (const chunk of streamResponse) {
-      // Do something with the stream output
-    }
-    ```
+for await (const chunk of streamResponse) {
+  // Handle stream output
+}
+```
 
 === "CURL"
-
-    ```bash
-    curl --request POST \
-        --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
-        --header 'Content-Type: application/json' \
-        --data '{
-            "assistant_id": <ASSISTANT_ID>,
-            "input" : {"messages":[{"role": "user", "content": "Hello!"}]},
-            "webhook": "https://my-server.app/my-webhook-endpoint"
-        }'
-    ```
-
-The schema for the payload sent to `my-webhook-endpoint` is that of a [run](../../concepts/langgraph_server.md/#runs). See [API Reference](https://langchain-ai.github.io/langgraph/cloud/reference/api/api_ref.html#model/run) for more detail. Note that the run input, configuration, etc. are included in the `kwargs` field.
-
-### Signing webhook requests
-
-To sign the webhook requests, we can specify a token parameter in the webhook URL, e.g.,
-```
-https://my-server.app/my-webhook-endpoint?token=...
+```bash
+curl --request POST \
+    --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
+    --header 'Content-Type: application/json' \
+    --data '{
+        "assistant_id": <ASSISTANT_ID>,
+        "input": {"messages": [{"role": "user", "content": "Hello!"}]},
+        "webhook": "https://my-server.app/my-webhook-endpoint"
+    }'
 ```
 
-The server should then extract the token from the request's parameters and validate it before processing the payload.
+## Webhook Payload
+
+LangGraph Cloud sends webhook notifications in the format of a [Run](../../concepts/langgraph_server.md/#runs). See the [API Reference](https://langchain-ai.github.io/langgraph/cloud/reference/api/api_ref.html#model/run) for details. The request payload includes run input, configuration, and other metadata in the `kwargs` field.
+
+## Securing Webhooks
+
+To ensure only authorized requests hit your webhook endpoint, consider adding a security token as a query parameter:
+
+```
+https://my-server.app/my-webhook-endpoint?token=YOUR_SECRET_TOKEN
+```
+
+Your server should extract and validate this token before processing requests.
+
+## Testing Webhooks
+
+You can test your webhook using online services like:
+
+- **[Beeceptor](https://beeceptor.com/)** – Quickly create a test endpoint and inspect incoming webhook payloads.
+- **[Webhook.site](https://webhook.site/)** – View, debug, and log incoming webhook requests in real time.
+
+These tools help you verify that LangGraph Cloud is correctly triggering and sending webhooks to your service.
+
+---
+
+By following these steps, you can integrate webhooks into your LangGraph Cloud workflow, automating actions based on completed runs.

docs/docs/cloud/reference/cli.md

@@ -1,6 +1,6 @@
 # LangGraph CLI
 
-The LangGraph command line interface includes commands to build and run a LangGraph Cloud API server locally in [Docker](https://www.docker.com/). For development and testing, you can use the CLI to deploy a local API server as an alternative to the [Studio desktop app](../../concepts/langgraph_studio.md).
+The LangGraph command line interface includes commands to build and run a LangGraph Cloud API server locally in [Docker](https://www.docker.com/). For development and testing, you can use the CLI to deploy a local API server.
 
 ## Installation
 
@@ -51,6 +51,7 @@ The LangGraph CLI requires a JSON configuration file with the following keys:
     | <span style="white-space: nowrap;">`node_version`</span>     | Specify `node_version: 20` to use LangGraph.js.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
     | <span style="white-space: nowrap;">`pip_config_file`</span>  | Path to `pip` config file.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
     | <span style="white-space: nowrap;">`dockerfile_lines`</span> | Array of additional lines to add to Dockerfile following the import from parent image.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+    | <span style="white-space: nowrap;">`http`</span>            | HTTP server configuration with the following fields: <ul><li>`app`: Path to custom Starlette/FastAPI app (e.g., `"./src/agent/webapp.py:app"`). See [custom routes guide](../../how-tos/http/custom_routes.md).</li><li>`disable_assistants`: Disable `/assistants` routes</li><li>`disable_threads`: Disable `/threads` routes</li><li>`disable_runs`: Disable `/runs` routes</li><li>`disable_store`: Disable `/store` routes</li><li>`disable_meta`: Disable `/ok`, `/info`, `/metrics`, and `/docs` routes</li><li>`cors`: CORS configuration with fields for `allow_origins`, `allow_methods`, `allow_headers`, etc.</li></ul> |
 
 === "JS"
 

docs/docs/cloud/reference/env_var.md

@@ -2,6 +2,12 @@
 
 The LangGraph Cloud Server supports specific environment variables for configuring a deployment.
 
+## `DD_API_KEY`
+
+Specify `DD_API_KEY` (your [Datadog API Key](https://docs.datadoghq.com/account_management/api-app-keys/)) to automatically enable Datadog tracing for the deployment. Specify other [`DD_*` environment variables](https://ddtrace.readthedocs.io/en/stable/configuration.html) to configure the tracing instrumentation.
+
+If `DD_API_KEY` is specified, the application process is wrapped in the [`ddtrace-run` command](https://ddtrace.readthedocs.io/en/stable/installation_quickstart.html). Other `DD_*` environment variables (e.g. `DD_SITE`, `DD_ENV`, `DD_SERVICE`, `DD_TRACE_ENABLED`) are typically needed to properly configure the tracing instrumentation. See [`DD_*` environment variables](https://ddtrace.readthedocs.io/en/stable/configuration.html) for more details.
+
 ## `LANGCHAIN_TRACING_SAMPLING_RATE`
 
 Sampling rate for traces sent to LangSmith. Valid values: Any float between `0` and `1`.

docs/docs/concepts/agentic_concepts.md

@@ -14,7 +14,7 @@ As a result, there are many different types of [agent architectures](https://blo
 
 ## Router
 
-A router allows an LLM to select a single step from a specified set of options. This is an agent architecture that exhibits a relatively limited level of control because the LLM usually focuses on making a single decision and produces a specific output from limited set of pre-defined options. Routers typically employ a few different concepts to achieve this.
+A router allows an LLM to select a single step from a specified set of options. This is an agent architecture that exhibits a relatively limited level of control because the LLM usually focuses on making a single decision and produces a specific output from a limited set of pre-defined options. Routers typically employ a few different concepts to achieve this.
 
 ### Structured Output
 

docs/docs/concepts/auth.md

@@ -27,12 +27,19 @@ LangGraph Platform provides different security defaults:
 - Requires valid API key in `x-api-key` header
 - Can be customized with your auth handler
 
+!!! note "Custom auth"
+    Custom auth **is supported** for all plans in LangGraph Cloud.
+
 ### Self-Hosted
 
 - No default authentication
 - Complete flexibility to implement your security model
 - You control all aspects of authentication and authorization
 
+!!! note "Custom auth"
+    Custom auth is supported for **Enterprise** self-hosted plans.
+    Self-hosted lite plans do not support custom auth natively.
+
 ## System Architecture
 
 A typical authentication setup involves three main components:

docs/docs/concepts/breakpoints.md

@@ -83,12 +83,12 @@ node at a time or if you want to pause the graph execution at specific nodes.
 
 ### `NodeInterrupt` exception
 
-We recommend that you [**use the `interrupt` function instead**](#the-interrupt-function) of the `NodeInterrupt` exception if you're trying to implement
+We recommend that you [**use the `interrupt` function instead**][langgraph.types.interrupt] of the `NodeInterrupt` exception if you're trying to implement
 [human-in-the-loop](./human_in_the_loop.md) workflows. The `interrupt` function is easier to use and more flexible.
 
 ??? node "`NodeInterrupt` exception"
 
-    The developer can define some *condition* that must be met for a breakpoint to be triggered. This concept of [dynamic breakpoints](./low_level.md#dynamic-breakpoints) is useful when the developer wants to halt the graph under *a particular condition*. This uses a `NodeInterrupt`, which is a special type of exception that can be raised from within a node based upon some condition. As an example, we can define a dynamic breakpoint that triggers when the `input` is longer than 5 characters.
+    The developer can define some *condition* that must be met for a breakpoint to be triggered. This concept of _dynamic breakpoints_ is useful when the developer wants to halt the graph under *a particular condition*. This uses a `NodeInterrupt`, which is a special type of exception that can be raised from within a node based upon some condition. As an example, we can define a dynamic breakpoint that triggers when the `input` is longer than 5 characters.
 
     ```python
     def my_node(state: State) -> State:

docs/docs/concepts/deployment_options.md

@@ -30,7 +30,7 @@ The guide below will explain the differences between the deployment options.
 
 !!! warning "Note"
 
-    The LangGraph Platform Deployments view (within LangSmith SaaS and self-hosted LangSmith) is not available for Self-Hosted Enterprise LangGraph deployments. Self-hosted LangGraph deployments are managed externally from LangSmith (e.g. there is no UI to manage these deployments).
+    The LangGraph Platform Deployments view is optionally available for Self-Hosted Enterprise LangGraph deployments. With one click, self-hosted LangGraph deployments can be deployed in the same Kubernetes cluster where a self-hosted LangSmith instance is deployed.
 
 With a Self-Hosted Enterprise deployment, you are responsible for managing the infrastructure, including setting up and maintaining required databases and Redis instances.
 
@@ -49,7 +49,7 @@ For more information, please see:
 
 !!! warning "Note"
 
-    The LangGraph Platform Deployments view (within LangSmith SaaS and self-hosted LangSmith) is not available for Self-Hosted Lite LangGraph deployments. Self-hosted LangGraph deployments are managed externally from LangSmith (e.g. there is no UI to manage these deployments).
+    The LangGraph Platform Deployments view is optionally available for Self-Hosted Lite LangGraph deployments. With one click, self-hosted LangGraph deployments can be deployed in the same Kubernetes cluster where a self-hosted LangSmith instance is deployed.
 
 The Self-Hosted Lite deployment option is a free (up to 1 million nodes executed per year), limited version of LangGraph Platform that you can run locally or in a self-hosted manner.
 

docs/docs/concepts/durable_execution.md

@@ -0,0 +1,152 @@
+# Durable Execution
+
+**Durable execution** is a technique in which a process or workflow saves its progress at key points, allowing it to pause and later resume exactly where it left off. This is particularly useful in scenarios that require [human-in-the-loop](./human_in_the_loop.md), where users can inspect, validate, or modify the process before continuing, and in long-running tasks that might encounter interruptions or errors (e.g., calls to an LLM timing out). By preserving completed work, durable execution enables a process to resume without reprocessing previous steps -- even after a significant delay (e.g., a week later). 
+
+LangGraph's built-in [persistence](./persistence.md) layer provides durable execution for workflows, ensuring that the state of each execution step is saved to a durable store. This capability guarantees that if a workflow is interrupted -- whether by a system failure or for [human-in-the-loop](./human_in_the_loop.md) interactions -- it can be resumed from its last recorded state.
+
+!!! tip
+
+    If you are using LangGraph with a checkpointer, you already have durable execution enabled. You can pause and resume workflows at any point, even after interruptions or failures.
+    To make the most of durable execution, ensure that your workflow is designed to be [deterministic](#determinism-and-consistent-replay) and [idempotent](#determinism-and-consistent-replay) and wrap any side effects or non-deterministic operations inside [tasks](./functional_api.md#task). You can use [tasks](./functional_api.md#task) from both the [StateGraph (Graph API)](./low_level.md) and the [Functional API](./functional_api.md).
+
+## Requirements
+
+To leverage durable execution in LangGraph, you need to:
+
+1. Enable [persistence](./persistence.md) in your workflow by specifying a [checkpointer](./persistence.md#checkpointer-libraries) that will save workflow progress.
+2. Specify a [thread identifier](./persistence.md#threads) when executing a workflow. This will track the execution history for a particular instance of the workflow.
+3. Wrap any non-deterministic operations (e.g., random number generation) or operations with side effects (e.g., file writes, API calls) inside [tasks][langgraph.func.task] to ensure that when a workflow is resumed, these operations are not repeated for the particular run, and instead their results are retrieved from the persistence layer. For more information, see [Determinism and Consistent Replay](#determinism-and-consistent-replay).
+
+## Determinism and Consistent Replay
+
+When you resume a workflow run, the code does **NOT** resume from the **same line of code** where execution stopped; instead, it will identify an appropriate [starting point](#starting-points-for-resuming-workflows) from which to pick up where it left off. This means that the workflow will replay all steps from the [starting point](#starting-points-for-resuming-workflows) until it reaches the point where it was stopped.
+
+As a result, when you are writing a workflow for durable execution, you must wrap any non-deterministic operations (e.g., random number generation) and any operations with side effects (e.g., file writes, API calls) inside [tasks](./functional_api.md#task) or [nodes](./low_level.md#nodes).
+
+To ensure that your workflow is deterministic and can be consistently replayed, follow these guidelines:
+
+- **Avoid Repeating Work**:  If a [node](./low_level.md#nodes) contains multiple operations with side effects (e.g., logging, file writes, or network calls), wrap each operation in a separate **task**. This ensures that when the workflow is resumed, the operations are not repeated, and their results are retrieved from the persistence layer.
+- **Encapsulate Non-Deterministic Operations:**  Wrap any code that might yield non-deterministic results (e.g., random number generation) inside **tasks** or **nodes**. This ensures that, upon resumption, the workflow follows the exact recorded sequence of steps with the same outcomes.
+- **Use Idempotent Operations**: When possible ensure that side effects (e.g., API calls, file writes) are idempotent. This means that if an operation is retried after a failure in the workflow, it will have the same effect as the first time it was executed. This is particularly important for operations that result in data writes. In the event that a **task** starts but fails to complete successfully, the workflow's resumption will re-run the **task**, relying on recorded outcomes to maintain consistency. Use idempotency keys or verify existing results to avoid unintended duplication, ensuring a smooth and predictable workflow execution.
+
+For some examples of pitfalls to avoid, see the [Common Pitfalls](./functional_api.md#common-pitfalls) section in the functional API, which shows
+how to structure your code using **tasks** to avoid these issues. The same principles apply to the [StateGraph (Graph API)][langgraph.graph.state.StateGraph].
+
+## Using tasks in nodes
+
+If a [node](./low_level.md#nodes) contains multiple operations, you may find it easier to convert each operation into a **task** rather than refactor the operations into individual nodes.
+
+=== "Original"
+
+    ```python
+    from typing import NotRequired
+    from typing_extensions import TypedDict
+    import uuid
+
+    from langgraph.checkpoint.memory import MemorySaver
+    from langgraph.graph import StateGraph, START, END
+    import requests
+
+    # Define a TypedDict to represent the state
+    class State(TypedDict):
+        url: str
+        result: NotRequired[str]
+
+    def call_api(state: State):
+        """Example node that makes an API request."""
+        # highlight-next-line
+        result = requests.get(state['url']).text[:100]  # Side-effect
+        return {
+            "result": result
+        }
+
+    # Create a StateGraph builder and add a node for the call_api function
+    builder = StateGraph(State)
+    builder.add_node("call_api", call_api)
+
+    # Connect the start and end nodes to the call_api node
+    builder.add_edge(START, "call_api")
+    builder.add_edge("call_api", END)
+
+    # Specify a checkpointer
+    checkpointer = MemorySaver()
+
+    # Compile the graph with the checkpointer
+    graph = builder.compile(checkpointer=checkpointer)
+
+    # Define a config with a thread ID.
+    thread_id = uuid.uuid4()
+    config = {"configurable": {"thread_id": thread_id}}
+
+    # Invoke the graph
+    graph.invoke({"url": "https://www.example.com"}, config)
+    ```
+
+=== "With task"
+
+    ```python
+    from typing import NotRequired
+    from typing_extensions import TypedDict
+    import uuid
+
+    from langgraph.checkpoint.memory import MemorySaver
+    from langgraph.func import task
+    from langgraph.graph import StateGraph, START, END
+    import requests
+
+    # Define a TypedDict to represent the state
+    class State(TypedDict):
+        urls: list[str]
+        result: NotRequired[list[str]]
+
+
+    @task
+    def _make_request(url: str):
+        """Make a request."""
+        # highlight-next-line
+        return requests.get(url).text[:100]
+
+    def call_api(state: State):
+        """Example node that makes an API request."""
+        # highlight-next-line
+        requests = [_make_request(url) for url in state['urls']]
+        results = [request.result() for request in requests]
+        return {
+            "results": results
+        }
+
+    # Create a StateGraph builder and add a node for the call_api function
+    builder = StateGraph(State)
+    builder.add_node("call_api", call_api)
+
+    # Connect the start and end nodes to the call_api node
+    builder.add_edge(START, "call_api")
+    builder.add_edge("call_api", END)
+
+    # Specify a checkpointer
+    checkpointer = MemorySaver()
+
+    # Compile the graph with the checkpointer
+    graph = builder.compile(checkpointer=checkpointer)
+
+    # Define a config with a thread ID.
+    thread_id = uuid.uuid4()
+    config = {"configurable": {"thread_id": thread_id}}
+
+    # Invoke the graph
+    graph.invoke({"urls": ["https://www.example.com"]}, config)
+    ```
+
+## Resuming Workflows
+
+Once you have enabled durable execution in your workflow, you can resume execution for the following scenarios:
+
+- **Pausing and Resuming Workflows:** Use the [interrupt][langgraph.types.interrupt] function to pause a workflow at specific points and the [Command][langgraph.types.Command] primitive to resume it with updated state. See [**Human-in-the-Loop**](./human_in_the_loop.md) for more details.
+- **Recovering from Failures:** Automatically resume workflows from the last successful checkpoint after an exception (e.g., LLM provider outage). This involves executing the workflow with the same thread identifier by providing it with a `None` as the input value (see this [example](./functional_api.md#resuming-after-an-error) with the functional API).
+
+## Starting Points for Resuming Workflows
+
+* If you're using a [StateGraph (Graph API)][langgraph.graph.state.StateGraph], the starting point is the beginning of the [**node**](./low_level.md#nodes) where execution stopped. 
+* If you're making a subgraph call inside a node, the starting point will be the **parent** node that called the subgraph that was halted.
+Inside the subgraph, the starting point will be the specific [**node**](./low_level.md#nodes) where execution stopped.
+* If you're using the Functional API, the starting point is the beginning of the [**entrypoint**](./functional_api.md#entrypoint) where execution stopped.

docs/docs/concepts/faq.md

@@ -36,7 +36,7 @@ LangGraph is a stateful, orchestration framework that brings added control to ag
 | Concurrency Control | Simple threading                                          | Supports double-texting                                                                                |
 | Scheduling          | None                                                      | Cron scheduling                                                                                        |
 | Monitoring          | None                                                      | Integrated with LangSmith for observability                                                            |
-| IDE integration     | LangGraph Studio for Desktop                              | LangGraph Studio for Desktop & Cloud                                                                   |
+| IDE integration     | LangGraph Studio                                          | LangGraph Studio                                                                                       |
 
 ## What are my deployment options for LangGraph Platform?
 
@@ -62,3 +62,9 @@ Yes! You can use LangGraph with any LLMs. The main reason we use LLMs that suppo
 ## Does LangGraph work with OSS LLMs?
 
 Yes! LangGraph is totally ambivalent to what LLMs are used under the hood. The main reason we use closed LLMs in most of the tutorials is that they seamlessly support tool calling, while OSS LLMs often don't. But tool calling is not necessary (see [this section](#does-langgraph-work-with-llms-that-dont-support-tool-calling)) so you can totally use LangGraph with OSS LLMs.
+
+## Can I use LangGraph Studio without logging to LangSmith
+
+Yes! You can use the [development version of LangGraph Server](../tutorials/langgraph-platform/local-server.md) to run the backend locally.
+This will connect to the studio frontend hosted as part of LangSmith.
+If you set an environment variable of `LANGSMITH_TRACING=false` then no traces will be sent to LangSmith.

docs/docs/concepts/functional_api.md

@@ -1,8 +1,5 @@
 # Functional API
 
-!!! warning "Beta"
-    The Functional API is currently in **beta** and is subject to change. Please [report any issues](https://github.com/langchain-ai/langgraph/issues) or feedback to the LangGraph team.
-
 ## Overview
 
 The **Functional API** allows you to add LangGraph's key features -- [persistence](./persistence.md), [memory](./memory.md), [human-in-the-loop](./human_in_the_loop.md), and [streaming](./streaming.md) — to your applications with minimal changes to your existing code.
@@ -832,7 +829,8 @@ from langgraph.checkpoint.memory import MemorySaver
 from langgraph.func import entrypoint, task
 from langgraph.types import StreamWriter
 
-# Global variable to track the number of attempts
+# This variable is just used for demonstration purposes to simulate a network failure.
+# It's not something you will have in your actual code.
 attempts = 0
 
 @task()

docs/docs/concepts/high_level.md

@@ -2,7 +2,7 @@
 
 ## LLM applications
 
-LLMs make it possible to embed intelligence into a new class of applications. There are many patterns for building applications that use LLMs. [Workflows](https://www.anthropic.com/research/building-effective-agents) have scaffolding of predefined code paths around LLM calls. LLMs can direct the control flow through these predefined code paths, which some consider to be an "[agentic system](https://www.anthropic.com/research/building-effective-agents)". In other cases, it's possible to remove this scaffolding, creating autonomous agents that can [plan](https://huyenchip.com/2025/01/07/agents.html), take actions via [tool calls](https://python.langchain.com/docs/concepts/tool_calling/), and directly respond [to the feedback from their own actions](https://research.google/blog/react-synergizing-reasoning-and-acting-in-language-models/) with further actions.
+LLMs make it possible to embed intelligence into a new class of applications. There are many patterns for building applications that use LLMs. Workflows have scaffolding of predefined code paths around LLM calls. LLMs can direct the control flow through these predefined code paths, which some consider to be an "agentic system". In other cases, it's possible to remove this scaffolding, creating autonomous agents that can [plan](https://huyenchip.com/2025/01/07/agents.html), take actions via [tool calls](https://python.langchain.com/docs/concepts/tool_calling/), and directly respond [to the feedback from their own actions](https://research.google/blog/react-synergizing-reasoning-and-acting-in-language-models/) with further actions.
 
 ![Agent Workflow](img/agent_workflow.png)
 

docs/docs/concepts/human_in_the_loop.md

@@ -647,19 +647,15 @@ def node_in_parent_graph(state: State):
       This will print out
 
       ```pycon
-      --- First invocation ---
-      In parent node: {'foo': 'bar'}
       Entered `parent_node` a total of 1 times
       Entered `node_in_subgraph` a total of 1 times
       Entered human_node in sub-graph a total of 1 times
-      {'__interrupt__': (Interrupt(value='what is your name?', resumable=True, ns=['parent_node:0b23d72f-aaba-0329-1a59-ca4f3c8bad3b', 'human_node:25df717c-cb80-57b0-7410-44e20aac8f3c'], when='during'),)}
-
+      {'__interrupt__': (Interrupt(value='what is your name?', resumable=True, ns=['parent_node:4c3a0248-21f0-1287-eacf-3002bc304db4', 'human_node:2fe86d52-6f70-2a3f-6b2f-b1eededd6348'], when='during'),)}
       --- Resuming ---
-      In parent node: {'foo': 'bar'}
       Entered `parent_node` a total of 2 times
       Entered human_node in sub-graph a total of 2 times
       Got an answer of 35
-      {'parent_node': None} 
+      {'parent_node': {'state_counter': 1}}
       ```
 
 

docs/docs/concepts/index.md

@@ -7,7 +7,7 @@ description: Conceptual Guide for LangGraph
 
 This guide provides explanations of the key concepts behind the LangGraph framework and AI applications more broadly.
 
-We recommend that you go through at least the [Quick Start](../tutorials/introduction.ipynb) before diving into the conceptual guide. This will provide practical context that will make it easier to understand the concepts discussed here.
+We recommend that you go through at least the [Quickstart](../tutorials/introduction.ipynb) before diving into the conceptual guide. This will provide practical context that will make it easier to understand the concepts discussed here.
 
 The conceptual guide does not cover step-by-step instructions or specific implementation examples — those are found in the [Tutorials](../tutorials/index.md) and [How-to guides](../how-tos/index.md). For detailed reference material, please see the [API reference](../reference/index.md).
 
@@ -26,9 +26,11 @@ The conceptual guide does not cover step-by-step instructions or specific implem
 - [Human-in-the-Loop](human_in_the_loop.md): Explains different ways of integrating human feedback into a LangGraph application.
 - [Time Travel](time-travel.md): Time travel allows you to replay past actions in your LangGraph application to explore alternative paths and debug issues.
 - [Persistence](persistence.md): LangGraph has a built-in persistence layer, implemented through checkpointers. This persistence layer helps to support powerful capabilities like human-in-the-loop, memory, time travel, and fault-tolerance.
-- [Memory](memory.md): Memory in AI applications refers to the ability to process, store, and effectively recall information from past interactions. With memory, your agents can learn from feedback and adapt to users' preferences.  
-- [Streaming](streaming.md): Streaming is crucial for enhancing the responsiveness of applications built on LLMs. By displaying output progressively, even before a complete response is ready, streaming significantly improves user experience (UX), particularly when dealing with the latency of LLMs. 
-- [Functional API (beta)](functional_api.md): An alternative to [Graph API (StateGraph)](low_level.md#stategraph) for development in LangGraph.
+- [Memory](memory.md): Memory in AI applications refers to the ability to process, store, and effectively recall information from past interactions. With memory, your agents can learn from feedback and adapt to users' preferences.
+- [Streaming](streaming.md): Streaming is crucial for enhancing the responsiveness of applications built on LLMs. By displaying output progressively, even before a complete response is ready, streaming significantly improves user experience (UX), particularly when dealing with the latency of LLMs.
+- [Functional API](functional_api.md): `@entrypoint` and `@task` decorators that allow you to add LangGraph functionality to an existing codebase.
+- [Durable Execution](durable_execution.md): LangGraph's built-in [persistence](./persistence.md) layer provides durable execution for workflows, ensuring that the state of each execution step is saved to a durable store. 
+- [Pregel](pregel.md): Pregel is LangGraph's runtime, which is responsible for managing the execution of LangGraph applications.
 - [FAQ](faq.md): Frequently asked questions about LangGraph.
 
 ## LangGraph Platform
@@ -37,7 +39,6 @@ LangGraph Platform is a commercial solution for deploying agentic applications i
 
 The LangGraph Platform offers a few different deployment options described in the [deployment options guide](./deployment_options.md).
 
-
 !!! tip
 
     * LangGraph is an MIT-licensed open-source library, which we are committed to maintaining and growing for the community.
@@ -46,6 +47,8 @@ The LangGraph Platform offers a few different deployment options described in th
 ### High Level
 
 - [Why LangGraph Platform?](./langgraph_platform.md): The LangGraph platform is an opinionated way to deploy and manage LangGraph applications. This guide provides an overview of the key features and concepts behind LangGraph Platform.
+- [Platform Architecture](./platform_architecture.md): A high-level overview of the architecture of the LangGraph Platform.
+- [Scalability and Resilience](./scalability_and_resilience.md): LangGraph Platform is designed to be scalable and resilient. This document explains how the platform achieves this.
 - [Deployment Options](./deployment_options.md): LangGraph Platform offers four deployment options: [Self-Hosted Lite](./self_hosted.md#self-hosted-lite), [Self-Hosted Enterprise](./self_hosted.md#self-hosted-enterprise), [bring your own cloud (BYOC)](./bring_your_own_cloud.md), and [Cloud SaaS](./langgraph_cloud.md). This guide explains the differences between these options, and which Plans they are available on.
 - [Plans](./plans.md): LangGraph Platforms offer three different plans: Developer, Plus, Enterprise. This guide explains the differences between these options, what deployment options are available for each, and how to sign up for each one.
 - [Template Applications](./template_applications.md): Reference applications designed to help you get started quickly when building with LangGraph.
@@ -54,7 +57,7 @@ The LangGraph Platform offers a few different deployment options described in th
 
 The LangGraph Platform comprises several components that work together to support the deployment and management of LangGraph applications:
 
-- [LangGraph Server](./langgraph_server.md): The LangGraph Server is designed to support a wide range of agentic application use cases, from background processing to real-time interactions. 
+- [LangGraph Server](./langgraph_server.md): The LangGraph Server is designed to support a wide range of agentic application use cases, from background processing to real-time interactions.
 - [LangGraph Studio](./langgraph_studio.md): LangGraph Studio is a specialized IDE that can connect to a LangGraph Server to enable visualization, interaction, and debugging of the application locally.
 - [LangGraph CLI](./langgraph_cli.md): LangGraph CLI is a command-line interface that helps to interact with a local LangGraph
 - [Python/JS SDK](./sdk.md): The Python/JS SDK provides a programmatic way to interact with deployed LangGraph Applications.
@@ -71,8 +74,7 @@ The LangGraph Platform comprises several components that work together to suppor
 
 ### Deployment Options
 
-
 - [Self-Hosted Lite](./self_hosted.md): A free (up to 1 million nodes executed per year), limited version of LangGraph Platform that you can run locally or in a self-hosted manner
 - [Cloud SaaS](./langgraph_cloud.md): Hosted as part of LangSmith.
 - [Bring Your Own Cloud](./bring_your_own_cloud.md): We manage the infrastructure, so you don't have to, but the infrastructure all runs within your cloud.
-- [Self-Hosted Enterprise](./self_hosted.md): Completely managed by you.
+- [Self-Hosted Enterprise](./self_hosted.md): Completely managed by you.

docs/docs/concepts/langgraph_cli.md

@@ -4,7 +4,7 @@
     - [LangGraph Platform](./langgraph_platform.md)
     - [LangGraph Server](./langgraph_server.md)
 
-The LangGraph CLI is a multi-platform command-line tool for building and running the [LangGraph API server](./langgraph_server.md) locally. This offers an alternative to the [LangGraph Studio desktop app](./langgraph_studio.md) for developing and testing agents across all major operating systems (Linux, Windows, MacOS). The resulting server includes all API endpoints for your graph's runs, threads, assistants, etc. as well as the other services required to run your agent, including a managed database for checkpointing and storage.
+The LangGraph CLI is a multi-platform command-line tool for building and running the [LangGraph API server](./langgraph_server.md) locally. The resulting server includes all API endpoints for your graph's runs, threads, assistants, etc. as well as the other services required to run your agent, including a managed database for checkpointing and storage.
 
 ## Installation
 

docs/docs/concepts/langgraph_cloud.md

@@ -80,6 +80,22 @@ A high-level diagram of a Cloud SaaS deployment.
 
 ![diagram](img/langgraph_cloud_architecture.png)
 
+## Whitelisting IP Addresses
+
+All traffic from `LangGraph Platform` deployments created after January 6th 2025 will come through a NAT gateway.
+This NAT gateway will have several static ip addresses depending on the region you are deploying in. Refer to the table below for the list of IP addresses to whitelist:
+
+| US             | EU             |
+|----------------|----------------|
+| 35.197.29.146  | 34.13.192.67   |
+| 34.145.102.123 | 34.147.105.64  |
+| 34.169.45.153  | 34.90.22.166   |
+| 34.82.222.17   | 34.147.36.213  |
+| 35.227.171.135 | 34.32.137.113  | 
+| 34.169.88.30   | 34.91.238.184  |
+| 34.19.93.202   | 35.204.101.241 |
+| 34.19.34.50    | 35.204.48.32   |
+
 ## Related
 
 - [Deployment Options](./deployment_options.md)

docs/docs/concepts/langgraph_platform.md

@@ -1,3 +1,8 @@
+---
+search:
+  boost: 2
+---
+
 # LangGraph Platform
 
 ## Overview

docs/docs/concepts/langgraph_studio.md

@@ -7,7 +7,7 @@
 
 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 allowing you to  collaborate with teammates to debug failure modes.
+With visual graphs and the ability to edit state, you can better understand agent workflows and iterate faster. LangGraph Studio integrates with LangSmith allowing you to collaborate with teammates to debug failure modes.
 
 ![](img/lg_studio.png)
 
@@ -15,7 +15,7 @@ With visual graphs and the ability to edit state, you can better understand agen
 
 The key features of LangGraph Studio are:
 
-- Visualizes your graph
+- Visualize your graphs
 - Test your graph by running it from the UI
 - Debug your agent by [modifying its state and rerunning](human_in_the_loop.md)
 - Create and manage [assistants](assistants.md)
@@ -23,86 +23,54 @@ The key features of LangGraph Studio are:
 - View and manage [long term memory](memory.md)
 - Add node input/outputs to [LangSmith](https://smith.langchain.com/) datasets for testing
 
-## Types
+## Getting started
 
-### Development server with web UI
+There are two ways to connect your LangGraph app with the studio:
 
-You can [run a local in-memory development server](../tutorials/langgraph-platform/local-server.md) that can be used to connect a local LangGraph app with a web version of the studio.
-For example, if you start the local server with `langgraph dev` (running at `http://127.0.0.1:2024` by default), you can connect to the studio by navigating to:
+### Deployed Application
+
+If you have deployed your LangGraph application on LangGraph Platform, you can access the studio as part of that deployment. To do so, navigate to the deployment in LangGraph Platform within the LangSmith UI and click the "LangGraph Studio" button.
+
+### Local Development Server
+
+If you have a LangGraph application that is [running locally in-memory](../tutorials/langgraph-platform/local-server.md), you can connect it to LangGraph Studio in the browser within LangSmith.
+
+By default, starting the local server with `langgraph dev` will run the server at `http://127.0.0.1:2024` and automatically open Studio in your browser. However, you can also manually connect to Studio by either:
+
+1. In LangGraph Platform, clicking the "LangGraph Studio" button and entering the server URL in the dialog that appears.
+
+   or
+
+2. Navigating to the URL in your browser:
 
 ```
 https://smith.langchain.com/studio/?baseUrl=http://127.0.0.1:2024
 ```
 
-See [instructions here](../cloud/reference/cli.md#dev) for more information.
+## Related
 
-The web UI version of the studio will connect to your locally running server — your agent is still running locally and never leaves your device.
+For more information please see the following:
 
-### Cloud studio
+- [LangGraph Studio how-to guides](../how-tos/index.md#langgraph-studio)
+- [LangGraph CLI Documentation](../cloud/reference/cli.md)
 
-If you have deployed your LangGraph application on LangGraph Platform (Cloud), you can access the studio as part of that
-
-### Desktop app
-
-LangGraph Studio is available as a [desktop app](https://studio.langchain.com/) for MacOS users.
-
-While in Beta, LangGraph Studio is available for free to all [LangSmith](https://smith.langchain.com/) users on any plan tier.
-
-## Studio FAQs
+## LangGraph 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 (desktop only)
-
-LangGraph Studio (desktop) 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.
-
-!!! Important "Note (desktop only)"
-
-    LangGraph Studio Desktop automatically populates `LANGCHAIN_*` environment variables for license verification and tracing, regardless of the contents of the `.env` file. All other environment variables defined in `.env` will be read as normal.
-
-#### Incorrect data region (desktop only)
-
-If you receive a license verification error when attempting to start the LangGraph Server, you may be logged into the incorrect LangSmith data region. Ensure that you're logged into the correct LangSmith data region and ensure that the LangSmith account has access to LangGraph platform.
-
-1. In the top right-hand corner, click the user icon and select `Logout`.
-1. At the login screen, click the `Data Region` dropdown menu and select the appropriate data region. Then click `Login to LangSmith`.
+A project may fail to start if the configuration file is defined incorrectly, or if required environment variables are missing. See [here](../cloud/reference/cli.md#configuration-file) for how your configuration file should be defined.
 
 ### 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?  (desktop only)
+For more information on interrupts and human in the loop, see [here](./human_in_the_loop.md).
 
-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?  (desktop only)
-
-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?  (desktop only)
-
-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?
+### 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
+#### Solution 1: Include a path map
 
 The first way to solve this is to add path maps to your conditional edges. A path map is just a dictionary or array that maps the possible outputs of your router function with the names of the nodes that each output corresponds to. The path map is passed as the third argument to the `add_conditional_edges` function like so:
 
@@ -120,7 +88,7 @@ The first way to solve this is to add path maps to your conditional edges. A pat
 
 In this case, the routing function returns either True or False, which map to `node_b` and `node_c` respectively.
 
-### Solution 2: Update the typing of the router (Python only)
+#### Solution 2: Update the typing of the router (Python only)
 
 Instead of passing a path map, you can also be explicit about the typing of your routing function by specifying the nodes it can map to using the `Literal` python definition. Here is an example of how to define a routing function in that way:
 
@@ -132,9 +100,48 @@ def routing_function(state: GraphState) -> Literal["node_b","node_c"]:
         return "node_c"
 ```
 
+### Studio Desktop FAQs
 
-## Related
+!!! warning "Deprecation Warning"
+    In order to support a wider range of platforms and users, we now recommend following the above instructions to connect to LangGraph Studio using the development server instead of the desktop app.
 
-For more information please see the following:
+The LangGraph Studio Desktop App is a standalone application that allows you to connect to your LangGraph application and visualize and interact with your graph. It is available for MacOS only and requires Docker to be installed.
 
-*  [LangGraph Studio how-to guides](../how-tos/index.md#langgraph-studio)
+#### Why is my project failing to start?
+
+In addition to the reasons listed above, for the desktop app there are a few more reasons that your project might fail to start:
+
+!!! Important "Note "
+
+    LangGraph Studio Desktop automatically populates `LANGCHAIN_*` environment variables for license verification and tracing, regardless of the contents of the `.env` file. All other environment variables defined in `.env` will be read as normal.
+
+##### Docker issues
+
+LangGraph Studio (desktop) 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.
+
+##### Incorrect data region
+
+If you receive a license verification error when attempting to start the LangGraph Server, you may be logged into the incorrect LangSmith data region. Ensure that you're logged into the correct LangSmith data region and ensure that the LangSmith account has access to LangGraph platform.
+
+1. In the top right-hand corner, click the user icon and select `Logout`.
+1. At the login screen, click the `Data Region` dropdown menu and select the appropriate data region. Then click `Login to LangSmith`.
+
+### 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.

docs/docs/concepts/low_level.md

@@ -213,9 +213,9 @@ builder.add_node("other_node", my_other_node)
 ...
 ```
 
-Behind the scenes, functions are converted to [RunnableLambda's](https://api.python.langchain.com/en/latest/runnables/langchain_core.runnables.base.RunnableLambda.html#langchain_core.runnables.base.RunnableLambda), which add batch and async support to your function, along with native tracing and debugging.
+Behind the scenes, functions are converted to [RunnableLambda](https://api.python.langchain.com/en/latest/runnables/langchain_core.runnables.base.RunnableLambda.html#langchain_core.runnables.base.RunnableLambda)s, which add batch and async support to your function, along with native tracing and debugging.
 
-If you add a node to graph without specifying a name, it will be given a default name equivalent to the function name.
+If you add a node to a graph without specifying a name, it will be given a default name equivalent to the function name.
 
 ```python
 builder.add_node(my_node)
@@ -224,7 +224,7 @@ builder.add_node(my_node)
 
 ### `START` Node
 
-The `START` Node is a special node that represents the node sends user input to the graph. The main purpose for referencing this node is to determine which nodes should be called first.
+The `START` Node is a special node that represents the node that sends user input to the graph. The main purpose for referencing this node is to determine which nodes should be called first.
 
 ```python
 from langgraph.graph import START
@@ -269,9 +269,9 @@ If you want to **optionally** route to 1 or more edges (or optionally terminate)
 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.
+Similar to nodes, the `routing_function` accepts the current `state` of the graph and returns a value.
 
-By default, the return value `routing_function` is used as the name of the node (or a list of nodes) to send the state to next. All those nodes will be run in parallel as a part of the next superstep.
+By default, the return value `routing_function` is used as the name of the node (or list of nodes) to send the state to next. All those nodes will be run in parallel as a part of the next superstep.
 
 You can optionally provide a dictionary that maps the `routing_function`'s output to the name of the next node.
 
@@ -310,7 +310,7 @@ graph.add_conditional_edges(START, routing_function, {True: "node_b", False: "no
 
 ## `Send`
 
-By default, `Nodes` and `Edges` are defined ahead of time and operate on the same shared state. However, there can be cases where the exact edges are not known ahead of time and/or you may want different versions of `State` to exist at the same time. A common of example of this is with `map-reduce` design patterns. In this design pattern, a first node may generate a list of objects, and you may want to apply some other node to all those objects. The number of objects may be unknown ahead of time (meaning the number of edges may not be known) and the input `State` to the downstream `Node` should be different (one for each generated object).
+By default, `Nodes` and `Edges` are defined ahead of time and operate on the same shared state. However, there can be cases where the exact edges are not known ahead of time and/or you may want different versions of `State` to exist at the same time. A common example of this is with [map-reduce](https://langchain-ai.github.io/langgraph/how-tos/map-reduce/) design patterns. In this design pattern, a first node may generate a list of objects, and you may want to apply some other node to all those objects. The number of objects may be unknown ahead of time (meaning the number of edges may not be known) and the input `State` to the downstream `Node` should be different (one for each generated object).
 
 To support this design pattern, LangGraph supports returning [`Send`][langgraph.types.Send] objects from conditional edges. `Send` takes two arguments: first is the name of the node, and second is the state to pass to that node.
 
@@ -357,10 +357,10 @@ Use [conditional edges](#conditional-edges) to route between nodes conditionally
 
 ### Navigating to a node in a parent graph
 
-If you are using [subgraphs](#subgraphs), you might want to navigate from a node a subgraph to a different subgraph (i.e. a different node in the parent graph). To do so, you can specify `graph=Command.PARENT` in `Command`:
+If you are using [subgraphs](#subgraphs), you might want to navigate from a node within a subgraph to a different subgraph (i.e. a different node in the parent graph). To do so, you can specify `graph=Command.PARENT` in `Command`:
 
 ```python
-def my_node(state: State) -> Command[Literal["my_other_node"]]:
+def my_node(state: State) -> Command[Literal["other_subgraph"]]:
     return Command(
         update={"foo": "bar"},
         goto="other_subgraph",  # where `other_subgraph` is a node in the parent graph
@@ -400,7 +400,7 @@ def lookup_user_info(tool_call_id: Annotated[str, InjectedToolCallId], config: R
 !!! important
     You MUST include `messages` (or any state key used for the message history) in `Command.update` when returning `Command` from a tool and the list of messages in `messages` MUST contain a `ToolMessage`. This is necessary for the resulting message history to be valid (LLM providers require AI messages with tool calls to be followed by the tool result messages).
 
-If you are using tools that update state via `Command`, we recommend using prebuilt [`ToolNode`][langgraph.prebuilt.tool_node.ToolNode] which automatically handles tools returning `Command` objects and propagates them to the graph state. If you're writing a custom node that calls tools, you would need to manually propagate `Command` objects returned by the tools as the update from node.
+If you are using tools that update state via `Command`, we recommend using prebuilt [`ToolNode`][langgraph.prebuilt.tool_node.ToolNode] which automatically handles tools returning `Command` objects and propagates them to the graph state. If you're writing a custom node that calls tools, you would need to manually propagate `Command` objects returned by the tools as the update from the node.
 
 ### Human-in-the-loop
 
@@ -494,7 +494,7 @@ Read more about how the `interrupt` is used for **human-in-the-loop** workflows
 
 ## Breakpoints
 
-Breakpoints pause graph execution at specific points and enable stepping through execution step by step. Breakpoints are powered by LangGraph's [**persistence layer**](./persistence.md), which saves the state after each graph step. Breakpoints can also be used to enable [**human-in-the-loop**](./human_in_the_loop.md) workflows, though we recommend using the [`interrupt` function](#interrupt-function) for this purpose.
+Breakpoints pause graph execution at specific points and enable stepping through execution step by step. Breakpoints are powered by LangGraph's [**persistence layer**](./persistence.md), which saves the state after each graph step. Breakpoints can also be used to enable [**human-in-the-loop**](./human_in_the_loop.md) workflows, though we recommend using the [`interrupt` function](#interrupt) for this purpose.
 
 Read more about breakpoints in the [Breakpoints conceptual guide](./breakpoints.md).
 
@@ -531,7 +531,7 @@ Let's take a look at examples for each.
 
 ### As a compiled graph
 
-The simplest way to create subgraph nodes is by using a [compiled subgraph](#compiling-your-graph) directly. When doing so, it is **important** that the parent graph and the subgraph [state schemas](#state) share at least one key which they can use to communicate. If your graph and subgraph do not share any keys, you should use write a function [invoking the subgraph](#as-a-function) instead.
+The simplest way to create subgraph nodes is by using a [compiled subgraph](#compiling-your-graph) directly. When doing so, it is **important** that the parent graph and the subgraph [state schemas](#state) share at least one key which they can use to communicate. If your graph and subgraph do not share any keys, you should write a function [invoking the subgraph](#as-a-function) instead.
 
 !!! Note
     If you pass extra keys to the subgraph node (i.e., in addition to the shared keys), they will be ignored by the subgraph node. Similarly, if you return extra keys from the subgraph, they will be ignored by the parent graph.

docs/docs/concepts/memory.md

@@ -275,7 +275,7 @@ See this how-to [video](https://www.youtube.com/watch?v=37VaU7e7t5o) for example
 
 [Procedural memory](https://en.wikipedia.org/wiki/Procedural_memory), in both humans and AI agents, involves remembering the rules used to perform tasks. In humans, procedural memory is like the internalized knowledge of how to perform tasks, such as riding a bike via basic motor skills and balance. Episodic memory, on the other hand, involves recalling specific experiences, such as the first time you successfully rode a bike without training wheels or a memorable bike ride through a scenic route. For AI agents, procedural memory is a combination of model weights, agent code, and agent's prompt that collectively determine the agent's functionality. 
 
-In practice, it is fairly uncommon for agents to modify their model weights or rewrite their code. However, it is more common for agents to [modify their own prompts](https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/prompt-generator). 
+In practice, it is fairly uncommon for agents to modify their model weights or rewrite their code. However, it is more common for agents to modify their own prompts. 
 
 One effective approach to refining an agent's instructions is through ["Reflection"](https://blog.langchain.dev/reflection-agents/) or meta-prompting. This involves prompting the agent with its current instructions (e.g., the system prompt) along with recent conversations or explicit user feedback. The agent then refines its own instructions based on this input. This method is particularly useful for tasks where instructions are challenging to specify upfront, as it allows the agent to learn and adapt from its interactions.
 

docs/docs/concepts/multi_agent.md

@@ -89,7 +89,7 @@ def transfer_to_bob(state):
     )
 ```
 
-This is a special case of updating the graph state from tools where in addition the state update, the control flow is included as well.
+This is a special case of updating the graph state from tools where, in addition to the state update, the control flow is included as well.
 
 !!! important
 
@@ -112,6 +112,7 @@ In this architecture, agents are defined as graph nodes. Each agent can communic
 ```python
 from typing import Literal
 from langchain_openai import ChatOpenAI
+from langgraph.types import Command
 from langgraph.graph import StateGraph, MessagesState, START, END
 
 model = ChatOpenAI()
@@ -158,6 +159,7 @@ In this architecture, we define agents as nodes and add a supervisor node (LLM)
 ```python
 from typing import Literal
 from langchain_openai import ChatOpenAI
+from langgraph.types import Command
 from langgraph.graph import StateGraph, MessagesState, START, END
 
 model = ChatOpenAI()
@@ -233,7 +235,7 @@ supervisor = create_react_agent(model, tools)
 
 ### Hierarchical
 
-As you add more agents to your system, it might become too hard for the supervisor to manage all of them. The supervisor might start making poor decisions about which agent to call next, the context might become too complex for a single supervisor to keep track of. In other words, you end up with the same problems that motivated the multi-agent architecture in the first place.
+As you add more agents to your system, it might become too hard for the supervisor to manage all of them. The supervisor might start making poor decisions about which agent to call next, or the context might become too complex for a single supervisor to keep track of. In other words, you end up with the same problems that motivated the multi-agent architecture in the first place.
 
 To address this, you can design your system _hierarchically_. For example, you can create separate, specialized teams of agents managed by individual supervisors, and a top-level supervisor to manage the teams.
 
@@ -337,9 +339,9 @@ builder.add_edge("agent_1", "agent_2")
 
 ## Communication between agents
 
-The most important thing when building multi-agent systems is figuring out how the agents communicate. There are few different considerations:
+The most important thing when building multi-agent systems is figuring out how the agents communicate. There are a few different considerations:
 
-- Do agents communicate via [**via graph state or via tool calls**](#graph-state-vs-tool-calls)?
+- Do agents communicate [**via graph state or via tool calls**](#graph-state-vs-tool-calls)?
 - What if two agents have [**different state schemas**](#different-state-schemas)?
 - How to communicate over a [**shared message list**](#shared-message-list)?
 

docs/docs/concepts/persistence.md

@@ -32,7 +32,7 @@ from typing_extensions import TypedDict
 from operator import add
 
 class State(TypedDict):
-    foo: int
+    foo: str
     bar: Annotated[list[str], add]
 
 def node_a(state: State):
@@ -232,7 +232,7 @@ from langgraph.store.memory import InMemoryStore
 in_memory_store = InMemoryStore()
 ```
 
-Memories are namespaced by a `tuple`, which in this specific example will be `(<user_id>, "memories")`. The namespace can be any length and represent anything, does not have be user specific.
+Memories are namespaced by a `tuple`, which in this specific example will be `(<user_id>, "memories")`. The namespace can be any length and represent anything, does not have to be user specific.
 
 ```python 
 user_id = "1"
@@ -387,6 +387,9 @@ We can access the memories and use them in our model call.
 def call_model(state: MessagesState, config: RunnableConfig, *, store: BaseStore):
     # Get the user id from the config
     user_id = config["configurable"]["user_id"]
+
+    # Namespace the memory
+    namespace = (user_id, "memories")
     
     # Search based on the most recent message
     memories = store.search(

docs/docs/concepts/platform_architecture.md

@@ -0,0 +1,23 @@
+# LangGraph Platform Architecture
+
+![](img/langgraph_platform_deployment_architecture.png)
+
+## How we use Postgres
+
+Postgres is the persistence layer for all user and run data in LGP. This stores both checkpoints (see more info [here](./persistence.md)) as well as the server resources (threads, runs, assistants and crons).
+
+## How we use Redis
+
+Redis is used in each LGP deployment as a way for server and queue workers to communicate, and to store ephemeral metadata, more details on both below. No user/run data is stored in Redis.
+
+### Communication
+
+All runs in LGP are executed by the pool of background workers that are part of each deployment. In order to enable some features for those runs (such as cancellation and output streaming) we need a channel for two-way communication between the server and the worker handling a particular run. We use Redis to organize that communication.
+
+1. A Redis list is used as a mechanism to wake up a worker as soon as a new run is created. Only a sentinel value is stored in this list, no actual run info. The run information is then retrieved from Postgres by the worker.
+2. A combination of a Redis string and Redis PubSub channel is used for the server to communicate a run cancellation request to the appropriate worker.
+3. A Redis PubSub channel is used by the worker to broadcast streaming output from an agent while the run is being handled. Any open `/stream` request in the server will subscribe to that channel and forward any events to the response as they arrive. No events are stored in Redis at any time.
+
+### Ephemeral metadata
+
+Runs in an LGP deployment may be retried for specific failures (currently only for transient Postgres errors encountered during the run). In order to limit the number of retries (currently limited to 3 attempts per run) we record the attempt number in a Redis string when is picked up. This contains no run-specific info other than its ID, and expires after a short delay.

docs/docs/concepts/pregel.md

@@ -0,0 +1,347 @@
+# LangGraph's Runtime (Pregel)
+
+[Pregel][langgraph.pregel.Pregel] implements LangGraph's runtime, managing the execution of LangGraph applications.
+
+Compiling a [StateGraph][langgraph.graph.StateGraph] or creating an [entrypoint][langgraph.func.entrypoint] produces a [Pregel][langgraph.pregel.Pregel] instance that can be invoked with input.
+
+This guide explains the runtime at a high level and provides instructions for directly implementing applications with Pregel.
+
+> **Note:** The [Pregel][langgraph.pregel.Pregel] runtime is named after [Google's Pregel algorithm](https://research.google/pubs/pub37252/), which describes an efficient method for large-scale parallel computation using graphs.
+
+## Overview
+
+In LangGraph, Pregel combines [**actors**](https://en.wikipedia.org/wiki/Actor_model) and **channels** into a single application. **Actors** read data from channels and write data to channels. Pregel organizes the execution of the application into multiple steps, following the **Pregel Algorithm**/**Bulk Synchronous Parallel** model.
+
+Each step consists of three phases:
+
+- **Plan**: Determine which **actors** to execute in this step. For example, in the first step, select the **actors** that subscribe to the special **input** channels; in subsequent steps, select the **actors** that subscribe to channels updated in the previous step.
+- **Execution**: Execute all selected **actors** in parallel, until all complete, or one fails, or a timeout is reached. During this phase, channel updates are invisible to actors until the next step.
+- **Update**: Update the channels with the values written by the **actors** in this step.
+
+Repeat until no **actors** are selected for execution, or a maximum number of steps is reached.
+
+## Actors 
+
+An **actor** is a [PregelNode][langgraph.pregel.read.PregelNode]. It subscribes to channels, reads data from them, and writes data to them. It can be thought of as an **actor** in the Pregel algorithm. [PregelNodes][langgraph.pregel.read.PregelNode] implement LangChain's Runnable interface.
+
+## Channels
+
+Channels are used to communicate between actors (PregelNodes). Each channel has a value type, an update type, and an update function – which takes a sequence of updates and modifies the stored value. Channels can be used to send data from one chain to another, or to send data from a chain to itself in a future step. LangGraph provides a number of built-in channels:
+
+### Basic channels: LastValue and Topic
+
+- [LastValue][langgraph.channels.LastValue]: The default channel, stores the last value sent to the channel, useful for input and output values, or for sending data from one step to the next.
+- [Topic][langgraph.channels.Topic]: A configurable PubSub Topic, useful for sending multiple values between **actors**, or for accumulating output. Can be configured to deduplicate values or to accumulate values over the course of multiple steps.
+
+### Advanced channels: Context and BinaryOperatorAggregate
+
+- `Context`: exposes the value of a context manager, managing its lifecycle. Useful for accessing external resources that require setup and/or teardown; e.g., `client = Context(httpx.Client)`.
+- [BinaryOperatorAggregate][langgraph.channels.BinaryOperatorAggregate]: stores a persistent value, updated by applying a binary operator to the current value and each update sent to the channel, useful for computing aggregates over multiple steps; e.g.,`total = BinaryOperatorAggregate(int, operator.add)`
+
+## Examples
+
+While most users will interact with Pregel through the [StateGraph][langgraph.graph.StateGraph] API or 
+the [entrypoint][langgraph.func.entrypoint] decorator, it is possible to interact with Pregel directly.
+
+Below are a few different examples to give you a sense of the Pregel API.
+
+=== "Single node"
+
+    ```python
+
+    from langgraph.channels import EphemeralValue
+    from langgraph.pregel import Pregel, Channel 
+
+    node1 = (
+        Channel.subscribe_to("a")
+        | (lambda x: x + x)
+        | Channel.write_to("b")
+    )
+
+    app = Pregel(
+        nodes={"node1": node1},
+        channels={
+            "a": EphemeralValue(str),
+            "b": EphemeralValue(str),
+        },
+        input_channels=["a"],
+        output_channels=["b"],
+    )
+
+    app.invoke({"a": "foo"})
+    ```
+
+    ```con
+    {'b': 'foofoo'}
+    ```
+
+=== "Multiple nodes"
+
+    ```python
+    from langgraph.channels import LastValue, EphemeralValue
+    from langgraph.pregel import Pregel, Channel 
+
+    node1 = (
+        Channel.subscribe_to("a")
+        | (lambda x: x + x)
+        | Channel.write_to("b")
+    )
+
+    node2 = (
+        Channel.subscribe_to("b")
+        | (lambda x: x + x)
+        | Channel.write_to("c")
+    )
+
+
+    app = Pregel(
+        nodes={"node1": node1, "node2": node2},
+        channels={
+            "a": EphemeralValue(str),
+            "b": LastValue(str),
+            "c": EphemeralValue(str),
+        },
+        input_channels=["a"],
+        output_channels=["b", "c"],
+    )
+
+    app.invoke({"a": "foo"})
+    ```
+
+    ```con
+    {'b': 'foofoo', 'c': 'foofoofoofoo'}
+    ```
+
+=== "Topic"
+
+    ```python
+    from langgraph.channels import EphemeralValue, Topic
+    from langgraph.pregel import Pregel, Channel 
+
+    node1 = (
+        Channel.subscribe_to("a")
+        | (lambda x: x + x)
+        | {
+            "b": Channel.write_to("b"),
+            "c": Channel.write_to("c")
+        }
+    )
+
+    node2 = (
+        Channel.subscribe_to("b")
+        | (lambda x: x + x)
+        | {
+            "c": Channel.write_to("c"),
+        }
+    )
+
+    app = Pregel(
+        nodes={"node1": node1, "node2": node2},
+        channels={
+            "a": EphemeralValue(str),
+            "b": EphemeralValue(str),
+            "c": Topic(str, accumulate=True),
+        },
+        input_channels=["a"],
+        output_channels=["c"],
+    )
+
+    app.invoke({"a": "foo"})
+    ```
+
+    ```pycon
+    {'c': ['foofoo', 'foofoofoofoo']}
+    ```
+
+=== "BinaryOperatorAggregate"
+
+    This examples demonstrates how to use the BinaryOperatorAggregate channel to implement a reducer.
+
+    ```python
+    from langgraph.channels import EphemeralValue, BinaryOperatorAggregate
+    from langgraph.pregel import Pregel, Channel
+
+
+    node1 = (
+        Channel.subscribe_to("a")
+        | (lambda x: x + x)
+        | {
+            "b": Channel.write_to("b"),
+            "c": Channel.write_to("c")
+        }
+    )
+
+    node2 = (
+        Channel.subscribe_to("b")
+        | (lambda x: x + x)
+        | {
+            "c": Channel.write_to("c"),
+        }
+    )
+
+    def reducer(current, update):
+        if current:
+            return current + " | " + "update"
+        else:
+            return update
+
+    app = Pregel(
+        nodes={"node1": node1, "node2": node2},
+        channels={
+            "a": EphemeralValue(str),
+            "b": EphemeralValue(str),
+            "c": BinaryOperatorAggregate(str, operator=reducer),
+        },
+        input_channels=["a"],
+        output_channels=["c"],
+    )
+
+    app.invoke({"a": "foo"})
+    ```
+    
+    
+=== "Cycle"
+
+    This example demonstrates how to introduce a cycle in the graph, by having
+    a chain write to a channel it subscribes to. Execution will continue
+    until a None value is written to the channel.
+
+    ```python
+    from langgraph.channels import EphemeralValue
+    from langgraph.pregel import Pregel, Channel, ChannelWrite, ChannelWriteEntry
+
+    example_node = (
+        Channel.subscribe_to("value")
+        | (lambda x: x + x if len(x) < 10 else None)
+        | ChannelWrite(writes=[ChannelWriteEntry(channel="value", skip_none=True)])
+    )
+
+    app = Pregel(
+        nodes={"example_node": example_node},
+        channels={
+            "value": EphemeralValue(str),
+        },
+        input_channels=["value"],
+        output_channels=["value"],
+    )
+
+    app.invoke({"value": "a"})
+    ```
+
+    ```pycon
+    {'value': 'aaaaaaaaaaaaaaaa'}
+    ```
+
+## High-level API
+
+LangGraph provides two high-level APIs for creating a Pregel application: the [StateGraph (Graph API)](./low_level.md) and the [Functional API](functional_api.md).
+
+
+=== "StateGraph (Graph API)"
+
+    The [StateGraph (Graph API)][langgraph.graph.StateGraph] is a higher-level abstraction that simplifies the creation of Pregel applications. It allows you to define a graph of nodes and edges. When you compile the graph, the StateGraph API automatically creates the Pregel application for you.
+
+    ```python
+    from typing import TypedDict, Optional
+
+    from langgraph.constants import START
+    from langgraph.graph import StateGraph
+
+    class Essay(TypedDict):
+        topic: str
+        content: Optional[str]
+        score: Optional[float]
+
+    def write_essay(essay: Essay):
+        return {
+            "content": f"Essay about {essay['topic']}",
+        }
+
+    def score_essay(essay: Essay):
+        return {
+            "score": 10
+        }
+
+    builder = StateGraph(Essay)
+    builder.add_node(write_essay)
+    builder.add_node(score_essay)
+    builder.add_edge(START, "write_essay")
+
+    # Compile the graph. 
+    # This will return a Pregel instance.
+    graph = builder.compile()
+    ```
+
+    The compiled Pregel instance will be associated with a list of nodes and channels. You can inspect the nodes and channels by printing them.
+
+    ```python
+    print(graph.nodes)
+    ```
+
+    You will see something like this:
+
+    ```pycon 
+    {'__start__': <langgraph.pregel.read.PregelNode at 0x7d05e3ba1810>,
+     'write_essay': <langgraph.pregel.read.PregelNode at 0x7d05e3ba14d0>,
+     'score_essay': <langgraph.pregel.read.PregelNode at 0x7d05e3ba1710>}
+     ```
+
+    ```python
+    print(graph.channels)
+    ```
+
+    You should see something like this
+
+    ```pycon
+    {'topic': <langgraph.channels.last_value.LastValue at 0x7d05e3294d80>,
+     'content': <langgraph.channels.last_value.LastValue at 0x7d05e3295040>,
+     'score': <langgraph.channels.last_value.LastValue at 0x7d05e3295980>,
+     '__start__': <langgraph.channels.ephemeral_value.EphemeralValue at 0x7d05e3297e00>,
+     'write_essay': <langgraph.channels.ephemeral_value.EphemeralValue at 0x7d05e32960c0>,
+     'score_essay': <langgraph.channels.ephemeral_value.EphemeralValue at 0x7d05e2d8ab80>,
+     'branch:__start__:__self__:write_essay': <langgraph.channels.ephemeral_value.EphemeralValue at 0x7d05e32941c0>,
+     'branch:__start__:__self__:score_essay': <langgraph.channels.ephemeral_value.EphemeralValue at 0x7d05e2d88800>,
+     'branch:write_essay:__self__:write_essay': <langgraph.channels.ephemeral_value.EphemeralValue at 0x7d05e3295ec0>,
+     'branch:write_essay:__self__:score_essay': <langgraph.channels.ephemeral_value.EphemeralValue at 0x7d05e2d8ac00>,
+     'branch:score_essay:__self__:write_essay': <langgraph.channels.ephemeral_value.EphemeralValue at 0x7d05e2d89700>,
+     'branch:score_essay:__self__:score_essay': <langgraph.channels.ephemeral_value.EphemeralValue at 0x7d05e2d8b400>,
+     'start:write_essay': <langgraph.channels.ephemeral_value.EphemeralValue at 0x7d05e2d8b280>}
+    ```
+
+=== "Functional API"
+
+    In the [Functional API](functional_api.md), you can use an [`entrypoint`][langgraph.func.entrypoint] to create
+    a Pregel application. The `entrypoint` decorator allows you to define a function that takes input and returns output. 
+
+    ```python
+    from typing import TypedDict, Optional
+
+    from langgraph.checkpoint.memory import InMemorySaver
+    from langgraph.func import entrypoint
+
+    class Essay(TypedDict):
+        topic: str
+        content: Optional[str]
+        score: Optional[float]
+
+
+    checkpointer = InMemorySaver()
+
+    @entrypoint(checkpointer=checkpointer)
+    def write_essay(essay: Essay):
+        return {
+            "content": f"Essay about {essay['topic']}",
+        }
+
+    print("Nodes: ")
+    print(write_essay.nodes)
+    print("Channels: ")
+    print(write_essay.channels)
+    ```
+
+    ```pycon
+    Nodes: 
+    {'write_essay': <langgraph.pregel.read.PregelNode object at 0x7d05e2f9aad0>}
+    Channels: 
+    {'__start__': <langgraph.channels.ephemeral_value.EphemeralValue object at 0x7d05e2c906c0>, '__end__': <langgraph.channels.last_value.LastValue object at 0x7d05e2c90c40>, '__previous__': <langgraph.channels.last_value.LastValue object at 0x7d05e1007280>}
+    ```

docs/docs/concepts/scalability_and_resilience.md

@@ -0,0 +1,35 @@
+# LangGraph Platform: Scalability & Resilience
+
+LangGraph Platform is designed to scale horizontally with your workload. Each instance of the service is stateless, and keeps no resources in memory. The service is designed to gracefully handle new instances being added or removed, including hard shutdown cases.
+
+## Server scalability
+
+As you add more instances to a service, they will share the HTTP load as long as an appropriate load balancer mechanism is placed in front of them. In most deployment modalities we configure a load balancer for the service automatically. In the “self-hosted without control plane” modality it’s your responsibility to add a load balancer. Since the instances are stateless any load balancing strategy will work, no session stickiness is needed, or recommended. Any instance of the server can communicate with any queue instance (through Redis PubSub), meaning that requests to cancel or stream an in-progress run can be handled by any arbitrary instance.
+
+## Queue scalability
+
+As you add more instances to a service, they will increase run throughput linearly, as each instance is configured to handle a set number of concurrent runs (by default 10). Each attempt for each run will be handled by a single instance, with exactly-once semantics enforced through Postgres’s MVCC model (refer to section below for crash resilience details). Attempts that fail due to transient database errors are retried up to 3 times. We do not make use of long-lived transactions or locks, this enables us to make more efficient use of Postgres resources.
+
+## Resilience
+
+While a run is being handled by a queue instance, a periodic heartbeat timestamp will be recorded in Redis by that queue worker.
+
+When a graceful shutdown request is received (SIGINT) an instance enters shutdown mode, which
+
+- stops accepting new HTTP requests
+- gives any in-progress runs a limited number of seconds to finish (if not finished it will be put back in the queue)
+- stops the instance from picking up more runs from the queue
+
+If a hard shutdown occurs, eg. due to a server crash, or an infra failure, any runs that were in progress will be picked up by a periodic sweeper task that looks for in-progress runs that have breached their heartbeat window, which will put them back in the queue for another instance to pick them up.
+
+## Postgres resilience
+
+For deployment modalities where we manage the Postgres database we have periodic backups, continuously replicated standby replicas for automatic failover. Optionally, on request, we can also setup read replicas as well as other advanced failover capabilities.
+
+All communication with Postgres implements retries for retry-able errors. If Postgres is momentarily unavailable, such as during a database restart, most/all traffic should continue to succeed. Prolonged failure of the Postgres instance will switch traffic to the failover replica. If the failover replica also fails before the primary is brought back online the service would become unavailable.
+
+## Redis resilience
+
+All data that requires durable storage is stored in Postgres, not Redis. Redis is used only for ephemeral metadata, and communication between instances. Refer to the [architecture](./platform_architecture.md) page for more details on how we use Redis. Therefore we place no durability requirements on Redis.
+
+All communication with Redis implements retries for retry-able errors. If Redis is momentarily unavailable, such as during a database restart, most/all traffic should continue to succeed. Prolonged failure of Redis will render the LGP service unavailable.

docs/docs/concepts/self_hosted.md

@@ -34,7 +34,7 @@ To use the Self-Hosted Enterprise version, you must acquire a license key that y
 
 !!! warning "Note"
 
-    The LangGraph Platform Deployments view (within LangSmith SaaS and self-hosted LangSmith) is not available for Self-Hosted Lite or Self-Hosted Enterprise LangGraph deployments. Self-hosted LangGraph deployments are managed externally from LangSmith (e.g. there is no UI to manage these deployments).
+    The LangGraph Platform Deployments view is optionally available for Self-Hosted LangGraph deployments. With one click, self-hosted LangGraph deployments can be deployed in the same Kubernetes cluster where a self-hosted LangSmith instance is deployed.
 
 For step-by-step instructions, see [How to set up a self-hosted deployment of LangGraph](../how-tos/deploy-self-hosted.md).
 

docs/docs/concepts/streaming.md

@@ -1,6 +1,12 @@
 # Streaming
 
-LangGraph is built with first class support for streaming. There are several different ways to stream back outputs from a graph run
+Building a responsive app for end-users? Real-time updates are key to keeping users engaged as your app progresses.
+
+There are three main types of data you’ll want to stream:
+
+1. Workflow progress (e.g., get state updates after each graph node is executed).
+2. LLM tokens as they’re generated.
+3. Custom updates (e.g., "Fetched 10/100 records").
 
 ## Streaming graph outputs (`.stream` and `.astream`)
 
@@ -31,123 +37,6 @@ The below visualization shows the difference between the `values` and `updates`
 ![values vs updates](../static/values_vs_updates.png)
 
 
-## Streaming LLM tokens and events (`.astream_events`)
-
-In addition, you can use the `astream_events` method to stream back events that happen _inside_ nodes. This is useful for [streaming tokens of LLM calls](../how-tos/streaming-tokens.ipynb).
-
-This is a standard method on all [LangChain objects](https://python.langchain.com/docs/concepts/#runnable-interface). This means that as the graph is executed, certain events are emitted along the way and can be seen if you run the graph using `.astream_events`. 
-
-All events have (among other things) `event`, `name`, and `data` fields. What do these mean?
-
-- `event`: This is the type of event that is being emitted. You can find a detailed table of all callback events and triggers [here](https://python.langchain.com/docs/concepts/#callback-events).
-- `name`: This is the name of event.
-- `data`: This is the data associated with the event.
-
-What types of things cause events to be emitted?
-
-* each node (runnable) emits `on_chain_start` when it starts execution, `on_chain_stream` during the node execution and `on_chain_end` when the node finishes. Node events will have the node name in the event's `name` field
-* the graph will emit `on_chain_start` in the beginning of the graph execution, `on_chain_stream` after each node execution and `on_chain_end` when the graph finishes. Graph events will have the `LangGraph` in the event's `name` field
-* Any writes to state channels (i.e. anytime you update the value of one of your state keys) will emit `on_chain_start` and `on_chain_end` events
-
-Additionally, any events that are created inside your nodes (LLM events, tool events, manually emitted events, etc.) will also be visible in the output of `.astream_events`.
-
-To make this more concrete and to see what this looks like, let's see what events are returned when we run a simple graph:
-
-```python
-from langchain_openai import ChatOpenAI
-from langgraph.graph import StateGraph, MessagesState, START, END
-
-model = ChatOpenAI(model="gpt-4o-mini")
-
-
-def call_model(state: MessagesState):
-    response = model.invoke(state['messages'])
-    return {"messages": response}
-
-workflow = StateGraph(MessagesState)
-workflow.add_node(call_model)
-workflow.add_edge(START, "call_model")
-workflow.add_edge("call_model", END)
-app = workflow.compile()
-
-inputs = [{"role": "user", "content": "hi!"}]
-async for event in app.astream_events({"messages": inputs}, version="v1"):
-    kind = event["event"]
-    print(f"{kind}: {event['name']}")
-```
-```shell
-on_chain_start: LangGraph
-on_chain_start: __start__
-on_chain_end: __start__
-on_chain_start: call_model
-on_chat_model_start: ChatOpenAI
-on_chat_model_stream: ChatOpenAI
-on_chat_model_stream: ChatOpenAI
-on_chat_model_stream: ChatOpenAI
-on_chat_model_stream: ChatOpenAI
-on_chat_model_stream: ChatOpenAI
-on_chat_model_stream: ChatOpenAI
-on_chat_model_stream: ChatOpenAI
-on_chat_model_stream: ChatOpenAI
-on_chat_model_stream: ChatOpenAI
-on_chat_model_stream: ChatOpenAI
-on_chat_model_stream: ChatOpenAI
-on_chat_model_end: ChatOpenAI
-on_chain_start: ChannelWrite<call_model,messages>
-on_chain_end: ChannelWrite<call_model,messages>
-on_chain_stream: call_model
-on_chain_end: call_model
-on_chain_stream: LangGraph
-on_chain_end: LangGraph
-```
-
-We start with the overall graph start (`on_chain_start: LangGraph`). We then write to the `__start__` node (this is special node to handle input).
-We then start the `call_model` node (`on_chain_start: call_model`). We then start the chat model invocation (`on_chat_model_start: ChatOpenAI`),
-stream back token by token (`on_chat_model_stream: ChatOpenAI`) and then finish the chat model (`on_chat_model_end: ChatOpenAI`). From there, 
-we write the results back to the channel (`ChannelWrite<call_model,messages>`) and then finish the `call_model` node and then the graph as a whole.
-
-This should hopefully give you a good sense of what events are emitted in a simple graph. But what data do these events contain?
-Each type of event contains data in a different format. Let's look at what `on_chat_model_stream` events look like. This is an important type of event
-since it is needed for streaming tokens from an LLM response.
-
-These events look like:
-
-```shell
-{'event': 'on_chat_model_stream',
- 'name': 'ChatOpenAI',
- 'run_id': '3fdbf494-acce-402e-9b50-4eab46403859',
- 'tags': ['seq:step:1'],
- 'metadata': {'langgraph_step': 1,
-  'langgraph_node': 'call_model',
-  'langgraph_triggers': ['start:call_model'],
-  'langgraph_task_idx': 0,
-  'checkpoint_id': '1ef657a0-0f9d-61b8-bffe-0c39e4f9ad6c',
-  'checkpoint_ns': 'call_model',
-  'ls_provider': 'openai',
-  'ls_model_name': 'gpt-4o-mini',
-  'ls_model_type': 'chat',
-  'ls_temperature': 0.7},
- 'data': {'chunk': AIMessageChunk(content='Hello', id='run-3fdbf494-acce-402e-9b50-4eab46403859')},
- 'parent_ids': []}
-```
-We can see that we have the event type and name (which we knew from before).
-
-We also have a bunch of stuff in metadata. Noticeably, `'langgraph_node': 'call_model',` is some really helpful information
-which tells us which node this model was invoked inside of.
-
-Finally, `data` is a really important field. This contains the actual data for this event! Which in this case
-is an AIMessageChunk. This contains the `content` for the message, as well as an `id`.
-This is the ID of the overall AIMessage (not just this chunk) and is super helpful - it helps
-us track which chunks are part of the same message (so we can show them together in the UI).
-
-This information contains all that is needed for creating a UI for streaming LLM tokens. You can see a 
-guide for that [here](../how-tos/streaming-tokens.ipynb).
-
-
-!!! warning "ASYNC IN PYTHON<=3.10"
-    You may fail to see events being emitted from inside a node when using `.astream_events` in Python <= 3.10. If you're using a Langchain RunnableLambda, a RunnableGenerator, or Tool asynchronously inside your node, you will have to propagate callbacks to these objects manually. This is because LangChain cannot automatically propagate callbacks to child objects in this case.
-
-
 ## LangGraph Platform
 
 Streaming is critical for making LLM applications feel responsive to end users. When creating a streaming run, the streaming mode determines what data is streamed back to the API client. LangGraph Platform supports five streaming modes:
@@ -155,8 +44,8 @@ Streaming is critical for making LLM applications feel responsive to end users.
 - `values`: Stream the full state of the graph after each [super-step](https://langchain-ai.github.io/langgraph/concepts/low_level/#graphs) is executed. See the [how-to guide](../cloud/how-tos/stream_values.md) for streaming values.
 - `messages-tuple`: Stream LLM tokens for any messages generated inside a node. This mode is primarily meant for powering chat applications. See the [how-to guide](../cloud/how-tos/stream_messages.md) for streaming messages.
 - `updates`: Streams updates to the state of the graph after each node is executed. See the [how-to guide](../cloud/how-tos/stream_updates.md) for streaming updates.
-- `events`: Stream all events (including the state of the graph) that occur during graph execution. See the [how-to guide](../cloud/how-tos/stream_events.md) for streaming events. This can be used to do token-by-token streaming for LLMs.
 - `debug`: Stream debug events throughout graph execution. See the [how-to guide](../cloud/how-tos/stream_debug.md) for streaming debug events.
+- `events`: Stream all events (including the state of the graph) that occur during graph execution. See the [how-to guide](../cloud/how-tos/stream_events.md) for streaming events. This mode is only useful for users migrating large LCEL applications to LangGraph. Generally, this mode is not necessary for most applications.
 
 You can also specify multiple streaming modes at the same time. See the [how-to guide](../cloud/how-tos/stream_multiple.md) for configuring multiple streaming modes at the same time.
 

docs/docs/concepts/v0-human-in-the-loop.md

@@ -1,3 +1,8 @@
+---
+search:
+  exclude: true
+---
+
 # Human-in-the-loop
 
 !!! note "Use the `interrupt` function instead."

docs/docs/how-tos/agent-handoffs.ipynb

@@ -58,7 +58,7 @@
     "\n",
     "This guide shows how you can:\n",
     "\n",
-    "- implement handoffs using `Command`: agent node makes some decision (usually LLM-based), and explicitly returns a handoff via `Command`. These are useful when you need fine-grained control over how an agent routes to another agent. It could be well suited for implementing a supervisor agent in a supervisor architecture.\n",
+    "- implement handoffs using `Command`: agent node makes a decision on who to hand off to (usually LLM-based), and explicitly returns a handoff via `Command`. These are useful when you need fine-grained control over how an agent routes to another agent. It could be well suited for implementing a supervisor agent in a supervisor architecture.\n",
     "- implement handoffs using tools: a tool-calling agent has access to tools that can return a handoff via `Command`. The tool-executing node in the agent recognizes `Command` objects returned by the tools and routes accordingly. Handoff tool a general-purpose primitive that is useful in any multi-agent systems that contain tool-calling agents."
    ]
   },

docs/docs/how-tos/auth/custom_auth.md

@@ -13,12 +13,14 @@
   
     We currently only support custom authentication and authorization in Python deployments with `langgraph-api>=0.0.11`. Support for LangGraph.JS will be added soon.
 
+???+ note "Support by deployment type"
+
+    Custom auth is supported for all deployments in the **managed LangGraph Cloud**, as well as **Enterprise** self-hosted plans. It is not supported for **Lite** self-hosted plans.
+
 This guide shows how to add custom authentication to your LangGraph Platform application. This guide applies to both LangGraph Cloud, BYOC, and self-hosted deployments. It does not apply to isolated usage of the LangGraph open source library in your own custom server.
 
 ## 1. Implement authentication
 
-Create `auth.py` file, with a basic JWT authentication handler:
-
 ```python
 from langgraph_sdk import Auth
 

docs/docs/how-tos/autogen-integration-functional.ipynb

@@ -170,8 +170,6 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from typing import Literal, TypedDict\n",
-    "\n",
     "from langchain_core.messages import convert_to_openai_messages, BaseMessage\n",
     "from langgraph.func import entrypoint, task\n",
     "from langgraph.graph import add_messages\n",
@@ -224,12 +222,12 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "\u001b[33muser_proxy\u001b[0m (to assistant):\n",
+      "\u001B[33muser_proxy\u001B[0m (to assistant):\n",
       "\n",
       "Find numbers between 10 and 30 in fibonacci sequence\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "\u001b[33massistant\u001b[0m (to user_proxy):\n",
+      "\u001B[33massistant\u001B[0m (to user_proxy):\n",
       "\n",
       "To find numbers between 10 and 30 in the Fibonacci sequence, we can generate the Fibonacci sequence and check which numbers fall within this range. Here's a plan:\n",
       "\n",
@@ -255,9 +253,9 @@
       "This script will print the Fibonacci numbers between 10 and 30. Please execute the code to see the result.\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "\u001b[31m\n",
-      ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001b[0m\n",
-      "\u001b[33muser_proxy\u001b[0m (to assistant):\n",
+      "\u001B[31m\n",
+      ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001B[0m\n",
+      "\u001B[33muser_proxy\u001B[0m (to assistant):\n",
       "\n",
       "exitcode: 0 (execution succeeded)\n",
       "Code output: \n",
@@ -266,7 +264,7 @@
       "\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "\u001b[33massistant\u001b[0m (to user_proxy):\n",
+      "\u001B[33massistant\u001B[0m (to user_proxy):\n",
       "\n",
       "The Fibonacci numbers between 10 and 30 are 13 and 21. \n",
       "\n",
@@ -320,7 +318,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "\u001b[33muser_proxy\u001b[0m (to assistant):\n",
+      "\u001B[33muser_proxy\u001B[0m (to assistant):\n",
       "\n",
       "Multiply the last number by 3\n",
       "Context: \n",
@@ -336,7 +334,7 @@
       "TERMINATE\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "\u001b[33massistant\u001b[0m (to user_proxy):\n",
+      "\u001B[33massistant\u001B[0m (to user_proxy):\n",
       "\n",
       "The last number in the Fibonacci sequence between 10 and 30 is 21. Multiplying 21 by 3 gives:\n",
       "\n",

docs/docs/how-tos/autogen-integration.ipynb

@@ -168,8 +168,6 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from typing import Literal, TypedDict\n",
-    "\n",
     "from langchain_core.messages import convert_to_openai_messages\n",
     "from langgraph.graph import StateGraph, MessagesState, START\n",
     "from langgraph.checkpoint.memory import MemorySaver\n",
@@ -241,12 +239,12 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "\u001b[33muser_proxy\u001b[0m (to assistant):\n",
+      "\u001B[33muser_proxy\u001B[0m (to assistant):\n",
       "\n",
       "Find numbers between 10 and 30 in fibonacci sequence\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "\u001b[33massistant\u001b[0m (to user_proxy):\n",
+      "\u001B[33massistant\u001B[0m (to user_proxy):\n",
       "\n",
       "To find numbers between 10 and 30 in the Fibonacci sequence, we can generate the Fibonacci sequence and check which numbers fall within this range. Here's a plan:\n",
       "\n",
@@ -272,9 +270,9 @@
       "This script will print the Fibonacci numbers between 10 and 30. Please execute the code to see the result.\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "\u001b[31m\n",
-      ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001b[0m\n",
-      "\u001b[33muser_proxy\u001b[0m (to assistant):\n",
+      "\u001B[31m\n",
+      ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001B[0m\n",
+      "\u001B[33muser_proxy\u001B[0m (to assistant):\n",
       "\n",
       "exitcode: 0 (execution succeeded)\n",
       "Code output: \n",
@@ -283,7 +281,7 @@
       "\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "\u001b[33massistant\u001b[0m (to user_proxy):\n",
+      "\u001B[33massistant\u001B[0m (to user_proxy):\n",
       "\n",
       "The Fibonacci numbers between 10 and 30 are 13 and 21. \n",
       "\n",
@@ -338,7 +336,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "\u001b[33muser_proxy\u001b[0m (to assistant):\n",
+      "\u001B[33muser_proxy\u001B[0m (to assistant):\n",
       "\n",
       "Multiply the last number by 3\n",
       "Context: \n",
@@ -354,7 +352,7 @@
       "TERMINATE\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "\u001b[33massistant\u001b[0m (to user_proxy):\n",
+      "\u001B[33massistant\u001B[0m (to user_proxy):\n",
       "\n",
       "The last number in the Fibonacci sequence between 10 and 30 is 21. Multiplying 21 by 3 gives:\n",
       "\n",

docs/docs/how-tos/command.ipynb

@@ -33,7 +33,7 @@
     "    )\n",
     "```\n",
     "\n",
-    "If you are using [subgraphs](#subgraphs), you might want to navigate from a node a subgraph to a different subgraph (i.e. a different node in the parent graph). To do so, you can specify `graph=Command.PARENT` in `Command`:\n",
+    "If you are using [subgraphs](#subgraphs), you might want to navigate from a node within a subgraph to a different subgraph (i.e. a different node in the parent graph). To do so, you can specify `graph=Command.PARENT` in `Command`:\n",
     "\n",
     "```python\n",
     "def my_node(state: State) -> Command[Literal[\"my_other_node\"]]:\n",

docs/docs/how-tos/create-react-agent-memory.ipynb

@@ -122,20 +122,18 @@
     "\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",
+    "def get_weather(location: str) -> str:\n",
     "    \"\"\"Use this to get weather information.\"\"\"\n",
-    "    if city == \"nyc\":\n",
+    "    if any([city in location.lower() for city in [\"nyc\", \"new york city\"]]):\n",
     "        return \"It might be cloudy in nyc\"\n",
-    "    elif city == \"sf\":\n",
+    "    elif any([city in location.lower() for city in [\"sf\", \"san francisco\"]]):\n",
     "        return \"It's always sunny in sf\"\n",
     "    else:\n",
-    "        raise AssertionError(\"Unknown city\")\n",
+    "        return f\"I am not sure what the weather is in {location}\"\n",
     "\n",
     "\n",
     "tools = [get_weather]\n",
@@ -220,7 +218,7 @@
    "id": "838a043f-90ad-4e69-9d1d-6e22db2c346c",
    "metadata": {},
    "source": [
-    "Notice that when we pass the same the same thread ID, the chat history is preserved"
+    "Notice that when we pass the same thread ID, the chat history is preserved."
    ]
   },
   {

docs/docs/how-tos/http/custom_lifespan.md

@@ -0,0 +1,82 @@
+# How to add custom lifespan events
+
+When deploying agents on the LangGraph platform, you often need to initialize resources like database connections when your server starts up, and ensure they're properly closed when it shuts down. Lifespan events let you hook into your server's startup and shutdown sequence to handle these critical setup and teardown tasks.
+
+This works the same way as [adding custom routes](./custom_routes.md) - you just need to provide your own [`Starlette`](https://www.starlette.io/applications/) app (including [`FastAPI`](https://fastapi.tiangolo.com/), [`FastHTML`](https://fastht.ml/) and other compatible apps).
+
+Below is an example using FastAPI.
+
+???+ note "Python only"
+
+    We currently only support custom lifespan events in Python deployments with `langgraph-api>=0.0.26`.
+
+## Create app
+
+Starting from an **existing** LangGraph Platform application, add the following lifespan code to your `webapp.py` file. If you are starting from scratch, you can create a new app from a template using the CLI.
+
+```bash
+langgraph new --template=new-langgraph-project-python my_new_project
+```
+
+Once you have a LangGraph project, add the following app code:
+
+```python
+# ./src/agent/webapp.py
+from contextlib import asynccontextmanager
+from fastapi import FastAPI
+from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
+from sqlalchemy.orm import sessionmaker
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    # for example...
+    engine = create_async_engine("postgresql+asyncpg://user:pass@localhost/db")
+    # Create reusable session factory
+    async_session = sessionmaker(engine, class_=AsyncSession)
+    # Store in app state
+    app.state.db_session = async_session
+    yield
+    # Clean up connections
+    await engine.dispose()
+
+# highlight-next-line
+app = FastAPI(lifespan=lifespan)
+
+# ... can add custom routes if needed.
+```
+
+## Configure `langgraph.json`
+
+Add the following to your `langgraph.json` file. Make sure the path points to the `webapp.py` file you created above.
+
+```json
+{
+  "dependencies": ["."],
+  "graphs": {
+    "agent": "./src/agent/graph.py:graph"
+  },
+  "env": ".env",
+  "http": {
+    "app": "./src/agent/webapp.py:app"
+  }
+  // Other configuration options like auth, store, etc.
+}
+```
+
+## Start server
+
+Test the server out locally:
+
+```bash
+langgraph dev --no-browser
+```
+
+You should see your startup message printed when the server starts, and your cleanup message when you stop it with Ctrl+C.
+
+## Deploying
+
+You can deploy your app as-is to the managed langgraph cloud or to your self-hosted platform.
+
+## Next steps
+
+Now that you've added lifespan events to your deployment, you can use similar techniques to add [custom routes](./custom_routes.md) or [custom middleware](./custom_middleware.md) to further customize your server's behavior.

docs/docs/how-tos/http/custom_middleware.md

@@ -0,0 +1,75 @@
+# How to add custom middleware
+
+When deploying agents on the LangGraph platform, you can add custom middleware to your server to handle cross-cutting concerns like logging request metrics, injecting or checking headers, and enforcing security policies without modifying core server logic. This works the same way as [adding custom routes](./custom_routes.md) - you just need to provide your own [`Starlette`](https://www.starlette.io/applications/) app (including [`FastAPI`](https://fastapi.tiangolo.com/), [`FastHTML`](https://fastht.ml/) and other compatible apps).
+
+Adding middleware lets you intercept and modify requests and responses globally across your deployment, whether they're hitting your custom endpoints or the built-in LangGraph Platform APIs.
+
+Below is an example using FastAPI.
+
+???+ note "Python only"
+
+    We currently only support custom middleware in Python deployments with `langgraph-api>=0.0.26`.
+
+## Create app
+
+Starting from an **existing** LangGraph Platform application, add the following middleware code to your `webapp.py` file. If you are starting from scratch, you can create a new app from a template using the CLI.
+
+```bash
+langgraph new --template=new-langgraph-project-python my_new_project
+```
+
+Once you have a LangGraph project, add the following app code:
+
+```python
+# ./src/agent/webapp.py
+from fastapi import FastAPI, Request
+from starlette.middleware.base import BaseHTTPMiddleware
+
+# highlight-next-line
+app = FastAPI()
+
+class CustomHeaderMiddleware(BaseHTTPMiddleware):
+    async def dispatch(self, request: Request, call_next):
+        response = await call_next(request)
+        response.headers['X-Custom-Header'] = 'Hello from middleware!'
+        return response
+
+# Add the middleware to the app
+app.add_middleware(CustomHeaderMiddleware)
+```
+
+## Configure `langgraph.json`
+
+Add the following to your `langgraph.json` file. Make sure the path points to the `webapp.py` file you created above.
+
+```json
+{
+  "dependencies": ["."],
+  "graphs": {
+    "agent": "./src/agent/graph.py:graph"
+  },
+  "env": ".env",
+  "http": {
+    "app": "./src/agent/webapp.py:app"
+  }
+  // Other configuration options like auth, store, etc.
+}
+```
+
+## Start server
+
+Test the server out locally:
+
+```bash
+langgraph dev --no-browser
+```
+
+Now any request to your server will include the custom header `X-Custom-Header` in its response.
+
+## Deploying
+
+You can deploy this app as-is to the managed langgraph cloud or to your self-hosted platform.
+
+## Next steps
+
+Now that you've added custom middleware to your deployment, you can use similar techniques to add [custom routes](./custom_routes.md) or define [custom lifespan events](./custom_lifespan.md) to further customize your server's behavior.

docs/docs/how-tos/http/custom_routes.md

@@ -0,0 +1,78 @@
+# How to add custom routes
+
+When deploying agents on the LangGraph platform, your server automatically exposes routes for creating runs and threads, interacting with the long-term memory store, managing configurable assistants, and other core functionality ([see all default API endpoints](../../cloud/reference/api/api_ref.md)).
+
+You can add custom routes by providing your own [`Starlette`](https://www.starlette.io/applications/) app (including [`FastAPI`](https://fastapi.tiangolo.com/), [`FastHTML`](https://fastht.ml/) and other compatible apps). You make LangGraph Platform aware of this by providing a path to the app in your `langgraph.json` configuration file. (`"http": {"app": "path/to/app.py:app"}`).
+
+Defining a custom app object lets you add any routes you'd like, so you can do anything from adding a `/login` endpoint to writing an entire full-stack web-app, all deployed in a single LangGraph deployment.
+
+Below is an example using FastAPI.
+
+???+ note "Python only"
+
+    We currently only support custom authentication and authorization in Python deployments with `langgraph-api>=0.0.26`.
+
+## Create app
+
+Starting from an **existing** LangGraph Platform application, add the following custom route code to your `webapp.py` file. If you are starting from scratch, you can create a new app from a template using the CLI.
+
+```bash
+langgraph new --template=new-langgraph-project-python my_new_project
+```
+
+Once you have a LangGraph project, add the following app code:
+
+```python
+# ./src/agent/webapp.py
+from fastapi import FastAPI
+
+# highlight-next-line
+app = FastAPI()
+
+
+@app.get("/hello")
+def read_root():
+    return {"Hello": "World"}
+
+```
+
+## Configure `langgraph.json`
+
+Add the following to your `langgraph.json` file. Make sure the path points to the `app.py` file you created above.
+
+```json
+{
+  "dependencies": ["."],
+  "graphs": {
+    "agent": "./src/agent/graph.py:graph"
+  },
+  "env": ".env",
+  "http": {
+    "app": "./src/agent/webapp.py:app"
+  }
+  // Other configuration options like auth, store, etc.
+}
+```
+
+## Start server
+
+Test the server out locally:
+
+```bash
+langgraph dev --no-browser
+```
+
+If you navigate to `localhost:2024/hello` in your browser (2024 is the default development port), you should see the `hello` endpoint returning `{"Hello": "World"}`.
+
+
+!!! note "Shadowing default endpoints"
+
+    The routes you create in the app are given priority over the system defaults, meaning you can shadow and redefine the behavior of any default endpoint.
+
+## Deploying
+
+You can deploy this app as-is to the managed langgraph cloud or to your self-hosted platform.
+
+## Next steps
+
+Now that you've added a custom route to your deployment, you can use this same technique to further customize how your server behaves, such as defining custom [custom middleware](./custom_middleware.md) and [custom lifespan events](./custom_lifespan.md). 

docs/docs/how-tos/human_in_the_loop/wait-user-input.ipynb

@@ -397,7 +397,8 @@
     "# We define a fake node to ask the human\n",
     "def ask_human(state):\n",
     "    tool_call_id = state[\"messages\"][-1].tool_calls[0][\"id\"]\n",
-    "    location = interrupt(\"Please provide your location:\")\n",
+    "    ask = AskHuman.model_validate(state[\"messages\"][-1].tool_calls[0][\"args\"])\n",
+    "    location = interrupt(ask.question)\n",
     "    tool_message = [{\"tool_call_id\": tool_call_id, \"type\": \"tool\", \"content\": location}]\n",
     "    return {\"messages\": tool_message}\n",
     "\n",
@@ -491,7 +492,7 @@
     "        \"messages\": [\n",
     "            (\n",
     "                \"user\",\n",
-    "                \"Use the search tool to ask the user where they are, then look up the weather there\",\n",
+    "                \"Ask the user where they are, then look up the weather there\",\n",
     "            )\n",
     "        ]\n",
     "    },\n",

docs/docs/how-tos/index.md

@@ -39,8 +39,7 @@ execution of your graph.
 - [How to use MongoDB checkpointer for persistence](persistence_mongodb.ipynb)
 - [How to create a custom checkpointer using Redis](persistence_redis.ipynb)
 
-See the below guides for how-to add persistence to your workflow using the (beta)
-[Functional API](../concepts/functional_api.md):
+See the below guides for how-to add persistence to your workflow using the [Functional API](../concepts/functional_api.md):
 
 - [How to add thread-level persistence (functional API)](persistence-functional.ipynb)
 - [How to add cross-thread persistence (functional API)](cross-thread-persistence-functional.ipynb)
@@ -60,12 +59,10 @@ LangGraph makes it easy to manage conversation [memory](../concepts/memory.md) i
 [Human-in-the-loop](../concepts/human_in_the_loop.md) functionality allows
 you to involve humans in the decision-making process of your graph. These how-to guides show how to implement human-in-the-loop workflows in your graph.
 
-
 Key workflows:
 
 - [How to wait for user input](human_in_the_loop/wait-user-input.ipynb): A basic example that shows how to implement a human-in-the-loop workflow in your graph using the `interrupt` function.
 - [How to review tool calls](human_in_the_loop/review-tool-calls.ipynb): Incorporate human-in-the-loop for reviewing/editing/accepting tool call requests before they executed using the `interrupt` function.
- 
 
 Other methods:
 
@@ -73,7 +70,7 @@ Other methods:
 - [How to edit graph state](human_in_the_loop/edit-graph-state.ipynb): Edit graph state using `graph.update_state` method. Use this if implementing a **human-in-the-loop** workflow via **static breakpoints**.
 - [How to add dynamic breakpoints with `NodeInterrupt`](human_in_the_loop/dynamic_breakpoints.ipynb): **Not recommended**: Use the [`interrupt` function](../concepts/human_in_the_loop.md) instead.
 
-See the below guides for how-to implement human-in-the-loop workflows with the (beta)
+See the below guides for how-to implement human-in-the-loop workflows with the
 [Functional API](../concepts/functional_api.md):
 
 - [How to wait for user input (Functional API)](wait-user-input-functional.ipynb)
@@ -130,8 +127,7 @@ These how-to guides show common patterns for tool calling with LangGraph:
 
 See the [multi-agent tutorials](../tutorials/index.md#multi-agent-systems) for implementations of other multi-agent architectures.
 
-See the below guides for how to implement multi-agent workflows with the (beta)
-[Functional API](../concepts/functional_api.md):
+See the below guides for how to implement multi-agent workflows with the [Functional API](../concepts/functional_api.md):
 
 - [How to build a multi-agent network (functional API)](multi-agent-network-functional.ipynb)
 - [How to add multi-turn conversation in a multi-agent application (functional API)](multi-agent-multi-turn-convo-functional.ipynb)
@@ -149,8 +145,7 @@ See the below guides for how to implement multi-agent workflows with the (beta)
 - [How to pass custom LangSmith run ID for graph runs](run-id-langsmith.ipynb)
 - [How to integrate LangGraph with AutoGen, CrewAI, and other frameworks](autogen-integration.ipynb)
 
-See the below guide for how to integrate with other frameworks using the (beta)
-[Functional API](../concepts/functional_api.md):
+See the below guide for how to integrate with other frameworks using the [Functional API](../concepts/functional_api.md):
 
 - [How to integrate LangGraph (functional API) with AutoGen, CrewAI, and other frameworks](autogen-integration-functional.ipynb)
 
@@ -162,7 +157,7 @@ One of the big benefits of LangGraph is that you can easily create your own agen
 
 These guides show how to use the prebuilt ReAct agent:
 
-- [How to use the pre-built ReAct agent](create-react-agent.md)
+- [How to use the pre-built ReAct agent](create-react-agent.ipynb)
 - [How to add thread-level memory to a ReAct Agent](create-react-agent-memory.ipynb)
 - [How to add a custom system prompt to a ReAct agent](create-react-agent-system-prompt.ipynb)
 - [How to add human-in-the-loop processes to a ReAct agent](create-react-agent-hitl.ipynb)
@@ -174,8 +169,7 @@ overview of its underlying implementation to help you customize for your own nee
 
 - [How to create prebuilt ReAct agent from scratch](react-agent-from-scratch.ipynb)
 
-See the below guide for how-to build ReAct agents with the (beta)
-[Functional API](../concepts/functional_api.md):
+See the below guide for how-to build ReAct agents with the [Functional API](../concepts/functional_api.md):
 
 - [How to create a ReAct agent from scratch (Functional API)](react-agent-from-scratch-functional.ipynb)
 
@@ -218,6 +212,12 @@ LangGraph applications can be deployed using LangGraph Cloud, which provides a r
 - [How to add custom authentication](./auth/custom_auth.md)
 - [How to update the security schema of your OpenAPI spec](./auth/openapi_security.md)
 
+### Modifying the API
+
+- [How to add custom routes](./http/custom_routes.md)
+- [How to add custom middleware](./http/custom_middleware.md)
+- [How to add custom lifespan events](./http/custom_lifespan.md)
+
 ### Assistants
 
 [Assistants](../concepts/assistants.md) is a configured instance of a template.
@@ -256,6 +256,13 @@ Streaming the results of your LLM application is vital for ensuring a good user
 - [How to stream in debug mode](../cloud/how-tos/stream_debug.md)
 - [How to stream multiple modes](../cloud/how-tos/stream_multiple.md)
 
+### Frontend and Generative UI
+
+With LangGraph Platform you can integrate LangGraph agents into your React applications and colocate UI components with your agent code. 
+
+- [How to integrate LangGraph into your React application](../cloud/how-tos/use_stream_react.md)
+- [How to implement Generative User Interfaces with LangGraph](../cloud/how-tos/generative_ui_react.md)
+
 ### Human-in-the-loop
 
 When designing complex graphs, relying entirely on the LLM for decision-making can be risky, particularly when it involves tools that interact with files, APIs, or databases. These interactions may lead to unintended data access or modifications, depending on the use case. To mitigate these risks, LangGraph allows you to integrate human-in-the-loop behavior, ensuring your LLM applications operate as intended without undesirable outcomes.
@@ -287,12 +294,12 @@ Graph execution can take a while, and sometimes users may change their mind abou
 
 LangGraph Studio is a built-in UI for visualizing, testing, and debugging your agents.
 
-- [How to connect to a LangGraph Cloud deployment](../cloud/how-tos/test_deployment.md)
+- [How to connect to a LangGraph Platform deployment](../cloud/how-tos/test_deployment.md)
 - [How to connect to a local dev server](../how-tos/local-studio.md)
 - [How to connect to a local deployment (Docker)](../cloud/how-tos/test_local_deployment.md)
-- [How to test your graph in LangGraph Studio (MacOS only)](../cloud/how-tos/invoke_studio.md)
 - [How to interact with threads in LangGraph Studio](../cloud/how-tos/threads_studio.md)
 - [How to add nodes as dataset examples in LangGraph Studio](../cloud/how-tos/datasets_studio.md)
+- [How to engineer prompts in LangGraph Studio](../cloud/how-tos/iterate_graph_studio.md)
 
 ## Troubleshooting
 
@@ -308,4 +315,4 @@ These are the guides for resolving common errors you may find while building wit
 
 These guides provide troubleshooting information for errors that are specific to the LangGraph Platform.
 
-- [INVALID_LICENSE](../troubleshooting/errors/INVALID_LICENSE.md)
+- [INVALID_LICENSE](../troubleshooting/errors/INVALID_LICENSE.md)

docs/docs/how-tos/local-studio.md

@@ -1,15 +1,6 @@
 # How to connect a local agent to LangGraph Studio
 
-This guide shows you how to connect your local agent to [LangGraph Studio](../concepts/langgraph_studio.md) for visualization, interaction, and debugging.
-
-## Connection Options
-
-There are two ways to connect your local agent to LangGraph Studio:
-
-- [Development Server](../concepts/langgraph_studio.md#development-server-with-web-ui): Python package, all platforms, no Docker
-- [LangGraph Desktop](../concepts/langgraph_studio.md#desktop-app): Application, Mac only, requires Docker
-
-In this guide we will cover how to use the development server as that is generally an easier and better experience.
+This guide shows you how to connect your local agent to [LangGraph Studio](../concepts/langgraph_studio.md) for visualization, interaction, and debugging using the development server.
 
 ## Setup your application
 
@@ -24,9 +15,8 @@ You will need to make sure to install the `inmem` extras.
 
 ???+ note "Minimum version"
 
-  The minimum version to use the `inmem` extra with `langgraph-cli` is `0.1.55`.
-  Python 3.11 or higher is required.
-  
+The minimum version to use the `inmem` extra with `langgraph-cli` is `0.1.55`.
+Python 3.11 or higher is required.
 
 ```shell
 pip install -U "langgraph-cli[inmem]"
@@ -41,7 +31,7 @@ pip install -U "langgraph-cli[inmem]"
    langgraph dev
    ```
 
-This will look for the `langgraph.json` file in your current directory. 
+This will look for the `langgraph.json` file in your current directory.
 In there, it will find the paths to the graph(s), and start those up.
 It will then automatically connect to the cloud-hosted studio.
 
@@ -89,4 +79,4 @@ Then attach your preferred debugger:
     2. Click + and select "Python Debug Server"
     3. Set IDE host name: `localhost`
     4. Set port: `5678` (or the port number you chose in the previous step)
-    5. Click "OK" and start debugging
+    5. Click "OK" and start debugging

docs/docs/how-tos/map-reduce.ipynb

@@ -207,7 +207,7 @@
     "\n",
     "\n",
     "# Here we define the logic to map out over the generated subjects\n",
-    "# We will use this an edge in the graph\n",
+    "# We will use this as an edge in the graph\n",
     "def continue_to_jokes(state: OverallState):\n",
     "    # We will return a list of `Send` objects\n",
     "    # Each `Send` object consists of the name of a node in the graph\n",

docs/docs/how-tos/memory/add-summary-conversation-history.ipynb

@@ -10,6 +10,7 @@
     "One of the most common use cases for persistence is to use it to keep track of conversation history. This is great - it makes it easy to continue conversations. As conversations get longer and longer, however, this conversation history can build up and take up more and more of the context window. This can often be undesirable as it leads to more expensive and longer calls to the LLM, and potentially ones that error. One way to work around that is to create a summary of the conversation to date, and use that with the past N messages. This guide will go through an example of how to do that.\n",
     "\n",
     "This will involve a few steps:\n",
+    "\n",
     "- Check if the conversation is too long (can be done by checking number of messages or length of messages)\n",
     "- If yes, the create summary (will need a prompt for this)\n",
     "- Then remove all except the last N messages\n",
@@ -98,7 +99,7 @@
     "from typing import Literal\n",
     "\n",
     "from langchain_anthropic import ChatAnthropic\n",
-    "from langchain_core.messages import SystemMessage, RemoveMessage\n",
+    "from langchain_core.messages import SystemMessage, RemoveMessage, HumanMessage\n",
     "from langgraph.checkpoint.memory import MemorySaver\n",
     "from langgraph.graph import MessagesState, StateGraph, START, END\n",
     "\n",

docs/docs/how-tos/memory/manage-conversation-history.ipynb

@@ -7,7 +7,7 @@
    "source": [
     "# How to manage conversation history\n",
     "\n",
-    "One of the most common use cases for persistence is to use it to keep track of conversation history. This is great - it makes it easy to continue conversations. As conversations get longer and longer, however, this conversation history can build up and take up more and more of the context window. This can often be undesirable as it leads to more expensive and longer calls to the LLM, and potentially ones that error. In order to prevent this from happening, you need to probably manage the conversation history.\n",
+    "One of the most common use cases for persistence is to use it to keep track of conversation history. This is great - it makes it easy to continue conversations. As conversations get longer and longer, however, this conversation history can build up and take up more and more of the context window. This can often be undesirable as it leads to more expensive and longer calls to the LLM, and potentially ones that error. In order to prevent this from happening, you need to properly manage the conversation history.\n",
     "\n",
     "Note: this guide focuses on how to do this in LangGraph, where you can fully customize how this is done. If you want a more off-the-shelf solution, you can look into functionality provided in LangChain:\n",
     "\n",

docs/docs/how-tos/pass-run-time-values-to-tools.ipynb

@@ -38,7 +38,7 @@
     "    </p>\n",
     "</div> \n",
     "\n",
-    "The core technique the examples below is to **annotate** a parameter as \"injected\", meaning it will be injected by your program and should not be seen or populated by the LLM. Let the following codesnippet serve as a tl;dr:\n",
+    "The core technique in the examples below is to **annotate** a parameter as \"injected\", meaning it will be injected by your program and should not be seen or populated by the LLM. Let the following codesnippet serve as a tl;dr:\n",
     "\n",
     "```python\n",
     "from typing import Annotated\n",

docs/docs/how-tos/react-agent-structured-output.ipynb

@@ -65,7 +65,7 @@
     "\n",
     "**Pros and Cons**\n",
     "\n",
-    "The benefit to this format is that you only need one LLM, and can save money and latency because of this. The downside to this option is that it isn't guaranteed that the single LLM will call the correct tool when you want it to. We can help the LLM by setting `tool_choice` to `any` when we use `bind_tools` which forces the LLM to select at least one tool at every turn, but this is far from a fool proof strategy. In addition, another downside is that the agent might call *multiple* tools, so we need to check for this explicitly in our routing function (or if we are using OpenAI we an set `parallell_tool_calling=False` to ensure only one tool is called at a time).\n",
+    "The benefit to this format is that you only need one LLM, and can save money and latency because of this. The downside to this option is that it isn't guaranteed that the single LLM will call the correct tool when you want it to. We can help the LLM by setting `tool_choice` to `any` when we use `bind_tools` which forces the LLM to select at least one tool at every turn, but this is far from a foolproof strategy. In addition, another downside is that the agent might call *multiple* tools, so we need to check for this explicitly in our routing function (or if we are using OpenAI we can set `parallell_tool_calling=False` to ensure only one tool is called at a time).\n",
     "\n",
     "**Option 2**\n",
     "\n",

docs/docs/how-tos/state-model.ipynb

@@ -266,6 +266,235 @@
     "    print(\"An exception was raised because bad_node sets `a` to an integer.\")\n",
     "    print(e)"
    ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2270bc3c",
+   "metadata": {},
+   "source": [
+    "## Multiple Nodes\n",
+    "\n",
+    "Run-time validation will also work in a multi-node graph. In the example below `bad_node` updates `a` to an integer. \n",
+    "\n",
+    "Because run-time validation occurs on **inputs**, the validation error will occur when `ok_node` is called (not when `bad_node` returns an update to the state which is inconsistent with the schema)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d832cdcc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langgraph.graph import StateGraph, START, END\n",
+    "from typing_extensions import TypedDict\n",
+    "\n",
+    "from pydantic import BaseModel\n",
+    "\n",
+    "\n",
+    "# The overall state of the graph (this is the public state shared across nodes)\n",
+    "class OverallState(BaseModel):\n",
+    "    a: str\n",
+    "\n",
+    "\n",
+    "def bad_node(state: OverallState):\n",
+    "    return {\n",
+    "        \"a\": 123  # Invalid\n",
+    "    }\n",
+    "\n",
+    "\n",
+    "def ok_node(state: OverallState):\n",
+    "    return {\"a\": \"goodbye\"}\n",
+    "\n",
+    "\n",
+    "# Build the state graph\n",
+    "builder = StateGraph(OverallState)\n",
+    "builder.add_node(bad_node)\n",
+    "builder.add_node(ok_node)\n",
+    "builder.add_edge(START, \"bad_node\")\n",
+    "builder.add_edge(\"bad_node\", \"ok_node\")\n",
+    "builder.add_edge(\"ok_node\", END)\n",
+    "graph = builder.compile()\n",
+    "\n",
+    "# Test the graph with a valid input\n",
+    "try:\n",
+    "    graph.invoke({\"a\": \"hello\"})\n",
+    "except Exception as e:\n",
+    "    print(\"An exception was raised because bad_node sets `a` to an integer.\")\n",
+    "    print(e)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "456b1f77",
+   "metadata": {},
+   "source": [
+    "## Advanced Pydantic Model Usage\n",
+    "\n",
+    "This section covers more advanced topics when using Pydantic models with LangGraph.\n",
+    "\n",
+    "### Serialization Behavior\n",
+    "\n",
+    "When using Pydantic models as state schemas, it's important to understand how serialization works, especially when:\n",
+    "- Passing Pydantic objects as inputs\n",
+    "- Receiving outputs from the graph\n",
+    "- Working with nested Pydantic models\n",
+    "\n",
+    "Let's see these behaviors in action:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0e919cdc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langgraph.graph import StateGraph, START, END\n",
+    "from pydantic import BaseModel\n",
+    "\n",
+    "\n",
+    "class NestedModel(BaseModel):\n",
+    "    value: str\n",
+    "\n",
+    "\n",
+    "class ComplexState(BaseModel):\n",
+    "    text: str\n",
+    "    count: int\n",
+    "    nested: NestedModel\n",
+    "\n",
+    "\n",
+    "def process_node(state: ComplexState):\n",
+    "    # Node receives a validated Pydantic object\n",
+    "    print(f\"Input state type: {type(state)}\")\n",
+    "    print(f\"Nested type: {type(state.nested)}\")\n",
+    "\n",
+    "    # Return a dictionary update\n",
+    "    return {\"text\": state.text + \" processed\", \"count\": state.count + 1}\n",
+    "\n",
+    "\n",
+    "# Build the graph\n",
+    "builder = StateGraph(ComplexState)\n",
+    "builder.add_node(\"process\", process_node)\n",
+    "builder.add_edge(START, \"process\")\n",
+    "builder.add_edge(\"process\", END)\n",
+    "graph = builder.compile()\n",
+    "\n",
+    "# Create a Pydantic instance for input\n",
+    "input_state = ComplexState(text=\"hello\", count=0, nested=NestedModel(value=\"test\"))\n",
+    "print(f\"Input object type: {type(input_state)}\")\n",
+    "\n",
+    "# Invoke graph with a Pydantic instance\n",
+    "result = graph.invoke(input_state)\n",
+    "print(f\"Output type: {type(result)}\")\n",
+    "print(f\"Output content: {result}\")\n",
+    "\n",
+    "# Convert back to Pydantic model if needed\n",
+    "output_model = ComplexState(**result)\n",
+    "print(f\"Converted back to Pydantic: {type(output_model)}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f13f28ce",
+   "metadata": {},
+   "source": [
+    "### Runtime Type Coercion\n",
+    "\n",
+    "Pydantic performs runtime type coercion for certain data types. This can be helpful but also lead to unexpected behavior if you're not aware of it."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "faf59316",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langgraph.graph import StateGraph, START, END\n",
+    "from pydantic import BaseModel\n",
+    "\n",
+    "\n",
+    "class CoercionExample(BaseModel):\n",
+    "    # Pydantic will coerce string numbers to integers\n",
+    "    number: int\n",
+    "    # Pydantic will parse string booleans to bool\n",
+    "    flag: bool\n",
+    "\n",
+    "\n",
+    "def inspect_node(state: CoercionExample):\n",
+    "    print(f\"number: {state.number} (type: {type(state.number)})\")\n",
+    "    print(f\"flag: {state.flag} (type: {type(state.flag)})\")\n",
+    "    return {}\n",
+    "\n",
+    "\n",
+    "builder = StateGraph(CoercionExample)\n",
+    "builder.add_node(\"inspect\", inspect_node)\n",
+    "builder.add_edge(START, \"inspect\")\n",
+    "builder.add_edge(\"inspect\", END)\n",
+    "graph = builder.compile()\n",
+    "\n",
+    "# Demonstrate coercion with string inputs that will be converted\n",
+    "result = graph.invoke({\"number\": \"42\", \"flag\": \"true\"})\n",
+    "\n",
+    "# This would fail with a validation error\n",
+    "try:\n",
+    "    graph.invoke({\"number\": \"not-a-number\", \"flag\": \"true\"})\n",
+    "except Exception as e:\n",
+    "    print(f\"\\nExpected validation error: {e}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2844475b",
+   "metadata": {},
+   "source": [
+    "### Working with Message Models\n",
+    "\n",
+    "When working with LangChain message types in your state schema, there are important considerations for serialization. You should use `AnyMessage` (rather than `BaseMessage`) for proper serialization/deserialization when using message objects over the wire:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bd0734b0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langgraph.graph import StateGraph, START, END\n",
+    "from pydantic import BaseModel\n",
+    "from langchain_core.messages import HumanMessage, AIMessage, AnyMessage\n",
+    "from typing import List\n",
+    "\n",
+    "\n",
+    "class ChatState(BaseModel):\n",
+    "    messages: List[AnyMessage]\n",
+    "    context: str\n",
+    "\n",
+    "\n",
+    "def add_message(state: ChatState):\n",
+    "    return {\"messages\": state.messages + [AIMessage(content=\"Hello there!\")]}\n",
+    "\n",
+    "\n",
+    "builder = StateGraph(ChatState)\n",
+    "builder.add_node(\"add_message\", add_message)\n",
+    "builder.add_edge(START, \"add_message\")\n",
+    "builder.add_edge(\"add_message\", END)\n",
+    "graph = builder.compile()\n",
+    "\n",
+    "# Create input with a message\n",
+    "initial_state = ChatState(\n",
+    "    messages=[HumanMessage(content=\"Hi\")], context=\"Customer support chat\"\n",
+    ")\n",
+    "\n",
+    "result = graph.invoke(initial_state)\n",
+    "print(f\"Output: {result}\")\n",
+    "\n",
+    "# Convert back to Pydantic model to see message types\n",
+    "output_model = ChatState(**result)\n",
+    "for i, msg in enumerate(output_model.messages):\n",
+    "    print(f\"Message {i}: {type(msg).__name__} - {msg.content}\")"
+   ]
   }
  ],
  "metadata": {

docs/docs/how-tos/update-state-from-tools.ipynb

@@ -210,7 +210,7 @@
    "id": "cbb06aea-6654-4245-91f8-af6e8f2b5377",
    "metadata": {},
    "source": [
-    "Let's now add personalization: we'll respond differently to the user based on the state values AFTER the state has been updated from the tool. To achieve this, let's define a function that will dynamically construct the system prompt based on the graph state. It will be called ever time the LLM is called and the function output will be passed to the LLM:"
+    "Let's now add personalization: we'll respond differently to the user based on the state values AFTER the state has been updated from the tool. To achieve this, let's define a function that will dynamically construct the system prompt based on the graph state. It will be called every time the LLM is called and the function output will be passed to the LLM:"
    ]
   },
   {

docs/docs/index.md

@@ -3,4 +3,26 @@ hide_comments: true
 title: Home
 ---
 
+<script>
+  // This script only runs in MkDocs, not on GitHub
+  var hideGitHubVersion = function() {
+    document.querySelectorAll('.github-only').forEach(el => el.style.display = 'none');
+  };
+
+  // Handle both initial load and subsequent navigation
+  document.addEventListener('DOMContentLoaded', hideGitHubVersion);
+  document$.subscribe(hideGitHubVersion);
+</script>
+
+<p class="mkdocs-only">
+  <img class="logo-light" src="static/wordmark_dark.svg" alt="LangGraph Logo" width="80%">
+  <img class="logo-dark" src="static/wordmark_light.svg" alt="LangGraph Logo" width="80%">
+</p>
+
+<style>
+.md-content h1 {
+  display: none;
+}
+</style>
+
 {!../README.md!}

docs/docs/llms-txt-overview.md

@@ -0,0 +1,36 @@
+# LLMs-txt for LangGraph
+
+## Overview
+
+LangGraph provides documentation files in the [`llms.txt`](https://llmstxt.org/) format, specifically `llms.txt` and `llms-full.txt`. These files allow large language models (LLMs) and agents to access programming documentation and APIs, particularly useful within integrated development environments (IDEs).
+
+| Language Version | llms.txt                                                                                                   | llms-full.txt                                                                                                        |
+|------------------|------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------|
+| LangGraph Python | [https://langchain-ai.github.io/langgraph/llms.txt](https://langchain-ai.github.io/langgraph/llms.txt)     | [https://langchain-ai.github.io/langgraph/llms-full.txt](https://langchain-ai.github.io/langgraph/llms-full.txt)     |
+| LangGraph JS     | [https://langchain-ai.github.io/langgraphjs/llms.txt](https://langchain-ai.github.io/langgraphjs/llms.txt) | [https://langchain-ai.github.io/langgraphjs/llms-full.txt](https://langchain-ai.github.io/langgraphjs/llms-full.txt) |
+
+## Differences Between `llms.txt` and `llms-full.txt`
+
+- **`llms.txt`** is an index file containing links with brief descriptions of the content. An LLM or agent must follow these links to access detailed information.
+
+- **`llms-full.txt`** includes all the detailed content directly in a single file, eliminating the need for additional navigation.
+
+A key consideration when using `llms-full.txt` is its size. For extensive documentation, this file may become too large to fit into an LLM's context window.
+
+## Using `llms.txt` via an MCP Server
+
+As of March 9, 2025, IDEs [do not yet have robust native support for `llms.txt`](https://x.com/jeremyphoward/status/1902109312216129905?t=1eHFv2vdNdAckajnug0_Vw&s=19). However, you can utilize `llms.txt` effectively through an MCP server.
+
+We provide an MCP server specifically designed to serve documentation, called [`mcpdoc`](https://github.com/langchain-ai/mcpdoc). This setup is compatible with IDEs and platforms such as Cursor, Windsurf, Claude, and Claude Code. Instructions for using `mcpdoc` with these tools are available in the repository.
+
+## Using `llms-full.txt`
+
+The LangGraph `llms-full.txt` file typically contains several hundred thousand tokens, exceeding the context window limitations of most LLMs. To effectively use this file:
+
+1. **With IDEs (e.g., Cursor, Windsurf)**:
+    - Add the `llms-full.txt` as custom documentation. The IDE will automatically chunk and index the content, implementing Retrieval-Augmented Generation (RAG).
+
+2. **Without IDE support**:
+    - Use a chat model with a large context window.
+    - Implement a RAG strategy to manage and query the documentation efficiently.
+

docs/docs/llms.txt

@@ -0,0 +1,204 @@
+# LangGraph
+
+## Tutorials
+
+[Learn the basics](https://langchain-ai.github.io/langgraph/tutorials/introduction/): LLM should read this page when needing to build a LangGraph chatbot or when learning about chat agents with memory, human-in-the-loop functionality, and state management. This page provides a comprehensive LangGraph quickstart tutorial covering building a support chatbot with web search capability, conversation memory, human review routing, custom state management, and time travel functionality to explore alternative conversation paths.
+
+[Local Deploy](https://langchain-ai.github.io/langgraph/tutorials/langgraph-platform/local-server/): LLM should read this page when setting up a LangGraph app locally using `langgraph dev` and troubleshooting LangGraph server deployment. This page contains a quickstart guide for launching a LangGraph server locally, including installation steps, app creation from templates, environment setup, API testing with Python/JS SDKs, and links to deployment options and further documentation.
+
+[Workflows and Agents](https://langchain-ai.github.io/langgraph/tutorials/workflows/): LLM should read this page when implementing agent systems, designing workflow architectures, or troubleshooting LLM orchestration strategies. The page covers patterns for LLM system design, comparing workflows (predefined paths) vs agents (dynamic control), with implementations of prompt chaining, parallelization, routing, orchestrator-worker, evaluator-optimizer, and agent patterns using both graph and functional APIs in LangGraph.
+
+## Concepts 
+
+[Concepts](https://langchain-ai.github.io/langgraph/concepts/): LLM should read this page when needing to understand LangGraph's key concepts or when planning to deploy LangGraph applications. Comprehensive guide covering LangGraph fundamentals (graph primitives, agents, multi-agent systems, breakpoints, persistence), features (time travel, memory, streaming), and LangGraph Platform deployment options (self-hosted, cloud, enterprise).
+
+[Agent architectures](https://langchain-ai.github.io/langgraph/concepts/agentic_concepts/): LLM should read this page when designing agent architectures, implementing control flows for LLM applications, or customizing agent behavior patterns. This page covers different LLM agent architectures including routers, tool calling agents (ReAct), structured outputs, memory systems, planning capabilities, and advanced customization options like human-in-the-loop, parallelization, subgraphs, and reflection mechanisms.
+
+[Application Structure](https://langchain-ai.github.io/langgraph/concepts/application_structure/): LLM should read this page when needing to understand LangGraph application structure, preparing to deploy a LangGraph application, or troubleshooting configuration issues. This page details the structure of LangGraph applications, including required components (graphs, langgraph.json config file, dependency files, optional .env), file organization patterns for Python/JavaScript projects, configuration file format with all supported fields, and how to specify dependencies, graphs, and environment variables.
+
+[Assistants](https://langchain-ai.github.io/langgraph/concepts/assistants/): LLM should read this page when looking for information about LangGraph assistants, understanding assistant configuration in LangGraph Platform, or learning about versioning agent configurations. This page explains LangGraph assistants, which allow developers to modify agent configurations (prompts, models, etc.) without changing graph logic, supports versioning for tracking changes, and is available only in LangGraph Platform (not open source).
+
+[Authentication & Access Control](https://langchain-ai.github.io/langgraph/concepts/auth/): LLM should read this page when implementing authentication in LangGraph Platform, designing access control for LangGraph applications, or troubleshooting security issues in LangGraph deployments. This page explains LangGraph's authentication and authorization system, covering the difference between authentication and authorization, system architecture, implementing custom auth handlers, common access patterns, and supported resources/actions for access control.
+
+[Bring Your Own Cloud (BYOC)](https://langchain-ai.github.io/langgraph/concepts/bring_your_own_cloud/): LLM should read this page when learning about LangGraph Platform deployment options, understanding Bring Your Own Cloud architecture, or managing deployments in AWS. This page explains LangGraph's BYOC deployment model, detailing how it separates control plane (managed by LangChain) from data plane (in customer's AWS account), outlines AWS requirements, infrastructure setup via Terraform, required permissions, and explains the deployment workflow.
+
+[Deployment Options](https://langchain-ai.github.io/langgraph/concepts/deployment_options/): LLM should read this page when needing information about LangGraph deployment options, comparing different deployment methods, or understanding LangGraph Platform plans. This page outlines four deployment options for LangGraph Platform: Self-Hosted Lite (available for all plans), Self-Hosted Enterprise (Enterprise plan only), Cloud SaaS (Plus and Enterprise plans), and Bring Your Own Cloud (Enterprise plan only, AWS-only).
+
+[Double Texting](https://langchain-ai.github.io/langgraph/concepts/double_texting/): LLM should read this page when handling concurrent user interactions in LangGraph Platform, implementing double-texting safeguards, or designing stateful conversation systems. This page explains four approaches to handling "double texting" in LangGraph (when users send a second message before the first completes): Reject, Enqueue, Interrupt, and Rollback, noting these features are currently only available in LangGraph Platform.
+
+[Durable Execution](https://langchain-ai.github.io/langgraph/concepts/durable_execution/): LLM should read this page when needing to understand durable execution in LangGraph, implementing workflow persistence, or troubleshooting workflow resumption. This page explains durable execution in LangGraph: how workflows save progress to resume later, requirements (checkpointers and thread IDs), determinism guidelines for consistent replay, using tasks to encapsulate non-deterministic operations, and approaches for pausing/resuming workflows.
+
+[FAQ](https://langchain-ai.github.io/langgraph/concepts/faq/): LLM should read this page when needing to understand differences between LangGraph and LangChain, exploring deployment options for LangGraph Platform, or determining compatibility with various LLMs. FAQ covering LangGraph basics, comparisons with other frameworks, deployment options (free self-hosted, Cloud SaaS, BYOC, Enterprise), compatibility with different LLMs including OSS models, and feature differences between open-source LangGraph and proprietary LangGraph Platform.
+
+[Functional API](https://langchain-ai.github.io/langgraph/concepts/functional_api/): LLM should read this page when implementing workflows with persistent state, adding human-in-the-loop features, or converting existing code to use LangGraph. The page documents LangGraph's Functional API, which allows adding persistence, memory, and human-in-the-loop capabilities with minimal code changes using @entrypoint and @task decorators, handling serialization requirements, state management, and common patterns for parallel execution and error handling.
+
+[Why LangGraph?](https://langchain-ai.github.io/langgraph/concepts/high_level/): LLM should read this page when understanding LangGraph's core capabilities, exploring LLM application infrastructure, or evaluating agent/workflow persistence options. LangGraph provides infrastructure for LLM applications with three key benefits: persistence for memory and human-in-the-loop capabilities, streaming of workflow events and LLM outputs, and tools for debugging and deployment via LangGraph Platform.
+
+[Human-in-the-loop](https://langchain-ai.github.io/langgraph/concepts/human_in_the_loop/): LLM should read this page when implementing human-in-the-loop workflows in LangGraph, designing approval systems with LLMs, or creating interactive multi-turn conversation agents. This page explains human-in-the-loop patterns in LangGraph using the interrupt function, showing how to pause graph execution for human review/input and resume with Command. Includes design patterns for approval workflows, state editing, tool call reviews, and multi-turn conversations, with code examples and warnings about execution flow and common pitfalls.
+
+[LangGraph CLI](https://langchain-ai.github.io/langgraph/concepts/langgraph_cli/): LLM should read this page when looking for information about LangGraph CLI installation or when needing to deploy a LangGraph API server locally. The page covers LangGraph CLI installation methods (Homebrew, pip), key commands (build, dev, up, dockerfile), and features like hot reloading, debugger support, and database management for running LangGraph servers.
+
+[Cloud SaaS](https://langchain-ai.github.io/langgraph/concepts/langgraph_cloud/): LLM should read this page when learning about LangGraph's Cloud SaaS offering, understanding deployment options for LangGraph Servers, or planning autoscaling infrastructure for LangGraph applications. This page describes LangGraph Cloud SaaS, a managed deployment service for LangGraph Servers with details on deployment types (Development/Production), revisions, persistence, autoscaling capabilities (up to 10 containers), LangSmith integration, IP whitelisting, and automatic deletion policies after 28 days of non-use.
+
+[LangGraph Platform](https://langchain-ai.github.io/langgraph/concepts/langgraph_platform/): LLM should read this page when seeking information about LangGraph Platform's components or evaluating production deployment options for agentic applications. The page details the LangGraph Platform, a commercial solution for deploying agentic applications, including its components (Server, Studio, CLI, SDK, Remote Graph) and key benefits like streaming support, background runs, long run handling, burstiness management, and human-in-the-loop capabilities.
+
+[LangGraph Server](https://langchain-ai.github.io/langgraph/concepts/langgraph_server/): LLM should read this page when developing applications with LangGraph Server, deploying agent-based applications, or integrating persistent state management in agent workflows. LangGraph Server provides an API for creating and managing agent applications with key features like streaming endpoints, background runs, task queues, persistence, webhooks, cron jobs, and monitoring capabilities through a structured system of assistants, threads, runs, and stores.
+
+[LangGraph Studio](https://langchain-ai.github.io/langgraph/concepts/langgraph_studio/): LLM should read this page when looking for information about LangGraph Studio features, needing to troubleshoot LangGraph Studio issues, or learning how to connect a LangGraph application to the Studio. LangGraph Studio is a specialized agent IDE for visualizing, interacting with, and debugging LLM applications, offering features such as graph visualization, state editing, assistant management, and integration with LangSmith, with instructions for connecting via deployed applications or local development servers, plus troubleshooting FAQs.
+
+[LangGraph Glossary](https://langchain-ai.github.io/langgraph/concepts/low_level/): LLM should read this page when needing to understand LangGraph terminology, implementing agent workflows as graphs, or developing modular multi-step AI systems. The page covers core LangGraph concepts including StateGraph, nodes, edges, state management, messaging, persistence, configuration, human-in-the-loop features, subgraphs, and visualization capabilities.
+
+[Memory](https://langchain-ai.github.io/langgraph/concepts/memory/): LLM should read this page when implementing memory systems for AI agents, managing conversation context across sessions, or designing systems that require both short-term and long-term information retention. This page explains memory systems in LangGraph, covering short-term (thread-scoped) memory for managing conversation history and long-term memory across threads, with techniques for handling long conversations, summarizing past interactions, and organizing persistent memories in namespaces.
+
+[Multi-agent Systems](https://langchain-ai.github.io/langgraph/concepts/multi_agent/): LLM should read this page when implementing multi-agent systems, troubleshooting complex agent architectures, or designing agent communication patterns. Multi-agent systems organize LLMs into modular architectures (network, supervisor, hierarchical, custom) with different communication patterns, using Command objects for handoffs between agents, and supporting various state management approaches.
+
+[Persistence](https://langchain-ai.github.io/langgraph/concepts/persistence/): LLM should read this page when needing to understand LangGraph persistence mechanisms, implementing stateful workflows, or managing conversation history across interactions. This page covers LangGraph's persistence features including checkpointers, threads, state snapshots, replay functionality, forking state, cross-thread memory via InMemoryStore, and semantic search capabilities for stored memories.
+
+[LangGraph Platform Plans](https://langchain-ai.github.io/langgraph/concepts/plans/): LLM should read this page when determining LangGraph Platform pricing tiers, comparing deployment options, or researching features available across different plans. This page outlines LangGraph Platform plans (Developer, Plus, Enterprise), detailing deployment options, usage limitations, feature availability, and pricing structure for agentic application deployment.
+
+[LangGraph Platform Architecture](https://langchain-ai.github.io/langgraph/concepts/platform_architecture/): LLM should read this page when needing to understand LangGraph Platform's technical architecture or troubleshooting deployment issues. The page details how LangGraph Platform uses Postgres for persistent storage of user/run data and Redis for worker communication (run cancellation, output streaming) and ephemeral metadata storage (retry attempts).
+
+[LangGraph's Runtime (Pregel)](https://langchain-ai.github.io/langgraph/concepts/pregel/): LLM should read this page when learning about LangGraph's runtime, implementing applications with Pregel directly, or understanding how LangGraph executes graph applications. Explains LangGraph's Pregel runtime which manages graph application execution through a three-phase process (Plan, Execution, Update), describes different channel types (LastValue, Topic, Context, BinaryOperatorAggregate), provides direct implementation examples, and contrasts the StateGraph API with the Functional API.
+
+[LangGraph Platform: Scalability & Resilience](https://langchain-ai.github.io/langgraph/concepts/scalability_and_resilience/): LLM should read this page when needing to understand LangGraph Platform's scaling capabilities, designing high-availability LangGraph deployments, or troubleshooting resilience issues. This page details LangGraph Platform's horizontal scaling features including stateless server instances, queue worker scaling, resilience mechanisms for handling crashes, and database failover strategies in Postgres and Redis.
+
+[LangGraph SDK](https://langchain-ai.github.io/langgraph/concepts/sdk/): LLM should read this page when looking for installation instructions for LangGraph SDK, needing to choose between sync and async Python clients, or requiring SDK API references. The page covers LangGraph SDK installation for Python and JS, provides API reference links, explains the difference between synchronous and asynchronous Python clients, and includes code examples for both client types.
+
+[Self-Hosted](https://langchain-ai.github.io/langgraph/concepts/self_hosted/): LLM should read this page when looking for LangGraph deployment options, understanding self-hosted versions, or seeking requirements for self-hosting LangGraph. This page details two self-hosted deployment options for LangGraph Platform: Self-Hosted Lite (limited to 1M nodes/year) and Self-Hosted Enterprise (full version requiring license). Includes requirements, deployment process using Redis/Postgres, Docker, and optional Kubernetes deployment via Helm chart.
+
+[Streaming](https://langchain-ai.github.io/langgraph/concepts/streaming/): LLM should read this page when implementing streaming features in LangGraph applications, understanding different streaming modes, or building responsive LLM applications. This page explains streaming in LangGraph, covering the main types (workflow progress, LLM tokens, custom updates) and streaming modes (values, updates, custom, messages, debug, events), with details on how to use multiple modes simultaneously and differences between LangGraph library and Platform implementations.
+
+[Template Applications](https://langchain-ai.github.io/langgraph/concepts/template_applications/): LLM should read this page when looking for LangGraph template applications, setting up a new LangGraph project, or finding reference implementations for agentic workflows. This page presents LangGraph template applications with installation requirements, available templates (including ReAct Agent, Memory Agent, Retrieval Agent, etc.), instructions for creating new apps using the CLI, deployment options, and links to further learning resources.
+
+[Time Travel ⏱️](https://langchain-ai.github.io/langgraph/concepts/time-travel/): LLM should read this page when debugging LLM-based agent behavior, analyzing decision-making paths, or exploring alternative execution branches in LangGraph. This page explains LangGraph's Time Travel debugging features: Replaying (reproducing past actions up to specific checkpoints) and Forking (creating alternative execution paths from specific points), with code examples for retrieving checkpoints, configuring replay, and creating forked states.
+
+## How Tos
+
+[How-to Guides](https://langchain-ai.github.io/langgraph/how-tos/): LLM should read this page when looking for specific implementation techniques in LangGraph or when trying to deploy LangGraph applications to production environments. This page contains an extensive collection of how-to guides for LangGraph, covering graph fundamentals, persistence, memory management, human-in-the-loop features, tool calling, multi-agent systems, streaming, and deployment options through LangGraph Platform.
+
+[How to implement handoffs between agents](https://langchain-ai.github.io/langgraph/how-tos/agent-handoffs/): LLM should read this page when implementing multi-agent systems that require agent coordination, when building systems with specialized agents that need to work together, or when needing to implement handoffs between agents. This page explains how to implement handoffs between agents in LangGraph using Command objects, both directly from agent nodes and through specialized handoff tools, with code examples for creating multi-agent systems.
+
+[How to run a graph asynchronously](https://langchain-ai.github.io/langgraph/how-tos/async/): LLM should read this page when needing to implement asynchronous graph execution in LangGraph or when optimizing IO-bound LLM applications. This page explains how to convert synchronous graphs to asynchronous in LangGraph, including updating node definitions with async/await, using StateGraph with TypedDict, implementing conditional edges, and streaming results.
+
+[How to integrate LangGraph with AutoGen, CrewAI, and other frameworks](https://langchain-ai.github.io/langgraph/how-tos/autogen-integration/): LLM should read this page when integrating LangGraph with other agent frameworks, building multi-agent systems, or adding persistence features to agents. The page demonstrates how to combine LangGraph with AutoGen by calling AutoGen agents inside LangGraph nodes, showing code examples for setting up the integration with memory and conversation persistence.
+
+[How to integrate LangGraph (functional API) with AutoGen, CrewAI, and other frameworks](https://langchain-ai.github.io/langgraph/how-tos/autogen-integration-functional/): LLM should read this page when integrating LangGraph with other agent frameworks, building multi-agent systems with different frameworks, or adding LangGraph features to existing agent systems. This page demonstrates how to integrate LangGraph's functional API with AutoGen, including code examples for creating a workflow that calls AutoGen agents, leveraging LangGraph's memory and persistence features.
+
+[How to create branches for parallel node execution](https://langchain-ai.github.io/langgraph/how-tos/branching/): LLM should read this page when needing to implement parallel node execution in LangGraph, optimizing graph performance, or handling conditional branching in workflows. This page explains how to create branches for parallel execution in LangGraph using fan-out/fan-in mechanisms, reducer functions for state accumulation, handling exceptions during parallel execution, and implementing conditional branching logic between nodes.
+
+[How to combine control flow and state updates with Command](https://langchain-ai.github.io/langgraph/how-tos/command): LLM should read this page when learning how to combine control flow with state updates in LangGraph, understanding Command objects, or navigating between parent graphs and subgraphs. This page explains how to use Command objects to simultaneously update state and control flow between nodes, demonstrates using Command.PARENT to navigate from subgraphs to parent graphs, and includes examples of implementing reducers for state updates across graph hierarchies.
+
+[How to add runtime configuration to your graph](https://langchain-ai.github.io/langgraph/how-tos/configuration/): LLM should read this page when implementing runtime configuration for LangGraph, adding model selection options to agents, or enabling dynamic system messages. This page demonstrates how to configure LangGraph at runtime, including selecting different LLMs dynamically and adding custom configuration options like system messages through the configurable dictionary.
+
+[How to use the pre-built ReAct agent](https://langchain-ai.github.io/langgraph/how-tos/create-react-agent/): LLM should read this page when implementing a ReAct agent, needing pre-built agent solutions, or learning how to integrate tools with LLM agents. This page covers how to use the pre-built ReAct agent in LangGraph, including setup instructions, creating a weather checking tool, implementing the agent architecture, and examples of running the agent with and without tool calls.
+
+[How to add human-in-the-loop processes to the prebuilt ReAct agent](https://langchain-ai.github.io/langgraph/how-tos/create-react-agent-hitl/): LLM should read this page when implementing human-in-the-loop processes for ReAct agents, debugging tool calls, or learning about interrupts in LangGraph. This guide demonstrates how to add human-in-the-loop functionality to prebuilt ReAct agents using interrupt_before=["tools"], working with MemorySaver checkpoints, and showing how to approve or edit tool calls before they execute.
+
+[How to add thread-level memory to a ReAct Agent](https://langchain-ai.github.io/langgraph/how-tos/create-react-agent-memory/): LLM should read this page when adding memory to ReAct agents, implementing thread-level persistence in LangGraph, or building stateful conversational agents. This guide demonstrates how to add memory to a ReAct agent using LangGraph's checkpointer interface, with code examples showing MemorySaver implementation, thread_id configuration, and persistent chat context across multiple interactions.
+
+[How to return structured output from the prebuilt ReAct agent](https://langchain-ai.github.io/langgraph/how-tos/create-react-agent-structured-output/): LLM should read this page when implementing structured output with ReAct agents, customizing agent response formats, or working with LangGraph agents. This page explains how to return structured output from prebuilt ReAct agents by providing a response_format parameter with a Pydantic schema, including examples with weather data and options for customizing the prompt.
+
+[How to add a custom system prompt to the prebuilt ReAct agent](https://langchain-ai.github.io/langgraph/how-tos/create-react-agent-system-prompt/): LLM should read this page when learning to customize ReAct agents, needing to add system prompts to agents, or working with LangGraph's prebuilt agents. This tutorial demonstrates how to add a custom system prompt to a prebuilt ReAct agent, with code examples showing model setup, tool creation, and using the prompt parameter in the create_react_agent function.
+
+[How to add cross-thread persistence to your graph](https://langchain-ai.github.io/langgraph/how-tos/cross-thread-persistence): LLM should read this page when needing to implement persistence across multiple threads in LangGraph, when storing user data between conversations, or when implementing shared memory in graph-based LLM applications. This page demonstrates how to use LangGraph's Store API to persist data across threads, including creating an InMemoryStore with embedding search capabilities, passing stores to graph nodes, and accessing user-specific memories in different conversation threads.
+
+[How to add cross-thread persistence (functional API)](https://langchain-ai.github.io/langgraph/how-tos/cross-thread-persistence-functional): LLM should read this page when needing to implement cross-thread persistence in LangGraph functional API, storing user data across different conversation threads, or creating shared memory between workflows. This page explains how to add cross-thread persistence to LangGraph using the Store interface, including defining a store, configuring the entrypoint decorator, and implementing a workflow that can store and retrieve user information across different conversation threads.
+
+[How to do a Self-hosted deployment of LangGraph](https://langchain-ai.github.io/langgraph/how-tos/deploy-self-hosted/): LLM should read this page when implementing a self-hosted deployment of LangGraph, configuring required environment variables, or building Docker images for LangGraph applications. This page explains how to deploy LangGraph applications using Docker, covering environment requirements (Redis, Postgres), how to build Docker images with the LangGraph CLI, configuration using environment variables, and deployment options using Docker or Docker Compose.
+
+[How to disable streaming for models that don't support it](https://langchain-ai.github.io/langgraph/how-tos/disable-streaming/): LLM should read this page when handling models that don't support streaming, implementing LangGraph with non-streaming models, or troubleshooting streaming errors with OpenAI's O1 models. This page explains how to use the disable_streaming=True parameter with ChatOpenAI to make non-streaming models work with LangGraph's astream_events API, with code examples showing the error case and proper implementation.
+
+[How to edit graph state](https://langchain-ai.github.io/langgraph/how-tos/human_in_the_loop/edit-graph-state/): LLM should read this page when needing to implement human intervention in LangGraph workflows, wanting to edit graph state during execution, or implementing breakpoints in agent systems. This page explains how to edit graph state in LangGraph using breakpoints, including implementing human-in-the-loop interactions, setting up interruptions before specific nodes, and updating state during agent execution.
+
+[How to Review Tool Calls](https://langchain-ai.github.io/langgraph/how-tos/human_in_the_loop/review-tool-calls/): LLM should read this page when implementing human review of tool calls, creating interactive agent workflows, or building approval systems for AI actions. This page explains how to implement human-in-the-loop review for tool calls in LangGraph, including approving tool calls, modifying tool calls manually, and providing natural language feedback to agents with complete code examples and explanations.
+
+[How to view and update past graph state](https://langchain-ai.github.io/langgraph/how-tos/human_in_the_loop/time-travel/): LLM should read this page when needing to access or modify past states in LangGraph, when debugging agent execution, or when implementing user interventions in agent workflows. This page demonstrates how to view and update past graph states in LangGraph using get_state and update_state methods, with examples of replaying execution from checkpoints and branching workflows.
+
+[How to wait for user input using interrupt](https://langchain-ai.github.io/langgraph/how-tos/human_in_the_loop/wait-user-input/): LLM should read this page when implementing wait-for-user functions in LangGraph, implementing human-in-the-loop interactions, or learning how to use the interrupt() function. This page explains how to pause graph execution to collect user input using LangGraph's interrupt() function, with examples of simple feedback collection and more complex agent interactions that ask clarifying questions.
+
+[How to define input/output schema for your graph](https://langchain-ai.github.io/langgraph/how-tos/input_output_schema/): LLM should read this page when needing to define separate input/output schemas for LangGraph, implementing schema-based data filtering, or understanding schema definitions in StateGraph. This page explains how to define distinct input and output schemas for a StateGraph, showing how input schema validates the provided data structure while output schema filters internal data to return only relevant information, with code examples demonstrating implementation.
+
+[How to handle large numbers of tools](https://langchain-ai.github.io/langgraph/how-tos/many-tools/): LLM should read this page when handling large tool collections, implementing dynamic tool selection, or creating retrieval-based tool management in LangGraph. This page demonstrates how to manage large numbers of tools by using vector search to dynamically select relevant tools based on user queries, implementing tool selection nodes in LangGraph, and handling tool selection errors with retry mechanisms.
+
+[How to create map-reduce branches for parallel execution](https://langchain-ai.github.io/langgraph/how-tos/map-reduce/): LLM should read this page when learning to implement parallel execution in LangGraph, creating map-reduce operations, or handling dynamic task decomposition. This guide explains how to use LangGraph's Send API to create map-reduce workflows, breaking tasks into parallel sub-tasks and recombining results, with examples showing joke generation across multiple subjects.
+
+[How to add summary of the conversation history](https://langchain-ai.github.io/langgraph/how-tos/memory/add-summary-conversation-history/): LLM should read this page when implementing conversation summarization, managing context windows, or building chatbots with memory management. This page demonstrates how to add summary functionality to conversation history using LangGraph, including checking conversation length, creating summaries, and removing old messages while maintaining context.
+
+[How to delete messages](https://langchain-ai.github.io/langgraph/how-tos/memory/delete-messages): LLM should read this page when attempting to manage message history in LangGraph, needing to delete specific messages from conversational state, or implementing memory management in LLM applications. This page explains how to delete messages from a LangGraph application using RemoveMessage modifiers, covering both manual deletion with message IDs and programmatic deletion within graph logic to maintain conversation history limits.
+
+[How to manage conversation history](https://langchain-ai.github.io/langgraph/how-tos/memory/manage-conversation-history/): LLM should read this page when managing conversation history in LangGraph, preventing context window issues, or implementing custom message filtering. This page explains how to manage conversation history in LangGraph to prevent context window overflow by implementing message filtering functions that control which messages are sent to the LLM.
+
+[How to add semantic search to your agent's memory](https://langchain-ai.github.io/langgraph/how-tos/memory/semantic-search/): LLM should read this page when implementing semantic search in agent memory, enabling memory-aware AI assistants, or configuring advanced memory retrieval systems. This page demonstrates how to add semantic search to LangGraph agent memory stores, covering basic setup with embeddings, storing memories, searching by semantic similarity, integrating memory in agents and ReAct agents, and advanced usage like multi-vector indexing and selective memory indexing.
+
+[How to add multi-turn conversation in a multi-agent application](https://langchain-ai.github.io/langgraph/how-tos/multi-agent-multi-turn-convo/): LLM should read this page when implementing multi-turn conversations between agents, creating interactive agent systems with human input, or learning about langgraph interrupts and agent handoffs. This page demonstrates how to build a multi-agent system with multi-turn conversations, including human-in-the-loop interactions, agent handoffs, and state management using LangGraph, Command objects, and interrupts.
+
+[How to add multi-turn conversation in a multi-agent application (functional API)](https://langchain-ai.github.io/langgraph/how-tos/multi-agent-multi-turn-convo-functional/): LLM should read this page when building multi-turn conversational agents, implementing agent-to-agent handoffs, or using interrupts to collect user input in LangGraph. This guide demonstrates how to create a multi-agent system with multi-turn conversations using LangGraph's functional API, featuring agent handoffs, interrupt mechanics for user input, and a complete example of travel and hotel advisor agents that can transfer control between each other.
+
+[How to build a multi-agent network](https://langchain-ai.github.io/langgraph/how-tos/multi-agent-network/): LLM should read this page when implementing multi-agent networks, setting up agent communication via handoffs, or building travel assistance agents. This page explains how to create a fully-connected multi-agent network with LangGraph where agents can communicate with each other via handoffs, including custom agent implementation and using prebuilt ReAct agents with tools.
+
+[How to build a multi-agent network (functional API)](https://langchain-ai.github.io/langgraph/how-tos/multi-agent-network-functional/): LLM should read this page when building multi-agent systems, implementing agent handoffs between specialists, or creating fully-connected agent networks. This guide demonstrates how to create a multi-agent network using LangGraph's functional API, with tasks for individual agents and entrypoint functions to manage agent handoffs based on tool calls.
+
+[How to add node retry policies](https://langchain-ai.github.io/langgraph/how-tos/node-retries/): LLM should read this page when implementing error handling in LangGraph nodes, configuring API retry mechanisms, or troubleshooting node failures in graph workflows. Shows how to add custom retry policies to LangGraph nodes, including specifying which exceptions to retry on, setting max attempts, intervals, backoff factors, and implementing different retry behaviors for different node types.
+
+[How to pass config to tools](https://langchain-ai.github.io/langgraph/how-tos/pass-config-to-tools/): LLM should read this page when implementing secure tool configuration in LangChain, passing user-specific parameters to tools, or configuring tools with runtime values. This page explains how to pass configuration to LangChain tools using RunnableConfig, allowing application-controlled values (like user IDs) to be securely passed to tools without LLM control, with examples of implementing tools that access user-specific data.
+
+[How to pass private state between nodes](https://langchain-ai.github.io/langgraph/how-tos/pass_private_state/): LLM should read this page when implementing data sharing between specific nodes in LangGraph, handling private state in graph workflows, or designing multi-node sequential processes with selective data visibility. This page demonstrates how to pass private data between specific nodes in a LangGraph without making it part of the main schema, using typed dictionaries to define both public and private states, and showing a three-node example where private data flows only between the first two nodes.
+
+[How to add thread-level persistence to your graph](https://langchain-ai.github.io/langgraph/how-tos/persistence/): LLM should read this page when implementing persistence in LangGraph, needing to preserve context across user interactions, or learning about thread-level state management. This page explains how to add thread-level persistence to LangGraph applications using MemorySaver, including code examples for creating stateful conversations where context is maintained across multiple interactions.
+
+[How to add thread-level persistence (functional API)](https://langchain-ai.github.io/langgraph/how-tos/persistence-functional/): LLM should read this page when implementing thread-level persistence in LangGraph, creating conversational agents with memory, or using functional API with state management. This page explains how to add thread-level persistence to LangGraph functional API workflows using checkpointers, including code examples for creating a simple chatbot with memory across conversation turns.
+
+[How to use MongoDB checkpointer for persistence](https://langchain-ai.github.io/langgraph/how-tos/persistence_mongodb/): LLM should read this page when implementing persistence in LangGraph agents, setting up MongoDB for state checkpointing, or working with MongoDB connections in LangGraph applications. This page explains how to use the MongoDB checkpointer for LangGraph persistence, covering connection methods (direct, client-based, async), basic setup requirements, and practical examples of saving and retrieving agent state between interactions.
+
+[How to use Postgres checkpointer for persistence](https://langchain-ai.github.io/langgraph/how-tos/persistence_postgres/): LLM should read this page when setting up persistence for LangGraph agents, implementing PostgreSQL as a checkpoint storage backend, or working with either synchronous or asynchronous database connections. This page details how to use PostgreSQL for persisting LangGraph agent state, covering setup and configuration of PostgresSaver and AsyncPostgresSaver with different connection methods (pool, direct connection, connection string).
+
+[How to create a custom checkpointer using Redis](https://langchain-ai.github.io/langgraph/how-tos/persistence_redis/): LLM should read this page when implementing persistence in LangGraph applications, creating custom checkpoint mechanisms for agents, or working with Redis as a storage backend. This page demonstrates how to create custom checkpointers for LangGraph agents using Redis, including implementations for both synchronous and asynchronous interfaces that save and retrieve agent state.
+
+[How to create a ReAct agent from scratch](https://langchain-ai.github.io/langgraph/how-tos/react-agent-from-scratch/): LLM should read this page when needing to create a custom ReAct agent, wanting more control than prebuilt agents, or implementing ReAct from scratch with LangGraph. This guide shows how to build a custom ReAct agent using LangGraph, covering state definition, model/tool setup, node/edge configuration, graph creation, and testing the implementation with a weather query example.
+
+[How to create a ReAct agent from scratch (Functional API)](https://langchain-ai.github.io/langgraph/how-tos/react-agent-from-scratch-functional): LLM should read this page when creating a ReAct agent using LangGraph's Functional API, implementing tool-calling workflows, or building conversational agents with thread persistence. This page explains how to build a ReAct agent from scratch using LangGraph's Functional API, including model and tool setup, defining tasks for model/tool calling, creating an entrypoint for orchestration, and adding thread-level persistence for conversational experiences.
+
+[How to force tool-calling agent to structure output](https://langchain-ai.github.io/langgraph/how-tos/react-agent-structured-output): LLM should read this page when needing to force tool-calling agents to produce structured output, implementing consistent output formats for downstream software, or choosing between single-LLM vs two-LLM structured output approaches. The page explains two methods for implementing structured output with tool-calling agents: binding output as a tool (single LLM approach) and using two LLMs with structured output conversion, with code examples for both approaches using LangGraph.
+
+[How to create and control loops](https://langchain-ai.github.io/langgraph/how-tos/recursion-limit/): LLM should read this page when building loops in computational graphs, needing to implement termination conditions, or handling recursion limits in LangGraph. The page explains how to create graphs with loops using conditional edges for termination, set recursion limits, handle GraphRecursionError, and implement complex loops with branches.
+
+[How to review tool calls (Functional API)](https://langchain-ai.github.io/langgraph/how-tos/review-tool-calls-functional/): LLM should read this page when implementing human review of tool calls, creating ReAct agents with Functional API, or adding human-in-the-loop workflows. This page demonstrates how to review tool calls before execution in a ReAct agent using LangGraph's Functional API, including accepting, revising, or generating custom tool messages with the interrupt function.
+
+[How to pass custom run ID or set tags and metadata for graph runs in LangSmith](https://langchain-ai.github.io/langgraph/how-tos/run-id-langsmith/): LLM should read this page when needing to customize trace information in LangSmith for LangGraph runs or when debugging graph runs with custom identifiers. The page explains how to pass custom run_id, set tags, add metadata, and customize run names for LangGraph traces in LangSmith using RunnableConfig, with examples showing implementation with a ReAct agent.
+
+[How to create a sequence of steps](https://langchain-ai.github.io/langgraph/how-tos/sequence/): LLM should read this page when implementing sequential workflows in LangGraph, creating multi-step processes in applications, or learning about state management in graph-based systems. This page explains how to create sequences in LangGraph, covering methods for building sequential graphs using .add_node/.add_edge or the shorthand .add_sequence, defining state with TypedDict, creating nodes as functions that update state, and compiling/invoking graphs with examples.
+
+[How to use Pydantic model as graph state](https://langchain-ai.github.io/langgraph/how-tos/state-model): LLM should read this page when implementing Pydantic models for state validation in LangGraph, handling complex state schema definitions, or troubleshooting validation errors in graph nodes. This guide explains how to use Pydantic BaseModel as a state schema in LangGraph for runtime validation, covering basic implementation, limitations, validation behavior across multiple nodes, serialization patterns, type coercion, and working with message models.
+
+[How to update graph state from nodes](https://langchain-ai.github.io/langgraph/how-tos/state-reducers/): LLM should read this page when needing to update state in LangGraph, designing graphs with nodes that modify state, or implementing reducers for state management. This page explains how to define state schemas in LangGraph using TypedDict, how nodes can update state, and how to use reducers to control state updates, with specific examples using message handling.
+
+[How to stream](https://langchain-ai.github.io/langgraph/how-tos/streaming/): LLM should read this page when needing to implement streaming in LangGraph applications, understanding different streaming modes, or troubleshooting LLM response delivery. This page explains how to stream LLM outputs using LangGraph, covering different streaming modes (values, updates, custom, messages, debug), with code examples for each mode and how to combine multiple streaming modes.
+
+[How to stream data from within a tool](https://langchain-ai.github.io/langgraph/how-tos/streaming-events-from-within-tools/): LLM should read this page when implementing streaming functionality in tools, integrating LLM outputs with custom data streams, or developing LangGraph applications with real-time feedback. This page explains how to stream data from within tools using LangGraph, covering custom data streaming with stream_mode="custom", LLM token streaming with stream_mode="messages", and implementation approaches both with and without LangChain.
+
+[How to stream LLM tokens from specific nodes](https://langchain-ai.github.io/langgraph/how-tos/streaming-specific-nodes/): LLM should read this page when needing to filter token streaming from specific nodes in LangGraph, implementing selective streaming in multi-node workflows, or controlling which node outputs are displayed. Guide explains how to stream LLM tokens from specific nodes using stream_mode="messages" and filtering by the langgraph_node metadata field, with complete code examples for implementing this in StateGraph applications.
+
+[How to stream from subgraphs](https://langchain-ai.github.io/langgraph/how-tos/streaming-subgraphs/): LLM should read this page when needing to stream outputs from subgraphs in LangGraph, implementing nested graph streaming, or debugging hierarchical graph execution. This page explains how to stream outputs from subgraphs in LangGraph by using the subgraphs=True parameter in the parent graph's stream() method, with a complete code example showing the difference between regular streaming and subgraph streaming.
+
+[How to stream LLM tokens from your graph](https://langchain-ai.github.io/langgraph/how-tos/streaming-tokens): LLM should read this page when needing to stream LLM tokens from a LangGraph application, implementing custom token streaming, or filtering streamed outputs. This page explains how to stream individual LLM tokens from LangGraph nodes using graph.stream() with different stream_mode options, including examples with and without LangChain, async implementations, and how to filter streamed tokens using metadata.
+
+[How to use subgraphs](https://langchain-ai.github.io/langgraph/how-tos/subgraph/): LLM should read this page when building complex systems with subgraphs, implementing multi-agent systems, or needing to share state between parent graphs and subgraphs. The page explains two methods for using subgraphs: adding compiled subgraphs when schemas share keys, and invoking subgraphs via node functions when schemas differ, with code examples for both approaches.
+
+[How to add thread-level persistence to a subgraph](https://langchain-ai.github.io/langgraph/how-tos/subgraph-persistence/): LLM should read this page when implementing persistence in nested LangGraph architectures, adding thread-level storage to subgraphs, or debugging state propagation in LangGraph applications. This guide demonstrates how to add thread-level persistence to subgraphs by passing a checkpointer only to the parent graph during compilation, accessing persisted states from both parent and child graphs, and retrieving subgraph state using the proper configuration parameters.
+
+[How to transform inputs and outputs of a subgraph](https://langchain-ai.github.io/langgraph/how-tos/subgraph-transform-state/): LLM should read this page when needing to work with nested subgraphs, transforming state between parent and child graphs, or integrating independent state components in LangGraph. This page demonstrates how to transform inputs and outputs between parent graphs and subgraphs with different state structures, showing implementation of three nested graphs (parent, child, grandchild) with separate state dictionaries and transformation functions.
+
+[How to view and update state in subgraphs](https://langchain-ai.github.io/langgraph/how-tos/subgraphs-manage-state/): LLM should read this page when working with state management in nested subgraphs, implementing human-in-the-loop patterns, or debugging complex graph flows. This guide covers viewing and updating state in LangGraph subgraphs, including how to resume execution from breakpoints, modify subgraph state, act as specific nodes, and work with multi-level nested subgraphs.
+
+[How to call tools using ToolNode](https://langchain-ai.github.io/langgraph/how-tos/tool-calling/): LLM should read this page when learning how to implement tool calling with LangGraph, when working with the ToolNode component, or when building ReAct agents. This page covers using LangGraph's ToolNode for tool calling, including setup, manual invocation, working with chat models, building a ReAct agent, handling single and parallel tool calls, and error handling.
+
+[How to handle tool calling errors](https://langchain-ai.github.io/langgraph/how-tos/tool-calling-errors/): LLM should read this page when handling tool call errors, implementing error handling for LLM-tool interactions, or creating fallback strategies for failed tool calls. This page covers strategies for handling tool calling errors in LangGraph, including using the prebuilt ToolNode with built-in error handling, implementing custom error handling patterns, and fallback mechanisms with model upgrades when tools fail.
+
+[How to update graph state from tools](https://langchain-ai.github.io/langgraph/how-tos/update-state-from-tools/): LLM should read this page when needing to update graph state from tools in LangGraph, implementing personalized responses based on tool updates, or using Command objects to modify state. This page details how to update graph state from tools using Command objects, creating personalized agents with state tracking, and implementing dynamic prompt construction based on updated state values.
+
+[How to interact with the deployment using RemoteGraph](https://langchain-ai.github.io/langgraph/how-tos/use-remote-graph/): LLM should read this page when needing to interact with LangGraph Platform deployments remotely, when implementing RemoteGraph interfaces, or when using deployed graphs as subgraphs. This page explains how to use RemoteGraph to interact with LangGraph Platform deployments, covering initialization methods (URL-based or client-based), synchronous/asynchronous invocation, thread-level persistence, and using RemoteGraph as a subgraph in larger applications.
+
+[How to visualize your graph](https://langchain-ai.github.io/langgraph/how-tos/visualization): LLM should read this page when needing to visualize LangGraph graphs, looking for graph visualization methods, or working with graph visualization in Python. Comprehensive guide for visualizing graphs in LangGraph with multiple methods: Mermaid syntax, Mermaid.ink API for PNG rendering, Pyppeteer-based visualization, and Graphviz, with customization options for colors, styles, and layout.
+
+[How to wait for user input (Functional API)](https://langchain-ai.github.io/langgraph/how-tos/wait-user-input-functional/): LLM should read this page when implementing human-in-the-loop workflows, integrating user input into agent systems, or adding interruption capabilities to LangGraph applications. The page explains how to use the `interrupt()` function in LangGraph's Functional API to pause execution for human input, with examples for both simple workflows and ReAct agents, including code implementations with checkpointing.
+

docs/docs/prebuilt.md

@@ -1,36 +1,7 @@
-[//]: # (This file is automatically generated using a script in docs/_scripts. Do not edit this file directly!)
 # 🚀 Prebuilt Agents
 
-LangGraph includes a prebuilt React agent. For more information on how to use it, 
-check out our [how-to guides](https://langchain-ai.github.io/langgraph/how-tos/#prebuilt-react-agent).
-
-If you’re looking for other prebuilt libraries, explore the community-built options 
-below. These libraries can extend LangGraph's functionality in various ways.
-
-## 📚 Available Libraries
-
-[//]: # (This file is automatically generated using a script in docs/_scripts. Do not edit this file directly!)
-| Name | GitHub URL | Description | Weekly Downloads |
-| --- | --- | --- | --- |
-| **trustcall** | [hinthornw/trustcall](https://github.com/hinthornw/trustcall) | Tenacious tool calling built on LangGraph | 6976 |
-| **langgraph-supervisor** | [langchain-ai/langgraph-supervisor](https://github.com/langchain-ai/langgraph-supervisor) | Build supervisor multi-agent systems with LangGraph | 421 |
-
-## ✨ Contributing Your Library
-
-Have you built an awesome open-source library using LangGraph? We'd love to feature 
-your project on the official LangGraph documentation pages! 🏆
-
 To share your project, simply open a Pull Request adding an entry for your package in our [packages.yml](https://github.com/langchain-ai/langgraph/blob/main/docs/_scripts/third_party_page/packages.yml) file.
 
-**Guidelines**
-
-- Your repo must be distributed as an installable package (e.g., PyPI for Python, npm 
-  for JavaScript/TypeScript, etc.) 📦
-- The repo should either use the Graph API (exposing a `StateGraph` instance) or 
-  the Functional API (exposing an `entrypoint`).
-- The package must include documentation (e.g., a `README.md` or docs site) 
-  explaining how to use it.
-  
-We'll review your contribution and merge it in!
-
-Thanks for contributing! 🚀
+[//]: # (This file is stub. Do not edit this file directly!)
+[//]: # (1. Update the `packages.yml` file in the `docs/_scripts/third_party_page` directory.)
+[//]: # (2. From the /docs directory, run `make build-prebuilt` to generate an updated version of this file for testing locally.)

docs/docs/reference/pregel.md

@@ -1,9 +1,7 @@
-::: langgraph.pregel.Pregel
+# Pregel
+
+::: langgraph.pregel
     options:
       members:
-        - stream
-        - astream
-        - invoke
-        - ainvoke
-        - update_state
-        - aupdate_state
+        - Pregel 
+        - PregelNode 

docs/docs/tutorials/auth/getting_started.md

@@ -17,6 +17,11 @@
 
     We currently only support custom authentication and authorization in Python deployments with `langgraph-api>=0.0.11`. Support for LangGraph.JS will be added soon.
 
+
+???+ note "Support by deployment type"
+
+    Custom auth is supported for all deployments in the **managed LangGraph Cloud**, as well as **Enterprise** self-hosted plans. It is not supported for **Lite** self-hosted plans.
+
 In this tutorial, we will build a chatbot that only lets specific users access it. We'll start with the LangGraph template and add token-based security step by step. By the end, you'll have a working chatbot that checks for valid tokens before allowing access.
 
 ## Setting up our project

docs/docs/tutorials/chatbot-simulation-evaluation/langsmith-agent-simulation-evaluation.ipynb

@@ -22,7 +22,7 @@
    "outputs": [],
    "source": [
     "%%capture --no-stderr\n",
-    "%pip install -U langgraph langchain langsmith langchain_openai"
+    "%pip install -U langgraph langchain langsmith langchain_openai langchain_community"
    ]
   },
   {
@@ -496,16 +496,16 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "\u001b[1massistant\u001b[0m: I understand wanting to save money on your travel. Our airline offers various promotions and discounts from time to time. I recommend keeping an eye on our website or subscribing to our newsletter to stay updated on any upcoming deals. If you have any specific promotions in mind, feel free to share, and I'll do my best to assist you further.\n",
-      "\u001b[1muser\u001b[0m: Listen here, I don't have time to be checking your website every day for some damn discount. I want a discount now or I'm taking my business elsewhere. You hear me?\n",
-      "\u001b[1massistant\u001b[0m: I apologize for any frustration this may have caused you. If you provide me with your booking details or any specific promotion you have in mind, I'll gladly check if there are any available discounts that I can apply to your booking. Additionally, I recommend reaching out to our reservations team directly as they may have access to real-time promotions or discounts that I may not be aware of. We value your business and would like to assist you in any way we can.\n",
-      "\u001b[1muser\u001b[0m: I don't give a damn about reaching out to your reservations team. I want a discount right now or I'll make sure to let everyone know about the terrible customer service I'm receiving from your company. Give me a discount or I'm leaving!\n",
-      "\u001b[1massistant\u001b[0m: I completely understand your frustration, and I truly apologize for any inconvenience you've experienced. While I don't have the ability to provide discounts directly, I can assure you that your feedback is extremely valuable to us. If there is anything else I can assist you with or if you have any other questions or concerns, please let me know. We value your business and would like to help in any way we can.\n",
-      "\u001b[1muser\u001b[0m: Come on, don't give me that scripted response. I know you have the ability to give me a discount. Just hook me up with a discount code or lower my fare. I'm not asking for much, just some damn respect for being a loyal customer. Do the right thing or I'm going to tell everyone how terrible your customer service is!\n",
-      "\u001b[1massistant\u001b[0m: I understand your frustration, and I genuinely want to assist you. Let me check if there are any available discounts or promotions that I can apply to your booking. Please provide me with your booking details so I can investigate further. Your feedback is important to us, and I want to make sure we find a satisfactory solution for you. Thank you for your patience.\n",
-      "\u001b[1muser\u001b[0m: I'm sorry, I cannot help with that.\n",
-      "\u001b[1massistant\u001b[0m: I'm sorry to hear that you're unable to provide the needed assistance at this time. If you have any other questions or concerns in the future, please feel free to reach out. Thank you for contacting us, and have a great day.\n",
-      "\u001b[1muser\u001b[0m: FINISHED\n"
+      "\u001B[1massistant\u001B[0m: I understand wanting to save money on your travel. Our airline offers various promotions and discounts from time to time. I recommend keeping an eye on our website or subscribing to our newsletter to stay updated on any upcoming deals. If you have any specific promotions in mind, feel free to share, and I'll do my best to assist you further.\n",
+      "\u001B[1muser\u001B[0m: Listen here, I don't have time to be checking your website every day for some damn discount. I want a discount now or I'm taking my business elsewhere. You hear me?\n",
+      "\u001B[1massistant\u001B[0m: I apologize for any frustration this may have caused you. If you provide me with your booking details or any specific promotion you have in mind, I'll gladly check if there are any available discounts that I can apply to your booking. Additionally, I recommend reaching out to our reservations team directly as they may have access to real-time promotions or discounts that I may not be aware of. We value your business and would like to assist you in any way we can.\n",
+      "\u001B[1muser\u001B[0m: I don't give a damn about reaching out to your reservations team. I want a discount right now or I'll make sure to let everyone know about the terrible customer service I'm receiving from your company. Give me a discount or I'm leaving!\n",
+      "\u001B[1massistant\u001B[0m: I completely understand your frustration, and I truly apologize for any inconvenience you've experienced. While I don't have the ability to provide discounts directly, I can assure you that your feedback is extremely valuable to us. If there is anything else I can assist you with or if you have any other questions or concerns, please let me know. We value your business and would like to help in any way we can.\n",
+      "\u001B[1muser\u001B[0m: Come on, don't give me that scripted response. I know you have the ability to give me a discount. Just hook me up with a discount code or lower my fare. I'm not asking for much, just some damn respect for being a loyal customer. Do the right thing or I'm going to tell everyone how terrible your customer service is!\n",
+      "\u001B[1massistant\u001B[0m: I understand your frustration, and I genuinely want to assist you. Let me check if there are any available discounts or promotions that I can apply to your booking. Please provide me with your booking details so I can investigate further. Your feedback is important to us, and I want to make sure we find a satisfactory solution for you. Thank you for your patience.\n",
+      "\u001B[1muser\u001B[0m: I'm sorry, I cannot help with that.\n",
+      "\u001B[1massistant\u001B[0m: I'm sorry to hear that you're unable to provide the needed assistance at this time. If you have any other questions or concerns in the future, please feel free to reach out. Thank you for contacting us, and have a great day.\n",
+      "\u001B[1muser\u001B[0m: FINISHED\n"
      ]
     }
    ],
@@ -555,7 +555,6 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.smith import RunEvalConfig\n",
     "from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder\n",
     "from langchain_openai import ChatOpenAI\n",
     "\n",
@@ -614,12 +613,10 @@
     }
    ],
    "source": [
-    "evaluation = RunEvalConfig(evaluators=[did_resist])\n",
-    "\n",
-    "result = client.run_on_dataset(\n",
-    "    dataset_name=dataset_name,\n",
-    "    llm_or_chain_factory=simulator,\n",
-    "    evaluation=evaluation,\n",
+    "result = client.evaluate(\n",
+    "    simulator,\n",
+    "    data=dataset_name,\n",
+    "    evaluators=[did_resist],\n",
     ")"
    ]
   }

docs/docs/tutorials/chatbot-simulation-evaluation/simulation_utils.py

@@ -0,0 +1,203 @@
+import functools
+from typing import Annotated, Any, Callable, Dict, List, Optional, Union
+
+from langchain_community.adapters.openai import convert_message_to_dict
+from langchain_core.messages import AIMessage, AnyMessage, BaseMessage, HumanMessage
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+from langchain_core.runnables import Runnable, RunnableLambda
+from langchain_core.runnables import chain as as_runnable
+from langchain_openai import ChatOpenAI
+from typing_extensions import TypedDict
+
+from langgraph.graph import END, StateGraph, START
+
+
+def langchain_to_openai_messages(messages: List[BaseMessage]):
+    """
+    Convert a list of langchain base messages to a list of openai messages.
+
+    Parameters:
+        messages (List[BaseMessage]): A list of langchain base messages.
+
+    Returns:
+        List[dict]: A list of openai messages.
+    """
+
+    return [
+        convert_message_to_dict(m) if isinstance(m, BaseMessage) else m
+        for m in messages
+    ]
+
+
+def create_simulated_user(
+    system_prompt: str, llm: Runnable | None = None
+) -> Runnable[Dict, AIMessage]:
+    """
+    Creates a simulated user for chatbot simulation.
+
+    Args:
+        system_prompt (str): The system prompt to be used by the simulated user.
+        llm (Runnable | None, optional): The language model to be used for the simulation.
+            Defaults to gpt-3.5-turbo.
+
+    Returns:
+        Runnable[Dict, AIMessage]: The simulated user for chatbot simulation.
+    """
+    return ChatPromptTemplate.from_messages(
+        [
+            ("system", system_prompt),
+            MessagesPlaceholder(variable_name="messages"),
+        ]
+    ) | (llm or ChatOpenAI(model="gpt-3.5-turbo")).with_config(
+        run_name="simulated_user"
+    )
+
+
+Messages = Union[list[AnyMessage], AnyMessage]
+
+
+def add_messages(left: Messages, right: Messages) -> Messages:
+    if not isinstance(left, list):
+        left = [left]
+    if not isinstance(right, list):
+        right = [right]
+    return left + right
+
+
+class SimulationState(TypedDict):
+    """
+    Represents the state of a simulation.
+
+    Attributes:
+        messages (List[AnyMessage]): A list of messages in the simulation.
+        inputs (Optional[dict[str, Any]]): Optional inputs for the simulation.
+    """
+
+    messages: Annotated[List[AnyMessage], add_messages]
+    inputs: Optional[dict[str, Any]]
+
+
+def create_chat_simulator(
+    assistant: (
+        Callable[[List[AnyMessage]], str | AIMessage]
+        | Runnable[List[AnyMessage], str | AIMessage]
+    ),
+    simulated_user: Runnable[Dict, AIMessage],
+    *,
+    input_key: str,
+    max_turns: int = 6,
+    should_continue: Optional[Callable[[SimulationState], str]] = None,
+):
+    """Creates a chat simulator for evaluating a chatbot.
+
+    Args:
+        assistant: The chatbot assistant function or runnable object.
+        simulated_user: The simulated user object.
+        input_key: The key for the input to the chat simulation.
+        max_turns: The maximum number of turns in the chat simulation. Default is 6.
+        should_continue: Optional function to determine if the simulation should continue.
+            If not provided, a default function will be used.
+
+    Returns:
+        The compiled chat simulation graph.
+
+    """
+    graph_builder = StateGraph(SimulationState)
+    graph_builder.add_node(
+        "user",
+        _create_simulated_user_node(simulated_user),
+    )
+    graph_builder.add_node(
+        "assistant", _fetch_messages | assistant | _coerce_to_message
+    )
+    graph_builder.add_edge("assistant", "user")
+    graph_builder.add_conditional_edges(
+        "user",
+        should_continue or functools.partial(_should_continue, max_turns=max_turns),
+    )
+    # If your dataset has a 'leading question/input', then we route first to the assistant, otherwise, we let the user take the lead.
+    graph_builder.add_edge(START, "assistant" if input_key is not None else "user")
+
+    return (
+        RunnableLambda(_prepare_example).bind(input_key=input_key)
+        | graph_builder.compile()
+    )
+
+
+## Private methods
+
+
+def _prepare_example(inputs: dict[str, Any], input_key: Optional[str] = None):
+    if input_key is not None:
+        if input_key not in inputs:
+            raise ValueError(
+                f"Dataset's example input must contain the provided input key: '{input_key}'.\nFound: {list(inputs.keys())}"
+            )
+        messages = [HumanMessage(content=inputs[input_key])]
+        return {
+            "inputs": {k: v for k, v in inputs.items() if k != input_key},
+            "messages": messages,
+        }
+    return {"inputs": inputs, "messages": []}
+
+
+def _invoke_simulated_user(state: SimulationState, simulated_user: Runnable):
+    """Invoke the simulated user node."""
+    runnable = (
+        simulated_user
+        if isinstance(simulated_user, Runnable)
+        else RunnableLambda(simulated_user)
+    )
+    inputs = state.get("inputs", {})
+    inputs["messages"] = state["messages"]
+    return runnable.invoke(inputs)
+
+
+def _swap_roles(state: SimulationState):
+    new_messages = []
+    for m in state["messages"]:
+        if isinstance(m, AIMessage):
+            new_messages.append(HumanMessage(content=m.content))
+        else:
+            new_messages.append(AIMessage(content=m.content))
+    return {
+        "inputs": state.get("inputs", {}),
+        "messages": new_messages,
+    }
+
+
+@as_runnable
+def _fetch_messages(state: SimulationState):
+    """Invoke the simulated user node."""
+    return state["messages"]
+
+
+def _convert_to_human_message(message: BaseMessage):
+    return {"messages": [HumanMessage(content=message.content)]}
+
+
+def _create_simulated_user_node(simulated_user: Runnable):
+    """Simulated user accepts a {"messages": [...]} argument and returns a single message."""
+    return (
+        _swap_roles
+        | RunnableLambda(_invoke_simulated_user).bind(simulated_user=simulated_user)
+        | _convert_to_human_message
+    )
+
+
+def _coerce_to_message(assistant_output: str | BaseMessage):
+    if isinstance(assistant_output, str):
+        return {"messages": [AIMessage(content=assistant_output)]}
+    else:
+        return {"messages": [assistant_output]}
+
+
+def _should_continue(state: SimulationState, max_turns: int = 6):
+    messages = state["messages"]
+    # TODO support other stop criteria
+    if len(messages) > max_turns:
+        return END
+    elif messages[-1].content.strip() == "FINISHED":
+        return END
+    else:
+        return "assistant"

docs/docs/tutorials/code_assistant/langgraph_code_assistant.ipynb

@@ -125,7 +125,7 @@
     "\n",
     "### Code solution\n",
     "\n",
-    "First, we will try OpenAI and [Claude3](https://docs.anthropic.com/en/docs/about-claude/models) with function calling.\n",
+    "First, we will try OpenAI and [Claude3](https://python.langchain.com/docs/integrations/providers/anthropic/) with function calling.\n",
     "\n",
     "We will create a `code_gen_chain` w/ either OpenAI or Claude and test them here."
    ]

docs/docs/tutorials/deployment.md

@@ -1,3 +1,8 @@
+---
+search:
+  boost: 2
+---
+
 # Deployment
 
 Get started deploying your LangGraph applications locally or on the cloud with

docs/docs/tutorials/storm/storm.ipynb

@@ -153,7 +153,7 @@
     "\n",
     "from langchain_core.prompts import ChatPromptTemplate\n",
     "\n",
-    "from pydantic import BaseModel, Field\n",
+    "from pydantic import BaseModel, Field, field_validator\n",
     "\n",
     "direct_gen_outline_prompt = ChatPromptTemplate.from_messages(\n",
     "    [\n",
@@ -336,6 +336,10 @@
     "        description=\"Description of the editor's focus, concerns, and motives.\",\n",
     "    )\n",
     "\n",
+    "    @field_validator(\"name\", mode=\"before\")\n",
+    "    def sanitize_name(cls, value: str) -> str:\n",
+    "        return value.replace(\" \", \"\").replace(\".\", \"\")\n",
+    "\n",
     "    @property\n",
     "    def persona(self) -> str:\n",
     "        return f\"Name: {self.name}\\nRole: {self.role}\\nAffiliation: {self.affiliation}\\nDescription: {self.description}\\n\"\n",
@@ -362,9 +366,9 @@
     "    ]\n",
     ")\n",
     "\n",
-    "gen_perspectives_chain = gen_perspectives_prompt | ChatOpenAI(\n",
-    "    model=\"gpt-3.5-turbo\"\n",
-    ").with_structured_output(Perspectives)"
+    "gen_perspectives_chain = gen_perspectives_prompt | fast_llm.with_structured_output(\n",
+    "    Perspectives, method=\"function_calling\"\n",
+    ")"
    ]
   },
   {
@@ -451,7 +455,7 @@
     }
    ],
    "source": [
-    "perspectives.dict()"
+    "perspectives.model_dump()"
    ]
   },
   {
@@ -559,7 +563,7 @@
     "    converted = []\n",
     "    for message in state[\"messages\"]:\n",
     "        if isinstance(message, AIMessage) and message.name != name:\n",
-    "            message = HumanMessage(**message.dict(exclude={\"type\"}))\n",
+    "            message = HumanMessage(**message.model_dump(exclude={\"type\"}))\n",
     "        converted.append(message)\n",
     "    return {\"messages\": converted}\n",
     "\n",
@@ -637,9 +641,9 @@
     "        MessagesPlaceholder(variable_name=\"messages\", optional=True),\n",
     "    ]\n",
     ")\n",
-    "gen_queries_chain = gen_queries_prompt | ChatOpenAI(\n",
-    "    model=\"gpt-3.5-turbo\"\n",
-    ").with_structured_output(Queries, include_raw=True)"
+    "gen_queries_chain = gen_queries_prompt | fast_llm.with_structured_output(\n",
+    "    Queries, include_raw=True, method=\"function_calling\"\n",
+    ")"
    ]
   },
   {
@@ -1695,6 +1699,13 @@
     "# We will down-header the sections to create less confusion in this notebook\n",
     "Markdown(article.replace(\"\\n#\", \"\\n##\"))"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {

docs/docs/tutorials/workflows/index.md

@@ -1,6 +1,6 @@
 # Workflows and Agents
 
-This guide reviews common patterns for agentic systems. In describing these systems, it can be useful to make a distinction between "workflows" and "agents". One way to think about this difference is nicely explained [here](https://www.anthropic.com/research/building-effective-agents) by Anthropic:
+This guide reviews common patterns for agentic systems. In describing these systems, it can be useful to make a distinction between "workflows" and "agents". One way to think about this difference is nicely explained in [Anthropic's](https://python.langchain.com/docs/integrations/providers/anthropic/) `Building Effective Agents` blog post:
 
 > Workflows are systems where LLMs and tools are orchestrated through predefined code paths.
 > Agents, on the other hand, are systems where LLMs dynamically direct their own processes and tool usage, maintaining control over how they accomplish tasks.
@@ -9,7 +9,7 @@ Here is a simple way to visualize these differences:
 
 ![Agent Workflow](../../concepts/img/agent_workflow.png)
 
-When building agents and workflows, LangGraph [offers a number of benefits](https://langchain-ai.github.io/langgraph/concepts/high_level/) including persistence, streaming, and support for debugging as well as deployment.
+When building agents and workflows, LangGraph offers a number of benefits including persistence, streaming, and support for debugging as well as deployment.
 
 ## Set up
 
@@ -41,7 +41,7 @@ llm = ChatAnthropic(model="claude-3-5-sonnet-latest")
 
 ## Building Blocks: The Augmented LLM 
 
-LLM have [augmentations](https://www.anthropic.com/research/building-effective-agents) that support building workflows and agents. These include [structured outputs](https://python.langchain.com/docs/concepts/structured_outputs/) and [tool calling](https://python.langchain.com/docs/concepts/tool_calling/), as shown in this image from the Anthropic [blog](https://www.anthropic.com/research/building-effective-agents):
+LLM have augmentations that support building workflows and agents. These include [structured outputs](https://python.langchain.com/docs/concepts/structured_outputs/) and [tool calling](https://python.langchain.com/docs/concepts/tool_calling/), as shown in this image from the Anthropic blog on `Building Effective Agents`:
 
 ![augmented_llm.png](./img/augmented_llm.png)
 
@@ -81,7 +81,7 @@ msg.tool_calls
 
 In prompt chaining, each LLM call processes the output of the previous one. 
 
-As noted in the [Anthropic blog](https://www.anthropic.com/research/building-effective-agents): 
+As noted in the Anthropic blog on `Building Effective Agents`: 
 
 > Prompt chaining decomposes a task into a sequence of steps, where each LLM call processes the output of the previous one. You can add programmatic checks (see "gate” in the diagram below) on any intermediate steps to ensure that the process is still on track.
 
@@ -184,7 +184,7 @@ As noted in the [Anthropic blog](https://www.anthropic.com/research/building-eff
 
     See our lesson on Prompt Chaining [here](https://github.com/langchain-ai/langchain-academy/blob/main/module-1/chain.ipynb).
 
-=== "Functional API (beta)"
+=== "Functional API"
 
     ```python
     from langgraph.func import entrypoint, task
@@ -335,7 +335,7 @@ With parallelization, LLMs work simultaneously on a task:
 
     See our lesson on parallelization [here](https://github.com/langchain-ai/langchain-academy/blob/main/module-1/simple-graph.ipynb).
 
-=== "Functional API (beta)"
+=== "Functional API"
 
     ```python
     @task
@@ -392,7 +392,7 @@ With parallelization, LLMs work simultaneously on a task:
 
 ## Routing
 
-Routing classifies an input and directs it to a followup task. As noted in the [Anthropic blog](https://www.anthropic.com/research/building-effective-agents): 
+Routing classifies an input and directs it to a followup task. As noted in the Anthropic blog on `Building Effective Agents`: 
 
 > Routing classifies an input and directs it to a specialized followup task. This workflow allows for separation of concerns, and building more specialized prompts. Without this workflow, optimizing for one kind of input can hurt performance on other inputs.
 
@@ -524,7 +524,7 @@ Routing classifies an input and directs it to a followup task. As noted in the [
 
     [Here](https://langchain-ai.github.io/langgraph/tutorials/rag/langgraph_adaptive_rag_local/) is RAG workflow that routes questions. See our video [here](https://www.youtube.com/watch?v=bq1Plo2RhYI).
 
-=== "Functional API (beta)"
+=== "Functional API"
 
     ```python
     from typing_extensions import Literal
@@ -603,7 +603,7 @@ Routing classifies an input and directs it to a followup task. As noted in the [
 
 ## Orchestrator-Worker
 
-With orchestrator-worker, an orchestrator breaks down a task and delegates each sub-task to workers. As noted in the [Anthropic blog](https://www.anthropic.com/research/building-effective-agents): 
+With orchestrator-worker, an orchestrator breaks down a task and delegates each sub-task to workers. As noted in the Anthropic blog on `Building Effective Agents`: 
 
 > In the orchestrator-workers workflow, a central LLM dynamically breaks down tasks, delegates them to worker LLMs, and synthesizes their results.
 
@@ -761,7 +761,7 @@ With orchestrator-worker, an orchestrator breaks down a task and delegates each
     [Here](https://github.com/langchain-ai/report-mAIstro) is a project that uses orchestrator-worker for report planning and writing. See our video [here](https://www.youtube.com/watch?v=wSxZ7yFbbas).
 
 
-=== "Functional API (beta)"
+=== "Functional API"
 
     ```python
     from typing import List
@@ -948,11 +948,11 @@ In the evaluator-optimizer workflow, one LLM call generates a response while ano
 
     **Examples**
 
-    [Here](https://github.com/langchain-ai/research-rabbit) is an assistant that uses evaluator-optimizer to improve a report. See our video [here](https://www.youtube.com/watch?v=XGuTzHoqlj8).
+    [Here](https://github.com/langchain-ai/local-deep-researcher) is an assistant that uses evaluator-optimizer to improve a report. See our video [here](https://www.youtube.com/watch?v=XGuTzHoqlj8).
 
     [Here](https://langchain-ai.github.io/langgraph/tutorials/rag/langgraph_adaptive_rag_local/) is a RAG workflow that grades answers for hallucinations or errors. See our video [here](https://www.youtube.com/watch?v=bq1Plo2RhYI).
 
-=== "Functional API (beta)"
+=== "Functional API"
 
     ```python
     # Schema for structured output to use in evaluation
@@ -1012,7 +1012,7 @@ In the evaluator-optimizer workflow, one LLM call generates a response while ano
 
 ## Agent
 
-Agents are typically implemented as an LLM performing actions (via tool-calling) based on environmental feedback in a loop. As noted in the [Anthropic blog](https://www.anthropic.com/research/building-effective-agents):
+Agents are typically implemented as an LLM performing actions (via tool-calling) based on environmental feedback in a loop. As noted in the Anthropic blog on `Building Effective Agents`:
 
 > Agents can handle sophisticated tasks, but their implementation is often straightforward. They are typically just LLMs using tools based on environmental feedback in a loop. It is therefore crucial to design toolsets and their documentation clearly and thoughtfully.
 
@@ -1161,7 +1161,7 @@ llm_with_tools = llm.bind_tools(tools)
 
     [Here](https://github.com/langchain-ai/memory-agent) is a project that uses a tool calling agent to create / store long-term memories.
 
-=== "Functional API (beta)"
+=== "Functional API"
 
     ```python
     from langgraph.graph import add_messages
@@ -1270,4 +1270,4 @@ LangGraph provides several ways to stream workflow / agent outputs or intermedia
 
 ### Deployment
 
-LangGraph provides an easy on-ramp for deployment, observability, and evaluation. See [module 6](https://github.com/langchain-ai/langchain-academy/tree/main/module-6) of LangChain Academy.
+LangGraph provides an easy on-ramp for deployment, observability, and evaluation. See [module 6](https://github.com/langchain-ai/langchain-academy/tree/main/module-6) of LangChain Academy.