checkpoint-postgres: release 2.0.9 (#2849)

This PR adds a "shallow" version of `PostgresSaver` checkpointer that
ONLY stores the most recent checkpoint and does NOT retain any history.
It is meant to be a light-weight drop-in replacement for the
PostgresSaver that supports most of the LangGraph persistence
functionality with the exception of time travel.

.github/workflows/_lint.yml

@@ -42,7 +42,6 @@ jobs:
         with:
           python-version: ${{ matrix.python-version }}
           poetry-version: ${{ env.POETRY_VERSION }}
-          working-directory: ${{ inputs.working-directory }}
           cache-key: lint-${{ inputs.working-directory }}
 
       - name: Check Poetry File

.github/workflows/_test.yml

@@ -31,7 +31,6 @@ jobs:
         with:
           python-version: ${{ matrix.python-version }}
           poetry-version: ${{ env.POETRY_VERSION }}
-          working-directory: ${{ inputs.working-directory }}
           cache-key: test-${{ inputs.working-directory }}
       - name: Login to Docker Hub
         uses: docker/login-action@v3

.github/workflows/_test_release.yml

@@ -29,7 +29,6 @@ jobs:
         with:
           python-version: ${{ env.PYTHON_VERSION }}
           poetry-version: ${{ env.POETRY_VERSION }}
-          working-directory: ${{ inputs.working-directory }}
           cache-key: release
 
       # We want to keep this build stage *separate* from the release stage,

.github/workflows/deploy_docs.yml

@@ -89,6 +89,8 @@ jobs:
               --check-links-ignore "https://x.com/.*" \
               --check-links-ignore "https://github\.com/.*" \
               --check-links-ignore "http://localhost:8123/.*" \
+              --check-links-ignore "http://localhost:2024.*" \
+              --check-links-ignore "http://127.0.0.1:.*" \
               --check-links-ignore "/.*\.(ipynb|html)$" \
               --check-links-ignore "https://python\.langchain\.com/.*" \
               --check-links-ignore "https://openai\.com/.*" \
@@ -106,6 +108,8 @@ jobs:
               poetry run pytest -v \
                 --check-links-ignore "https://(api|web|docs)\.smith\.langchain\.com/.*" \
                 --check-links-ignore "http://localhost:8123/.*" \
+                --check-links-ignore "http://localhost:2024.*" \
+                --check-links-ignore "http://127.0.0.1:.*" \
                 --check-links-ignore "https://x.com/.*" \
                 --check-links-ignore "https://github\.com/.*" \
                 --check-links-ignore "/.*\.(ipynb|html)$" \

.github/workflows/release.yml

@@ -31,7 +31,6 @@ jobs:
         with:
           python-version: ${{ env.PYTHON_VERSION }}
           poetry-version: ${{ env.POETRY_VERSION }}
-          working-directory: ${{ inputs.working-directory }}
           cache-key: release
 
       # We want to keep this build stage *separate* from the release stage,
@@ -169,7 +168,6 @@ jobs:
         with:
           python-version: ${{ env.PYTHON_VERSION }}
           poetry-version: ${{ env.POETRY_VERSION }}
-          working-directory: ${{ inputs.working-directory }}
 
       - name: Import published package
         shell: bash
@@ -256,7 +254,6 @@ jobs:
         with:
           python-version: ${{ env.PYTHON_VERSION }}
           poetry-version: ${{ env.POETRY_VERSION }}
-          working-directory: ${{ inputs.working-directory }}
           cache-key: release
 
       - uses: actions/download-artifact@v4
@@ -298,7 +295,6 @@ jobs:
         with:
           python-version: ${{ env.PYTHON_VERSION }}
           poetry-version: ${{ env.POETRY_VERSION }}
-          working-directory: ${{ inputs.working-directory }}
           cache-key: release
 
       - uses: actions/download-artifact@v4

Makefile

@@ -13,7 +13,7 @@ serve-clean-docs: clean-docs
 	poetry run python -m mkdocs serve -c -f docs/mkdocs.yml --strict -w ./libs/langgraph
 
 serve-docs: build-typedoc
-	poetry run python -m mkdocs serve -f docs/mkdocs.yml -w ./libs/langgraph  -w ./libs/checkpoint --dirty
+	poetry run python -m mkdocs serve -f docs/mkdocs.yml -w ./libs/langgraph  -w ./libs/checkpoint -w ./libs/sdk-py --dirty
 
 clean-docs:
 	find ./docs/docs -name "*.ipynb" -type f -delete

docs/_scripts/notebook_hooks.py

@@ -1,4 +1,5 @@
 import logging
+import os
 from typing import Any, Dict
 
 from mkdocs.structure.pages import Page
@@ -8,6 +9,7 @@ from notebook_convert import convert_notebook
 logger = logging.getLogger(__name__)
 logging.basicConfig()
 logger.setLevel(logging.INFO)
+DISABLED = os.getenv("DISABLE_NOTEBOOK_CONVERT") in ("1", "true", "True")
 
 
 class NotebookFile(File):
@@ -16,6 +18,8 @@ class NotebookFile(File):
 
 
 def on_files(files: Files, **kwargs: Dict[str, Any]):
+    if DISABLED:
+        return files
     new_files = Files([])
     for file in files:
         if file.src_path.endswith(".ipynb"):
@@ -32,6 +36,8 @@ def on_files(files: Files, **kwargs: Dict[str, Any]):
 
 
 def on_page_markdown(markdown: str, page: Page, **kwargs: Dict[str, Any]):
+    if DISABLED:
+        return markdown
     if page.file.src_path.endswith(".ipynb"):
         logger.info("Processing Jupyter notebook: %s", page.file.src_path)
         body = convert_notebook(page.file.abs_src_path)

docs/cassettes/agent-handoffs_62ba5113-e972-41e6-8392-cc970d4eea72.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/agent-handoffs_f39f99b0-95c7-422f-96a6-e612fde186df.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/multi-agent-network_26a0d4df-ff99-40f0-92a8-0b3f2c591040.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/multi-agent-network_68a547d4-0a15-43bd-aeed-c9ba1dfe388f.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/persistence_mongodb_2e65b3b2-8e3e-4d96-8db4-4846a3bc2eac.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/persistence_mongodb_5fe54e79-9eaf-44e2-b2d9-1e0284b984d0.msgpack.zlib

@@ -1 +0,0 @@
-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

docs/cassettes/persistence_mongodb_623b81ea-9415-4c49-9ded-9c7830a3ef6b.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/persistence_mongodb_6a39d1ff-ca37-4457-8b52-07d33b59c36e.msgpack.zlib

@@ -1 +0,0 @@
-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

docs/cassettes/persistence_mongodb_e3a9889d-7a60-455f-96d6-95a8a2e7dbf6.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/persistence_mongodb_f7aaec32-1755-4ae4-a40b-ade58491a5bb.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/review-tool-calls_1b3aa6fc-c7fb-4819-8d7f-ba6057cc4edf.msgpack.zlib

@@ -1 +1 @@
-eNqFVGtsFFUUboMISjBCTBRj0mFFg7F3d2ZnH2yJlWYLtJTa2l0tYJtyO3N3Z+js3GHmbmm7qQkVyo9SzNBgUBOidrtrl9p2IwqhEBLERMLDWvBRFYIRX8SoGPxj0uCd7W5b0qbOrzv3fOec75zv3NORbEa6IWM1f0BWCdKhQOiPYXYkdbQzigyyJxFBRMJivLoqEOyN6vL4UxIhmlHkcEBNtkOVSDrWZMEu4IijmXNEkGHAMDLijVhs/Tb/yZgtAlsaCG5CqmErYjjW6SpkbDkUvXklZtOxgujJFjWQbqNWAVMqKrGuJHmlrb3e8sAiUqwbQYFREQEeuIGBVRUR4KQxWY+TtVwJxko2qgojmai7ECQS0hsMBHVBskAiMgRd1qxKLUAgY2BCWGcokMniLaCsalHSYAgSikCKjNk0WivSiZxhHrMJMmnNHEirlsllEF1Ww7b2dupsNVDWkWixmURadeSQuHEHEghF1rcnJQRFqsLrcQkbxEzP6usQFASkEYBUAYs0vvlBuE3WChkRhRRIUEqw+pARzkw1IaQBqMjNKDHpZQ5DTVNkAVp2xw7as4Fsf4HFZbY5ZckAqDoqMY+X5Hg4qlvpGKgMa+dddudwCzAIlFWF6ggUSCkltIx9ZKZBg0ITjQOyI2YmJp0HZ2KwYfZVQqEqcE9ISxCzD+oRj+vDmfd6VCVyBJlJf/XsdFnjdDreznF2X/qewEarKph9IagYKD3V5CmXFJ0lHrAewHKDuS4pSA0Tyex1+rj3dWRo9Hmg1xI0JIkaHXGqCLr4WTI70O9VVeTUvJ63PF5K1TFPB6VoIeP0MAGkMdasMhxfxHuKOC+zsTI44M+mCc4pRjqoQ9UIUUHW58RPClJUbUJiyj+n7OO26bJ0ml+RIzIB2ddMxbJ+zbiLZdnxp+dF6nToZdXKGOd9Pt//xKWdQcQ8ZtUHWB9weoKTVbpd28aZuTwnV0KWT8LiQxmtmgc5zSeHZuZFz82H825LZUkDWTRP0XMDy3mN6M5qrtKPImhTzWaurE1zV2qej1qAoOCoCAjdiwhkBqKFmONMiOeh14s4H4Is7250Ix/rXOP1Ch6ODzkbvaHeZhmaKc7OMWGMwwoa8m8AfkjXCAhkxsZMlm59oaSy3D+wBdTgRkz7F4S0zypWUSKAdDqOZiqTmj5wHSWoe03JVvPYGsHHQ5fbzQuiV3C53GB9bc1wboCmBiRubYfM/t2dmFxIn+Y/UtC1OC/zLdhcVVnxybqHJ579se7UqoOJxL66tr/GbGXLSkrjA2/LI6G1PaFQf/rOmYpUR3LRnz27zo5u745dG+w6fye96ei+5JcT12Jrvxgqb+v3FCy6ONp5YMOj/ScB7Dx9ztRSJZfSsDMmr27sLj55tbr40tG6vW8WOrr+/vjwoYWhX/d2fzP86nMThx5vP3B7ydUT7zz204NHnmkbv7K08Obi61zhD+El95dvHzsBH6pY+N2LVTdahutvAGljsdJRUP/10nOjyw+vu6Df99u7D9zqufXE53hFqvz4H+f72a/Kvh8A/+w/0zG2clns7FuB/SsSF27/u2f3iNjU88aW9JGXX+o8+PvztZcv/4Jp+XfvLsi7eeXn1bX5eXn/Af6Nxeo=
+eNqNVWtsFFUU3lJrDNGE+AjBUBjWUrBltjO726dBWrdQEaG1XQRKsNy9c6cz7ezc4c6d0qX2BxVNDCYyaQLB2GrodhfWAi3gIyIKUUwxSpQfkEJsNESJqFExiMTEemcftNjy2F937vnOOd853zl3u+JtiJgq1rMGVJ0iAiBlH6bdFSdok4VMui0WRlTBUrSutiHYZxF1ZL5CqWFWFBUBQ/UAnSoEGyr0QBwuahOLwsg0QTMyoyEsRc5nzetwh0F7E8WtSDfdFZwoeP2LOHcGxW7Wd7gJ1hA7uS0TETezQsyo6NS5UtR57s4NjgeWkObcQA1YEuJ9fDFvYl1HlNcAZUQdR4qxlo6pg3Ay5mYEqIJIk4kAgYoDkpAJiWo4dTqAhqSBkzHhGJBL4x2gqhsWbTKhgsKAITvcBqsUEaomeXe4oUojyQONGMlcJiWq3uzu7GTOTvtUgiSHTQrpVJFB4lALgpQhN3TGFQQkpsHrUQWb1B6a1NWDAEJkUB7pEEssvr2/eYtqLOIkJDuVJ6DThaRsdqIVIYMHmtqGYikvexAYhqZC4NiLWljHBtLd5R0uk80JRwSeaaNT+/2qDI+iuggbAp0TPD6/xzvYzpsUqLrGVGTdZ5RiRtJ+dKLBALCVxeHTA2bHUs4HJmKwafevBLC24aaQjiB2PyDhEv/hiffE0qkaRnY8UDc5Xdo4ns7nEUVP+dBNgc2IDu1+GWgmGrrR5BsuCa/g9fFCCS+IBzJd0pDeTBW7z1tWvpcg02DLgV6KsZDUMruiTBH05XA8Pc57aldk1Bx1zYxWM3XsY2uQtIgTRa4aQY7F93NiWYUgVAilXM3K4EAgnSY4pRhDQQJ0U2aCLM2IH4eKpbciKRGYUvYR93hZhOXX1LBK+fQuM7GcTzvqFwRhJP+2SMKGXtWdjFFfeXn5HeKyziBqH3Hq40UvL4rBdJXFjVPnSe4Wn3oW0qxiDivGq+CO+HFuGZ/8u/C5BcPSxpEFU3lji06i2F+WzFZ4Z/w4xbTPgrvxuTVFbir3/7UvlSjvNsiJjUuhuduib8knkVaeVyX7I3ZuEsRqEoF1z5Cwz2pcE/CWlDRWrd60OdLXpgI7IXpErhnjZg0dDCzjA4A9qXxDcoXsePW6VVUrlwcG1vL1OITZLAUBmzkd6yjWgAhbTTsBNWxJ7LEjKMbc66vW2UfKZKG0WPaHvGUhvyCX+Pmla+oHM8t0Y1mizkuZ/CfaGks9ziezlszdfp8r+csO7qha8WnljJfHvqCeY3lnYo8/5em9Z/vMnJ+X5mml3fIpOf/bnnd3nhnz7Ju+5dH2P0evfdfzTfHa72dcuxq63v7311f1wtoLh2bVP9R74dw/u7LlvXE7f+ZJ5a9ts+79o3tjiD73QKFc9nRgTuGR0egrV1Z/fLpP6P7x5J6Fu7bvOX7//sEHC5/Hl5r2nrn08Ce90+cOd+w+IT9ZWbO1MqfiymNv5n21Mfus8OKuVdNn97RtfOLQsYuLlRojry83R5lfefH8zmlDXdblhaPH81fFKmcg7tdY3exTH54debUUHz/6b+P5w7NP/JL305IBKAhvvH06H09rH1rW83vuC6O+1wpg7nA1GNjxwb7inM/fqokG3O9te2TBb75nz/Hv+CrmdJ8tWLzpsxZrvbxw+VjLD1fI9Wku19hYtmsuvKwlslyu/wBhhTld

docs/cassettes/review-tool-calls_2561a38f-edb5-4b44-b2d7-6a7b70d2e6b7.msgpack.zlib

@@ -1 +1 @@
-eNqFVH9sE1Uc3yAhokAMKIsa9Wwci8Br73rXsm7gaMo0yoCxFoGROV7vXnfHrne3u9exOTYFB3+wCF5080f8A7auJc0cDCZMQIIimSQa0GRggSgIgsoQTRQE+eG7roURFuw/ffe+n++vz+f7vmvitUg3JFXJ7pIUjHTIY/JhmGviOqqJIAM3x8IIi6oQLV3gD3REdCmZK2KsGQUOB9QkO1SwqKuaxNt5NeyoZRxhZBiwChnRoCrUH8/2NNjCsK4Sq9VIMWwFFEM7uemULYMiN8sabLoqI3KyRQyk24iVV0kpCrauVooQ5xkUFhG1EkHyp1OSQhmhIltjhRVHFZBs4XgZRgQEWOAChqooCAMnyUS7nbQVEKuqnM6lwHAqVzpapYGgzosWSEAGr0ua1b8F8KcMVEjVh2e3gJKiRXClwYsoDAmywaYRBpCOpVQ/DTZewvWpA67XUrkMrEtKla2xkThbtEo6EqxqhpBWHxmkGlyBeEyQFY1xEUGBaLMxKqoGNnvuYXsr5HmkYYAUXhVIfPPjqtckbToloJAMMUrwFg8pOc1ENUIagLJUi2JDXuY2qGmyxEPL7lhBOOtKsw6sWu41JyxxANFMweYub6YOR2k9GQ6Fou0sZ3duqwMGhpIiE3WBDElJMS1l3zPcoEG+msQB6cEzY0PO3cMxqmF2zoP8Av9dIS1BzE6oh93cjuH3ekTBUhiZcV/pvenSxjvpWDvD2D09dwU26hXe7AxB2UA9t0m+7ZIgs8QC2g1opjvDkoyUKiyaHSzDbtGRoZFHg96MkZA4YqyJEkXQ11/F02PevmBuRs0fsiZG5xB1zM8CYmQ65XRTfqRR1qxSDFvAuguYfOrFeYEuXzpNYEQxegI6VIwQEaQ4I36cFyNKNRISvhFlT9rutKWT/LIUljBIv3EilvVpRjmappNT7ovUydBLipUxyno8nv+JS5hB2Oy1+gO0BzjdgaEuXVx5khrJc2hRpOuJWfWQip69D/JOPRk0dV/0yPUw+eWJdNFAEsy95FxJM8XekiVqOSNqnLsUR1yIWxxaOYP9pA7wshoRACbbEoHUQNRhM0mxbuRyu0Nuxhn0uIKs2xOig1w+63HS7AzOIzg7aiVoJhg7Q1WpapWMtvpeAD5I1gjwp8bGjM9ZOt877yVf1xJQpgZVwl8AEp4VVUExP9LJOJqJVGrywHUUI+5l3qVmbz7vYSHnCs7gWZrnOBcoXly2LTNAtwckam2H1FZeHRtaSAezpadbHshK/UYHFlZUP+Edd31a4tVr2905ea5f97W+4aNWT86Lxpr5HXn/2pPvdO8p/+nAydcdF7jepomPS6G/avZ3e1sajw8MJBdN+vHazd8RO7NvVVHX2RNnyo6Kpf2rX87pPFvbPKajeVTfu7ujGx4df/m70tktz/edPDK46jJqa/4A79wyOWdAX7jZ6+j6cv3lY6d9Aanyl/7lf65v373hwD9jlf2F69q+yOoQ/gBXFx9pO/XWRzsf2cwvKVy3CA/uOYsmXBlVWHbk6HN4b+v3hRebx59cNSFbb5/UZMtpfGjqxHPa3Adnfd7WO7t4U81vy6f19B2ucd6aMnlsZP7PE/rPtM48NpA82Hd137Ki+I3coutvf3PxcP+Fi01rxyT/Xnvl2K6mK0B+anv7rE2X8JyWvBOnuFmPlUz1PXko97T/PP/Mt5dKBseC8w+PO3emYfB0xaev1OfOFw+/1+o9dK2o9mrkw5uE01u3Rme931SZfyM7K+s/SQ38Dw==
+eNqNVWtMFFcUXsqPAvaZNMU/1snGIhFnd4ZdHos/WrOgqKWou5TiI+Qyc5cZmL13OnMHXRGTLrSNMT4mTWo0tkll2TULym6xKUb7MMZaE/80VRPaVElbbcSY2KcGo/TOPgALovtnZ+75zjnfOd85d8KxDqjpMkY5AzIiUAMCoS+6GY5p8B0D6qQnGoREwmJkbb3P32to8sirEiGqXuV0AlV2AEQkDauy4BBw0NnBO4NQ10Er1CMtWAz9mFPRaQ+Crc0Et0Ok26sYnit1L2XsWRQ92dhp17AC6ZPd0KFmp1YBUyqIWEdbJEAW6wyRILMFAvqnMTJi9MBr9q7NVhwsQsXCCQowRMi62DJWxwhBwiqAUPpWOIKxksmEQDCVKROrWYdAEyQLJEJd0GTVqt4C+FIGJoC16bktoIxUgzTrggSDgCI77SqtH2pETlXTaRdkEko9kJCayqUTTUat9q4u6mw1VdagaLFJI60qskjc0gYFQpGbu2ISBCJVZm9EwjoxkzN6PQgEAaqEhUjAIo1vHm3dJqtLGREGrMrjgtWFlJhmvB1ClQWK3AGjaS8zAVRVkQVg2Z1ttGMDmZ6zFpeZ5rglDUsVQ8T8YnmWh3NtiI4GYjiHy+0oTWxldQJkpFBtafcppaiasp+cblCB0E7jsJmxM6Np52PTMVg3++qAUO97KKQliNkHtGC5e2j6uWYgIgehGfOunZkuY5xK53LwvMOTfCiwHkKC2RcAig6Tk02edImXcqUulitnOf5YtksKRK1EMntdPH9Eg7pKVwZ2R2lIYujhCFUEXvgulhnyw/VrsmpesRVGqqk65peNUFzK8DxTDQWGxnczfGUVx1VxHmZlnX/Am0njn1WMpF8DSA9QQWqy4scEyUDtUIx7Z5V9xD5VlkbzK3JQJmxmw6lY1qsZcXMcN1I0J1KjQy8jK2PE5fF4HhOXdgYS87hVH8uXsjzvz1RZsWH2PKndYtOXRYZV1GJFeS15LH6KW9an6Al8HsHQs2Fk8Wze2CAzKPZVprKVPB4/RTHjs/hJfB5NkZnN/X/tSydaNAdyeuPSaGZO9CP5xDPKs7JonqLPzRy/oqaNhGo7gt4mt9fHA1zrW+krFXs7ZGDGeQfPtGLcqsBB7wrWC+iVyvpSK2TGqpveXF63yjvwNrset2A6S35AZw5hBKM+qNHVNOOCgg2RXnYajFL39cubzOOVAa6iLFBW7m5xu7hAuZutaVyfyC7T5LJErJsy9X16N5q+nM/mLFm4K8+W+uX699XVn+GeeX9i9W/z9r9kLPhJQpu+PZefPPNCXsO6sR2JCzfGqgfi41fXFeRVNu24deePc3nB/II9mwpvtEx80lDivvfzry/f++r6Z6fO3ny29rb3g+S8A8Zu5tMt5QUHT8DB8909vSXfh58SjGK+qai/Z8GL44vWDPXXHITM6co/a1+5ePNu7j9b9/zrKR7+OvGWW1rGDzNvdF9ntnf/kvs5ThSyOz8uSt4qO/DR7pM9qx4cPjRUMzo8ur3hgtd0XK6vOHHad+m50INNFSFj5fO/F+57fXx+19Xb4XV3ojvRWPjpsrB831YwHJa3ffjNFaNm78EF9xdWFM6vzznPFBdcXp3319DFu++VnFrG8EeuFe0fDU/0H2384e98m21iItd2aeO1i7tybLb/APjLO6s=

docs/cassettes/review-tool-calls_3f05f8b6-6128-4de5-8884-862fc93f1227.msgpack.zlib

@@ -1 +1 @@
-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
+eNqNVmtsFFUUboUf8jASokiMwrhCm0hnd2e77bYNEer2QSG1S3cLfYib25m73Wln507n3m27QFUKYrRRnCAhwYA8trtks0ArCNEiapBKkdCoGFMS0IivUJTGGBKNBu/M7vZdYP/MzL3nfOc75zvnZDuiLVDFIpLT46JMoAp4Qj+w1hFVYXMQYrItEoDEj4Swq8LtORRUxcGlfkIUXGCxAEU0A5n4VaSIvJlHAUsLZwlAjEEDxOF6JISuPDC8yRQAbV6CmqCMTQUMZ7XZsxhTyoqe1G0yqUiC9M0UxFA10VseUSoy0Y9a/YBkYob4IdMKAX2ojCgz2LfC1J7FjHoCjEVMKJnx7hSbwDYDqCxTkhg/lBQmhIIM74d800RUN5CZEhXIvIh5ZNaRSEgx4A0QI+DICUKSl/LVrWQQMM6SUF4Mgcr79RtRVoJ69E0mXiQh3WZcDB3SJAopvKDXyq2r8bmVYHkzBrmrMb+xtrJVqM3LMbVvGJfu5ELVTaCmQhyUJlTDVEXdmKSuUKBFADLVoIChcMxynWEWw6OgTNTQs4wPqQFA9AcjIR7oXWFUJJm3975o6+lhL1RVpFJrH5AwpJls0BsACVDSEXgJBAXIZrM5LEayDAkrAUL5pYIlW2T6GgsQ86qoGAT1AhsXBu8x8o6I4cVU+gAwNFFo40KViEYbjkg0WkhMVFFuMLXrKulVE1WoJ12XsNwwpj9QfSPkaYfQ5KJ+CAQ6UjvCfoSJ1jNpSI4BnocKYaHMI4Hia0caNopKFiNAn555jNerYEyhFmuCUGGBJLbASMJL6waKIokJPSyNtGLxpL6szmXydUxvFZaOmky0U4UpHhZXiM60zFjN2XazrbuNpbMjyhIdSlp9SimiGPe9Yy8UwDdRHDa5L7RIwvnoWBuEta5ywFe4x0HqgmhdQA3k2o+PPVdpq4kBqEWdrsnhkpej4bLNHGfO7xkHjEMyr3UZfdUzUuQRl5jNastmrbmslTuaqpIE5Qbi1w45cmyH6YwodNfBrREKSYK4I0wVgRfPR5Pb6WDFmpSa19IeCxdRdbSP10Mhi+E4pgjyDMW3M1xegdVawDmY0nJP3JkM45lSjB4PnXzso4IUp8SP8v6g3ASFmHNK2QdNo2mpNL4kBkTCJkeYiqV/amG71WodzLirpUqbXpT1iOHs/Pz8e+DSykCindDzYzkby3GeZJa5tVPHMWaLTWz5JKuIzoryeuae9qPcUj4Z9+EzDUNH7WDmVN4oSCZR7Mozoi27t/0oxaRP5v34TE+Rmcp9QvkSgZbcxXJs4RLWzF2tp+UTSyrPioJ2mr7Tjb6qrai6Wqla1ebylQrVtpCzem2j23GoRQRajDNzTANCDRI85ixhnYCuVNZtjJAWLap5vrC8zBmvZitRPaK95AG052Qkw4gbqnQ0tRgvoaBAl50KI9S9srBGO5HnszpyfHlCjuCrt/py7Wzx+sru1DCNDEtY35TGH4stkcRyPpduX9z5YJrxm+FxfbX685Vz/921dKDOP1RDvp994+yB1yqXF2nvn+w50tI6lLHmVtZ/rWLx5ejbZb6MnbM+evyRhY0X8soW9V/bPnDx1nEnWNQSGdy+e8GS4eZP4ZzXyVbms96X0u1rS+Ps1pnXG28WFn475OLJ/L0lP8WL3/o67+qS5j0d2y7UlHy5f19k8dq+s895OzuaBODqXjFbzplz9bdLb/RcX6d01g/LKy0v7nXsefTin+v7Pjwz98QTpzJq/3H19d8OZPVxA5bWzd/d2Nj78N/n3pwxa927rzoO/rKgvexw+wfC7zfnLbw8s+qLUpfLv+zo6ZNVpbt2/njmPNj33tJ5vQf+Otw/eOf20CvDT+8/Mu+dh9otT8V3uL85tbn/jyfZLVeEX+e/8MMn1S25A15anjt3ZqR1Xvr55d3paWn/A/LD19Y=

docs/cassettes/review-tool-calls_a30d40ad-611d-4ec3-84be-869ea05acb89.msgpack.zlib

@@ -1 +1 @@
-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
+eNq9Vm1sU1UYHkERjT+IoBgT8dBMlmBv17tuo60ErNsQ5srHOmAfWZqze0/by27Pudxz7kqZmIASJQTwqvzRxMTRtaZOYI74EZUIzkQNkIhEHUEk8YeKZhiDiUHIPPe23We38cPYP+095/143ud53/d2T6YL6VQheE6fghnSocT4AzX3ZHS03UCUPZ+OIxYjcmrjhlDTEUNXhh6NMaZRf3k51BQXxCymE02RXBKJl3eJ5XFEKYwimuogcvLiHdu7HXG4I8xIJ8LU4Qeiu6LSCRwFK37S1u3QiYr4L4dBke7gtxLhUDCzjhIxyMooYDEEEgjyLx0oGNDIascuJxjzhJQqlHEwE915bIZ22IHWlakqiCFVA0liACmGpM7JUUMQgzU6xJJCJeKyIrGkZoe3g9gJR08IUcMcr2WFYdw+y4cKUwR1KWbdKFgzrOzdDklhSctmQg4rpEORC/GMsFvc0hIJaUZwO4XV9VTa2dqYkFu9VY5d7RPKnUpU2yRoOqKGOokNx2buBvK6IpmTADHXwA94OLDSQugEEjEw05OrQIToccisL6ASCVpdYTOSrzt8W7Ct8mgY6TrRuXUEqhRNqmR24RoQA3EEOCiuF0cEo5BrlVBYzNZP493Hq8rB9f8PojnB5lCgiHL12xKhRCIQqFvPNsWgXL/FCNQGyX+kXMjAOLl0BgGmyV5cgHZrAomMVCuCpEJDRoJHqBIowRgxQYWMN0ghWX5Gp+dLRlTSFc3uEAuqfWE3zrj5GiU2TPnsxaHNb047pth7YJTuMT4o0xUcdeyyyLbaVtGRVXRbzrJ9nNakYxuSuNq8uEwMQZnvtEOpGKHM7J+ypY5BSUIaExCWiMzjm+9EdyqaE8goYlWelSwW7DVoZjsR0gSoKl0onfMyj0NNU5XcQJRv44z15WUSLCxTr7OW4gLfdZiZ7wcKOMo3JvlSxcDt8lS6Ko7vEPgMKFjlW5GzzyGlNfv+o/EXGpQ6eRwhv7DNdM756HgbQs3eIJQ2hCaEtAQxe6Eer64cGH+u81lX4sjM1Gycmi5/OZbO4xJFl69/QmCaxJLZa/dV/yjJoy7ZCneFR3BXC27xaIElFeEoi5kpUfSseIv3usbfNui5NI/JDLonxSVBZ77I5N8PPRueLsh5uWRxqpbLY36yFclOIIqgFkmAJ6gEotfvdvtFH3gq2NRXk8/TVFSN/iY+xjTCFakrqJ+RYgbuRHK2pqjuQ46xunSeX1XiChPyS5SrZT2aqUq32z20bEZLnXe9gq2MKY/P55slLmcGMfOEVZ8gVgii2JSv0ttaPI89XELuPZtHlbZQcVzLZ7Ufw1bwWXYbPtMg9LUOlRXzJgabArHXa2d7bHb7MYh5n7Lb8ZkeIijmPom+XKLSGSzHE5ezBjNaT4snm1deUGTzY/6br/S1rZ01HXVBX210S0VzfUsi4ZM7twaPdCnQzIouEUQJiaroWM0aoQbynSqE7BEyM7Ut6wPBdTV9zUIj6SC8l5og7zlMMEqHkM5n08xKKjFkvu10lObujYEW84Q34l5RFfF5fV7J445UVwp1WxuPF4ZpdFhS1qq0/9rtTue28+Cvj+yfX2J/5jYcPFv/2ROL9obRyt/uLv1m3lfqXpcTn7jyZOm9X1Y93HBt8NLjF+/7c/jlnitXP0086/V03HVo4Hqw5Ydr108P//39tfdeyNz6Z2l8ydVji5t/MVJVdY43y5oblObAgn09u+9/4OcLX5cc6pr/4ZGO0IW9pZHzpw/jtsPnTvUE+wbvGfGPHFje/u2N4MqDZRU/Lrpe+8o+9Y25r99a9MGB88sWfr42cvIyTA4sCEqeTS8N/gGGHzq78KfvFtw4Myicokvm7X+mezhau2Sg+rVVL9558ujT+1/9a/Xbl969yWsaGZlbcrPx3O8Pzikp+RdvMzCt

docs/cassettes/review-tool-calls_b2f73998-baae-4c00-8a90-f4153e924941.msgpack.zlib

@@ -0,0 +1 @@
+eNqNVmtsFFUULqJREoMJz0R+MKxAUXd2Z7ZL220atfQFpS3QWdJCUza3M3d3hs7eO8y903ZtmkjFQJRIJkRjYsBAt7u6KX2EGjTlYYQYmsgf/khVIMbE+EMTjSQkRsA7s7t9F+if7t5zzne+c75zTrYv3QlNomG0ZFBDFJpApuwLsfvSJjxkQUKPpOKQqlhJ7t4lhfstU5vcpFJqkDK/HxiaDyCqmtjQZJ+M4/5O0R+HhIAYJMl2rCR+fOZijycOuiMUd0BEPGWcKASCXs6T92IvrT0eE+uQffJYBJoeZpUxo4Ko89SlAlpIOKpCrgsC9s/kNMSR6JueXi83HQkI0QhlZGaHM2wKu12gHYW6zqlQN7gEtjhZhXLHXFQJIK7GBEjWiIx9DhJNGC68C+ImnHrBWI8wvo4XAnH3LQcVIRCYsupYNGRYTvYej6zRhOMzK4eX2ytVOLgeTcmDWhFBrEkYAYV2ldS2N9cXt6jbVKlREls8vW2zap7frdY5/ExILH1OSzyShVBig1tdrobIU2V3WJIINE1sMu8o0AlkhNocMbECdQdB1oGlQL6I38oTjBCkvA4om6F8spzci/dLgUQ2NcMZQZeqa+Ci2Jwp1VRjI4TJGAdufw02hNCkmjtSU+2e7gehpoZinl6n2c5kayZ0im7NerbN0Bq3H4QyU5sVl1YhUNh6nEiqmFB7dN7ADwNZhgblIZKxwvDtc7G3NcPLKTDqVJ6RnS64G2VnOiA0eKBrnTCVjbJHgGHomgwcu/8g69hgTibe4TLfnHEU59naIGpfqMjz8O9OsP1EnOArCvoCI9082wMN6WzBWPcZpZTh2sdnGgwgdzAcPrf7diobPDTTBxN7oAHIu6RZkI4g9gAw48XB8zPfTQtRLQ7tdOXu+elyxul0RT5R9IVGZwGTBJLtAXeuRqeaPBWSCQiBIl4o5gVxKN8lHaIYVe3+EkH4nI26we4WfDfFIKlF+pJMEfj99XTu0pzdtTOv5p2Ctckqpo59qRkqXk4UuSoocww/yImlZYJQJga52obwYGUuTXhBMUbDbItJlAlSnRc/LasW6oBKpnJB2Sc902WZLL+uxTXK584sE8v5aieDgiBMbn6sp8mGXkNOxmRRKBR6Ai7rDKT2mFMfLwZ4UQznqizav3Aed7f47MXOsUo5rBiv157oP80tH7P5KWIWYRjcP1m4UDS26DyKA6Vuttef7D9NMRdT+DQxi1PkFgqf075soo2P8ZzZuKw391jvRflkcsrzmmJfZJ/ZRa9orK1Vw1rXwdD+urpY4yEFVVcF6vs7NWBnRJ/IxTCO6XC4soavBOyk8pK7Qna6al9jRcOOysEWvgm3YzZLYcBmDmEEUxI02WraGVnHlsKOnQlTLLypYp89VhoVSrZGS9rF0kBIiBYH+ermppH8Mk0tS9K5lO6PhMOp7HG+9mD9By8UuH9L60/cqLv61qr3IrB8XcnK7e2rT8GKtUOrzqyzhQbfxK2JU2X3P/zy48vjY1u+Kvvr1PrS548sWX7+eNvt8uHiw90H7pZ0PPz59tDdzy43//OKl14ZkN6v+m/7yPVXT7+zdtnZ06vXkJe3fHvmxOUXw217f/hoY/Rm5txP1dIF3vvvtbpBY/jolT0Dw9ID7/Kd/uAn12oKA9veuH9yYuOmTMvKe03HV/12aZl+oPzTo398/dLNwpNXS7/4ZWz8m79vbAvGx+sPrLh6uPv3MeW74Q339hzr6ft1RX916K75/LN31vwZjB97Dh2SWpNnH+0jXeUPWZ2PHi0t2Hyrd2LrkoKC/wFNFp9z

docs/cassettes/review-tool-calls_d57d5131-7912-4216-aa87-b7272507fa51.msgpack.zlib

@@ -1 +1 @@
-eNqFVG1sE2Uc3zIgCkpgvsT4Ei+Vt+muvd5dO27KyxyIG47Vrgjbsoxnd0/bW693xz1Px7oxlAkSgmy7kAlEvjBKq10Zm4Ia5mC+RYNGgWDMWJzDD/hBjTHxFRPnc107RliwH67P3f/3f/v9/s+/PdEEDSRram5KVjE0gIjJCzLbEwbcGoEI74qHIQ5qUsxTWeU7FjHkkcVBjHVU7HAAXbYDFQcNTZdFu6iFHU1ORxgiBAIQxRo0KXolV2i1hUFzPdZCUEW2YsrJsHwhZcuiyJfaVpuhKZCcbBEEDRuxihopRcXWp21BgJciCgchtQ0C8mdQskoh/ypbW50VR5OgYuFEBUQkSHO0i0aaqkJMsyQT42YZKyDWNCWTSwXhdK5MtHoEgSEGLZAEkWjIutW/BahKGyi/ZkzPbgFlVY/geiQGYRgQZKtNJwxAA8vpflptooyj6QOO6ulcCBuyGrC1tRFni1bZgJJVzSTS6iOL1BoaoYgJsq4tEYRAItp0xoIawubALWyfBKIIdUxDVdQkEt88EWiR9UJKgn4FYJgULR7ScprJEIQ6DRS5CcYnvcx+oOuKLALL7mgknKUyrNNWLbeak5Y4NNFMxea7Jdk6HJ4oGQ6VYuwcb2f7m2mEgawqRF1aAaSkuJ62D0436EAMkTh0ZvDM+KRz33SMhszjFUCsrLoppCWIeRwYYTf/9vTvRkTFchiaiVLPrekyxhvpOLvTaRcGbgqMoqpoHvcDBcGBKZKnXJJkljiacdOMsy/LkgLVAA6axzgn94YBkU4uDXw5TkLiCGqPEUXgF58lMmPeU7k+q+ZYTn5sDVHHHPIFI4UU66aqoE5Zs0o5uWLOXUwO6yp8qdJMGt+MYgz4DKAiPxFkbVb8hBiMqCEoJUtnlH3EdqMtg+RX5LCM6cwdJ2JZr2aMZxhmZMltkQYZelm1MsY4QRD+Jy5hBmLzlNUfzQg06/ZNdunia0aomTwnF0WmnrhVD6lo0W2QN+rJoqnbomeuh+VrkpmiaVky3yfnesbpYbdW8Bwb4BrcoQh+IVDd6G0WN59upkVFi0g0JtsS0umBaMbmCMUWLRcFAfg5F3SxbsHPuIrIE7gEQXLzTAN/rEkGZtJpd1IBTQso8GTpM3QpIGuErkqPjZlYU72hpKKsNLWZ9moNGuHPBwjPqqbCeBU0yDiayXRqcsENGCfu3pJq8xTJygF+OVvUwEoiz7votZu8/dkBmhqQmLUd0lt5Z3xyIX2SW/bovjty0r88X9e35R+tXrC7Hh7+Mbz3zf3Q0T33UsvzPb577/zcf2XWgcP8k+sfWj9Wl79wtBfsOIv81+6C8+c0nvuq5/WfjbPF9nkTdcqZwX+WVHg7Nt3PP/vNOLN7bHRF+yuv9R7dMuQY2px/wYM67ntA775b2OA/8PfH3MLzizq+H12297EL44dmlQ1vPzKxZnZl3so5eY7UH8vK5/rWnfJu6S2/srW2tuDw5Y7a7hpv54nFm1o+rVlRECib3XnQc+3iO32ewdVqTqJxf0+jT3iiIPXq04/sKfjt+ov3XHt83o73tO3nu/YUnom2rVS+++mMMLQ0er3/uaKEOFj/0py3fh+ua53Pu0qGj3zQfWnnzt79R39Z5Wq+uiR0sSUe+mHg6q8Luh5uP+rZ+OCHfzWhfzd+uetc11OHqvPlcerg6bWX/1xFOJuYyMtpTe3r/jo3J+c/5ePcUw==
+eNqNVWtsFFUU3qUaCWiMBIEETScbBITO7sx26UubAltAIKWvRVqk1Lszd7vTnb13mHu3D2o1FAKJGO1QowbBhLLdxbVCK6gJlMSioImiNBTI+qMYEsVXCD5iIIB4Zx+02Afsn5255zvnfOd859xpizZAnSgYWbsVRKEOJMpeiNEW1eGmECR0WyQIqR/L4bLSSs/+kK7En/JTqpEChwNoih0g6texpkh2CQcdDaIjCAkBdZCEvVhu/t6a22ILgqZaigMQEVsBJwpOVxZnS6PYyQstNh2rkD3ZQgTqNmaVMKOCqHnU6Ad0HuGoH3KNELA/nVMQR3xFttYaMw6WoWriJBWEZMhn84t4ghGClFcBZfTNcBRjNZUJgWAiUypWLYFAl/wmSIZE0hXNrN4EVCYMnA/rI3ObQAVpIVpLJD8MAoZssWmsfqhTJVFNi01SaHPigTZriVyE6gqqs7W2MmezqYoOZZNNEmlWkUZibz2UKEPWtEb9EMhMmTfCfkyo0Tuq14eAJEGN8hBJWGbxjQ/rNitaFidDn1l5TDK7kBDTiAUg1HigKg0wkvQyeoCmqYoETLujnnWsO9Vz3uQy2hwzpeGZYogany5J83CUNbPRQJxgz3bZnT1NPKFAQSrTlnWfUYpoCfuxkQYNSAEWh0+NnRFJOh8cicHE6CoBUmnlXSFNQYwuoAdzXIdHnushRJUgNKLustHpUsbhdNl2UbTn994VmDQjyejyAZXA3jtNvuMScwrObF7I4QXxYLpLKkR11G/szxbFAzokGlsZuDXCQtIQaQszReA3X0VTQ95Zujqt5pBlZriYqWMcXwflLE4UuWIocSy+ixPzCgShQMzhVpR4ut2pNJ4xxej16AARHxNkWVr8qOQPoQCUY+4xZY/bhsvSWX5VCSqUT204E8t8NcIuQRDicydE6mzoFWRmDGfn5+ffIy7rDKTGEbM+XnTyouhJVelaP3aexG7xycsixSpismK8FtwTP8wt7TP3PnzGYZizPj5vLG8coqModuUlsi28N36YYspn3v34jE+RG8v9f+1LJpozAXJk45JobkL0uHxiKeV5RTb62HOtIK71lHufR95NMqivJt7AqtxV+VR+bn+DAoyYaBe5OozrVHjIvZx3A3al8pWJFTKixdVrlpSsdHdX8RXYi9kseQCbOYQRjFRCna2mEZNUHJLZZafDCHOvWFJtHMnzCbmLfHlOKHmh4Mtx8cvWVfSkl+nOsoTNmzLxfdoSSV7OJ6185s7JlsQvw1NWUvq58PCthYZjQ8VgSO3Zc/0J70Pb22ctXfvm0UDVTzTUKcb+bRyc1LY3q+jG8cuXZ6jWKZ/0fXt24Pdfzm/ceBrdnPR2oLXIcfHrzeVbtmkHei8u9R1f3n6m6ULG7rh+ZvriE+dn/rx4y6aCGe+81rHyxHuT3bu64vH5p53tLz77YNjy68e3Hn/k2sDZHZ0/XPkiv3zfByf7V4AFrtmPLZjeMrjvxPKqaatLLh0dkLNmvzJl782OP4d+NG5k7PC0Zv5F/75ZYf/tWo9UuPfw9Q2FV3aeO/nAnPahf/oy/9hTnhv5LvD+61bP1FPbM+bnfbTtYEvHZ/0XmrfuLnzymUczTtUUOye/2kmmXbqae+7lhZf7cfuswWsvze3/8mrmu2uOXZlqsdy+nWHhnrb2vWW1WP4Da5ZAYQ==

docs/cassettes/review-tool-calls_df4a9900-d953-4465-b8af-bd2858cb63ea.msgpack.zlib

@@ -1 +0,0 @@
-eNqNVX1sE2UY3xgkOiAQVFSUcDYogrvu2l63dcboKGwO2IdrHYxl1Ld3b9tj17vj3ve6DkLCV4JR+Tid8vGHICutlAqbbqAyTAbRQSCIxIhDlIQ/FELUEUKIRjPfu7X7Fu0/vXvf5+P3/H7P89ymRASqSJCl7JQgYagCDpMXpG9KqHCNBhHeEg9DHJL5WHWVx9uqqULv0yGMFVScnw8UwQokHFJlReCsnBzOj9jywxAhEIQo5pf55is5U9ZZwiDqw3IjlJClmLIxdjaPsmSsyEn9Oosqi5A8WTQEVQu55WQCRcLGUVMI4HmIwiFINUFA/lRKkCgUeNGyPo8a8gQICQgTMCPdSWwMo2Ygr0wFIR4VKCCrYWAUTJEnygMkqlQFEicgTs6jyimOHBBMw518CAKVC1EBTTKZslLLSNQwpAIQk2NM4I6J2yxrVgMXblZMsCYkE/7giSyLPpLJsJJA2DwbmdC4ESRFM2pZZ+EE3GzYjEL8qqfEiGsR+ExQzcfY6rx8nX+h2x6pq8OFfjfkAjjkbLKsbxjB4Fju60fhUyHSxFEEWzyaJDU/ZVaXrsH3v7IbKJEPqqqsEusAEBEkgBqM1pB5KBoROBFoPKQdtJNGsiRBTNtJ8zAFdiaTLt0+/84YDxGnCoqhhAk2rR3RZJikg9T6EBeCYWAyrJCmhioWzBYdJHyIEYRVQQpa1ht0G5MiqNAou37AsmGY2rJ/NeSI3qS8RAgCnozbjlhIRlhvHzNARwHHQQXTUOJknsTXPwquFZQ8iocBEWCY5AwezL7Tk40QKjQQhQiMD3jpbUBRRIEzGy9/NeEslRaKNrCMvU4amtNkDCWsHy/J4MivbibzLlGM1cFa7W1RmsyVIIlkYGkREEhxxbw/MfxCAVwjiUOnd4keH3A+MtxGRvrBCsBVeUaENATRDwI1XMB+Mvxc1SQshKGecFePTZe+HErnsNpsVlf7iMCoWeL0g2ZntQ+SPOiSJL3koJkCmrEdybAkQimIQ3prYRHzIWl2hexBuDlOQmINbYoRReD5M4n05jpQtTSj5k9ZM2KLiDr6SW9Iy6PsBZQHKpTRq5TNUewoKLY7qLIKb8qdTuMdV4x2L5ljFCCCLM6In+BCmtQI+aR7XNl7LUNlqSS/KIQFTKfXNhHLeNVjLMMwvc/c11IlTS9IRsaYw+Vy/UdcwgzEeodRH824aHuBd6BKJ7uylxrPc2D3p/HEDTwE0dz7WA7hyVhT97UeH4/dsTKZBk0LvN5Fnsk6WuYvjIZKK/2SVBtdGaldoYJFTtvazijNibLG05h8ACFtNkQU670Uy7N8EWPjgJ9leSfJUcAGGMj7eQY4bX4H1xoRgJ60WW1UUJaDIjzqLqXdgKwR2mO2jZ5YVFdZUlHuTq2ga2S/TPjzAsKzJEsw7oEqaUc9aaYmA67COHGvKanTO4o4lwOwhUU8LHJwLOukFy+vacs00GCDxIztYH5oN8YHFtKX2ZVz3nwgy/zleKu7l+S8MuWvd3cvza8/1El/+mhJd01f7cXNL5dfi/9Y5nvnz7eDDUv6G449e2P+aT7w2M9b2rtn3TvWsE1atWpX07mqfZ7vnaee3P71nZ6K7tyTzytH/Y4r9trdzrsT9yxGM3py711RTs1yH7jU1xcpmr33jbZpPa23efaJHW2n9l/P2373h5uF3/5x+Livcts0/uqG3Oi515a5Onb2LlEPW6/qZ+svTJ/03ty+lvKFHfunT029jpe39W3M7t57KHq1ZeJU7eQXx7femJ06MXmVp2nq5FtrAtTNrm0fT6r86qLwOLvz+vbuRyIHyvZ3zuy/XIJ+n/D3/I5vuubtWNC24aUJdMI9Z2LPjV9feP/ac+zl0wsce3K/O3Mp1cV379t6uww8+FZnS8uCvF2dtx4qdT3s++y3FVNuncW1H8zsP1fR88udQkJcf39O1ucX2Mbz2VlZ/wBwZ4U6

docs/cassettes/review-tool-calls_ec77831c-e6b8-4903-9146-e098a4b2fda1.msgpack.zlib

@@ -1 +1 @@
-eNqFVH9sE1Uc3wAJI4iIERIj8XJBMIbX3rXXbl2WYB0/5MfG2MoGDKxv7157x673jrvXsTJnYCPEaCacJhIlKmFdi80GmwPUoAlRjBOVfwTcBiqJJEYMKAgGMAHfdS2MsGD/6bv3/Xx/fT7f921LN2HTUole2K3qFJsQUfZh2W1pE2+MY4tuS8UwVYicrFpRE+qMm+rQ0wqlhlXqdkNDdUGdKiYxVORCJOZuEt0xbFkwiq1kA5ETw4WBFj4Gm8OUNGLd4ks5UfBI8zg+j2I39S28STTMTnzcwibPrIiwUnTqXG1SIJ1rcVTB3CYM2Z/JqTpnRebzreudOETGmoNDGozLGHiBD1hE1zEFHpZJ8HsEJyAlRMvl0mEsmysXLWxhaCLFAcnYQqZqOP07gJqsgYsQc3R2B6jqRpyGLaTgGGTIFt5gDGCTqtl+Wnik0kT2QBNGNpdFTVWP8q2tzNmhVTWx7FQzgnT6yCNJwwaMKEOub00rGMpMmx1JhVjU7ruP7QMQIWxQgHVEZBbf7oluVo15nIwjGqQ4gxwesnLamUaMDQA1tQmnRrzsXmgYmoqgY3dvYJx151gHTi33mzOOOIBpplP742C+DndVgg2Hzgkur+Ty9DYDi0JV15i6QIOspJSRtR8ZbTAgamRxQG7w7NSI8/7RGGLZXRUQrai5J6QjiN0FzZhf6h99b8Z1qsawnS6vuj9dzng3ndcliq5A3z2BrYSO7K4I1Czcd4fkOy4ZNkteIPiBIO7Ps6RhPUoVu9MreveZ2DLYo8HtKRaSxq22JFMEfzeQzo353hXL8mr+XDA9uYCpY38eUuLzOI+fq8EG58wqJ3pLvf5Sj8gtrgh1l+fShMYUoy9kQt2KMEEW5sVPIyWuN2I5Uz6m7EP83bZMll9TYyoFuTfOxHI+7aQkCMLQnAciTTb0qu5kTHoDgcD/xGXMYGofdPoDQgB4/KGRLn3S2iFuLM+RRZGrJ+XUwyqa/QDk3XryaO6B6LHr8YhrM7migSrbn7FzWBAXBxRj4/NysGmtZxXCDcFYpeVbZB5qBkgjcRlQti0xyA5EM7WHOKm4ISJjiP2S6JMhFLEPBfwlCEYETwAKyN/ZpEI7I7pELkpIVMMHyheBcsjWCKjJjo2dXrCmMlixpLx7NagmDYTxF4KMZ53oOFWDTTaOdiabmj1wE6eYe3VwjX2wBAW8UCoWJFTsRZLkAwvrqnvzA3RnQJLOdshu5a2pkYX0VeGyp16fVJD9jZftM0u/fG7a9jB+54+KJdX12A0mtbWd5CfavT8tf3dQPvz9ieHTOzft6ngVvPiwdf1W4FrVzD174rvLKmu/3TH3/Znuq9dvrtLf+vXWJ+EL9TuPpmdtf5ZWkmmz6eGiwovrLq5+rH3b6RmDW8b9oIRfkjoidv+CgZVPpOsul3UE2/qOvTDlQs/tx3HZxJelybW12s6H6p6Zuu/TLypPhob3n1pXP73r4rH+ORt/VD2HvLWvtUCp6M+/njw+68KJ0N6r8riSRx8Z2LtwJb97qdF144NL39wsmnKFCI27zx7pvdTcee7fssqPVtk9ZObv0bcvX9u8NXV+Q1NBUfLM0fVvTFOGExNPtX94Y8Jk14wtsHnXucFLV6Ye6qdDieUlZ1tmt+8ZKO6YMP+V4LX5xwNnwJvjfe99Pb37t78HKzxTfmGs3b49vuD65PZ/zhcWFPwHw7bk8g==
+eNqNVWtsFFUUbkWNPARSmyBRcRyFRunszuxul26L0nYLSklt2a4WWpt6O3O3O+3snWHu3aUPaqQSEy1IJxKNhQSl211YSh+xiUQ0aIjEGIzwB1NMKqmGoAExEiTKj/XOPtpiX+yfvTPnO+d853zn3OmMhqCOZRVl9suIQB2IhD5gozOqwx1BiMmeSAASvyqFKyuqvL1BXR5d7SdEwwVWK9BkC0DEr6uaLFpENWANCdYAxBg0QhxuUKXWS5nr2tkAaKknajNEmC1gBN7myGXYNIq+qW1ndVWB9MQGMdRZahVVSgUR89VOPyA5mCF+yOyEgP7pjIwY7NvAdtSZcVQJKiZOVEBQgpydy+OwihAknAIIpW+GI6qqpDIhEEhkSsWqxxDoot8ESRCLuqyZ1ZuAqoSB8an61NwmUEZakNRj0Q8DgCLbWY3WD3UiJ6ppZ0WZtCYOpFVL5MJEl1Ej29FBnc2myjqUTDZJpFlFGqk2NEGRUGRdR9QPgUSV2R/2q5gYw9N6PQhEEWqEg0hUJRrfONHYJmu5jAR9ZuUx0exCQkwj1gyhxgFFDsFI0ssYApqmyCIw7dYm2rH+VM85k8t0c8yUhqOKIWJ8VpzmYa1spaOBGN5id1hsQy0cJkBGCtWWdp9SimgJ+6mpBg2IzTQOlxo7I5J0HpiKUbHRVw7Eiqq7QpqCGH1ADzgdn059rwcRkQPQiLorp6dLGSfT2S2CYHEN3xUYtyLR6PMBBcPhiSZPuMRsvM3O8U6OFwbSXVIgaiR+o9cuCEd1iDW6MvCtCA1JgrgzTBWB576Npob8SMWWtJpjGSvCpVQd48tqKOUygsCUQpGh8R2MkF/A8wWCnXmx3NvvTqXxzijGsFcHCPuoIBvT4kdFfxA1QynmnlH2UXayLJ3mV+SATLjUhlOxzEcj7OB5fnTNnEidDr2MzIxhu8vlmicu7QwkxohZHyfYOEHwpqoUambOk9gtLnlZpFhFTFaU13Pz4ie5pX3W3IPPLAztNaM5M3mrQTKNYl9+Itva+fGTFFM+OffiMztFZib3/7UvmeiZOZBTG5dEM3OiZ+UTSynPyZLxBT3X88JWZ1mz0+aR2lBbiTvf0xTSBM9Wf29IBkZMsAhMo6o2KnDQvYlzA3qlclWJFTKipdtfLi7f7O7fxnnUBpXOkhfQmUMqgpEqqNPVNGKiogYletnpMELdPcXbjZF8H78uz+cUgYvP431OB7ex2jOUXqaJZQmbN2Xi+7Q7krycv8nknux6KCPxW+DtLt9ypmj52/HvbCusj232/DS+6vire8ZXv76YBadWHjz/Per5qO9sd9zyTtktx7nCmy/cvOB+5c3OnqWth3JvrHqXnF4YDew7fPv4wLHYNfhw1slm7VoJ21HUfb6tcFHPUfbie8Ul1xePfPzVticW7fVdWM/eeFw/cPa38qzosy/xY0LBg7cuxUtWbth0Jzt7fd32tWUj+67uWh4pxdmvHcnvvZJVu9VlyDkXT4Qi7C+DoHvFgdvOZQ5Lfl3elaf2vx/8MfzA4Q/337nuG15bDf8+tLqw+zJ5/t83Lrs+QeWuz+seedS7LDK+NPt84ZIzB+9v+PlXrumvP+InjxW1LLq6pFP/umYhaPvg99M7XHeeLrgvr3as7M/d8aauf/hdmRkZ8fiCjNAPy1Z10fN/12s1SQ==

docs/cassettes/review-tool-calls_f9a0d5d4-52ff-49e0-a6f4-41f9a0e844d8.msgpack.zlib

@@ -1 +1 @@
-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
+eNqNVt1vFFUUL5AYjSaCSjTGxGGgbYKd3Zl2u3RrGty0RUFKobsCbQOb25k7O5fO3jude2fpWvpQRB80gmPUKDExge0ubgptFQUiJpDIxwNEVBSKHyQ8kPgHiAmJ4J3Z3X7z0Zfu3nPO7/zO+Z1zsrvzaWhTRPCCEYQZtIHK+Bfq7s7bsM+BlO3JpSAziJbd2B6LH3RsNFFpMGbRxmAQWCgAMDNsYiE1oJJUMK0EU5BSkIQ020O0zLWFIwNiCvQnGOmFmIqNgiLXhmoEsezFX7oHRJuYkH8SHQptkVtVwqlg5j3tNACrpgIzoLATAv7PFhAWqL5aHKwRpiIBpYgyTmZmOMdmsN8HWlttmoIBTUvIEEdQDaj2zkaNASyssQFWEVVJwENiGcuH90H8hJMvhJgJztfzwiDlv5WgEhQCWzU8C8KW42UfEFXEMp4P1T0cEWllECchK+GOaESFfTrKRCJbk0ZEfw2v6+8SB7fNqHFud7pn8bEhdcxZLRBjDsaZZX41Jc6Jh8rusaQJaNvE5t46MCnkhLZ54hENmh6CagJHg1KdVC9RgjFkkgkYn5lyspK89+6PBqlqI8sbOZ+qbxB0Yk+XZrKRCcplSwG/nxYfOmgz5I/QZHun+kGZjXBSHPSa7U0ysqFXdHfRc9s0bUnPDqhydXlxeQMCja/DvqxBKHPH5wz4KFBVaDEJYpVoHN89nHwTWTWCBnWv8oLqdcHfILfQC6ElAROlYa4Y5Y4ByzKRCjx7cAfv2EhJJsnjMtdc8BSX+Jpg5h6LlnkEN2b4PmJBDtSFArVj/RKfe4RNvlC8+5xSzvLt3003WEDt5ThSadfdXDH4yHQfQt3hNqC2x2ZAeoK4w8BOhUNfT3+3HcxQCrr55o1z05WMU+nqAooSiIzPAKYZrLrD/lyNTzZ5MqRQK9fWSXJYkpUj5S6ZECeZ4R4MN4QO8VG3+J2Cb+U4JHPo7ixXBF44ny9dlgPtr5fV/Kvi2WwLV8f9fgvUagRFEVqgKnD8kKA0NMpyoyILr7bFR5pLaeLzijEe55eB6lyQ1rL4edVwcC/UCs3zyj4hTpVl8/wmSiEmlc4qF8v76mZDsixPVN3X0+ZDj7CXMVsXiUQegMs7A5l71KtPUmolRYkXq5QjXfPn8XdLKl7oEqucx4rzWvlA/ylu5Ziqh4iZn6Eid01UzxdNHDaH4nCDn+2lB/tPUSzFVD9MzL0pCvOFz2pfMdGK+3hOb1zRW7iv9z35FErKS0hzT/LP/KJvskOd0VV96zo6N7e2bGjr60LpekM/mEbALSgBRUgSkjThaPMaqRnwkyrF/BVy8y2dG6Jta5tHtkodpIfwWYoDPnOYYJiLQZuvpltQTeJo/NjZMMfDO6Kd7tEGXV5Vr4frG2CoTtbDIal1S8dYeZkmlyXrXUr/R8FQrnicf7j54nuPVvh/i9bvvbhjzyuL9yTOXIbB5Yc6l9z85IWFYOKX7QuXnZfDehjvu9a0eMn1puMrPoid3rL68ruXTt+oGuz+KOl+mW6/8mPsbtXFyrdvn/hsg3wJZptaxSPVz13ouzr09GMH9i595NjVnyoeX3388qY7n1450aL/fHJlQe2ML31il1a5+eq//5D43wOj18/ceOPJD9f2bP/q1MSZvlu1L9+K7roQSuPMqVtAeP5cuqraBdE/vtmvnx1dFqrsaR/7/J3Twp+J35cOncsePhvsGWr67f3o+ttffPzrt//xgu7eXVQxsvzOU88sqKj4H6D2kjg=

docs/cassettes/wait-user-input_a9f599b5-1a55-406b-a76b-f52b3ca06975.msgpack.zlib

@@ -1 +1 @@
-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

docs/cassettes/wait-user-input_cfd140f0-a5a6-4697-8115-322242f197b5.msgpack.zlib

@@ -1 +1 @@
-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
+eNqNVQtsFFUUbUWNYsCCpNAEcNxgAdvZX7efLUhcln60lNZ2SSlam9eZt7vDzs4Mb94USq2fWhTFgIP4CZFI6HZXN+VTgUAUiISIECpKwE/VIoSEECHFxMjHEPC92Vla7ALdbHbevHvuu+fdc+/d9lgzRKogS+ndgoQhAhwmL6reHkNwqQZV3BENQxyU+Uh1Va2vU0NC35NBjBW12GYDimAFEg4iWRE4KyeHbc0OWxiqKghANdIk8y2/3jep1RIGyxuxHIKSailmHHanK5exJFFk54VWC5JFSFYWTYXIQqycTKhImG4tVCGDg5BRIUBckMGyLJIfBqghY5t6MMuCEBmoFgYgmEtXEiPKcojRFAO1DALyQHSNoKWtgRKQeSjSAJwINB6yeWw+q8qSBDErAkzuTXnQaCZFCYQNigke1MhDlUOCQtNFDV4gGsxUDfnNoE1WihMkRcONKheEYUCArRaF5AsiLBi3b7WQLKMWY4VblEQMjAQpYGlrI95UBQFBnrIwoZR+Eio3LYEcNqCDHD1qqFwLAykFS4+ZtyC1M4AxJKa2kRFVzXNGxjWBTkm3oS0WhIAnpbc2EpRVrPcMK6ZtgOOgglkocTJPYuhbAisEJZfhoZ8qFOeoWka16vEQhAoLRKEZRhNe+nagKKLAAWq3LSHKdptFxVIuw81xWkksKUkJ67s9SR626hZS+xJjt+a5rM7ty1kVA0ESSfGSKiGUooph/2qoQQFciJzDmn2lRxPOW4diZFXvqgRcVe1tR9LK0rsAChe4dgzdR5qEhTDUY97q4eFM42C4PKvDYXX33Haw2iJxepcfiCrsuZXkWy5xp92Zx9oLWLtjazJLIpQCOKh35ucVfIagqpCZAN+IkiOxprZHiCKw93DM7OLNVRVJNU+lTYzMI+ro++ogn8s4HMw8yDHkfBfjKCzOJ183U1bp6/aaYXwpxejxISCpfiJISVL8GBfUpBDk496UsvdZBq+FSHxRCAuYNUcYEYu+6hGX3W7vy74rEpHiFyQaMZLndrvvcS7JDMT6Tno/1uFkHQ6fecuixanjGD3GJqahySpKWRFeT90TP8gt6ZM9Ap87MHQv7pueylvW8DCKXUVGtJx74wcpmj7TR+JzZ4pMKvf/pS8RaNpdkEMTl0Azd0XfkU/cVJ4VeH0vWTfaHSXlBc+r80ufC5R4Khe6lWbPEm9haVlnswD0uMPqYAKyHBDhNm8p6wVktLK1RgvpsXn1CzyVz3q7F7E1cpNMaskHSM1JsgSjtRCR1tTjnChrPBl2CEaJe42nXt9Z5LcX5nNO3u8vLHI5ORdbUlezPdlMt5olQiel8Qf8ejQxoL9JL3t89UNpxmfU/OqGioPPZFzP+Xb/VTQz/NhvK2w11dUZ4yKZOeO3HjnXue/3rr6nwzOvXULjeqqO9g5c7B3I+nPyBJcvevbIlzOEXa0L1rw1fuK1C5t/2Xv85UfGXz3Z9PFcS4Ol/PwnD3dkx9/eBd/7Yc/kMTMOv3vZXboUT9F3ZLo3rIkd4WdvbO/orS89umnOsVcrstZ65kx4YG3doVWjK3MWHFt9aUPOgQ/O6cvnZo55Z/PAqpXRfadHr5x+seNU8ffpP220W0+8OGtW+0s3ZhUFaqqeuKKIX8+ZUjVw9qOrez6XnK982r+luW9vfWbj1GmL+u/vX3f50f3HC86LF7JOZo2dOnPSa+3ayimj+89kaMqh65n/3qi9ryd0Ymz+mPcnpr/54JkDnd9lrP/nUPlfB+t+vPZzNtxdVrFp3bQPT89uRH/X/3GTZOzmzVFpV77YtX5nelraf/0LlPM=

docs/docs/cloud/deployment/cloud.md

@@ -5,7 +5,7 @@ LangGraph Cloud is available within <a href="https://www.langchain.com/langsmith
 ## Prerequisites
 
 1. LangGraph Cloud applications are deployed from GitHub repositories. Configure and upload a LangGraph Cloud application to a GitHub repository in order to deploy it to LangGraph Cloud.
-1. [Verify that the LangGraph API runs locally](test_locally.md). If the API does not build and run successfully (i.e. `langgraph up`), deploying to LangGraph Cloud will fail as well.
+1. [Verify that the LangGraph API runs locally](test_locally.md). If the API does not run successfully (i.e. `langgraph dev`), deploying to LangGraph Cloud will fail as well.
 
 ## Create New Deployment
 
@@ -15,7 +15,7 @@ Starting from the <a href="https://smith.langchain.com/" target="_blank">LangSmi
 1. In the top-right corner, select `+ New Deployment` to create a new deployment.
 1. In the `Create New Deployment` panel, fill out the required fields.
     1. `Deployment details`
-        1. Select `Import from GitHub` and follow the GitHub OAuth workflow to install and authorize LangChain's `hosted-langserve` GitHub app to  access the selected repositories. After installation is complete, return to the `Create New Deployment` panel and select the GitHub repository to deploy from the dropdown menu.
+        1. Select `Import from GitHub` and follow the GitHub OAuth workflow to install and authorize LangChain's `hosted-langserve` GitHub app to access the selected repositories. After installation is complete, return to the `Create New Deployment` panel and select the GitHub repository to deploy from the dropdown menu. **Note**: The GitHub user installing LangChain's `hosted-langserve` GitHub app must be an [owner](https://docs.github.com/en/organizations/managing-peoples-access-to-your-organization-with-roles/roles-in-an-organization#organization-owners) of the organization or account.
         1. Specify a name for the deployment.
         1. Specify the desired `Git Branch`. A deployment is linked to a branch. When a new revision is created, code for the linked branch will be deployed. The branch can be updated later in the [Deployment Settings](#deployment-settings).
         1. Specify the full path to the [LangGraph API config file](../reference/cli.md#configuration-file) including the file name. For example, if the file `langgraph.json` is in the root of the repository, simply specify `langgraph.json`.

docs/docs/cloud/deployment/setup.md

@@ -36,8 +36,8 @@ 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.30,<0.3.0
-langgraph-checkpoint>=1.0.14
+langgraph>=0.2.56,<0.3.0
+langgraph-checkpoint>=2.0.5,<3.0
 langchain-core>=0.2.38,<0.4.0
 langsmith>=0.1.63
 orjson>=3.9.7

docs/docs/cloud/deployment/setup_pyproject.md

@@ -36,8 +36,8 @@ 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.30,<0.3.0
-langgraph-checkpoint>=1.0.14
+langgraph>=0.2.56,<0.3.0
+langgraph-checkpoint>=2.0.5,<3.0
 langchain-core>=0.2.38,<0.4.0
 langsmith>=0.1.63
 orjson>=3.9.7

docs/docs/cloud/deployment/test_locally.md

@@ -6,17 +6,11 @@ Testing locally ensures that there are no errors or conflicts with Python depend
 
 ## Setup
 
-Install the proper packages:
+Install the LangGraph CLI package:
 
-
-=== "pip" 
-    ```bash
-    pip install -U langgraph-cli
-    ```
-=== "Homebrew (macOS only)"
-    ```bash
-    brew install langgraph-cli
-    ```
+```bash
+pip install -U "langgraph-cli[inmem]"
+```
 
 Ensure you have an API key, which you can create from the [LangSmith UI](https://smith.langchain.com) (Settings > API Keys). This is required to authenticate that you have LangGraph Cloud access. After you have saved the key to a safe place, place the following line in your `.env` file:
 
@@ -29,16 +23,26 @@ LANGSMITH_API_KEY = *********
 Once you have installed the CLI, you can run the following command to start the API server for local testing:
 
 ```shell
-langgraph up
+langgraph dev
 ```
 
 This will start up the LangGraph API server locally. If this runs successfully, you should see something like:
 
-```shell
-Ready!
-- API: http://localhost:8123
-2024-06-26 19:20:41,056:INFO:uvicorn.access 127.0.0.1:44138 - "GET /ok HTTP/1.1" 200
-```
+>    Ready!
+> 
+>    - API: [http://localhost:2024](http://localhost:2024/)
+>     
+>    - Docs: http://localhost:2024/docs
+>     
+>    - LangGraph Studio Web UI: https://smith.langchain.com/studio/?baseUrl=http://127.0.0.1:2024
+
+!!! note "In-Memory Mode"
+
+    The `langgraph dev` command starts LangGraph Server in an in-memory mode. This mode is suitable for development and testing purposes. For production use, you should deploy LangGraph Server with access to a persistent storage backend.
+
+    If you want to test your application with a persistent storage backend, you can use the `langgraph up` command instead of `langgraph dev`. You will
+    need to have `docker` installed on your machine to use this command.
+
 
 ### Interact with the server
 
@@ -53,7 +57,7 @@ You can either initialize by passing authentication or by setting an environment
     ```python
     from langgraph_sdk import get_client
 
-    # only pass the url argument to get_client() if you changed the default port when calling langgraph up
+    # only pass the url argument to get_client() if you changed the default port when calling langgraph dev
     client = get_client(url=<DEPLOYMENT_URL>,api_key=<LANGSMITH_API_KEY>)
     # Using the graph deployed with the name "agent"
     assistant_id = "agent"
@@ -65,7 +69,7 @@ You can either initialize by passing authentication or by setting an environment
     ```js
     import { Client } from "@langchain/langgraph-sdk";
 
-    // only set the apiUrl if you changed the default port when calling langgraph up
+    // only set the apiUrl if you changed the default port when calling langgraph dev
     const client = new Client({ apiUrl: <DEPLOYMENT_URL>, apiKey: <LANGSMITH_API_KEY> });
     // Using the graph deployed with the name "agent"
     const assistantId = "agent";
@@ -91,7 +95,7 @@ If you have a `LANGSMITH_API_KEY` set in your environment, you do not need to ex
     ```python
     from langgraph_sdk import get_client
 
-    # only pass the url argument to get_client() if you changed the default port when calling langgraph up
+    # only pass the url argument to get_client() if you changed the default port when calling langgraph dev
     client = get_client()
     # Using the graph deployed with the name "agent"
     assistant_id = "agent"
@@ -103,7 +107,7 @@ If you have a `LANGSMITH_API_KEY` set in your environment, you do not need to ex
     ```js
     import { Client } from "@langchain/langgraph-sdk";
 
-    // only set the apiUrl if you changed the default port when calling langgraph up
+    // only set the apiUrl if you changed the default port when calling langgraph dev
     const client = new Client();
     // Using the graph deployed with the name "agent"
     const assistantId = "agent";

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

@@ -0,0 +1,17 @@
+# Adding nodes as dataset examples in Studio
+
+In LangGraph Studio you can create dataset examples from the thread history in the right-hand pane. This can be especially useful when you want to evaluate intermediate steps of the agent.
+
+1. Click on the `Add to Dataset` button to enter the dataset mode.
+1. Select nodes which you want to add to dataset.
+1. Select the target dataset to create the example in.
+
+You can edit the example payload before sending it to the dataset, which is useful if you need to make changes to conform the example to the dataset schema.
+
+Finally, you can customise the target dataset by clicking on the `Settings` button.
+
+See [Evaluating intermediate steps](https://docs.smith.langchain.com/evaluation/how_to_guides/langgraph#evaluating-intermediate-steps) for more details on how to evaluate intermediate steps.
+
+<video controls allowfullscreen="true" poster="../img/studio_datasets.jpg">
+    <source src="https://langgraph-docs-assets.pages.dev/studio_datasets.mp4" type="video/mp4">
+</video>

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

@@ -83,7 +83,7 @@ Now, let's import our required packages and instantiate our client, assistant, a
 
 ## Create runs
 
-Now we can start our two runs and join the second on euntil it has completed:
+Now we can start our two runs and join the second one until it has completed:
 
 === "Python"
 

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

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

docs/docs/cloud/quick_start.md

@@ -1,462 +1,272 @@
-# LangGraph Cloud Quick Start
+# Quickstart: Deploy on LangGraph Cloud
 
-In this tutorial you will build and deploy a simple chatbot agent that can look things up on the internet. You will be using [LangGraph Cloud](../concepts/langgraph_cloud.md), [LangGraph Studio](../concepts/langgraph_studio.md) to visualize and test it out, and [LangGraph SDK](./reference/sdk/python_sdk_ref.md) to interact with the deployed agent.
+!!! note "Prerequisites"
 
-If you want to learn how to build an agent like this from scratch, take a look at the [LangGraph Quick Start tutorial](../tutorials/introduction.ipynb).
+    Before you begin, ensure you have the following:
 
-## Set up requirements
+    - [GitHub account](https://github.com/)
+    - [LangSmith account](https://smith.langchain.com/)
 
-This tutorial will use:
+## Create a repository on GitHub
 
-- Anthropic for the LLM - sign up and get an API key [here](https://console.anthropic.com/).
-- Tavily for the search engine - sign up and get an API key [here](https://app.tavily.com/).
-- LangSmith for hosting - sign up and get an API key [here](https://smith.langchain.com/).
+To deploy a LangGraph application to **LangGraph Cloud**, your application code must reside in a GitHub repository. Both public and private repositories are supported.
 
-## Create and configure your app
+You can deploy any [LangGraph Application](../concepts/application_structure.md) to LangGraph Cloud.
 
-First, let's set create all of the necessary files for our LangGraph application.
+For this guide, we'll use the pre-built Python [**ReAct Agent**](https://github.com/langchain-ai/react-agent) template.
 
-1. __Create application directory and files__
+??? note "Get Required API Keys for the ReAct Agent template"
 
-    Create a new application `my-app` with the following file structure:
+    This **ReAct Agent** application requires an API key from [Anthropic](https://console.anthropic.com/) and [Tavily](https://app.tavily.com/). You can get these API keys by signing up on their respective websites.
 
-    ```shell
-    mkdir my-app
-    ```
+    **Alternative**: If you'd prefer a scaffold application that doesn't require API keys, use the [**New LangGraph Project**](https://github.com/langchain-ai/new-langgraph-project) template instead of the **ReAct Agent** template.
 
-    === "Python"
 
-            my-app/
-            |-- agent.py            # code for your LangGraph agent
-            |-- requirements.txt    # Python packages required for your graph
-            |-- langgraph.json      # configuration file for LangGraph
-            |-- .env                # environment files with API keys
-
-    === "Javascript"
-
-            my-app/
-            |-- agent.ts            # code for your LangGraph agent
-            |-- package.json        # Javascript packages required for your graph
-            |-- langgraph.json      # configuration file for LangGraph
-            |-- .env                # environment files with API keys
-
-
-1. __Define your graph__
-
-    === "Python"
-        The `agent.py` file should contain code with your graph.
-
-    === "Javascript"
-        The `agent.ts` file should contain code with your graph.
-
-    The following code example is a simple chatbot agent (similar to the one in the [previous tutorial](../tutorials/introduction.ipynb)). Specifically, it uses [create_react_agent][langgraph.prebuilt.chat_agent_executor.create_react_agent], a prebuilt [ReAct](../concepts/agentic_concepts.md#react-implementation)-style agent.
-
-    The `agent` file needs to have a variable with a [CompiledGraph][langgraph.graph.graph.CompiledGraph] (in this case the `graph` variable).
-
-    === "Python"
-
-        ```python
-        # agent.py
-        from langchain_anthropic import ChatAnthropic
-        from langchain_community.tools.tavily_search import TavilySearchResults
-        from langgraph.prebuilt import create_react_agent
-
-        model = ChatAnthropic(model="claude-3-5-sonnet-20240620")
-
-        tools = [TavilySearchResults(max_results=2)]
-
-        # compiled graph
-        graph = create_react_agent(model, tools)
-        ```
-
-    === "Javascript"
-
-        ```ts
-        // agent.ts
-        import { ChatAnthropic } from "@langchain/anthropic";
-        import { TavilySearchResults } from "@langchain/community/tools/tavily_search";
-        import { createReactAgent } from "@langchain/langgraph/prebuilt";
-
-        const model = new ChatAnthropic({
-          model: "claude-3-5-sonnet-20240620",
-        });
-
-        const tools = [
-          new TavilySearchResults({ maxResults: 3, }),
-        ];
-
-        // compiled graph
-        export const graph = createReactAgent({ llm: model, tools });
-        ```
-
-1. __Specify dependencies__
-
-    === "Python"
-        You should add dependencies for your graph(s) to `requirements.txt`.
-
-    === "Javascript"
-        You should add dependencies for your graph(s) to `package.json`.
-
-    In this case we only require four packages for our graph to run:
-
-    === "Python"
-
-          ```python
-          langgraph
-          langchain_anthropic
-          tavily-python
-          langchain_community
-          ```
-
-    === "Javascript"
-
-          ```js
-          {
-            "name": "my-app",
-            "packageManager": "yarn@1.22.22",
-            "dependencies": {
-              "@langchain/community": "^0.3.11",
-              "@langchain/core": "^0.3.16",
-              "@langchain/langgraph": "0.2.18",
-              "@langchain/anthropic": "^0.3.7"
-            }
-          }
-          ```
-
-1. __Create LangGraph configuration file__
-
-    The [`langgraph.json`][langgraph.json] file is a configuration file that describes what graph(s) you are going to deploy. In this case we only have one graph: the compiled `graph` object from `agent.py` / `agent.ts`.
-
-    === "Python"
-
-        ```json
-        {
-          "dependencies": ["."],
-          "graphs": {
-            "agent": "./agent.py:graph"
-          },
-          "env": ".env"
-        }
-        ```
-
-    === "Javascript"
-
-        ```json
-        {
-          "node_version": "20",
-          "dockerfile_lines": [],
-          "dependencies": ["."],
-          "graphs": {
-            "agent": "./src/agent.ts:graph"
-          },
-          "env": ".env"
-        }
-        ```
-
-    Learn more about the LangGraph CLI configuration file [here](./reference/cli.md#configuration-file).
-
-1. __Specify environment variables__
-
-    The `.env` file should have any environment variables needed to run your graph. This will only be used for local testing, so if you are not testing locally you can skip this step. 
-
-    !!! warning
-        The `.env` file should NOT be included with the rest of source code in your Github repository. When creating a deployment using LangGraph Cloud, you will be able to specify the environment variables manually.
-
-    For this graph, we need two environment variables:
-
-    ```shell
-    ANTHROPIC_API_KEY=...
-    TAVILY_API_KEY=...
-    ```
-
-!!! tip
-    Learn more about different application structure options [here](../how-tos/index.md#application-structure).
-
-Now that we have set everything up on our local file system, we are ready to test our graph locally.
-
-## Test the app locally
-
-To test the LangGraph app before deploying it using LangGraph Cloud, you can start the [LangGraph server](../concepts/langgraph_server.md) locally or use [LangGraph Studio](../concepts/langgraph_studio.md).
-
-## Using local server
-
-You can test your app by running [LangGraph server](../concepts/langgraph_server.md) locally. This is useful to make sure you have configured our [CLI configuration file][langgraph.json] correctly and can interact with your graph.
-
-To run the server locally, you need to first install the LangGraph CLI:
-
-```shell
-pip install langgraph-cli
-```
-
-You can then test our API server locally. In order to run the server locally, you will need to add your `LANGSMITH_API_KEY` to the `.env` file.
-
-```shell
-langgraph up
-```
-
-This will start up the LangGraph API server locally. If this runs successfully, you should see something like:
-
-```shell
-Ready!
-- API: http://localhost:8123
-```
-
-First, let's verify that the server is running correctly by calling `/ok` endpoint:
-
-```shell
-curl --request GET --url http://localhost:8123/ok
-```
-
-Output:
-
-```
-{"ok": "true"}
-```
-
-Now we're ready to test the app with the real inputs!
-
-```shell
-curl --request POST \
-    --url http://localhost:8123/runs/stream \
-    --header 'Content-Type: application/json' \
-    --data '{
-    "assistant_id": "agent",
-    "input": {
-        "messages": [
-            {
-                "role": "user",
-                "content": "What is the weather in NYC?"
-            }
-        ]
-    },
-    "stream_mode": "updates"
-}'
-```
-
-Output:
-
-```
-...
-
-data: {
-  "agent": {
-    "messages": [
-      {
-        "content": "The search results from Tavily provide the current weather conditions in New York City, including temperature, wind speed, precipitation, humidity, and cloud cover. According to the results, as of 3:00pm on October 30th, 2024, it is overcast in NYC with a temperature of around 66°F (19°C), light winds from the southwest around 8 mph (13 km/h), and 66% humidity.\n\nSo in summary, the current weather in NYC is overcast with mild temperatures in the mid 60sF and light winds, based on the search results. Let me know if you need any other details!",
-        "type": "ai",
-        ...
-      }
-    ]
-  }
-}
-```
-
-You can see that our agent responds with the up-to-date search results!
-
-###  Using LangGraph Studio Desktop
-
-You can also test your app locally with [LangGraph Studio](../concepts/langgraph_studio.md). 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.
-
-LangGraph Studio is available as a [desktop app](https://studio.langchain.com/) for MacOS users. Once you have installed the app, you can select `my-app` directory, which will automatically start the server locally and load the graph in the UI.
-
-To interact with your chatbot agent in LangGraph Studio, you can add a new message in the `Input` section and press `Submit`.
-
-![LangGraph Studio Desktop](./deployment/img/quick_start_studio.png)
+1. Go to the [ReAct Agent](https://github.com/langchain-ai/react-agent) repository.
+2. Fork the repository to your GitHub account by clicking the `Fork` button in the top right corner.
 
 ## Deploy to LangGraph Cloud
 
-Once you've tested your graph locally and verified that it works as expected, you can deploy it to the LangGraph Cloud.
+??? note "1. Log in to [LangSmith](https://smith.langchain.com/)"
 
-First, you'll need to turn the `my-app` directory into a GitHub repo and [push it to GitHub](https://docs.github.com/en/migrations/importing-source-code/using-the-command-line-to-import-source-code/adding-locally-hosted-code-to-github).
+    <figure markdown="1">
+    [![Login to LangSmith](deployment/img/01_login.png){: style="max-height:300px"}](deployment/img/01_login.png)
+    <figcaption>
+    Go to [LangSmith](https://smith.langchain.com/) and log in. If you don't have an account, you can sign up for free.
+    </figcaption>
+    </figure>
 
-Once you have created your GitHub repository with a Python file containing your compiled graph as well as a `langgraph.json` with the configuration, you can head over to [LangSmith](https://smith.langchain.com/) and click on the graph icon (`LangGraph Cloud`) on the bottom of the left navbar. This will open the LangGraph deployments page. On this page, click the `+ New Deployment` button in the top right corner.
 
-![Langsmith Workflow](./deployment/img/cloud_deployment.png)
+??? note "2. Click on <em>LangGraph Platform</em> (the left sidebar)"
 
-**_If you have not deployed to LangGraph Cloud before:_** there will be a button that shows up saying `Import from GitHub`. You’ll need to follow that flow to connect LangGraph Cloud to GitHub.
+    <figure markdown="1">
+    [![Login to LangSmith](deployment/img/02_langgraph_platform.png){: style="max-height:300px"}](deployment/img/02_langgraph_platform.png)
+    <figcaption>
+    Select **LangGraph Platform** from the left sidebar.
+    </figcaption>
+    </figure>
 
-**_Once you have set up your GitHub connection:_** the new deployment page will look as follows:
+??? note "3. Click on + New Deployment (top right corner)"
 
-![Deployment before being filled out](./deployment/img/deployment_page.png)
+    <figure markdown="1">
+    [![Login to LangSmith](deployment/img/03_deployments_page.png){: style="max-height:300px"}](deployment/img/03_deployments_page.png)
+    <figcaption>
+    Click on **+ New Deployment** to create a new deployment. This button is located in the top right corner.
+    It'll open a new modal where you can fill out the required fields.
+    </figcaption>
+    </figure>
 
-To deploy your application, you should do the following:
+??? note "4. Click on Import from GitHub (first time users)"
 
-1. Select your GitHub username or organization from the selector
-1. Search for your repo to deploy in the search bar and select it
-1. Choose a name for your deployment
-1. In the `Git Branch` field, you can specify either the branch for the code you want to deploy, or the exact commit SHA.
-1. In the `LangGraph API config file` field, enter the path to your `langgraph.json` file (which in this case is just `langgraph.json`)
-1. If your application needs environment variables, add those in the `Environment Variables` section. They will be propagated to the underlying server so your code can access them. In this case, we will need `ANTHROPIC_API_KEY` and `TAVILY_API_KEY`.
+    <figure markdown="1">
+    [![image](deployment/img/04_create_new_deployment.png)](deployment/img/04_create_new_deployment.png)
+    <figcaption>
+    Click on **Import from GitHub** and follow the instructions to connect your GitHub account. This step is needed for **first-time users** or to add private repositories that haven't been connected before.</figcaption>
+        </figure>
 
-Hit `Submit` and your application will start deploying!
+??? note "5. Select the repository, configure ENV vars etc"
 
-After your deployment is complete, your deployments page should look as follows:
+    <figure markdown="1">
+    [![image](deployment/img/05_configure_deployment.png){: style="max-height:300px"}](deployment/img/05_configure_deployment.png)
+    <figcaption>
+    Select the <strong>repository</strong>, add env variables and secrets, and set other configuration options.
+    </figcaption>
+    </figure>
 
-![Deployed page](./deployment/img/deployed_page.png)
+    - **Repository**: Select the repository you forked earlier (or any other repository you want to deploy).
+    - Set the secrets and environment variables required by your application. For the **ReAct Agent** template, you need to set the following secrets:
+        - **ANTHROPIC_API_KEY**: Get an API key from [Anthropic](https://console.anthropic.com/).
+        - **TAVILY_API_KEY**: Get an API key on the [Tavily website](https://app.tavily.com/).
 
-## Interact with your deployment
+??? note "6. Click Submit to Deploy!"
 
-### Using LangGraph Studio (Cloud)
 
-On the deployment page for your application,, you should see a button in the top right corner that says `LangGraph Studio`. Clicking on this button will take you to the web version of LangGraph Studio. This is the same UI that you interacted with when [testing the app locally](#using-langgraph-studio-recommended), but instead of using a local LangGraph server, it uses the one from your LangGraph Cloud deployment.
+    <figure markdown="1">
+    [![image](deployment/img/05_configure_deployment.png){: style="max-height:300px"}](deployment/img/05_configure_deployment.png)
+    <figcaption>
+        Please note that this step may ~15 minutes to complete. You can check the status of your deployment in the **Deployments** view.
+        Click the <strong>Submit</strong> button at the top right corner to deploy your application.
+    </figcaption>
+    </figure>
 
-![Studio UI once being run](./deployment/img/graph_run.png)
 
-### Using LangGraph SDK
+## Lagraph Studio Web UI
 
-You can also interact with your deployed LangGraph application programmatically, using [LangGraph SDK](./reference/sdk/python_sdk_ref.md).
+Once your application is deployed, you can test it in **LangGraph Studio**. 
 
-First, make sure you have the SDK installed:
+??? note "1. Click on an existing deployment"
 
-=== "Python"
+    <figure markdown="1">
+    [![image](deployment/img/07_deployments_page.png){: style="max-height:300px"}](deployment/img/07_deployments_page.png)
+    <figcaption>
+        Click on the deployment you just created to view more details.
+    </figcaption>
+    </figure>
 
-    ```shell
-    pip install langgraph_sdk
-    ```
+??? note "2. Click on LangGraph Studio"
 
-=== "Javascript"
+    <figure markdown="1">
+    [![image](deployment/img/08_deployment_view.png){: style="max-height:300px"}](deployment/img/08_deployment_view.png)
+    <figcaption>
+        Click on the <strong>LangGraph Studio</strong> button to open LangGraph Studio.
+    </figcaption>
+    </figure>
 
-    ```shell
-    yarn add @langchain/langgraph-sdk
-    ```
+<figure markdown="1">
+[![image](deployment/img/09_langgraph_studio.png){: style="max-height:400px"}](deployment/img/09_langgraph_studio.png)
+<figcaption>
+    Sample graph run in LangGraph Studio.
+</figcaption>
+</figure>
 
-Before using, you need to get the URL of your LangGraph deployment. You can find this in the `Deployment` view. Click the URL to copy it to the clipboard.
+## Test the API
 
-You also need to make sure you have set up your API key properly so you can authenticate with LangGraph Cloud.
+!!! note
+
+    The API calls below are for the **ReAct Agent** template. If you're deploying a different application, you may need to adjust the API calls accordingly.
+
+Before using, you need to get the `URL` of your LangGraph deployment. You can find this in the `Deployment` view. Click the `URL` to copy it to the clipboard.
+
+You also need to make sure you have set up your API key properly, so you can authenticate with LangGraph Cloud.
 
 ```shell
 export LANGSMITH_API_KEY=...
 ```
 
-The first thing to do when using the SDK is to setup our client, access our assistant, and create a thread to execute a run on:
+=== "Python SDK (Async)"
 
-=== "Python"
+    **Install the LangGraph Python SDK**
 
-     ```python
-     from langgraph_sdk import get_client
+    ```shell
+    pip install langgraph-sdk
+    ```
 
-     client = get_client(url=<DEPLOYMENT_URL>)
-     # get default assistant
-     assistants = await client.assistants.search(metadata={"created_by": "system"})
-     assistant = assistants[0]
-     # create thread
-     thread = await client.threads.create()
-     print(thread)
-     ```
-
-=== "Javascript"
-
-     ```js
-     import { Client } from "@langchain/langgraph-sdk";
-
-     const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
-     // get default assistant
-     const assistants = await client.assistants.search({ metadata: {"created_by": "system"} })
-     const assistant = assistants[0];
-     // create thread
-     const thread = await client.threads.create();
-     console.log(thread)
-     ```
-
-=== "CURL"
-
-     ```bash
-     curl --request POST \
-         --url <DEPLOYMENT_URL>/assistants/search \
-         --header 'Content-Type: application/json' \
-         --data '{
-             "limit": 10,
-             "offset": 0,
-             "metadata": {"created_by": "system"}
-         }' &&
-     curl --request POST \
-         --url <DEPLOYMENT_URL>/threads \
-         --header 'Content-Type: application/json' \
-         --data '{}'
-     ```
-
-We can then execute a run on the thread:
-
-=== "Python"
+    **Send a message to the assistant (threadless run)**
 
     ```python
-    input = {
-        "messages": [{"role": "user", "content": "What is the weather in NYC?"}]
-    }
+    from langgraph_sdk import get_client
+
+    client = get_client(url="your-deployment-url", api_key="your-langsmith-api-key")
 
     async for chunk in client.runs.stream(
-        thread["thread_id"],
-        assistant["assistant_id"],
-        input=input,
+        None,  # Threadless run
+        "agent", # Name of assistant. Defined in langgraph.json.
+        input={
+            "messages": [{
+                "role": "human",
+                "content": "What is LangGraph?",
+            }],
+        },
         stream_mode="updates",
     ):
-        if chunk.data:
-            print(chunk.data)
+        print(f"Receiving new event of type: {chunk.event}...")
+        print(chunk.data)
+        print("\n\n")
     ```
 
-=== "Javascript"
+=== "Python SDK (Sync)"
+
+    **Install the LangGraph Python SDK**
+
+    ```shell
+    pip install langgraph-sdk
+    ```
+
+    **Send a message to the assistant (threadless run)**
+
+    ```python
+    from langgraph_sdk import get_sync_client
+
+    client = get_sync_client(url="your-deployment-url", api_key="your-langsmith-api-key")
+
+    for chunk in client.runs.stream(
+        None,  # Threadless run
+        "agent", # Name of assistant. Defined in langgraph.json.
+        input={
+            "messages": [{
+                "role": "human",
+                "content": "What is LangGraph?",
+            }],
+        },
+        stream_mode="updates",
+    ):
+        print(f"Receiving new event of type: {chunk.event}...")
+        print(chunk.data)
+        print("\n\n")
+    ```
+
+=== "Javascript SDK"
+
+    **Install the LangGraph JS SDK**
+
+    ```shell
+    npm install @langchain/langgraph-sdk
+    ```
+
+    **Send a message to the assistant (threadless run)**
 
     ```js
-    const input = { "messages": [{ "role": "user", "content": "What is the weather in NYC?" }] };
+    const { Client } = await import("@langchain/langgraph-sdk");
+
+    const client = new Client({ apiUrl: "your-deployment-url", apiKey: "your-langsmith-api-key" });
 
     const streamResponse = client.runs.stream(
-      thread["thread_id"],
-      assistant["assistant_id"],
-      {
-        input,
-        streamMode: "updates"
-      }
+        null, // Threadless run
+        "agent", // Assistant ID
+        {
+            input: {
+                "messages": [
+                    { "role": "user", "content": "What is LangGraph?"}
+                ]
+            },
+            streamMode: "messages",
+        }
     );
+
     for await (const chunk of streamResponse) {
-      if (chunk.data) {
-        console.log(chunk.data);
-      }
+        console.log(`Receiving new event of type: ${chunk.event}...`);
+        console.log(JSON.stringify(chunk.data));
+        console.log("\n\n");
     }
     ```
 
-=== "CURL"
+=== "Rest API"
 
     ```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": "What is the weather in NYC?"
-            }
-          ]
-        },
-        "stream_mode": "updates"
-      }'
+    curl -s --request POST \
+        --url <DEPLOYMENT_URL> \
+        --header 'Content-Type: application/json' \
+        --data "{
+            \"assistant_id\": \"agent\",
+            \"input\": {
+                \"messages\": [
+                    {
+                        \"role\": \"human\",
+                        \"content\": \"What is LangGraph?\"
+                    }
+                ]
+            },
+            \"stream_mode\": \"updates\"
+        }" 
     ```
 
-Output:
 
-```
-...
-
-data: {
-  "agent": {
-    "messages": [
-      {
-        "content": "The search results from Tavily provide the current weather conditions in New York City, including temperature, wind speed, precipitation, humidity, and cloud cover. According to the results, as of 3:00pm on October 30th, 2024, it is overcast in NYC with a temperature of around 66°F (19°C), light winds from the southwest around 8 mph (13 km/h), and 66% humidity.\n\nSo in summary, the current weather in NYC is overcast with mild temperatures in the mid 60sF and light winds, based on the search results. Let me know if you need any other details!",
-        "type": "ai",
-        ...
-      }
-    ]
-  }
-}
-```
-
-## Next steps
+## Next Steps
 
 Congratulations! If you've worked your way through this tutorial you are well on your way to becoming a LangGraph Cloud expert. Here are some other resources to check out to help you out on the path to expertise:
 
-* [LangGraph How-to guides](../how-tos/index.md)
-* [LangGraph Tutorials](../tutorials/index.md)
+### LangGraph Framework
+
+- **[LangGraph Tutorial](../tutorials/introduction.ipynb)**: Get started with LangGraph framework.
+- **[LangGraph Concepts](../concepts/index.md)**: Learn the foundational concepts of LangGraph.
+- **[LangGraph How-to Guides](../how-tos/index.md)**: Guides for common tasks with LangGraph.
+ 
+### 📚 Learn More about LangGraph Platform
+
+Expand your knowledge with these resources:
+
+- **[LangGraph Platform Concepts](../concepts/index.md#langgraph-platform)**: Understand the foundational concepts of the LangGraph Platform.
+- **[LangGraph Platform How-to Guides](../how-tos/index.md#langgraph-platform)**: Discover step-by-step guides to build and deploy applications.
+- **[Launch Local LangGraph Server](../tutorials/langgraph-platform/local-server.md)**: This quick start guide shows how to start a LangGraph Server locally for the **ReAct Agent** template. The steps are similar for other templates.
+
+

docs/docs/cloud/reference/cli.md

@@ -21,14 +21,15 @@ The LangGraph command line interface includes commands to build and run a LangGr
 
 [](){#langgraph.json}
 
-## Configuration File
+## Configuration File {#configuration-file}
 
 The LangGraph CLI requires a JSON configuration file with the following keys:
 
-| Key                | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| Key                | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
 | ------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `dependencies`     | **Required**. Array of dependencies for LangGraph Cloud API server. Dependencies can be one of the following: (1) `"."`, which will look for local Python packages, (2) `pyproject.toml`, `setup.py` or `requirements.txt` in the app directory `"./local_package"`, or (3) a package name.                                                                                                                                                                                                                                                  |
 | `graphs`           | **Required**. Mapping from graph ID to path where the compiled graph or a function that makes a graph is defined. Example: <ul><li>`./your_package/your_file.py:variable`, where `variable` is an instance of `langgraph.graph.state.CompiledStateGraph`</li><li>`./your_package/your_file.py:make_graph`, where `make_graph` is a function that takes a config dictionary (`langchain_core.runnables.RunnableConfig`) and creates an instance of `langgraph.graph.state.StateGraph` / `langgraph.graph.state.CompiledStateGraph`.</li></ul> |
+| `auth`             | _(Added in v0.0.11)_ Auth configuration containing the path to your authentication handler. Example: `./your_package/auth.py:auth`, where `auth` is an instance of `langgraph_sdk.Auth`. See [authentication guide](../../concepts/auth.md) for details.                                                                                                                                                                                                                                                                                                                      |
 | `env`              | Path to `.env` file or a mapping from environment variable to its value.                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
 | `store`            | Configuration for adding semantic search to the BaseStore. Contains the following fields: <ul><li>`index`: Configuration for semantic search indexing with fields:<ul><li>`embed`: Embedding provider (e.g., "openai:text-embedding-3-small") or path to custom embedding function</li><li>`dims`: Dimension size of the embedding model. Used to initialize the vector table.</li><li>`fields` (optional): List of fields to index. Defaults to `["$"]`, meaningto index entire documents. Can be specific fields like `["text", "summary", "some.value"]`</li></ul></li></ul>                                                                  |
 | `python_version`   | `3.11` or `3.12`. Defaults to `3.11`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
@@ -120,6 +121,35 @@ def embed_texts(texts: list[str]) -> list[list[float]]:
     return [[0.1, 0.2, ...] for _ in texts]  # dims-dimensional vectors
 ```
 
+#### Adding custom authentication
+
+```json
+{
+  "dependencies": ["."],
+  "graphs": {
+    "chat": "./chat/graph.py:graph"
+  },
+  "auth": {
+    "path": "./auth.py:auth",
+    "openapi": {
+      "securitySchemes": {
+        "apiKeyAuth": {
+          "type": "apiKey",
+          "in": "header",
+          "name": "X-API-Key"
+        }
+      },
+      "security": [
+        {"apiKeyAuth": []}
+      ]
+    },
+    "disable_studio_auth": false
+  }
+}
+```
+
+See the [authentication conceptual guide](../../concepts/auth.md) for details, and the [setting up custom authentication](../../tutorials/auth/getting_started.md) guide for a practical walk through of the process.
+
 ## Commands
 
 The base command for the LangGraph CLI is `langgraph`.
@@ -134,6 +164,11 @@ langgraph [OPTIONS] COMMAND [ARGS]
 
 Run LangGraph API server in development mode with hot reloading and debugging capabilities. This lightweight server requires no Docker installation and is suitable for development and testing. State is persisted to a local directory.
 
+!!! note "Python only"
+
+    Currently, the CLI only supports Python >= 3.11.
+    JS support is coming soon.
+
 **Installation**
 
 This command requires the "inmem" extra to be installed:
@@ -253,3 +288,4 @@ RUN set -ex && \
 RUN PIP_CONFIG_FILE=/pipconfig.txt PYTHONDONTWRITEBYTECODE=1 pip install --no-cache-dir -c /api/constraints.txt -e /deps/*
 
 ENV LANGSERVE_GRAPHS='{"agent": "/deps/__outer_graphs/src/agent.py:graph", "storm": "/deps/__outer_graphs/src/storm.py:graph"}'
+```

docs/docs/cloud/reference/sdk/python_sdk_ref.md

@@ -6,3 +6,12 @@
 
 ::: langgraph_sdk.schema
     handler: python
+
+::: langgraph_sdk.auth
+    handler: python
+
+::: langgraph_sdk.auth.types
+    handler: python
+
+::: langgraph_sdk.auth.exceptions
+    handler: python

docs/docs/concepts/agentic_concepts.md

@@ -1,26 +1,26 @@
 # Agent architectures
 
-Many LLM applications implement a particular control flow of steps before and / or after LLM calls. As an example, [RAG](https://github.com/langchain-ai/rag-from-scratch) performs retrieval of relevant documents to a question, and passes those documents to an LLM in order to ground the model's response. 
+Many LLM applications implement a particular control flow of steps before and / or after LLM calls. As an example, [RAG](https://github.com/langchain-ai/rag-from-scratch) performs retrieval of documents relevant to a user question, and passes those documents to an LLM in order to ground the model's response in the provided document context. 
 
-Instead of hard-coding a fixed control flow, we sometimes want LLM systems that can pick its own control flow to solve more complex problems! This is one definition of an [agent](https://blog.langchain.dev/what-is-an-agent/): *an agent is a system that uses an LLM to decide the control flow of an application.* There are many ways that an LLM can control application:
+Instead of hard-coding a fixed control flow, we sometimes want LLM systems that can pick their own control flow to solve more complex problems! This is one definition of an [agent](https://blog.langchain.dev/what-is-an-agent/): *an agent is a system that uses an LLM to decide the control flow of an application.* There are many ways that an LLM can control application:
 
 - An LLM can route between two potential paths
 - An LLM can decide which of many tools to call
 - An LLM can decide whether the generated answer is sufficient or more work is needed
 
-As a result, there are many different types of [agent architectures](https://blog.langchain.dev/what-is-a-cognitive-architecture/), which given an LLM varying levels of control. 
+As a result, there are many different types of [agent architectures](https://blog.langchain.dev/what-is-a-cognitive-architecture/), which give an LLM varying levels of control. 
 
 ![Agent Types](img/agent_types.png)
 
 ## 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 governs a single decision and can return a narrow set of outputs. 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 limited set of pre-defined options. Routers typically employ a few different concepts to achieve this.
 
 ### Structured Output
 
 Structured outputs with LLMs work by providing a specific format or schema that the LLM should follow in its response. This is similar to tool calling, but more general. While tool calling typically involves selecting and using predefined functions, structured outputs can be used for any type of formatted response. Common methods to achieve structured outputs include:
 
-1. Prompt engineering: Instructing the LLM to respond in a specific format.
+1. Prompt engineering: Instructing the LLM to respond in a specific format via the system prompt.
 2. Output parsers: Using post-processing to extract structured data from LLM responses.
 3. Tool calling: Leveraging built-in tool calling capabilities of some LLMs to generate structured outputs.
 
@@ -30,7 +30,7 @@ Structured outputs are crucial for routing as they ensure the LLM's decision can
 
 While a router allows an LLM to make a single decision, more complex agent architectures expand the LLM's control in two key ways:
 
-1. Multi-step decision making: The LLM can control a sequence of decisions rather than just one.
+1. Multi-step decision making: The LLM can make a series of decisions, one after another, instead of just one.
 2. Tool access: The LLM can choose from and use a variety of tools to accomplish tasks.
 
 [ReAct](https://arxiv.org/abs/2210.03629) is a popular general purpose agent architecture that combines these expansions, integrating three core concepts. 
@@ -39,13 +39,13 @@ While a router allows an LLM to make a single decision, more complex agent archi
 2. `Memory`: Enabling the agent to retain and use information from previous steps.
 3. `Planning`: Empowering the LLM to create and follow multi-step plans to achieve goals.
 
-This architecture allows for more complex and flexible agent behaviors, going beyond simple routing to enable dynamic problem-solving across multiple steps. You can use it with [`create_react_agent`][langgraph.prebuilt.chat_agent_executor.create_react_agent].
+This architecture allows for more complex and flexible agent behaviors, going beyond simple routing to enable dynamic problem-solving with multiple steps. You can use it with [`create_react_agent`][langgraph.prebuilt.chat_agent_executor.create_react_agent].
 
 ### Tool calling
 
-Tools are useful whenever you want an agent to interact with external systems. External systems (e.g., APIs) often require a particular input schema or payload, rather than natural language. When we bind an API, for example, as a tool we given the model awareness of the required input schema. The model will choose to call a tool based upon the natural language input from the user and  it will return an output that adheres to the tool's schema. 
+Tools are useful whenever you want an agent to interact with external systems. External systems (e.g., APIs) often require a particular input schema or payload, rather than natural language. When we bind an API, for example, as a tool, we give the model awareness of the required input schema. The model will choose to call a tool based upon the natural language input from the user and it will return an output that adheres to the tool's required schema. 
 
-[Many LLM providers support tool calling](https://python.langchain.com/v0.1/docs/integrations/chat/) and [tool calling interface](https://blog.langchain.dev/improving-core-tool-interfaces-and-docs-in-langchain/) in LangChain is simple: you can simply pass any Python `function` into `ChatModel.bind_tools(function)`.
+[Many LLM providers support tool calling](https://python.langchain.com/docs/integrations/chat/) and [tool calling interface](https://blog.langchain.dev/improving-core-tool-interfaces-and-docs-in-langchain/) in LangChain is simple: you can simply pass any Python `function` into `ChatModel.bind_tools(function)`.
 
 ![Tools](img/tool_call.png)
 
@@ -67,11 +67,11 @@ Effective memory management enhances an agent's ability to maintain context, lea
 
 ### Planning
 
-In the ReAct architecture, an LLM is called repeatedly in a while-loop. At each step the agent decides which tools to call, and what the inputs to those tools should be. Those tools are then executed, and the outputs are fed back into the LLM as observations. The while-loop terminates when the agent decides it is not worth calling any more tools.
+In the ReAct architecture, an LLM is called repeatedly in a while-loop. At each step the agent decides which tools to call, and what the inputs to those tools should be. Those tools are then executed, and the outputs are fed back into the LLM as observations. The while-loop terminates when the agent decides it has enough information to solve the user request and it is not worth calling any more tools.
 
 ### ReAct implementation 
 
-There are several differences between this paper and the pre-built [`create_react_agent`][langgraph.prebuilt.chat_agent_executor.create_react_agent] implementation:
+There are several differences between [this](https://arxiv.org/abs/2210.03629) paper and the pre-built [`create_react_agent`][langgraph.prebuilt.chat_agent_executor.create_react_agent] implementation:
 
 - First, we use [tool-calling](#tool-calling) to have LLMs call tools, whereas the paper used prompting + parsing of raw output. This is because tool calling did not exist when the paper was written, but is generally better and more reliable.
 - Second, we use messages to prompt the LLM, whereas the paper used string formatting. This is because at the time of writing, LLMs didn't even expose a message-based interface, whereas now that's the only interface they expose.

docs/docs/concepts/auth.md

@@ -0,0 +1,428 @@
+# Authentication & Access Control
+
+LangGraph Platform provides a flexible authentication and authorization system that can integrate with most authentication schemes.
+
+!!! note "Python only"
+
+    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.
+
+## Core Concepts
+
+### Authentication vs Authorization
+
+While often used interchangeably, these terms represent distinct security concepts:
+
+- [**Authentication**](#authentication) ("AuthN") verifies _who_ you are. This runs as middleware for every request.
+- [**Authorization**](#authorization) ("AuthZ") determines _what you can do_. This validates the user's privileges and roles on a per-resource basis.
+
+In LangGraph Platform, authentication is handled by your [`@auth.authenticate`](../cloud/reference/sdk/python_sdk_ref.md#langgraph_sdk.auth.Auth.authenticate) handler, and authorization is handled by your [`@auth.on`](../cloud/reference/sdk/python_sdk_ref.md#langgraph_sdk.auth.Auth.on) handlers.
+
+## Default Security Models
+
+LangGraph Platform provides different security defaults:
+
+### LangGraph Cloud
+
+- Uses LangSmith API keys by default
+- Requires valid API key in `x-api-key` header
+- Can be customized with your auth handler
+
+### Self-Hosted
+
+- No default authentication
+- Complete flexibility to implement your security model
+- You control all aspects of authentication and authorization
+
+## System Architecture
+
+A typical authentication setup involves three main components:
+
+1. **Authentication Provider** (Identity Provider/IdP)
+
+    * A dedicated service that manages user identities and credentials
+    * Handles user registration, login, password resets, etc.
+    * Issues tokens (JWT, session tokens, etc.) after successful authentication
+    * Examples: Auth0, Supabase Auth, Okta, or your own auth server
+
+2. **LangGraph Backend** (Resource Server)
+
+    * Your LangGraph application that contains business logic and protected resources
+    * Validates tokens with the auth provider
+    * Enforces access control based on user identity and permissions
+    * Doesn't store user credentials directly
+
+3. **Client Application** (Frontend)
+
+    * Web app, mobile app, or API client
+    * Collects time-sensitive user credentials and sends to auth provider
+    * Receives tokens from auth provider
+    * Includes these tokens in requests to LangGraph backend
+
+Here's how these components typically interact:
+
+```mermaid
+sequenceDiagram
+    participant Client as Client App
+    participant Auth as Auth Provider
+    participant LG as LangGraph Backend
+
+    Client->>Auth: 1. Login (username/password)
+    Auth-->>Client: 2. Return token
+    Client->>LG: 3. Request with token
+    Note over LG: 4. Validate token (@auth.authenticate)
+    LG-->>Auth:  5. Fetch user info
+    Auth-->>LG: 6. Confirm validity
+    Note over LG: 7. Apply access control (@auth.on.*)
+    LG-->>Client: 8. Return resources
+```
+
+Your [`@auth.authenticate`](../cloud/reference/sdk/python_sdk_ref.md#langgraph_sdk.auth.Auth.authenticate) handler in LangGraph handles steps 4-6, while your [`@auth.on`](../cloud/reference/sdk/python_sdk_ref.md#langgraph_sdk.auth.Auth.on) handlers implement step 7.
+
+## Authentication
+
+Authentication in LangGraph runs as middleware on every request. Your [`@auth.authenticate`](../cloud/reference/sdk/python_sdk_ref.md#langgraph_sdk.auth.Auth.authenticate) handler receives request information and should:
+
+1. Validate the credentials
+2. Return [user info](../cloud/reference/sdk/python_sdk_ref.md#langgraph_sdk.auth.types.MinimalUserDict) containing the user's identity and user information if valid
+3. Raise an [HTTP exception](../cloud/reference/sdk/python_sdk_ref.md#langgraph_sdk.auth.exceptions.HTTPException) or AssertionError if invalid
+
+```python
+from langgraph_sdk import Auth
+
+auth = Auth()
+
+@auth.authenticate
+async def authenticate(headers: dict) -> Auth.types.MinimalUserDict:
+    # Validate credentials (e.g., API key, JWT token)
+    api_key = headers.get("x-api-key")
+    if not api_key or not is_valid_key(api_key):
+        raise Auth.exceptions.HTTPException(
+            status_code=401,
+            detail="Invalid API key"
+        )
+
+    # Return user info - only identity and is_authenticated are required
+    # Add any additional fields you need for authorization
+    return {
+        "identity": "user-123",        # Required: unique user identifier
+        "is_authenticated": True,      # Optional: assumed True by default
+        "permissions": ["read", "write"] # Optional: for permission-based auth
+        # You can add more custom fields if you want to implement other auth patterns
+        "role": "admin",
+        "org_id": "org-456"
+
+    }
+```
+
+The returned user information is available:
+
+- To your authorization handlers via [`ctx.user`](../cloud/reference/sdk/python_sdk_ref.md#langgraph_sdk.auth.types.AuthContext)
+- In your application via `config["configuration"]["langgraph_auth_user"]`
+
+??? tip "Supported Parameters"
+
+    The [`@auth.authenticate`](../cloud/reference/sdk/python_sdk_ref.md#langgraph_sdk.auth.Auth.authenticate) handler can accept any of the following parameters by name:
+
+    * request (Request): The raw ASGI request object
+    * body (dict): The parsed request body
+    * path (str): The request path, e.g., "/threads/abcd-1234-abcd-1234/runs/abcd-1234-abcd-1234/stream"
+    * method (str): The HTTP method, e.g., "GET"
+    * path_params (dict[str, str]): URL path parameters, e.g., {"thread_id": "abcd-1234-abcd-1234", "run_id": "abcd-1234-abcd-1234"}
+    * query_params (dict[str, str]): URL query parameters, e.g., {"stream": "true"}
+    * headers (dict[bytes, bytes]): Request headers
+    * authorization (str | None): The Authorization header value (e.g., "Bearer <token>")
+    
+    In many of our tutorials, we will just show the "authorization" parameter to be concise, but you can opt to accept more information as needed
+    to implement your custom authentication scheme.
+
+## Authorization
+
+After authentication, LangGraph calls your [`@auth.on`](../cloud/reference/sdk/python_sdk_ref.md#langgraph_sdk.auth.Auth.on) handlers to control access to specific resources (e.g., threads, assistants, crons). These handlers can:
+
+1. Add metadata to be saved during resource creation by mutating the `value["metadata"]` dictionary directly. See the [supported actions table](##supported-actions) for the list of types the value can take for each action.
+2. Filter resources by metadata during search/list or read operations by returning a [filter dictionary](#filter-operations).
+3. Raise an HTTP exception if access is denied.
+
+If you want to just implement simple user-scoped access control, you can use a single [`@auth.on`](../cloud/reference/sdk/python_sdk_ref.md#langgraph_sdk.auth.Auth.on) handler for all resources and actions. If you want to have different control depending on the resource and action, you can use [resource-specific handlers](#resource-specific-handlers). See the [Supported Resources](#supported-resources) section for a full list of the resources that support access control.
+
+```python
+@auth.on
+async def add_owner(
+    ctx: Auth.types.AuthContext,
+    value: dict  # The payload being sent to this access method
+) -> dict:  # Returns a filter dict that restricts access to resources
+    """Authorize all access to threads, runs, crons, and assistants.
+
+    This handler does two things:
+        - Adds a value to resource metadata (to persist with the resource so it can be filtered later)
+        - Returns a filter (to restrict access to existing resources)
+
+    Args:
+        ctx: Authentication context containing user info, permissions, the path, and
+        value: The request payload sent to the endpoint. For creation
+              operations, this contains the resource parameters. For read
+              operations, this contains the resource being accessed.
+
+    Returns:
+        A filter dictionary that LangGraph uses to restrict access to resources.
+        See [Filter Operations](#filter-operations) for supported operators.
+    """
+    # Create filter to restrict access to just this user's resources
+    filters = {"owner": ctx.user.identity}
+
+    # Get or create the metadata dictionary in the payload
+    # This is where we store persistent info about the resource
+    metadata = value.setdefault("metadata", {})
+
+    # Add owner to metadata - if this is a create or update operation,
+    # this information will be saved with the resource
+    # So we can filter by it later in read operations
+    metadata.update(filters)
+
+    # Return filters to restrict access
+    # These filters are applied to ALL operations (create, read, update, search, etc.)
+    # to ensure users can only access their own resources
+    return filters
+```
+
+### Resource-Specific Handlers {#resource-specific-handlers}
+
+You can register handlers for specific resources and actions by chaining the resource and action names together with the [`@auth.on`](../cloud/reference/sdk/python_sdk_ref.md#langgraph_sdk.auth.Auth.on) decorator.
+When a request is made, the most specific handler that matches that resource and action is called. Below is an example of how to register handlers for specific resources and actions. For the following setup:
+
+1. Authenticated users are able to create threads, read thread, create runs on threads
+2. Only users with the "assistants:create" permission are allowed to create new assistants
+3. All other endpoints (e.g., e.g., delete assistant, crons, store) are disabled for all users.
+
+!!! tip "Supported Handlers"
+
+    For a full list of supported resources and actions, see the [Supported Resources](#supported-resources) section below.
+
+```python
+# Generic / global handler catches calls that aren't handled by more specific handlers
+@auth.on
+async def reject_unhandled_requests(ctx: Auth.types.AuthContext, value: Any) -> False:
+    print(f"Request to {ctx.path} by {ctx.user.identity}")
+    raise Auth.exceptions.HTTPException(
+        status_code=403,
+        detail="Forbidden"
+    )
+
+# Matches the "thread" resource and all actions - create, read, update, delete, search
+# Since this is **more specific** than the generic @auth.on handler, it will take precedence
+# over the generic handler for all actions on the "threads" resource
+@auth.on.threads
+async def on_thread_create(
+    ctx: Auth.types.AuthContext,
+    value: Auth.types.threads.create.value
+):
+    if "write" not in ctx.permissions:
+        raise Auth.exceptions.HTTPException(
+            status_code=403,
+            detail="User lacks the required permissions."
+        )
+    # Setting metadata on the thread being created
+    # will ensure that the resource contains an "owner" field
+    # Then any time a user tries to access this thread or runs within the thread,
+    # we can filter by owner
+    metadata = value.setdefault("metadata", {})
+    metadata["owner"] = ctx.user.identity
+    return {"owner": ctx.user.identity}
+
+# Thread creation. This will match only on thread create actions
+# Since this is **more specific** than both the generic @auth.on handler and the @auth.on.threads handler,
+# it will take precedence for any "create" actions on the "threads" resources
+@auth.on.threads.create
+async def on_thread_create(
+    ctx: Auth.types.AuthContext,
+    value: Auth.types.threads.create.value
+):
+    # Setting metadata on the thread being created
+    # will ensure that the resource contains an "owner" field
+    # Then any time a user tries to access this thread or runs within the thread,
+    # we can filter by owner
+    metadata = value.setdefault("metadata", {})
+    metadata["owner"] = ctx.user.identity
+    return {"owner": ctx.user.identity}
+
+# Reading a thread. Since this is also more specific than the generic @auth.on handler, and the @auth.on.threads handler,
+# it will take precedence for any "read" actions on the "threads" resource
+@auth.on.threads.read
+async def on_thread_read(
+    ctx: Auth.types.AuthContext,
+    value: Auth.types.threads.read.value
+):
+    # Since we are reading (and not creating) a thread,
+    # we don't need to set metadata. We just need to
+    # return a filter to ensure users can only see their own threads
+    return {"owner": ctx.user.identity}
+
+# Run creation, streaming, updates, etc.
+# This takes precedenceover the generic @auth.on handler and the @auth.on.threads handler
+@auth.on.threads.create_run
+async def on_run_create(
+    ctx: Auth.types.AuthContext,
+    value: Auth.types.threads.create_run.value
+):
+    metadata = value.setdefault("metadata", {})
+    metadata["owner"] = ctx.user.identity
+    # Inherit thread's access control
+    return {"owner": ctx.user.identity}
+
+# Assistant creation
+@auth.on.assistants.create
+async def on_assistant_create(
+    ctx: Auth.types.AuthContext,
+    value: Auth.types.assistants.create.value
+):
+    if "assistants:create" not in ctx.permissions:
+        raise Auth.exceptions.HTTPException(
+            status_code=403,
+            detail="User lacks the required permissions."
+        )
+```
+
+Notice that we are mixing global and resource-specific handlers in the above example. Since each request is handled by the most specific handler, a request to create a `thread` would match the `on_thread_create` handler but NOT the `reject_unhandled_requests` handler. A request to `update` a thread, however would be handled by the global handler, since we don't have a more specific handler for that resource and action. Requests to create, update, 
+
+### Filter Operations {#filter-operations}
+
+Authorization handlers can return `None`, a boolean, or a filter dictionary.
+- `None` and `True` mean "authorize access to all underling resources"
+- `False` means "deny access to all underling resources (raises a 403 exception)"
+- A metadata filter dictionary will restrict access to resources
+
+A filter dictionary is a dictionary with keys that match the resource metadata. It supports three operators:
+
+- The default value is a shorthand for exact match, or "$eq", below. For example, `{"owner": user_id}` will include only resources with metadata containing `{"owner": user_id}`
+- `$eq`: Exact match (e.g., `{"owner": {"$eq": user_id}}`) - this is equivalent to the shorthand above, `{"owner": user_id}`
+- `$contains`: List membership (e.g., `{"allowed_users": {"$contains": user_id}}`) The value here must be an element of the list. The metadata in the stored resource must be a list/container type.
+
+A dictionary with multiple keys is treated using a logical `AND` filter. For example, `{"owner": org_id, "allowed_users": {"$contains": user_id}}` will only match resources with metadata whose "owner" is `org_id` and whose "allowed_users" list contains `user_id`.
+See the reference [here](../cloud/reference/sdk/python_sdk_ref.md#langgraph_sdk.auth.types.FilterType) for more information.
+
+## Common Access Patterns
+
+Here are some typical authorization patterns:
+
+### Single-Owner Resources
+
+This common pattern lets you scope all threads, assistants, crons, and runs to a single user. It's useful for common single-user use cases like regular chatbot-style apps.
+
+```python
+@auth.on
+async def owner_only(ctx: Auth.types.AuthContext, value: dict):
+    metadata = value.setdefault("metadata", {})
+    metadata["owner"] = ctx.user.identity
+    return {"owner": ctx.user.identity}
+```
+
+### Permission-based Access
+
+This pattern lets you control access based on **permissions**. It's useful if you want certain roles to have broader or more restricted access to resources.
+
+```python
+# In your auth handler:
+@auth.authenticate
+async def authenticate(headers: dict) -> Auth.types.MinimalUserDict:
+    ...
+    return {
+        "identity": "user-123",
+        "is_authenticated": True,
+        "permissions": ["threads:write", "threads:read"]  # Define permissions in auth
+    }
+
+def _default(ctx: Auth.types.AuthContext, value: dict):
+    metadata = value.setdefault("metadata", {})
+    metadata["owner"] = ctx.user.identity
+    return {"owner": ctx.user.identity}
+
+@auth.on.threads.create
+async def create_thread(ctx: Auth.types.AuthContext, value: dict):
+    if "threads:write" not in ctx.permissions:
+        raise Auth.exceptions.HTTPException(
+            status_code=403,
+            detail="Unauthorized"
+        )
+    return _default(ctx, value)
+
+
+@auth.on.threads.read
+async def rbac_create(ctx: Auth.types.AuthContext, value: dict):
+    if "threads:read" not in ctx.permissions and "threads:write" not in ctx.permissions:
+        raise Auth.exceptions.HTTPException(
+            status_code=403,
+            detail="Unauthorized"
+        )
+    return _default(ctx, value)
+```
+
+## Supported Resources
+
+LangGraph provides three levels of authorization handlers, from most general to most specific:
+
+1. **Global Handler** (`@auth.on`): Matches all resources and actions
+2. **Resource Handler** (e.g., `@auth.on.threads`, `@auth.on.assistants`, `@auth.on.crons`): Matches all actions for a specific resource
+3. **Action Handler** (e.g., `@auth.on.threads.create`, `@auth.on.threads.read`): Matches a specific action on a specific resource
+
+The most specific matching handler will be used. For example, `@auth.on.threads.create` takes precedence over `@auth.on.threads` for thread creation.
+If a more specific handler is registered, the more general handler will not be called for that resource and action.
+
+???+ tip "Type Safety"
+    Each handler has type hints available for its `value` parameter at `Auth.types.on.<resource>.<action>.value`. For example:
+    ```python
+    @auth.on.threads.create
+    async def on_thread_create(
+        ctx: Auth.types.AuthContext,
+        value: Auth.types.on.threads.create.value  # Specific type for thread creation
+    ):
+        ...
+    
+    @auth.on.threads
+    async def on_threads(
+        ctx: Auth.types.AuthContext,
+        value: Auth.types.on.threads.value  # Union type of all thread actions
+    ):
+        ...
+    
+    @auth.on
+    async def on_all(
+        ctx: Auth.types.AuthContext,
+        value: dict  # Union type of all possible actions
+    ):
+        ...
+    ```
+    More specific handlers provide better type hints since they handle fewer action types.
+
+#### Supported actions and types {#supported-actions}
+Here are all the supported action handlers:
+
+| Resource | Handler | Description | Value Type |
+|----------|---------|-------------|------------|
+| **Threads** | `@auth.on.threads.create` | Thread creation | [`ThreadsCreate`](../cloud/reference/sdk/python_sdk_ref.md#langgraph_sdk.auth.types.ThreadsCreate) |
+| | `@auth.on.threads.read` | Thread retrieval | [`ThreadsRead`](../cloud/reference/sdk/python_sdk_ref.md#langgraph_sdk.auth.types.ThreadsRead) |
+| | `@auth.on.threads.update` | Thread updates | [`ThreadsUpdate`](../cloud/reference/sdk/python_sdk_ref.md#langgraph_sdk.auth.types.ThreadsUpdate) |
+| | `@auth.on.threads.delete` | Thread deletion | [`ThreadsDelete`](../cloud/reference/sdk/python_sdk_ref.md#langgraph_sdk.auth.types.ThreadsDelete) |
+| | `@auth.on.threads.search` | Listing threads | [`ThreadsSearch`](../cloud/reference/sdk/python_sdk_ref.md#langgraph_sdk.auth.types.ThreadsSearch) |
+| | `@auth.on.threads.create_run` | Creating or updating a run | [`RunsCreate`](../cloud/reference/sdk/python_sdk_ref.md#langgraph_sdk.auth.types.RunsCreate) |
+| **Assistants** | `@auth.on.assistants.create` | Assistant creation | [`AssistantsCreate`](../cloud/reference/sdk/python_sdk_ref.md#langgraph_sdk.auth.types.AssistantsCreate) |
+| | `@auth.on.assistants.read` | Assistant retrieval | [`AssistantsRead`](../cloud/reference/sdk/python_sdk_ref.md#langgraph_sdk.auth.types.AssistantsRead) |
+| | `@auth.on.assistants.update` | Assistant updates | [`AssistantsUpdate`](../cloud/reference/sdk/python_sdk_ref.md#langgraph_sdk.auth.types.AssistantsUpdate) |
+| | `@auth.on.assistants.delete` | Assistant deletion | [`AssistantsDelete`](../cloud/reference/sdk/python_sdk_ref.md#langgraph_sdk.auth.types.AssistantsDelete) |
+| | `@auth.on.assistants.search` | Listing assistants | [`AssistantsSearch`](../cloud/reference/sdk/python_sdk_ref.md#langgraph_sdk.auth.types.AssistantsSearch) |
+| **Crons** | `@auth.on.crons.create` | Cron job creation | [`CronsCreate`](../cloud/reference/sdk/python_sdk_ref.md#langgraph_sdk.auth.types.CronsCreate) |
+| | `@auth.on.crons.read` | Cron job retrieval | [`CronsRead`](../cloud/reference/sdk/python_sdk_ref.md#langgraph_sdk.auth.types.CronsRead) |
+| | `@auth.on.crons.update` | Cron job updates | [`CronsUpdate`](../cloud/reference/sdk/python_sdk_ref.md#langgraph_sdk.auth.types.CronsUpdate) |
+| | `@auth.on.crons.delete` | Cron job deletion | [`CronsDelete`](../cloud/reference/sdk/python_sdk_ref.md#langgraph_sdk.auth.types.CronsDelete) |
+| | `@auth.on.crons.search` | Listing cron jobs | [`CronsSearch`](../cloud/reference/sdk/python_sdk_ref.md#langgraph_sdk.auth.types.CronsSearch) |
+
+???+ note "About Runs"
+    Runs are scoped to their parent thread for access control. This means permissions are typically inherited from the thread, reflecting the conversational nature of the data model. All run operations (reading, listing) except creation are controlled by the thread's handlers.
+    There is a specific `create_run` handler for creating new runs because it had more arguments that you can view in the handler.
+
+
+## Next Steps
+
+For implementation details:
+
+- Check out the introductory tutorial on [setting up authentication](../tutorials/auth/getting_started.md)
+- See the how-to guide on implementing a [custom auth handlers](../how-tos/auth/custom_auth.md)

docs/docs/concepts/breakpoints.md

@@ -0,0 +1,132 @@
+# 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](./human_in_the_loop.md#interrupt) for this purpose.
+
+## Requirements
+
+To use breakpoints, you will need to:
+
+1. [**Specify a checkpointer**](persistence.md#checkpoints) to save the graph state after each step.
+2. [**Set breakpoints**](#setting-breakpoints) to specify where execution should pause.
+3. **Run the graph** with a [**thread ID**](./persistence.md#threads) to pause execution at the breakpoint.
+4. **Resume execution** using `invoke`/`ainvoke`/`stream`/`astream` (see [**The `Command` primitive**](./human_in_the_loop.md#the-command-primitive)).
+
+## Setting breakpoints
+
+There are two places where you can set breakpoints:
+
+1. **Before** or **after** a node executes by setting breakpoints at **compile time** or **run time**. We call these [**static breakpoints**](#static-breakpoints).
+2. **Inside** a node using the [`NodeInterrupt` exception](#nodeinterrupt-exception).
+ 
+### Static breakpoints
+
+Static breakpoints are triggered either **before** or **after** a node executes. You can set static breakpoints by specifying `interrupt_before` and `interrupt_after` at **"compile" time** or **run time**.
+
+=== "Compile time"
+
+    ```python
+    graph = graph_builder.compile(
+        interrupt_before=["node_a"], 
+        interrupt_after=["node_b", "node_c"],
+        checkpointer=..., # Specify a checkpointer
+    )
+
+    thread_config = {
+        "configurable": {
+            "thread_id": "some_thread"
+        }
+    }
+
+    # Run the graph until the breakpoint
+    graph.invoke(inputs, config=thread_config)
+
+    # Optionally update the graph state based on user input
+    graph.update_state(update, config=thread_config)
+
+    # Resume the graph
+    graph.invoke(None, config=thread_config)
+    ```
+
+=== "Run time"
+
+    ```python
+    graph.invoke(
+        inputs, 
+        config={"configurable": {"thread_id": "some_thread"}}, 
+        interrupt_before=["node_a"], 
+        interrupt_after=["node_b", "node_c"]
+    )
+
+    thread_config = {
+        "configurable": {
+            "thread_id": "some_thread"
+        }
+    }
+
+    # Run the graph until the breakpoint
+    graph.invoke(inputs, config=thread_config)
+
+    # Optionally update the graph state based on user input
+    graph.update_state(update, config=thread_config)
+
+    # Resume the graph
+    graph.invoke(None, config=thread_config)
+    ```
+
+    !!! note
+
+        You cannot set static breakpoints at runtime for **sub-graphs**.
+        If you have a sub-graph, you must set the breakpoints at compilation time.
+
+Static breakpoints can be especially useful for debugging if you want to step through the graph execution one
+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
+[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.
+
+    ```python
+    def my_node(state: State) -> State:
+        if len(state['input']) > 5:
+            raise NodeInterrupt(f"Received input that is longer than 5 characters: {state['input']}")
+
+        return state
+    ```
+
+
+    Let's assume we run the graph with an input that triggers the dynamic breakpoint and then attempt to resume the graph execution simply by passing in `None` for the input.
+
+    ```python
+    # Attempt to continue the graph execution with no change to state after we hit the dynamic breakpoint 
+    for event in graph.stream(None, thread_config, stream_mode="values"):
+        print(event)
+    ```
+
+    The graph will *interrupt* again because this node will be *re-run* with the same graph state. We need to change the graph state such that the condition that triggers the dynamic breakpoint is no longer met. So, we can simply edit the graph state to an input that meets the condition of our dynamic breakpoint (< 5 characters) and re-run the node.
+
+    ```python 
+    # Update the state to pass the dynamic breakpoint
+    graph.update_state(config=thread_config, values={"input": "foo"})
+    for event in graph.stream(None, thread_config, stream_mode="values"):
+        print(event)
+    ```
+
+    Alternatively, what if we want to keep our current input and skip the node (`my_node`) that performs the check? To do this, we can simply perform the graph update with `as_node="my_node"` and pass in `None` for the values. This will make no update the graph state, but run the update as `my_node`, effectively skipping the node and bypassing the dynamic breakpoint.
+
+    ```python
+    # This update will skip the node `my_node` altogether
+    graph.update_state(config=thread_config, values=None, as_node="my_node")
+    for event in graph.stream(None, thread_config, stream_mode="values"):
+        print(event)
+    ```
+
+## Additional Resources 📚
+
+- [**Conceptual Guide: Persistence**](persistence.md): Read the persistence guide for more context about persistence.
+- [**Conceptual Guide: Human-in-the-loop**](human_in_the_loop.md): Read the human-in-the-loop guide for more context on integrating human feedback into LangGraph applications using breakpoints.
+- [**How to View and Update Past Graph State**](../how-tos/human_in_the_loop/time-travel.ipynb): Step-by-step instructions for working with graph state that demonstrate the **replay** and **fork** actions.

docs/docs/concepts/double_texting.md

@@ -16,7 +16,7 @@ If you do not want to use LangGraph Platform, we describe the options we have im
 
 ## Reject
 
-This is the simplest option, this just rejects any follow up runs and does not allow double texting. 
+This is the simplest option, this just rejects any follow-up runs and does not allow double texting. 
 See the [how-to guide](../cloud/how-tos/reject_concurrent.md) for configuring the reject double text option.
 
 ## Enqueue

docs/docs/concepts/faq.md

@@ -22,21 +22,21 @@ Yes. LangGraph is an MIT-licensed open-source library and is free to use.
 
 LangGraph is a stateful, orchestration framework that brings added control to agent workflows. LangGraph Platform is a service for deploying and scaling LangGraph applications, with an opinionated API for building agent UXs, plus an integrated developer studio.
 
-| Features | LangGraph (open source) | LangGraph Platform |
-|----------|------------------------|-------------------|
-| Description | Stateful orchestration framework for agentic applications | Scalable infrastructure for deploying LangGraph applications |
-| SDKs | Python and JavaScript | Python and JavaScript |
-| HTTP APIs | None | Yes - useful for retrieving & updating state or long-term memory, or creating a configurable assistant |
-| Streaming | Basic | Dedicated mode for token-by-token messages |
-| Checkpointer | Community contributed | Supported out-of-the-box |
-| Persistence Layer | Self-managed | Managed Postgres with efficient storage |
-| Deployment | Self-managed | • Cloud SaaS <br> • Free self-hosted <br> • Enterprise (BYOC or paid self-hosted) |
-| Scalability | Self-managed | Auto-scaling of task queues and servers |
-| Fault-tolerance | Self-managed | Automated retries |
-| 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 |
+| Features            | LangGraph (open source)                                   | LangGraph Platform                                                                                     |
+|---------------------|-----------------------------------------------------------|--------------------------------------------------------------------------------------------------------|
+| Description         | Stateful orchestration framework for agentic applications | Scalable infrastructure for deploying LangGraph applications                                           |
+| SDKs                | Python and JavaScript                                     | Python and JavaScript                                                                                  |
+| HTTP APIs           | None                                                      | Yes - useful for retrieving & updating state or long-term memory, or creating a configurable assistant |
+| Streaming           | Basic                                                     | Dedicated mode for token-by-token messages                                                             |
+| Checkpointer        | Community contributed                                     | Supported out-of-the-box                                                                               |
+| Persistence Layer   | Self-managed                                              | Managed Postgres with efficient storage                                                                |
+| Deployment          | Self-managed                                              | • Cloud SaaS <br> • Free self-hosted <br> • Enterprise (BYOC or paid self-hosted)                      |
+| Scalability         | Self-managed                                              | Auto-scaling of task queues and servers                                                                |
+| Fault-tolerance     | Self-managed                                              | Automated retries                                                                                      |
+| 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                                                                   |
 
 ## What are my deployment options for LangGraph Platform?
 

docs/docs/concepts/human_in_the_loop.md

@@ -1,322 +1,744 @@
 # Human-in-the-loop
 
-Human-in-the-loop (or "on-the-loop") enhances agent capabilities through several common user interaction patterns.
+!!! tip "This guide uses the new `interrupt` function."
 
-Common interaction patterns include:
+    As of LangGraph 0.2.57, the recommended way to set breakpoints is using the [`interrupt` function][langgraph.types.interrupt] as it simplifies **human-in-the-loop** patterns.
 
-(1) `Approval` - We can interrupt our agent, surface the current state to a user, and allow the user to accept an action. 
+    If you're looking for the previous version of this conceptual guide, which relied on static breakpoints and `NodeInterrupt` exception, it is available [here](v0-human-in-the-loop.md). 
 
-(2) `Editing` - We can interrupt our agent, surface the current state to a user, and allow the user to edit the agent state. 
+A **human-in-the-loop** (or "on-the-loop") workflow integrates human input into automated processes, allowing for decisions, validation, or corrections at key stages. This is especially useful in **LLM-based applications**, where the underlying model may generate occasional inaccuracies. In low-error-tolerance scenarios like compliance, decision-making, or content generation, human involvement ensures reliability by enabling review, correction, or override of model outputs.
 
-(3) `Input` - We can explicitly create a graph node to collect human input and pass that input directly to the agent state.
 
-Use-cases for these interaction patterns include:
+## Use cases
 
-(1) `Reviewing tool calls` - We can interrupt an agent to review and edit the results of tool calls.
+Key use cases for **human-in-the-loop** workflows in LLM-based applications include:
 
-(2) `Time Travel` - We can manually re-play and / or fork past actions of an agent.
+1. [**🛠️ Reviewing tool calls**](#review-tool-calls): Humans can review, edit, or approve tool calls requested by the LLM before tool execution.
+2. **✅ Validating LLM outputs**: Humans can review, edit, or approve content generated by the LLM.
+3. **💡 Providing context**: Enable the LLM to explicitly request human input for clarification or additional details or to support multi-turn conversations.
 
-## Persistence
+## `interrupt`
 
-All of these interaction patterns are enabled by LangGraph's built-in [persistence](./persistence.md) layer, which will write a checkpoint of the graph state at each step. Persistence allows the graph to stop so that a human can review and / or edit the current state of the graph and then resume with the human's input.
-
-### Breakpoints
-
-Adding a [breakpoint](./low_level.md#breakpoints) a specific location in the graph flow is one way to enable human-in-the-loop. In this case, the developer knows *where* in the workflow human input is needed and simply places a breakpoint prior to or following that particular graph node.
-
-Here, we compile our graph with a checkpointer and a breakpoint at the node we want to interrupt before, `step_for_human_in_the_loop`. We then perform one of the above interaction patterns, which will create a new checkpoint if a human edits the graph state. The new checkpoint is saved to the `thread` and we can resume the graph execution from there by passing in `None` as the input.
+The [`interrupt` function][langgraph.types.interrupt] in LangGraph enables human-in-the-loop workflows by pausing the graph at a specific node, presenting information to a human, and resuming the graph with their input. This function is useful for tasks like approvals, edits, or collecting additional input. The [`interrupt` function][langgraph.types.interrupt] is used in conjunction with the [`Command`](../reference/types.md#langgraph.types.Command) object to resume the graph with a value provided by the human.
 
 ```python
-# Compile our graph with a checkpointer and a breakpoint before "step_for_human_in_the_loop"
-graph = builder.compile(checkpointer=checkpointer, interrupt_before=["step_for_human_in_the_loop"])
+from langgraph.types import interrupt
 
-# Run the graph up to the breakpoint
-thread_config = {"configurable": {"thread_id": "1"}}
-for event in graph.stream(inputs, thread_config, stream_mode="values"):
-    print(event)
+def human_node(state: State):
+    value = interrupt(
+        # Any JSON serializable value to surface to the human.
+        # For example, a question or a piece of text or a set of keys in the state
+       {
+          "text_to_revise": state["some_text"]
+       }
+    )
+    # Update the state with the human's input or route the graph based on the input.
+    return {
+        "some_text": value
+    }
+
+graph = graph_builder.compile(
+    checkpointer=checkpointer # Required for `interrupt` to work
+)
+
+# Run the graph until the interrupt
+thread_config = {"configurable": {"thread_id": "some_id"}}
+graph.invoke(some_input, config=thread_config)
     
-# Perform some action that requires human in the loop
-
-# Continue the graph execution from the current checkpoint 
-for event in graph.stream(None, thread_config, stream_mode="values"):
-    print(event)
+# Resume the graph with the human's input
+graph.invoke(Command(resume=value_from_human), config=thread_config)
 ```
 
-### Dynamic Breakpoints
+```pycon
+{'some_text': 'Edited text'}
+```
 
-Alternatively, 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.
+!!! warning
+      Interrupts are both powerful and ergonomic. However, while they may resemble Python's input() function in terms of developer experience, it's important to note that they do not automatically resume execution from the interruption point. Instead, they rerun the entire node where the interrupt was used.
+      For this reason, interrupts are typically best placed at the start of a node or in a dedicated node. Please read the [resuming from an interrupt](#how-does-resuming-from-an-interrupt-work) section for more details. 
+
+??? "Full Code"
+
+      Here's a full example of how to use `interrupt` in a graph, if you'd like
+      to see the code in action.
+
+      ```python
+      from typing import TypedDict
+      import uuid
+
+      from langgraph.checkpoint.memory import MemorySaver
+      from langgraph.constants import START
+      from langgraph.graph import StateGraph
+      from langgraph.types import interrupt, Command
+
+      class State(TypedDict):
+         """The graph state."""
+         some_text: str
+
+      def human_node(state: State):
+         value = interrupt(
+            # Any JSON serializable value to surface to the human.
+            # For example, a question or a piece of text or a set of keys in the state
+            {
+               "text_to_revise": state["some_text"]
+            }
+         )
+         return {
+            # Update the state with the human's input
+            "some_text": value
+         }
+
+
+      # Build the graph
+      graph_builder = StateGraph(State)
+      # Add the human-node to the graph
+      graph_builder.add_node("human_node", human_node)
+      graph_builder.add_edge(START, "human_node")
+
+      # A checkpointer is required for `interrupt` to work.
+      checkpointer = MemorySaver()
+      graph = graph_builder.compile(
+         checkpointer=checkpointer
+      )
+
+      # Pass a thread ID to the graph to run it.
+      thread_config = {"configurable": {"thread_id": uuid.uuid4()}}
+
+      # Using stream() to directly surface the `__interrupt__` information.
+      for chunk in graph.stream({"some_text": "Original text"}, config=thread_config):
+         print(chunk)
+
+      # Resume using Command
+      for chunk in graph.stream(Command(resume="Edited text"), config=thread_config):
+         print(chunk)
+      ```
+
+      ```pycon
+      {'__interrupt__': (
+            Interrupt(
+               value={'question': 'Please revise the text', 'some_text': 'Original text'}, 
+               resumable=True, 
+               ns=['human_node:10fe492f-3688-c8c6-0d0a-ec61a43fecd6'], 
+               when='during'
+            ),
+         )
+      }
+      {'human_node': {'some_text': 'Edited text'}}
+      ```
+
+## Requirements
+
+To use `interrupt` in your graph, you need to:
+
+1. [**Specify a checkpointer**](persistence.md#checkpoints) to save the graph state after each step.
+2. **Call `interrupt()`** in the appropriate place. See the [Design Patterns](#design-patterns) section for examples.
+3. **Run the graph** with a [**thread ID**](./persistence.md#threads) until the `interrupt` is hit.
+4. **Resume execution** using `invoke`/`ainvoke`/`stream`/`astream` (see [**The `Command` primitive**](#the-command-primitive)).
+
+## Design Patterns
+
+There are typically three different **actions** that you can do with a human-in-the-loop workflow:
+
+1. **Approve or Reject**: Pause the graph before a critical step, such as an API call, to review and approve the action. If the action is rejected, you can prevent the graph from executing the step, and potentially take an alternative action. This pattern often involve **routing** the graph based on the human's input.
+2. **Edit Graph State**: Pause the graph to review and edit the graph state. This is useful for correcting mistakes or updating the state with additional information. This pattern often involves **updating** the state with the human's input.
+3. **Get Input**: Explicitly request human input at a particular step in the graph. This is useful for collecting additional information or context to inform the agent's decision-making process or for supporting **multi-turn conversations**.
+
+Below we show different design patterns that can be implemented using these **actions**.
+
+### Approve or Reject
+
+<figure markdown="1">
+![image](img/human_in_the_loop/approve-or-reject.png){: style="max-height:400px"}
+<figcaption>Depending on the human's approval or rejection, the graph can proceed with the action or take an alternative path.</figcaption>
+</figure>
+
+Pause the graph before a critical step, such as an API call, to review and approve the action. If the action is rejected, you can prevent the graph from executing the step, and potentially take an alternative action.
 
 ```python
-def my_node(state: State) -> State:
-    if len(state['input']) > 5:
-        raise NodeInterrupt(f"Received input that is longer than 5 characters: {state['input']}")
-    return state
+
+from typing import Literal
+from langgraph.types import interrupt, Command
+
+def human_approval(state: State) -> Command[Literal["some_node", "another_node"]]:
+    is_approved = interrupt(
+        {
+            "question": "Is this correct?",
+            # Surface the output that should be
+            # reviewed and approved by the human.
+            "llm_output": state["llm_output"]
+        }
+    )
+
+    if is_approved:
+        return Command(goto="some_node")
+    else:
+        return Command(goto="another_node")
+
+# Add the node to the graph in an appropriate location
+# and connect it to the relevant nodes.
+graph_builder.add_node("human_approval", human_approval)
+graph = graph_builder.compile(checkpointer=checkpointer)
+
+# After running the graph and hitting the interrupt, the graph will pause.
+# Resume it with either an approval or rejection.
+thread_config = {"configurable": {"thread_id": "some_id"}}
+graph.invoke(Command(resume=True), config=thread_config)
 ```
 
-Let's assume we run the graph with an input that triggers the dynamic breakpoint and then attempt to resume the graph execution simply by passing in `None` for the input. 
+See [how to review tool calls](../how-tos/human_in_the_loop/review-tool-calls.ipynb) for a more detailed example.
+
+### Review & Edit State
+
+<figure markdown="1">
+![image](img/human_in_the_loop/edit-graph-state-simple.png){: style="max-height:400px"}
+<figcaption>A human can review and edit the state of the graph. This is useful for correcting mistakes or updating the state with additional information.
+</figcaption>
+</figure>
 
 ```python
-# Attempt to continue the graph execution with no change to state after we hit the dynamic breakpoint 
-for event in graph.stream(None, thread_config, stream_mode="values"):
-    print(event)
+from langgraph.types import interrupt
+
+def human_editing(state: State):
+    ...
+    result = interrupt(
+        # Interrupt information to surface to the client.
+        # Can be any JSON serializable value.
+        {
+            "task": "Review the output from the LLM and make any necessary edits.",
+            "llm_generated_summary": state["llm_generated_summary"]
+        }
+    )
+
+    # Update the state with the edited text
+    return {
+        "llm_generated_summary": result["edited_text"] 
+    }
+
+# Add the node to the graph in an appropriate location
+# and connect it to the relevant nodes.
+graph_builder.add_node("human_editing", human_editing)
+graph = graph_builder.compile(checkpointer=checkpointer)
+
+...
+
+# After running the graph and hitting the interrupt, the graph will pause.
+# Resume it with the edited text.
+thread_config = {"configurable": {"thread_id": "some_id"}}
+graph.invoke(
+    Command(resume={"edited_text": "The edited text"}), 
+    config=thread_config
+)
 ```
 
-The graph will *interrupt* again because this node will be *re-run* with the same graph state. We need to change the graph state such that the condition that triggers the dynamic breakpoint is no longer met. So, we can simply edit the graph state to an input that meets the condition of our dynamic breakpoint (< 5 characters) and re-run the node.
+See [How to wait for user input using interrupt](../how-tos/human_in_the_loop/wait-user-input.ipynb) for a more detailed example.
 
-```python 
-# Update the state to pass the dynamic breakpoint
-graph.update_state(config=thread_config, values={"input": "foo"})
-for event in graph.stream(None, thread_config, stream_mode="values"):
-    print(event)
-```
+### Review Tool Calls
 
-Alternatively, what if we want to keep our current input and skip the node (`my_node`) that performs the check? To do this, we can simply perform the graph update with `as_node="my_node"` and pass in `None` for the values. This will make no update the graph state, but run the update as `my_node`, effectively skipping the node and bypassing the dynamic breakpoint.
+<figure markdown="1">
+![image](img/human_in_the_loop/tool-call-review.png){: style="max-height:400px"}
+<figcaption>A human can review and edit the output from the LLM before proceeding. This is particularly
+critical in applications where the tool calls requested by the LLM may be sensitive or require human oversight.
+</figcaption>
+</figure>
 
 ```python
-# This update will skip the node `my_node` altogether
-graph.update_state(config=thread_config, values=None, as_node="my_node")
-for event in graph.stream(None, thread_config, stream_mode="values"):
-    print(event)
+def human_review_node(state) -> Command[Literal["call_llm", "run_tool"]]:
+    # This is the value we'll be providing via Command(resume=<human_review>)
+    human_review = interrupt(
+        {
+            "question": "Is this correct?",
+            # Surface tool calls for review
+            "tool_call": tool_call
+        }
+    )
+
+    review_action, review_data = human_review
+
+    # Approve the tool call and continue
+    if review_action == "continue":
+        return Command(goto="run_tool")
+
+    # Modify the tool call manually and then continue
+    elif review_action == "update":
+        ...
+        updated_msg = get_updated_msg(review_data)
+        # Remember that to modify an existing message you will need
+        # to pass the message with a matching ID.
+        return Command(goto="run_tool", update={"messages": [updated_message]})
+
+    # Give natural language feedback, and then pass that back to the agent
+    elif review_action == "feedback":
+        ...
+        feedback_msg = get_feedback_msg(review_data)
+        return Command(goto="call_llm", update={"messages": [feedback_msg]})
 ```
 
-See [our guide](../how-tos/human_in_the_loop/dynamic_breakpoints.ipynb) for a detailed how-to on doing this!
+See [how to review tool calls](../how-tos/human_in_the_loop/review-tool-calls.ipynb) for a more detailed example.
 
-## Interaction Patterns
+### Multi-turn conversation
 
-### Approval
+<figure markdown="1">
+![image](img/human_in_the_loop/multi-turn-conversation.png){: style="max-height:400px"}
+<figcaption>A <strong>multi-turn conversation</strong> architecture where an <strong>agent</strong> and <strong>human node</strong> cycle back and forth until the agent decides to hand off the conversation to another agent or another part of the system.
+</figcaption>
+</figure>
 
-![](./img/human_in_the_loop/approval.png)
+A **multi-turn conversation** involves multiple back-and-forth interactions between an agent and a human, which can allow the agent to gather additional information from the human in a conversational manner.
 
-Sometimes we want to approve certain steps in our agent's execution. 
- 
-We can interrupt our agent at a [breakpoint](./low_level.md#breakpoints) prior to the step that we want to approve.
+This design pattern is useful in an LLM application consisting of [multiple agents](./multi_agent.md). One or more agents may need to carry out multi-turn conversations with a human, where the human provides input or feedback at different stages of the conversation. For simplicity, the agent implementation below is illustrated as a single node, but in reality 
+it may be part of a larger graph consisting of multiple nodes and include a conditional edge.
 
-This is generally recommend for sensitive actions (e.g., using external APIs or writing to a database).
- 
-With persistence, we can surface the current agent state as well as the next step to a user for review and approval. 
- 
-If approved, the graph resumes execution from the last saved checkpoint, which is saved to the `thread`:
+=== "Using a human node per agent"
+
+    In this pattern, each agent has its own human node for collecting user input. 
+    This can be achieved by either naming the human nodes with unique names (e.g., "human for agent 1", "human for agent 2") or by
+    using subgraphs where a subgraph contains a human node and an agent node.
+
+    ```python
+    from langgraph.types import interrupt
+
+    def human_input(state: State):
+        human_message = interrupt("human_input")
+        return {
+            "messages": [
+                {
+                    "role": "human",
+                    "content": human_message
+                }
+            ]
+        }
+
+    def agent(state: State):
+        # Agent logic
+        ...
+
+    graph_builder.add_node("human_input", human_input)
+    graph_builder.add_edge("human_input", "agent")
+    graph = graph_builder.compile(checkpointer=checkpointer)
+
+    # After running the graph and hitting the interrupt, the graph will pause.
+    # Resume it with the human's input.
+    graph.invoke(
+        Command(resume="hello!"),
+        config=thread_config
+    )
+    ```
+
+
+=== "Sharing human node across multiple agents"
+
+    In this pattern, a single human node is used to collect user input for multiple agents. The active agent is determined from the state, so after human input is collected, the graph can route to the correct agent.
+
+    ```python
+    from langgraph.types import interrupt
+
+    def human_node(state: MessagesState) -> Command[Literal["agent_1", "agent_2", ...]]:
+        """A node for collecting user input."""
+        user_input = interrupt(value="Ready for user input.")
+
+        # Determine the **active agent** from the state, so 
+        # we can route to the correct agent after collecting input.
+        # For example, add a field to the state or use the last active agent.
+        # or fill in `name` attribute of AI messages generated by the agents.
+        active_agent = ... 
+
+        return Command(
+            update={
+                "messages": [{
+                    "role": "human",
+                    "content": user_input,
+                }]
+            },
+            goto=active_agent,
+        )
+    ```
+
+See [how to implement multi-turn conversations](../how-tos/multi-agent-multi-turn-convo.ipynb) for a more detailed example.
+
+### Validating human input
+
+If you need to validate the input provided by the human within the graph itself (rather than on the client side), you can achieve this by using multiple interrupt calls within a single node.
 
 ```python
-# Compile our graph with a checkpointer and a breakpoint before the step to approve
-graph = builder.compile(checkpointer=checkpointer, interrupt_before=["node_2"])
+from langgraph.types import interrupt
 
-# Run the graph up to the breakpoint
-for event in graph.stream(inputs, thread, stream_mode="values"):
-    print(event)
-    
-# ... Get human approval ...
+def human_node(state: State):
+    """Human node with validation."""
+    question = "What is your age?"
 
-# If approved, continue the graph execution from the last saved checkpoint
-for event in graph.stream(None, thread, stream_mode="values"):
-    print(event)
+    while True:
+        answer = interrupt(question)
+
+        # Validate answer, if the answer isn't valid ask for input again.
+        if not isinstance(answer, int) or answer < 0:
+            question = f"'{answer} is not a valid age. What is your age?"
+            answer = None
+            continue
+        else:
+            # If the answer is valid, we can proceed.
+            break
+            
+    print(f"The human in the loop is {answer} years old.")
+    return {
+        "age": answer
+    }
 ```
 
-See [our guide](../how-tos/human_in_the_loop/breakpoints.ipynb) for a detailed how-to on doing this!
+## The `Command` primitive
 
-### Editing
+When using the `interrupt` function, the graph will pause at the interrupt and wait for user input.
 
-![](./img/human_in_the_loop/edit_graph_state.png)
+Graph execution can be resumed using the [Command](../reference/types.md#langgraph.types.Command) primitive which can be passed through the `invoke`, `ainvoke`, `stream` or `astream` methods.
 
-Sometimes we want to review and edit the agent's state. 
- 
-As with approval, we can interrupt our agent at a [breakpoint](./low_level.md#breakpoints) prior to the step we want to check. 
- 
-We can surface the current state to a user and allow the user to edit the agent state.
- 
-This can, for example, be used to correct the agent if it made a mistake (e.g., see the section on tool calling below).
+The `Command` primitive provides several options to control and modify the graph's state during resumption:
 
-We can edit the graph state by forking the current checkpoint, which is saved to the `thread`.
+1. **Pass a value to the `interrupt`**: Provide data, such as a user's response, to the graph using `Command(resume=value)`. Execution resumes from the beginning of the node where the `interrupt` was used, however, this time the `interrupt(...)` call will return the value passed in the `Command(resume=value)` instead of pausing the graph.
 
-We can then proceed with the graph from our forked checkpoint as done before. 
+       ```python
+       # Resume graph execution with the user's input.
+       graph.invoke(Command(resume={"age": "25"}), thread_config)
+       ```
+
+2. **Update the graph state**: Modify the graph state using `Command(update=update)`. Note that resumption starts from the beginning of the node where the `interrupt` was used. Execution resumes from the beginning of the node where the `interrupt` was used, but with the updated state.
+
+      ```python
+      # Update the graph state and resume.
+      # You must provide a `resume` value if using an `interrupt`.
+      graph.invoke(Command(update={"foo": "bar"}, resume="Let's go!!!"), thread_config)
+      ```
+
+By leveraging `Command`, you can resume graph execution, handle user inputs, and dynamically adjust the graph's state.
+
+## Using with `invoke` and `ainvoke`
+
+When you use `stream` or `astream` to run the graph, you will receive an `Interrupt` event that let you know the `interrupt` was triggered. 
+
+`invoke` and `ainvoke` do not return the interrupt information. To access this information, you must use the [get_state](../reference/graphs.md#langgraph.graph.graph.CompiledGraph.get_state) method to retrieve the graph state after calling `invoke` or `ainvoke`.
 
 ```python
-# Compile our graph with a checkpointer and a breakpoint before the step to review
-graph = builder.compile(checkpointer=checkpointer, interrupt_before=["node_2"])
-
-# Run the graph up to the breakpoint
-for event in graph.stream(inputs, thread, stream_mode="values"):
-    print(event)
-    
-# Review the state, decide to edit it, and create a forked checkpoint with the new state
-graph.update_state(thread, {"state": "new state"})
-
-# Continue the graph execution from the forked checkpoint
-for event in graph.stream(None, thread, stream_mode="values"):
-    print(event)
+# Run the graph up to the interrupt 
+result = graph.invoke(inputs, thread_config)
+# Get the graph state to get interrupt information.
+state = graph.get_state(thread_config)
+# Print the state values
+print(state.values)
+# Print the pending tasks
+print(state.tasks)
+# Resume the graph with the user's input.
+graph.invoke(Command(resume={"age": "25"}), thread_config)
 ```
 
-See [this guide](../how-tos/human_in_the_loop/edit-graph-state.ipynb) for a detailed how-to on doing this!
+```pycon
+{'foo': 'bar'} # State values
+(
+    PregelTask(
+        id='5d8ffc92-8011-0c9b-8b59-9d3545b7e553', 
+        name='node_foo', 
+        path=('__pregel_pull', 'node_foo'), 
+        error=None, 
+        interrupts=(Interrupt(value='value_in_interrupt', resumable=True, ns=['node_foo:5d8ffc92-8011-0c9b-8b59-9d3545b7e553'], when='during'),), state=None, 
+        result=None
+    ),
+) # Pending tasks. interrupts 
+```
 
-### Input
+## How does resuming from an interrupt work?
 
-![](./img/human_in_the_loop/wait_for_input.png)
+!!! warning
 
-Sometimes we want to explicitly get human input at a particular step in the graph. 
- 
-We can create a graph node designated for this (e.g., `human_input` in our example diagram).
- 
-As with approval and editing, we can interrupt our agent at a [breakpoint](./low_level.md#breakpoints) prior to this node.
- 
-We can then perform a state update that includes the human input, just as we did with editing state.
+    Resuming from an `interrupt` is **different** from Python's `input()` function, where execution resumes from the exact point where the `input()` function was called.
 
-But, we add one thing: 
+A critical aspect of using `interrupt` is understanding how resuming works. When you resume execution after an `interrupt`, graph execution starts from the **beginning** of the **graph node** where the last `interrupt` was triggered.
 
-We can use `as_node=human_input` with the state update to specify that the state update *should be treated as a node*.
-
-The is subtle, but important: 
-
-With editing, the user makes a decision about whether or not to edit the graph state.
-
-With input, we explicitly define a node in our graph for collecting human input!
-
-The state update with the human input then runs *as this node*.
+**All** code from the beginning of the node to the `interrupt` will be re-executed.
 
 ```python
-# Compile our graph with a checkpointer and a breakpoint before the step to to collect human input
-graph = builder.compile(checkpointer=checkpointer, interrupt_before=["human_input"])
-
-# Run the graph up to the breakpoint
-for event in graph.stream(inputs, thread, stream_mode="values"):
-    print(event)
-    
-# Update the state with the user input as if it was the human_input node
-graph.update_state(thread, {"user_input": user_input}, as_node="human_input")
-
-# Continue the graph execution from the checkpoint created by the human_input node
-for event in graph.stream(None, thread, stream_mode="values"):
-    print(event)
+counter = 0
+def node(state: State):
+    # All the code from the beginning of the node to the interrupt will be re-executed
+    # when the graph resumes.
+    global counter
+    counter += 1
+    print(f"> Entered the node: {counter} # of times")
+    # Pause the graph and wait for user input.
+    answer = interrupt()
+    print("The value of counter is:", counter)
+    ...
 ```
 
-See [this guide](../how-tos/human_in_the_loop/wait-user-input.ipynb) for a detailed how-to on doing this!
+Upon **resuming** the graph, the counter will be incremented a second time, resulting in the following output:
 
-## Use-cases
+```pycon
+> Entered the node: 2 # of times
+The value of counter is: 2
+```
 
-### Reviewing Tool Calls
+## Common Pitfalls
 
-Some user interaction patterns combine the above ideas.
+### Side-effects
 
-For example, many agents use [tool calling](https://python.langchain.com/docs/how_to/tool_calling/) to make decisions. 
+Place code with side effects, such as API calls, **after** the `interrupt` to avoid duplication, as these are re-triggered every time the node is resumed. 
 
-Tool calling presents a challenge because the agent must get two things right: 
+=== "Side effects before interrupt (BAD)"
 
-(1) The name of the tool to call 
+    This code will re-execute the API call another time when the node is resumed from
+    the `interrupt`.
 
-(2) The arguments to pass to the tool
+    This can be problematic if the API call is not idempotent or is just expensive.
 
-Even if the tool call is correct, we may also want to apply discretion: 
+    ```python
+    from langgraph.types import interrupt
 
-(3) The tool call may be a sensitive operation that we want to approve 
+    def human_node(state: State):
+        """Human node with validation."""
+        api_call(...) # This code will be re-executed when the node is resumed.
+        answer = interrupt(question)
+    ```
 
-With these points in mind, we can combine the above ideas to create a human-in-the-loop review of a tool call.
+=== "Side effects after interrupt (OK)"
+
+    ```python
+    from langgraph.types import interrupt
+
+    def human_node(state: State):
+        """Human node with validation."""
+        
+        answer = interrupt(question)
+        
+        api_call(answer) # OK as it's after the interrupt
+    ```
+
+=== "Side effects in a separate node (OK)"
+
+    ```python
+    from langgraph.types import interrupt
+
+    def human_node(state: State):
+        """Human node with validation."""
+        
+        answer = interrupt(question)
+        
+        return {
+            "answer": answer
+        }
+
+    def api_call_node(state: State):
+        api_call(...) # OK as it's in a separate node
+    ```
+
+### Subgraphs called as functions
+
+When invoking a subgraph [as a function](low_level.md#as-a-function), the **parent graph** will resume execution from the **beginning of the node** where the subgraph was invoked (and where an `interrupt` was triggered). Similarly, the **subgraph**, will resume from the **beginning of the node** where the `interrupt()` function was called.
+
+For example,
 
 ```python
-# Compile our graph with a checkpointer and a breakpoint before the step to to review the tool call from the LLM 
-graph = builder.compile(checkpointer=checkpointer, interrupt_before=["human_review"])
-
-# Run the graph up to the breakpoint
-for event in graph.stream(inputs, thread, stream_mode="values"):
-    print(event)
-    
-# Review the tool call and update it, if needed, as the human_review node
-graph.update_state(thread, {"tool_call": "updated tool call"}, as_node="human_review")
-
-# Otherwise, approve the tool call and proceed with the graph execution with no edits 
-
-# Continue the graph execution from either: 
-# (1) the forked checkpoint created by human_review or 
-# (2) the checkpoint saved when the tool call was originally made (no edits in human_review)
-for event in graph.stream(None, thread, stream_mode="values"):
-    print(event)
+def node_in_parent_graph(state: State):
+    some_code()  # <-- This will re-execute when the subgraph is resumed.
+    # Invoke a subgraph as a function.
+    # The subgraph contains an `interrupt` call.
+    subgraph_result = subgraph.invoke(some_input)
+    ...
 ```
 
-See [this guide](../how-tos/human_in_the_loop/review-tool-calls.ipynb) for a detailed how-to on doing this!
+??? "**Example: Parent and Subgraph Execution Flow**"
 
-### Time Travel
+      Say we have a parent graph with 3 nodes:
 
-When working with agents, we often want closely examine their decision making process: 
+      **Parent Graph**: `node_1` → `node_2` (subgraph call) → `node_3`
 
-(1) Even when they arrive a desired final result, the reasoning that led to that result is often important to examine.
+      And the subgraph has 3 nodes, where the second node contains an `interrupt`:
 
-(2) When agents make mistakes, it is often valuable to understand why.
+      **Subgraph**: `sub_node_1` → `sub_node_2` (`interrupt`) → `sub_node_3`
 
-(3) In either of the above cases, it is useful to manually explore alternative decision making paths.
+      When resuming the graph, the execution will proceed as follows:
 
-Collectively, we call these debugging concepts `time-travel` and they are composed of `replaying` and `forking`.
+      1. **Skip `node_1`** in the parent graph (already executed, graph state was saved in snapshot).
+      2. **Re-execute `node_2`** in the parent graph from the start.
+      3. **Skip `sub_node_1`** in the subgraph (already executed, graph state was saved in snapshot).
+      4. **Re-execute `sub_node_2`** in the subgraph from the beginning.
+      5. Continue with `sub_node_3` and subsequent nodes.
 
-#### Replaying
+      Here is abbreviated example code that you can use to understand how subgraphs work with interrupts.
+      It counts the number of times each node is entered and prints the count.
 
-![](./img/human_in_the_loop/replay.png)
+      ```python
+      import uuid
+      from typing import TypedDict
 
-Sometimes we want to simply replay past actions of an agent. 
- 
-Above, we showed the case of executing an agent from the current state (or checkpoint) of the graph.
+      from langgraph.graph import StateGraph
+      from langgraph.constants import START
+      from langgraph.types import interrupt, Command
+      from langgraph.checkpoint.memory import MemorySaver
 
-We by simply passing in `None` for the input with a `thread`.
 
-```
-thread = {"configurable": {"thread_id": "1"}}
-for event in graph.stream(None, thread, stream_mode="values"):
-    print(event)
-```
+      class State(TypedDict):
+         """The graph state."""
+         state_counter: int
 
-Now, we can modify this to replay past actions from a *specific* checkpoint by passing in the checkpoint ID.
 
-To get a specific checkpoint ID, we can easily get all of the checkpoints in the thread and filter to the one we want.
+      counter_node_in_subgraph = 0
 
-```python
-all_checkpoints = []
-for state in app.get_state_history(thread):
-    all_checkpoints.append(state)
-```
+      def node_in_subgraph(state: State):
+         """A node in the sub-graph."""
+         global counter_node_in_subgraph
+         counter_node_in_subgraph += 1  # This code will **NOT** run again!
+         print(f"Entered `node_in_subgraph` a total of {counter_node_in_subgraph} times")
 
-Each checkpoint has a unique ID, which we can use to replay from a specific checkpoint.
+      counter_human_node = 0
 
-Assume from reviewing the checkpoints that we want to replay from one, `xxx`.
+      def human_node(state: State):
+         global counter_human_node
+         counter_human_node += 1 # This code will run again!
+         print(f"Entered human_node in sub-graph a total of {counter_human_node} times")
+         answer = interrupt("what is your name?")
+         print(f"Got an answer of {answer}")
 
-We just pass in the checkpoint ID when we run the graph.
 
-```python
-config = {'configurable': {'thread_id': '1', 'checkpoint_id': 'xxx'}}
-for event in graph.stream(None, config, stream_mode="values"):
-    print(event)
-```
- 
-Importantly, the graph knows which checkpoints have been previously executed. 
+      checkpointer = MemorySaver()
 
-So, it will re-play any previously executed nodes rather than re-executing them.
+      subgraph_builder = StateGraph(State)
+      subgraph_builder.add_node("some_node", node_in_subgraph)
+      subgraph_builder.add_node("human_node", human_node)
+      subgraph_builder.add_edge(START, "some_node")
+      subgraph_builder.add_edge("some_node", "human_node")
+      subgraph = subgraph_builder.compile(checkpointer=checkpointer)
 
-See [this additional conceptual guide](https://langchain-ai.github.io/langgraph/concepts/persistence/#replay) for related context on replaying.
 
-See see [this guide](../how-tos/human_in_the_loop/time-travel.ipynb) for a detailed how-to on doing time-travel!
+      counter_parent_node = 0
 
-#### Forking
+      def parent_node(state: State):
+         """This parent node will invoke the subgraph."""
+         global counter_parent_node
 
-![](./img/human_in_the_loop/forking.png)
+         counter_parent_node += 1 # This code will run again on resuming!
+         print(f"Entered `parent_node` a total of {counter_parent_node} times")
+  
+         # Please note that we're intentionally incrementing the state counter
+         # in the graph state as well to demonstrate that the subgraph update
+         # of the same key will not conflict with the parent graph (until
+         subgraph_state = subgraph.invoke(state)
+         return subgraph_state
 
-Sometimes we want to fork past actions of an agent, and explore different paths through the graph.
 
-`Editing`, as discussed above, is *exactly* how we do this for the *current* state of the graph! 
+      builder = StateGraph(State)
+      builder.add_node("parent_node", parent_node)
+      builder.add_edge(START, "parent_node")
 
-But, what if we want to fork *past* states of the graph?
+      # A checkpointer must be enabled for interrupts to work!
+      checkpointer = MemorySaver()
+      graph = builder.compile(checkpointer=checkpointer)
 
-For example, let's say we want to edit a particular checkpoint, `xxx`.
+      config = {
+         "configurable": {
+            "thread_id": uuid.uuid4(),
+         }
+      }
 
-We pass this `checkpoint_id` when we update the state of the graph.
+      for chunk in graph.stream({"state_counter": 1}, config):
+         print(chunk)
 
-```python
-config = {"configurable": {"thread_id": "1", "checkpoint_id": "xxx"}}
-graph.update_state(config, {"state": "updated state"}, )
-```
+      print('--- Resuming ---')
 
-This creates a new forked checkpoint, `xxx-fork`, which we can then run the graph from.
+      for chunk in graph.stream(Command(resume="35"), config):
+         print(chunk)
+      ```
 
-```python
-config = {'configurable': {'thread_id': '1', 'checkpoint_id': 'xxx-fork'}}
-for event in graph.stream(None, config, stream_mode="values"):
-    print(event)
-```
+      This will print out
 
-See [this additional conceptual guide](https://langchain-ai.github.io/langgraph/concepts/persistence/#update-state) for related context on forking.
+      ```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'),)}
 
-See see [this guide](../how-tos/human_in_the_loop/time-travel.ipynb) for a detailed how-to on doing time-travel!
+      --- 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} 
+      ```
+
+
+
+### Using multiple interrupts
+
+Using multiple interrupts within a **single** node can be helpful for patterns like [validating human input](#validating-human-input). However, using multiple interrupts in the same node can lead to unexpected behavior if not handled carefully.
+
+When a node contains multiple interrupt calls, LangGraph keeps a list of resume values specific to the task executing the node. Whenever execution resumes, it starts at the beginning of the node. For each interrupt encountered, LangGraph checks if a matching value exists in the task's resume list. Matching is **strictly index-based**, so the order of interrupt calls within the node is critical.
+
+To avoid issues, refrain from dynamically changing the node's structure between executions. This includes adding, removing, or reordering interrupt calls, as such changes can result in mismatched indices. These problems often arise from unconventional patterns, such as mutating state via `Command(resume=..., update=SOME_STATE_MUTATION)` or relying on global variables to modify the node’s structure dynamically.
+
+??? "Example of incorrect code"
+
+    ```python
+    import uuid
+    from typing import TypedDict, Optional
+
+    from langgraph.graph import StateGraph
+    from langgraph.constants import START 
+    from langgraph.types import interrupt, Command
+    from langgraph.checkpoint.memory import MemorySaver
+
+
+    class State(TypedDict):
+        """The graph state."""
+
+        age: Optional[str]
+        name: Optional[str]
+
+
+    def human_node(state: State):
+        if not state.get('name'):
+            name = interrupt("what is your name?")
+        else:
+            name = "N/A"
+
+        if not state.get('age'):
+            age = interrupt("what is your age?")
+        else:
+            age = "N/A"
+            
+        print(f"Name: {name}. Age: {age}")
+        
+        return {
+            "age": age,
+            "name": name,
+        }
+
+
+    builder = StateGraph(State)
+    builder.add_node("human_node", human_node)
+    builder.add_edge(START, "human_node")
+
+    # A checkpointer must be enabled for interrupts to work!
+    checkpointer = MemorySaver()
+    graph = builder.compile(checkpointer=checkpointer)
+
+    config = {
+        "configurable": {
+            "thread_id": uuid.uuid4(),
+        }
+    }
+
+    for chunk in graph.stream({"age": None, "name": None}, config):
+        print(chunk)
+
+    for chunk in graph.stream(Command(resume="John", update={"name": "foo"}), config):
+        print(chunk)
+    ```
+
+    ```pycon
+    {'__interrupt__': (Interrupt(value='what is your name?', resumable=True, ns=['human_node:3a007ef9-c30d-c357-1ec1-86a1a70d8fba'], when='during'),)}
+    Name: N/A. Age: John
+    {'human_node': {'age': 'John', 'name': 'N/A'}}
+    ```
+
+## Additional Resources 📚
+
+- [**Conceptual Guide: Persistence**](persistence.md#replay): Read the persistence guide for more context on replaying.
+- [**How to Guides: Human-in-the-loop**](../how-tos/index.md#human-in-the-loop): Learn how to implement human-in-the-loop workflows in LangGraph.
+- [**How to implement multi-turn conversations**](../how-tos/multi-agent-multi-turn-convo.ipynb): Learn how to implement multi-turn conversations in LangGraph.

docs/docs/concepts/index.md

@@ -24,7 +24,9 @@ The conceptual guide does not cover step-by-step instructions or specific implem
 - [LangGraph Glossary](low_level.md): LangGraph workflows are designed as graphs, with nodes representing different components and edges representing the flow of information between them. This guide provides an overview of the key concepts associated with LangGraph graph primitives.
 - [Common Agentic Patterns](agentic_concepts.md): An agent uses an LLM to pick its own control flow to solve more complex problems! Agents are a key building block in many LLM applications. This guide explains the different types of agent architectures and how they can be used to control the flow of an application.
 - [Multi-Agent Systems](multi_agent.md): Complex LLM applications can often be broken down into multiple agents, each responsible for a different part of the application. This guide explains common patterns for building multi-agent systems.
+- [Breakpoints](breakpoints.md): Breakpoints allow pausing the execution of a graph at specific points. Breakpoints allow stepping through graph execution for debugging purposes.
 - [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. 
@@ -66,6 +68,7 @@ The LangGraph Platform comprises several components that work together to suppor
 - [Web-hooks](./langgraph_server.md#webhooks): Webhooks allow your running LangGraph application to send data to external services on specific events.
 - [Cron Jobs](./langgraph_server.md#cron-jobs): Cron jobs are a way to schedule tasks to run at specific times in your LangGraph application.
 - [Double Texting](./double_texting.md): Double texting is a common issue in LLM applications where users may send multiple messages before the graph has finished running. This guide explains how to handle double texting with LangGraph Deploy.
+- [Authentication & Access Control](./auth.md): Learn about options for authentication and access control when deploying the LangGraph Platform.
 
 ### Deployment Options
 

docs/docs/concepts/langgraph_cli.md

@@ -33,6 +33,11 @@ The `langgraph build` command builds a Docker image for the [LangGraph API serve
 !!! note "New in version 0.1.55"
     The `langgraph dev` command was introduced in langgraph-cli version 0.1.55.
 
+!!! note "Python only"
+
+    Currently, the CLI only supports Python >= 3.11.
+    JS support is coming soon.
+
 The `langgraph dev` command starts a lightweight development server that requires no Docker installation. This server is ideal for rapid development and testing, with features like:
 
 - Hot reloading: Changes to your code are automatically detected and reloaded

docs/docs/concepts/langgraph_cloud.md

@@ -19,7 +19,19 @@ See the [how-to guide](../cloud/deployment/cloud.md#create-new-deployment) for c
 | **Deployment Type** | **CPU** | **Memory** | **Scaling**         |
 |---------------------|---------|------------|---------------------|
 | Development         | 1 CPU   | 1 GB       | Up to 1 container   |
-| Production          | 1 CPU   | 2 GB       | Up to 10 containers |
+| Production          | 2 CPU   | 2 GB       | Up to 10 containers |
+
+## Autoscaling
+`Production` type deployments automatically scale up to 10 containers. Scaling is based on the current request load for a single container. Specifically, the autoscaling implementation scales the deployment so that each container is processing about 10 concurrent requests. For example... 
+
+- If the deployment is processing 20 concurrent requests, the deployment will scale up from 1 container to 2 containers (20 requests / 2 containers = 10 requests per container).
+- If a deployment of 2 containers is processing 10 requests, the deployment will scale down from 2 containers to 1 container (10 requests / 1 container = 10 requests per container).
+
+10 concurrent requests per container is the target threshold. However, 10 concurrent requests per container is not a hard limit. The number of concurrent requests can exceed 10 if there is a sudden burst of requests.
+
+Scale down actions are delayed for 30 minutes before any action is taken. In other words, if the autoscaling implementation decides to scale down a deployment, it will first wait for 30 minutes before scaling down. After 30 minutes, the concurrency metric is recomputed and the deployment will scale down if the concurrency metric has met the target threshold. Otherwise, the deployment remains scaled up. This "cool down" period ensures that deployments do not scale up and down too frequently.
+
+In the future, the autoscaling implementation may evolve to accommodate other metrics such as background run queue size.
 
 ## Revision
 
@@ -31,6 +43,12 @@ See the [how-to guide](../cloud/deployment/cloud.md#create-new-revision) for cre
 
 Infrastructure for [deployments](#deployment) and [revisions](#revision) are provisioned and deployed asynchronously. They are not deployed immediately after submission. Currently, deployment can take up to several minutes.
 
+- When a new deployment is created, a new database is created for the deployment. Database creation is a one-time step. This step contributes to a longer deployment time for the initial revision of the deployment.
+- When a subsequent revision is created for a deployment, there is no database creation step. The deployment time for a subsequent revision is significantly faster compared to the deployment time of the initial revision.
+- The deployment process for each revision contains a build step, which can take up to a few minutes.
+
+!!! info "Database creation for `Development` type deployments takes longer than database creation for `Production` type deployments."
+
 ## Architecture
 
 !!! warning "Subject to Change"
@@ -40,7 +58,6 @@ A high-level diagram of a Cloud SaaS deployment.
 
 ![diagram](img/langgraph_cloud_architecture.png)
 
-
 ## Related
 
 - [Deployment Options](./deployment_options.md)

docs/docs/concepts/langgraph_platform.md

@@ -18,32 +18,7 @@ The LangGraph Platform offers a few different deployment options described in th
 
 ## Why Use LangGraph Platform?
 
-LangGraph Platform is designed to make deploying agentic applications seamless and production-ready. 
-
-For simpler applications, deploying a LangGraph agent can be as straightforward as using your own server logic—for example, setting up a FastAPI endpoint and invoking LangGraph directly.
-
-### Option 1: Deploying with Custom Server Logic
-
-For basic LangGraph applications, you may choose to handle deployment using your custom server infrastructure. Setting up endpoints with frameworks like [FastAPI](https://fastapi.tiangolo.com/) allows you to quickly deploy and run LangGraph as you would any other Python application:
-
-```python
-from fastapi import FastAPI
-from your_agent_package import graph
-
-app = FastAPI()
-
-@app.get("/foo")
-async def foo(...):
-    return await graph.ainvoke({...})
-```
-
-This approach works well for simple applications with straightforward needs and provides you with full control over the deployment setup. For example, you might use this for a single-assistant application that doesn’t require long-running sessions or persistent memory.
-
-### Option 2: Leveraging LangGraph Platform for Complex Deployments
-
-As your applications scale or add complex features, the deployment requirements often evolve. Running an application with more nodes, longer processing times, or a need for persistent memory can introduce challenges that quickly become time-consuming and difficult to manage manually. [LangGraph Platform](./langgraph_platform.md) is built to handle these challenges seamlessly, allowing you to focus on agent logic rather than server infrastructure.
-
-Here are some common issues that arise in complex deployments, which LangGraph Platform addresses:
+**LangGraph Platform** handles common issues that arise when deploying LLM applications to production, allowing you to focus on agent logic instead of managing server infrastructure.
 
 - **[Streaming Support](streaming.md)**: As agents grow more sophisticated, they often benefit from streaming both token outputs and intermediate states back to the user. Without this, users are left waiting for potentially long operations with no feedback. LangGraph Server provides [multiple streaming modes](streaming.md) optimized for various application needs.
 

docs/docs/concepts/langgraph_studio.md

@@ -25,25 +25,28 @@ The key features of LangGraph Studio are:
 
 ## Types
 
-### Desktop app
+### Development server with web UI
 
-LangGraph Studio is available as a [desktop app](https://studio.langchain.com/) for MacOS users.
+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:
 
-While in Beta, LangGraph Studio is available for free to all [LangSmith](https://smith.langchain.com/) users on any plan tier.
+```
+https://smith.langchain.com/studio/?baseUrl=http://127.0.0.1:2024
+```
+
+See [instructions here](../cloud/reference/cli.md#dev) for more information.
+
+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.
 
 ### Cloud studio
 
 If you have deployed your LangGraph application on LangGraph Platform (Cloud), you can access the studio as part of that
 
-### Development server
+### Desktop app
 
-LangGraph CLI also contains a command for running an in-memory development server that can be used to connect a local LangGraph app with the studio.
-See [instructions here](../cloud/reference/cli.md#dev) for more information.
+LangGraph Studio is available as a [desktop app](https://studio.langchain.com/) for MacOS users.
 
-The way this works is that it runs inside your local environment.
-It will spin up an in-memory, development server to deploy the graph.
-You can then connect to the studio via the Cloud hosted version of LangGraph Platform.
-To be clear, the web studio will connect to your locally running server - your agent is still running locally and never leaves your device.
+While in Beta, LangGraph Studio is available for free to all [LangSmith](https://smith.langchain.com/) users on any plan tier.
 
 ## Studio FAQs
 

docs/docs/concepts/low_level.md

@@ -191,7 +191,7 @@ class State(MessagesState):
 
 ## Nodes
 
-In LangGraph, nodes are typically python functions (sync or `async`) where the **first** positional argument is the [state](#state), and (optionally), the **second** positional argument is a "config", containing optional [configurable parameters](#configuration) (such as a `thread_id`).
+In LangGraph, nodes are typically python functions (sync or async) where the **first** positional argument is the [state](#state), and (optionally), the **second** positional argument is a "config", containing optional [configurable parameters](#configuration) (such as a `thread_id`).
 
 Similar to `NetworkX`, you add these nodes to a graph using the [add_node][langgraph.graph.StateGraph.add_node] method:
 
@@ -339,37 +339,6 @@ def my_node(state: State) -> Command[Literal["my_other_node"]]:
     )
 ```
 
-`Command` has the following properties:
-
-| Property | Description |
-| --- | --- |
-| `graph` | Graph to send the command to. Supported values:<br>- `None`: the current graph (default)<br>- `Command.PARENT`: closest parent graph |
-| `update` | Update to apply to the graph's state. |
-| `resume` | Value to resume execution with. To be used together with [`interrupt()`][langgraph.types.interrupt]. |
-| `goto` | Can be one of the following:<br>- name of the node to navigate to next (any node that belongs to the specified `graph`)<br>- sequence of node names to navigate to next<br>- `Send` object (to execute a node with the input provided)<br>- sequence of `Send` objects<br>If `goto` is not specified and there are no other tasks left in the graph, the graph will halt after executing the current superstep. |
-
-```python
-from langgraph.graph import StateGraph, START
-from langgraph.types import Command
-from typing_extensions import Literal, TypedDict
-
-class State(TypedDict):
-    foo: str
-
-def my_node(state: State) -> Command[Literal["my_other_node"]]:
-    return Command(update={"foo": "bar"}, goto="my_other_node")
-
-def my_other_node(state: State):
-    return {"foo": state["foo"] + "baz"}
-
-builder = StateGraph(State)
-builder.add_edge(START, "my_node")
-builder.add_node("my_node", my_node)
-builder.add_node("my_other_node", my_other_node)
-
-graph = builder.compile()
-```
-
 With `Command` you can also achieve dynamic control flow behavior (identical to [conditional edges](#conditional-edges)):
 
 ```python
@@ -380,10 +349,44 @@ def my_node(state: State) -> Command[Literal["my_other_node"]]:
 
 !!! important
 
-    When returning `Command` in your node functions, you must add return type annotations with the list of node names the node is routing to, e.g. `Command[Literal["node_b", "node_c"]]`. This is necessary for the graph compilation and rendering, and tells LangGraph that `node_a` can navigate to `node_b` and `node_c`.
+    When returning `Command` in your node functions, you must add return type annotations with the list of node names the node is routing to, e.g. `Command[Literal["my_other_node"]]`. This is necessary for the graph rendering and tells LangGraph that `my_node` can navigate to `my_other_node`.
 
 Check out this [how-to guide](../how-tos/command.ipynb) for an end-to-end example of how to use `Command`.
 
+### When should I use Command instead of conditional edges?
+
+Use `Command` when you need to **both** update the graph state **and** route to a different node. For example, when implementing [multi-agent handoffs](./multi_agent.md#handoffs) where it's important to route to a different agent and pass some information to that agent.
+
+Use [conditional edges](#conditional-edges) to route between nodes conditionally without updating the state.
+
+### Using inside tools
+
+A common use case is updating graph state from inside a tool. For example, in a customer support application you might want to look up customer information based on their account number or ID in the beginning of the conversation. To update the graph state from the tool, you can return `Command(update={"my_custom_key": "foo", "messages": [...]})` from the tool:
+
+```python
+@tool
+def lookup_user_info(tool_call_id: Annotated[str, InjectedToolCallId], config: RunnableConfig):
+    """Use this to look up user information to better assist them with their questions."""
+    user_info = get_user_info(config.get("configurable", {}).get("user_id"))
+    return Command(
+        update={
+            # update the state keys
+            "user_info": user_info,
+            # update the message history
+            "messages": [ToolMessage("Successfully looked up user information", tool_call_id=tool_call_id)]
+        }
+    )
+```
+
+!!! 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.
+
+### Human-in-the-loop
+
+`Command` is an important part of human-in-the-loop workflows: when using `interrupt()` to collect user input, `Command` is then used to supply the input and resume execution via `Command(resume="User input")`. Check out [this conceptual guide](./human_in_the_loop.md) for more information.
+
 ## Persistence
 
 LangGraph provides built-in persistence for your agent's state using [checkpointers][langgraph.checkpoint.base.BaseCheckpointSaver]. Checkpointers save snapshots of the graph state at every superstep, allowing resumption at any time. This enables features like human-in-the-loop interactions, memory management, and fault-tolerance. You can even directly manipulate a graph's state after its execution using the
@@ -449,35 +452,32 @@ graph.invoke(inputs, config={"recursion_limit": 5, "configurable":{"llm": "anthr
 
 Read [this how-to](https://langchain-ai.github.io/langgraph/how-tos/recursion-limit/) to learn more about how the recursion limit works.
 
+## `interrupt`
+
+Use the [interrupt](../reference/types.md/#langgraph.types.interrupt) function to **pause** the graph at specific points to collect user input. The `interrupt` function surfaces interrupt information to the client, allowing the developer to collect user input, validate the graph state, or make decisions before resuming execution.
+
+```python
+from langgraph.types import interrupt
+
+def human_approval_node(state: State):
+    ...
+    answer = interrupt(
+        # This value will be sent to the client.
+        # It can be any JSON serializable value.
+        {"question": "is it ok to continue?"},
+    )
+    ...
+```
+
+Resuming the graph is done by passing a [`Command`](#command) object to the graph with the `resume` key set to the value returned by the `interrupt` function.
+
+Read more about how the `interrupt` is used for **human-in-the-loop** workflows in the [Human-in-the-loop conceptual guide](./human_in_the_loop.md).
+
 ## Breakpoints
 
-It can often be useful to set breakpoints before or after certain nodes execute. This can be used to wait for human approval before continuing. These can be set when you ["compile" a graph](#compiling-your-graph). You can set breakpoints either _before_ a node executes (using `interrupt_before`) or after a node executes (using `interrupt_after`.)
+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.
 
-You **MUST** use a [checkpointer](./persistence.md) when using breakpoints. This is because your graph needs to be able to resume execution.
-
-In order to resume execution, you can just invoke your graph with `None` as the input.
-
-```python
-# Initial run of graph
-graph.invoke(inputs, config=config)
-
-# Let's assume it hit a breakpoint somewhere, you can then resume by passing in None
-graph.invoke(None, config=config)
-```
-
-See [this guide](../how-tos/human_in_the_loop/breakpoints.ipynb) for a full walkthrough of how to add breakpoints.
-
-### Dynamic Breakpoints
-
-It may be helpful to **dynamically** interrupt the graph from inside a given node based on some condition. In `LangGraph` you can do so by using `NodeInterrupt` -- a special exception that can be raised from inside a node.
-
-```python
-def my_node(state: State) -> State:
-    if len(state['input']) > 5:
-        raise NodeInterrupt(f"Received input that is longer than 5 characters: {state['input']}")
-
-    return state
-```
+Read more about breakpoints in the [Breakpoints conceptual guide](./breakpoints.md).
 
 ## Subgraphs
 
@@ -518,7 +518,7 @@ The simplest way to create subgraph nodes is by using a [compiled subgraph](#com
     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.
 
 ```python
-from langgraph.graph import START, StateGraph
+from langgraph.graph import StateGraph
 from typing import TypedDict
 
 class State(TypedDict):

docs/docs/concepts/multi_agent.md

@@ -26,13 +26,88 @@ There are several ways to connect agents in a multi-agent system:
 - **Hierarchical**: you can define a multi-agent system with [a supervisor of supervisors](https://langchain-ai.github.io/langgraph/tutorials/multi_agent/hierarchical_agent_teams/). This is a generalization of the supervisor architecture and allows for more complex control flows.
 - **Custom multi-agent workflow**: each agent communicates with only a subset of agents. Parts of the flow are deterministic, and only some agents can decide which other agents to call next.
 
+### Handoffs
+
+In multi-agent architectures, agents can be represented as graph nodes. Each agent node executes its step(s) and decides whether to finish execution or route to another agent, including potentially routing to itself (e.g., running in a loop). A common pattern in multi-agent interactions is handoffs, where one agent hands off control to another. Handoffs allow you to specify:
+
+- __destination__: target agent to navigate to (e.g., name of the node to go to)
+- __payload__: [information to pass to that agent](#communication-between-agents) (e.g., state update)
+
+To implement handoffs in LangGraph, agent nodes can return [`Command`](./low_level.md#command) object that allows you to combine both control flow and state updates:
+
+```python
+def agent(state) -> Command[Literal["agent", "another_agent"]]:
+    # the condition for routing/halting can be anything, e.g. LLM tool call / structured output, etc.
+    goto = get_next_agent(...)  # 'agent' / 'another_agent'
+    return Command(
+        # Specify which agent to call next
+        goto=goto,
+        # Update the graph state
+        update={"my_state_key": "my_state_value"}
+    )
+```
+
+In a more complex scenario where each agent node is itself a graph (i.e., a [subgraph](./low_level.md#subgraphs)), a node in one of the agent subgraphs might want to navigate to a different agent. For example, if you have two agents, `alice` and `bob` (subgraph nodes in a parent graph), and `alice` needs to navigate to `bob`, you can set `graph=Command.PARENT` in the `Command` object:
+
+```python
+def some_node_inside_alice(state)
+    return Command(
+        goto="bob",
+        update={"my_state_key": "my_state_value"},
+        # specify which graph to navigate to (defaults to the current graph)
+        graph=Command.PARENT,
+    )
+```
+
+!!! note
+    If you need to support visualization for subgraphs communicating using `Command(graph=Command.PARENT)` you would need to wrap them in a node function with `Command` annotation, e.g. instead of this:
+
+    ```python
+    builder.add_node(alice)
+    ```
+
+    you would need to do this:
+
+    ```python
+    def call_alice(state) -> Command[Literal["bob"]]:
+        return alice.invoke(state)
+
+    builder.add_node("alice", call_alice)
+    ```
+
+#### Handoffs as tools
+
+One of the most common agent types is a ReAct-style tool-calling agents. For those types of agents, a common pattern is wrapping a handoff in a tool call, e.g.:
+
+```python
+def transfer_to_bob(state):
+    """Transfer to bob."""
+    return Command(
+        goto="bob",
+        update={"my_state_key": "my_state_value"},
+        graph=Command.PARENT,
+    )
+```
+
+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.
+
+!!! important
+
+    If you want to use tools that return `Command`, you can either use prebuilt [`create_react_agent`][langgraph.prebuilt.chat_agent_executor.create_react_agent] / [`ToolNode`][langgraph.prebuilt.tool_node.ToolNode] components, or implement your own tool-executing node that collects `Command` objects returned by the tools and returns a list of them, e.g.:
+    
+    ```python
+    def call_tools(state):
+        ...
+        commands = [tools_by_name[tool_call["name"]].invoke(tool_call) for tool_call in tool_calls]
+        return commands
+    ```
+
+Let's now take a closer look at the different multi-agent architectures.
+
 ### Network
 
 In this architecture, agents are defined as graph nodes. Each agent can communicate with every other agent (many-to-many connections) and can decide which agent to call next. This architecture is good for problems that do not have a clear hierarchy of agents or a specific sequence in which agents should be called.
 
-### Supervisor
-
-In this architecture, we define agents as nodes and add a supervisor node (LLM) that decides which agent nodes should be called next. We use [conditional edges](./low_level.md#conditional-edges) to route execution to the appropriate agent node based on supervisor's decision. This architecture also lends itself well to running multiple agents in parallel or using [map-reduce](../how-tos/map-reduce.ipynb) pattern.
 
 ```python
 from typing import Literal
@@ -41,39 +116,83 @@ from langgraph.graph import StateGraph, MessagesState, START
 
 model = ChatOpenAI()
 
-class AgentState(MessagesState):
-    next: Literal["agent_1", "agent_2", "__end__"]
-
-def supervisor(state: AgentState):
+def agent_1(state: MessagesState) -> Command[Literal["agent_2", "agent_3", END]]:
     # you can pass relevant parts of the state to the LLM (e.g., state["messages"])
     # to determine which agent to call next. a common pattern is to call the model
     # with a structured output (e.g. force it to return an output with a "next_agent" field)
     response = model.invoke(...)
-    # the "next" key will be used by the conditional edges to route execution
-    # to the appropriate agent
-    return {"next": response["next_agent"]}
+    # route to one of the agents or exit based on the LLM's decision
+    # if the LLM returns "__end__", the graph will finish execution
+    return Command(
+        goto=response["next_agent"],
+        update={"messages": [response["content"]]},
+    )
 
-def agent_1(state: AgentState):
+def agent_2(state: MessagesState) -> Command[Literal["agent_1", "agent_3", END]]:
+    response = model.invoke(...)
+    return Command(
+        goto=response["next_agent"],
+        update={"messages": [response["content"]]},
+    )
+
+def agent_3(state: MessagesState) -> Command[Literal["agent_1", "agent_2", END]]:
+    ...
+    return Command(
+        goto=response["next_agent"],
+        update={"messages": [response["content"]]},
+    )
+
+builder = StateGraph(MessagesState)
+builder.add_node(agent_1)
+builder.add_node(agent_2)
+builder.add_node(agent_3)
+
+builder.add_edge(START, "agent_1")
+network = builder.compile()
+```
+
+### Supervisor
+
+In this architecture, we define agents as nodes and add a supervisor node (LLM) that decides which agent nodes should be called next. We use [`Command`](./low_level.md#command) to route execution to the appropriate agent node based on supervisor's decision. This architecture also lends itself well to running multiple agents in parallel or using [map-reduce](../how-tos/map-reduce.ipynb) pattern.
+
+```python
+from typing import Literal
+from langchain_openai import ChatOpenAI
+from langgraph.graph import StateGraph, MessagesState, START, END
+
+model = ChatOpenAI()
+
+def supervisor(state: MessagesState) -> Command[Literal["agent_1", "agent_2", END]]:
+    # you can pass relevant parts of the state to the LLM (e.g., state["messages"])
+    # to determine which agent to call next. a common pattern is to call the model
+    # with a structured output (e.g. force it to return an output with a "next_agent" field)
+    response = model.invoke(...)
+    # route to one of the agents or exit based on the supervisor's decision
+    # if the supervisor returns "__end__", the graph will finish execution
+    return Command(goto=response["next_agent"])
+
+def agent_1(state: MessagesState) -> Command[Literal["supervisor"]]:
     # you can pass relevant parts of the state to the LLM (e.g., state["messages"])
     # and add any additional logic (different models, custom prompts, structured output, etc.)
     response = model.invoke(...)
-    return {"messages": [response]}
+    return Command(
+        goto="supervisor",
+        update={"messages": [response]},
+    )
 
-def agent_2(state: AgentState):
+def agent_2(state: MessagesState) -> Command[Literal["supervisor"]]:
     response = model.invoke(...)
-    return {"messages": [response]}
+    return Command(
+        goto="supervisor",
+        update={"messages": [response]},
+    )
 
-builder = StateGraph(AgentState)
+builder = StateGraph(MessagesState)
 builder.add_node(supervisor)
 builder.add_node(agent_1)
 builder.add_node(agent_2)
 
 builder.add_edge(START, "supervisor")
-# route to one of the agents or exit based on the supervisor's decisiion
-# if the supervisor returns "__end__", the graph will finish execution
-builder.add_conditional_edges("supervisor", lambda state: state["next"])
-builder.add_edge("agent_1", "supervisor")
-builder.add_edge("agent_2", "supervisor")
 
 supervisor = builder.compile()
 ```
@@ -121,37 +240,29 @@ To address this, you can design your system _hierarchically_. For example, you c
 ```python
 from typing import Literal
 from langchain_openai import ChatOpenAI
-from langgraph.graph import StateGraph, MessagesState, START
+from langgraph.graph import StateGraph, MessagesState, START, END
 
 model = ChatOpenAI()
 
 # define team 1 (same as the single supervisor example above)
-class Team1State(MessagesState):
-    next: Literal["team_1_agent_1", "team_1_agent_2", "__end__"]
 
-def team_1_supervisor(state: Team1State):
+def team_1_supervisor(state: MessagesState) -> Command[Literal["team_1_agent_1", "team_1_agent_2", END]]:
     response = model.invoke(...)
-    return {"next": response["next_agent"]}
+    return Command(goto=response["next_agent"])
 
-def team_1_agent_1(state: Team1State):
+def team_1_agent_1(state: MessagesState) -> Command[Literal["team_1_supervisor"]]:
     response = model.invoke(...)
-    return {"messages": [response]}
+    return Command(goto="team_1_supervisor", update={"messages": [response]})
 
-def team_1_agent_2(state: Team1State):
+def team_1_agent_2(state: MessagesState) -> Command[Literal["team_1_supervisor"]]:
     response = model.invoke(...)
-    return {"messages": [response]}
+    return Command(goto="team_1_supervisor", update={"messages": [response]})
 
 team_1_builder = StateGraph(Team1State)
 team_1_builder.add_node(team_1_supervisor)
 team_1_builder.add_node(team_1_agent_1)
 team_1_builder.add_node(team_1_agent_2)
 team_1_builder.add_edge(START, "team_1_supervisor")
-# route to one of the agents or exit based on the supervisor's decisiion
-# if the supervisor returns "__end__", the graph will finish execution
-team_1_builder.add_conditional_edges("team_1_supervisor", lambda state: state["next"])
-team_1_builder.add_edge("team_1_agent_1", "team_1_supervisor")
-team_1_builder.add_edge("team_1_agent_2", "team_1_supervisor")
-
 team_1_graph = team_1_builder.compile()
 
 # define team 2 (same as the single supervisor example above)
@@ -174,31 +285,22 @@ team_2_graph = team_2_builder.compile()
 
 # define top-level supervisor
 
-class TopLevelState(MessagesState):
-    next: Literal["team_1", "team_2", "__end__"]
-
-builder = StateGraph(TopLevelState)
-def top_level_supervisor(state: TopLevelState):
+builder = StateGraph(MessagesState)
+def top_level_supervisor(state: MessagesState):
     # you can pass relevant parts of the state to the LLM (e.g., state["messages"])
     # to determine which team to call next. a common pattern is to call the model
     # with a structured output (e.g. force it to return an output with a "next_team" field)
     response = model.invoke(...)
-    # the "next" key will be used by the conditional edges to route execution
-    # to the appropriate team
-    return {"next": response["next_team"]}
+    # route to one of the teams or exit based on the supervisor's decision
+    # if the supervisor returns "__end__", the graph will finish execution
+    return Command(goto=response["next_team"])
 
-builder = StateGraph(TopLevelState)
+builder = StateGraph(MessagesState)
 builder.add_node(top_level_supervisor)
 builder.add_node(team_1_graph)
 builder.add_node(team_2_graph)
 
 builder.add_edge(START, "top_level_supervisor")
-# route to one of the teams or exit based on the supervisor's decision
-# if the top-level supervisor returns "__end__", the graph will finish execution
-builder.add_conditional_edges("top_level_supervisor", lambda state: state["next"])
-builder.add_edge("team_1_graph", "top_level_supervisor")
-builder.add_edge("team_2_graph", "top_level_supervisor")
-
 graph = builder.compile()
 ```
 
@@ -208,7 +310,7 @@ In this architecture we add individual agents as graph nodes and define the orde
 
 - **Explicit control flow (normal edges)**: LangGraph allows you to explicitly define the control flow of your application (i.e. the sequence of how agents communicate) explicitly, via [normal graph edges](./low_level.md#normal-edges). This is the most deterministic variant of this architecture above — we always know which agent will be called next ahead of time.
 
-- **Dynamic control flow (conditional edges)**: in LangGraph you can allow LLMs to decide parts of your application control flow. This can be achieved by using [conditional edges](./low_level.md#conditional-edges). A special case of this is a [supervisor tool-calling](#supervisor-tool-calling) architecture. In that case, the tool-calling LLM powering the supervisor agent will make decisions about the order in which the tools (agents) are being called.
+- **Dynamic control flow (Command)**: in LangGraph you can allow LLMs to decide parts of your application control flow. This can be achieved by using [`Command`](./low_level.md#command). A special case of this is a [supervisor tool-calling](#supervisor-tool-calling) architecture. In that case, the tool-calling LLM powering the supervisor agent will make decisions about the order in which the tools (agents) are being called.
 
 ```python
 from langchain_openai import ChatOpenAI

docs/docs/concepts/persistence.md

@@ -168,7 +168,7 @@ Importantly, LangGraph knows whether a particular checkpoint has been executed p
 
 ### Update state
 
-In addition to re-playing the graph from specific `checkpoints`, we can also *edit* the graph state. We do this using `graph.update_state()`. This method three different arguments:
+In addition to re-playing the graph from specific `checkpoints`, we can also *edit* the graph state. We do this using `graph.update_state()`. This method accepts three different arguments:
 
 #### `config`
 
@@ -222,7 +222,7 @@ The final thing you can optionally specify when calling `update_state` is `as_no
 
 A [state schema](low_level.md#schema) specifies a set of keys that are populated as a graph is executed. As discussed above, state can be written by a checkpointer to a thread at each graph step, enabling state persistence.
 
-But, what if we want to retrain some information *across threads*? Consider the case of a chatbot where we want to retain specific information about the user across *all* chat conversations (e.g., threads) with that user!
+But, what if we want to retain some information *across threads*? Consider the case of a chatbot where we want to retain specific information about the user across *all* chat conversations (e.g., threads) with that user!
 
 With checkpointers alone, we cannot share information across threads. This motivates the need for the [`Store`](../reference/store.md#langgraph.store.base.BaseStore) interface. As an illustration, we can define an `InMemoryStore` to store information about a user across threads. We simply compile our graph with a checkpointer, as before, and with our new `in_memory_store` variable.
 
@@ -471,7 +471,7 @@ Second, checkpointers allow for ["memory"](agentic_concepts.md#memory) between i
 
 ### Time Travel
 
-Third, checkpointers allow for ["time travel"](../how-tos/human_in_the_loop/time-travel.ipynb), allowing users to replay prior graph executions to review and / or debug specific graph steps. In addition, checkpointers make it possible to fork the graph state at arbitrary checkpoints to explore alternative trajectories.
+Third, checkpointers allow for ["time travel"](time-travel.md), allowing users to replay prior graph executions to review and / or debug specific graph steps. In addition, checkpointers make it possible to fork the graph state at arbitrary checkpoints to explore alternative trajectories.
 
 ### Fault-tolerance
 

docs/docs/concepts/template_applications.md

@@ -1,14 +1,21 @@
 # Template Applications
 
-!!! note Prerequisites
-
-    - [LangGraph Studio](./langgraph_studio.md)
-
 Templates are open source reference applications designed to help you get started quickly when building with LangGraph. They provide working examples of common agentic workflows that can be customized to your needs.
 
-Templates can be accessed via [LangGraph Studio (macOS only)](langgraph_studio.md), or cloned directly from Github. You can download LangGraph Studio and see available templates [here](https://studio.langchain.com/).
+You can create an application from a template using the LangGraph CLI.
 
-## Available templates
+!!! info "Requirements"
+
+    - Python >= 3.11
+    - [LangGraph CLI](https://langchain-ai.github.io/langgraph/cloud/reference/cli/): Requires langchain-cli[inmem] >= 0.1.58
+
+## Install the LangGraph CLI
+
+```bash
+pip install "langgraph-cli[inmem]" --upgrade
+```
+
+## Available Templates
 
 | Template                  | Description                                                                              | Python                                                           | JS/TS                                                               |
 |---------------------------|------------------------------------------------------------------------------------------|------------------------------------------------------------------|---------------------------------------------------------------------|
@@ -17,3 +24,39 @@ Templates can be accessed via [LangGraph Studio (macOS only)](langgraph_studio.m
 | **Memory Agent**          | A ReAct-style agent with an additional tool to store memories for use across threads.    | [Repo](https://github.com/langchain-ai/memory-agent)             | [Repo](https://github.com/langchain-ai/memory-agent-js)             |
 | **Retrieval Agent**       | An agent that includes a retrieval-based question-answering system.                      | [Repo](https://github.com/langchain-ai/retrieval-agent-template) | [Repo](https://github.com/langchain-ai/retrieval-agent-template-js) |
 | **Data-Enrichment Agent** | An agent that performs web searches and organizes its findings into a structured format. | [Repo](https://github.com/langchain-ai/data-enrichment)          | [Repo](https://github.com/langchain-ai/data-enrichment-js)          |
+
+
+## 🌱 Create a LangGraph App
+
+To create a new app from a template, use the `langgraph new` command.
+
+```bash
+langgraph new
+```
+
+## Next Steps
+
+Review the `README.md` file in the root of your new LangGraph app for more information about the template and how to customize it.
+
+After configuring the app properly and adding your API keys, you can start the app using the LangGraph CLI:
+
+```bash
+langgraph dev 
+```
+
+See the following guides for more information on how to deploy your app:
+
+- **[Launch Local LangGraph Server](../tutorials/langgraph-platform/local-server.md)**: This quick start guide shows how to start a LangGraph Server locally for the **ReAct Agent** template. The steps are similar for other templates.
+- **[Deploy to LangGraph Cloud](../cloud/quick_start.md)**: Deploy your LangGraph app using LangGraph Cloud.
+ 
+### LangGraph Framework
+
+- **[LangGraph Concepts](../concepts/index.md)**: Learn the foundational concepts of LangGraph.
+- **[LangGraph How-to Guides](../how-tos/index.md)**: Guides for common tasks with LangGraph.
+
+### 📚 Learn More about LangGraph Platform
+
+Expand your knowledge with these resources:
+
+- **[LangGraph Platform Concepts](../concepts/index.md#langgraph-platform)**: Understand the foundational concepts of the LangGraph Platform.
+- **[LangGraph Platform How-to Guides](../how-tos/index.md#langgraph-platform)**: Discover step-by-step guides to build and deploy applications.

docs/docs/concepts/time-travel.md

@@ -0,0 +1,72 @@
+# Time Travel ⏱️
+
+!!! note "Prerequisites"
+
+    This guide assumes that you are familiar with LangGraph's checkpoints and states. If not, please review the [persistence](./persistence.md) concept first.
+
+
+When working with non-deterministic systems that make model-based decisions (e.g., agents powered by LLMs), it can be useful to examine their decision-making process in detail:
+
+1. 🤔 **Understand Reasoning**: Analyze the steps that led to a successful result.
+2. 🐞 **Debug Mistakes**: Identify where and why errors occurred.
+3. 🔍 **Explore Alternatives**: Test different paths to uncover better solutions.
+
+We call these debugging techniques **Time Travel**, composed of two key actions: [**Replaying**](#replaying) 🔁 and [**Forking**](#forking) 🔀 .
+
+## Replaying
+
+![](./img/human_in_the_loop/replay.png)
+
+Replaying allows us to revisit and reproduce an agent's past actions. This can be done either from the current state (or checkpoint) of the graph or from a specific checkpoint.
+
+To replay from the current state, simply pass `None` as the input along with a `thread`:
+
+```python
+thread = {"configurable": {"thread_id": "1"}}
+for event in graph.stream(None, thread, stream_mode="values"):
+    print(event)
+```
+
+To replay actions from a specific checkpoint, start by retrieving all checkpoints for the thread:
+
+```python
+all_checkpoints = []
+for state in graph.get_state_history(thread):
+    all_checkpoints.append(state)
+```
+
+Each checkpoint has a unique ID. After identifying the desired checkpoint, for instance, `xyz`, include its ID in the configuration:
+
+```python
+config = {'configurable': {'thread_id': '1', 'checkpoint_id': 'xyz'}}
+for event in graph.stream(None, config, stream_mode="values"):
+    print(event)
+```
+
+The graph efficiently replays previously executed nodes instead of re-executing them, leveraging its awareness of prior checkpoint executions.
+
+## Forking
+
+![](./img/human_in_the_loop/forking.png)
+
+Forking allows you to revisit an agent's past actions and explore alternative paths within the graph.
+
+To edit a specific checkpoint, such as `xyz`, provide its `checkpoint_id` when updating the graph's state:
+
+```python
+config = {"configurable": {"thread_id": "1", "checkpoint_id": "xyz"}}
+graph.update_state(config, {"state": "updated state"})
+```
+
+This creates a new forked checkpoint, xyz-fork, from which you can continue running the graph:
+
+```python
+config = {'configurable': {'thread_id': '1', 'checkpoint_id': 'xyz-fork'}}
+for event in graph.stream(None, config, stream_mode="values"):
+    print(event)
+```
+
+## Additional Resources 📚
+
+- [**Conceptual Guide: Persistence**](https://langchain-ai.github.io/langgraph/concepts/persistence/#replay): Read the persistence guide for more context on replaying.
+- [**How to View and Update Past Graph State**](../how-tos/human_in_the_loop/time-travel.ipynb): Step-by-step instructions for working with graph state that demonstrate the **replay** and **fork** actions.

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

@@ -0,0 +1,329 @@
+# Human-in-the-loop
+
+!!! note "Use the `interrupt` function instead."
+
+    As of LangGraph 0.2.57, the recommended way to set breakpoints is using the [`interrupt` function][langgraph.types.interrupt] as it simplifies **human-in-the-loop** patterns.
+
+    Please see the revised [human-in-the-loop guide](./human_in_the_loop.md) for the latest version that uses the `interrupt` function.
+
+
+Human-in-the-loop (or "on-the-loop") enhances agent capabilities through several common user interaction patterns.
+
+Common interaction patterns include:
+
+(1) `Approval` - We can interrupt our agent, surface the current state to a user, and allow the user to accept an action. 
+
+(2) `Editing` - We can interrupt our agent, surface the current state to a user, and allow the user to edit the agent state. 
+
+(3) `Input` - We can explicitly create a graph node to collect human input and pass that input directly to the agent state.
+
+Use-cases for these interaction patterns include:
+
+(1) `Reviewing tool calls` - We can interrupt an agent to review and edit the results of tool calls.
+
+(2) `Time Travel` - We can manually re-play and / or fork past actions of an agent.
+
+## Persistence
+
+All of these interaction patterns are enabled by LangGraph's built-in [persistence](./persistence.md) layer, which will write a checkpoint of the graph state at each step. Persistence allows the graph to stop so that a human can review and / or edit the current state of the graph and then resume with the human's input.
+
+### Breakpoints
+
+Adding a [breakpoint](./breakpoints.md) a specific location in the graph flow is one way to enable human-in-the-loop. In this case, the developer knows *where* in the workflow human input is needed and simply places a breakpoint prior to or following that particular graph node.
+
+Here, we compile our graph with a checkpointer and a breakpoint at the node we want to interrupt before, `step_for_human_in_the_loop`. We then perform one of the above interaction patterns, which will create a new checkpoint if a human edits the graph state. The new checkpoint is saved to the `thread` and we can resume the graph execution from there by passing in `None` as the input.
+
+```python
+# Compile our graph with a checkpointer and a breakpoint before "step_for_human_in_the_loop"
+graph = builder.compile(checkpointer=checkpointer, interrupt_before=["step_for_human_in_the_loop"])
+
+# Run the graph up to the breakpoint
+thread_config = {"configurable": {"thread_id": "1"}}
+for event in graph.stream(inputs, thread_config, stream_mode="values"):
+    print(event)
+    
+# Perform some action that requires human in the loop
+
+# Continue the graph execution from the current checkpoint 
+for event in graph.stream(None, thread_config, stream_mode="values"):
+    print(event)
+```
+
+### Dynamic Breakpoints
+
+Alternatively, the developer can define some *condition* that must be met for a breakpoint to be triggered. This concept of [dynamic breakpoints](./breakpoints.md) 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:
+    if len(state['input']) > 5:
+        raise NodeInterrupt(f"Received input that is longer than 5 characters: {state['input']}")
+    return state
+```
+
+Let's assume we run the graph with an input that triggers the dynamic breakpoint and then attempt to resume the graph execution simply by passing in `None` for the input. 
+
+```python
+# Attempt to continue the graph execution with no change to state after we hit the dynamic breakpoint 
+for event in graph.stream(None, thread_config, stream_mode="values"):
+    print(event)
+```
+
+The graph will *interrupt* again because this node will be *re-run* with the same graph state. We need to change the graph state such that the condition that triggers the dynamic breakpoint is no longer met. So, we can simply edit the graph state to an input that meets the condition of our dynamic breakpoint (< 5 characters) and re-run the node.
+
+```python 
+# Update the state to pass the dynamic breakpoint
+graph.update_state(config=thread_config, values={"input": "foo"})
+for event in graph.stream(None, thread_config, stream_mode="values"):
+    print(event)
+```
+
+Alternatively, what if we want to keep our current input and skip the node (`my_node`) that performs the check? To do this, we can simply perform the graph update with `as_node="my_node"` and pass in `None` for the values. This will make no update the graph state, but run the update as `my_node`, effectively skipping the node and bypassing the dynamic breakpoint.
+
+```python
+# This update will skip the node `my_node` altogether
+graph.update_state(config=thread_config, values=None, as_node="my_node")
+for event in graph.stream(None, thread_config, stream_mode="values"):
+    print(event)
+```
+
+See [our guide](../how-tos/human_in_the_loop/dynamic_breakpoints.ipynb) for a detailed how-to on doing this!
+
+## Interaction Patterns
+
+### Approval
+
+![](./img/human_in_the_loop/approval.png)
+
+Sometimes we want to approve certain steps in our agent's execution. 
+ 
+We can interrupt our agent at a [breakpoint](./breakpoints.md) prior to the step that we want to approve.
+
+This is generally recommend for sensitive actions (e.g., using external APIs or writing to a database).
+ 
+With persistence, we can surface the current agent state as well as the next step to a user for review and approval. 
+ 
+If approved, the graph resumes execution from the last saved checkpoint, which is saved to the `thread`:
+
+```python
+# Compile our graph with a checkpointer and a breakpoint before the step to approve
+graph = builder.compile(checkpointer=checkpointer, interrupt_before=["node_2"])
+
+# Run the graph up to the breakpoint
+for event in graph.stream(inputs, thread, stream_mode="values"):
+    print(event)
+    
+# ... Get human approval ...
+
+# If approved, continue the graph execution from the last saved checkpoint
+for event in graph.stream(None, thread, stream_mode="values"):
+    print(event)
+```
+
+See [our guide](../how-tos/human_in_the_loop/breakpoints.ipynb) for a detailed how-to on doing this!
+
+### Editing
+
+![](./img/human_in_the_loop/edit_graph_state.png)
+
+Sometimes we want to review and edit the agent's state. 
+ 
+As with approval, we can interrupt our agent at a [breakpoint](./breakpoints.md) prior to the step we want to check. 
+ 
+We can surface the current state to a user and allow the user to edit the agent state.
+ 
+This can, for example, be used to correct the agent if it made a mistake (e.g., see the section on tool calling below).
+
+We can edit the graph state by forking the current checkpoint, which is saved to the `thread`.
+
+We can then proceed with the graph from our forked checkpoint as done before. 
+
+```python
+# Compile our graph with a checkpointer and a breakpoint before the step to review
+graph = builder.compile(checkpointer=checkpointer, interrupt_before=["node_2"])
+
+# Run the graph up to the breakpoint
+for event in graph.stream(inputs, thread, stream_mode="values"):
+    print(event)
+    
+# Review the state, decide to edit it, and create a forked checkpoint with the new state
+graph.update_state(thread, {"state": "new state"})
+
+# Continue the graph execution from the forked checkpoint
+for event in graph.stream(None, thread, stream_mode="values"):
+    print(event)
+```
+
+See [this guide](../how-tos/human_in_the_loop/edit-graph-state.ipynb) for a detailed how-to on doing this!
+
+### Input
+
+![](./img/human_in_the_loop/wait_for_input.png)
+
+Sometimes we want to explicitly get human input at a particular step in the graph. 
+ 
+We can create a graph node designated for this (e.g., `human_input` in our example diagram).
+ 
+As with approval and editing, we can interrupt our agent at a [breakpoint](./breakpoints.md) prior to this node.
+ 
+We can then perform a state update that includes the human input, just as we did with editing state.
+
+But, we add one thing: 
+
+We can use `as_node=human_input` with the state update to specify that the state update *should be treated as a node*.
+
+The is subtle, but important: 
+
+With editing, the user makes a decision about whether or not to edit the graph state.
+
+With input, we explicitly define a node in our graph for collecting human input!
+
+The state update with the human input then runs *as this node*.
+
+```python
+# Compile our graph with a checkpointer and a breakpoint before the step to to collect human input
+graph = builder.compile(checkpointer=checkpointer, interrupt_before=["human_input"])
+
+# Run the graph up to the breakpoint
+for event in graph.stream(inputs, thread, stream_mode="values"):
+    print(event)
+    
+# Update the state with the user input as if it was the human_input node
+graph.update_state(thread, {"user_input": user_input}, as_node="human_input")
+
+# Continue the graph execution from the checkpoint created by the human_input node
+for event in graph.stream(None, thread, stream_mode="values"):
+    print(event)
+```
+
+See [this guide](../how-tos/human_in_the_loop/wait-user-input.ipynb) for a detailed how-to on doing this!
+
+## Use-cases
+
+### Reviewing Tool Calls
+
+Some user interaction patterns combine the above ideas.
+
+For example, many agents use [tool calling](https://python.langchain.com/docs/how_to/tool_calling/) to make decisions. 
+
+Tool calling presents a challenge because the agent must get two things right: 
+
+(1) The name of the tool to call 
+
+(2) The arguments to pass to the tool
+
+Even if the tool call is correct, we may also want to apply discretion: 
+
+(3) The tool call may be a sensitive operation that we want to approve 
+
+With these points in mind, we can combine the above ideas to create a human-in-the-loop review of a tool call.
+
+```python
+# Compile our graph with a checkpointer and a breakpoint before the step to to review the tool call from the LLM 
+graph = builder.compile(checkpointer=checkpointer, interrupt_before=["human_review"])
+
+# Run the graph up to the breakpoint
+for event in graph.stream(inputs, thread, stream_mode="values"):
+    print(event)
+    
+# Review the tool call and update it, if needed, as the human_review node
+graph.update_state(thread, {"tool_call": "updated tool call"}, as_node="human_review")
+
+# Otherwise, approve the tool call and proceed with the graph execution with no edits 
+
+# Continue the graph execution from either: 
+# (1) the forked checkpoint created by human_review or 
+# (2) the checkpoint saved when the tool call was originally made (no edits in human_review)
+for event in graph.stream(None, thread, stream_mode="values"):
+    print(event)
+```
+
+See [this guide](../how-tos/human_in_the_loop/review-tool-calls.ipynb) for a detailed how-to on doing this!
+
+### Time Travel
+
+When working with agents, we often want closely examine their decision making process: 
+
+(1) Even when they arrive a desired final result, the reasoning that led to that result is often important to examine.
+
+(2) When agents make mistakes, it is often valuable to understand why.
+
+(3) In either of the above cases, it is useful to manually explore alternative decision making paths.
+
+Collectively, we call these debugging concepts `time-travel` and they are composed of `replaying` and `forking`.
+
+#### Replaying
+
+![](./img/human_in_the_loop/replay.png)
+
+Sometimes we want to simply replay past actions of an agent. 
+ 
+Above, we showed the case of executing an agent from the current state (or checkpoint) of the graph.
+
+We by simply passing in `None` for the input with a `thread`.
+
+```
+thread = {"configurable": {"thread_id": "1"}}
+for event in graph.stream(None, thread, stream_mode="values"):
+    print(event)
+```
+
+Now, we can modify this to replay past actions from a *specific* checkpoint by passing in the checkpoint ID.
+
+To get a specific checkpoint ID, we can easily get all of the checkpoints in the thread and filter to the one we want.
+
+```python
+all_checkpoints = []
+for state in app.get_state_history(thread):
+    all_checkpoints.append(state)
+```
+
+Each checkpoint has a unique ID, which we can use to replay from a specific checkpoint.
+
+Assume from reviewing the checkpoints that we want to replay from one, `xxx`.
+
+We just pass in the checkpoint ID when we run the graph.
+
+```python
+config = {'configurable': {'thread_id': '1', 'checkpoint_id': 'xxx'}}
+for event in graph.stream(None, config, stream_mode="values"):
+    print(event)
+```
+ 
+Importantly, the graph knows which checkpoints have been previously executed. 
+
+So, it will re-play any previously executed nodes rather than re-executing them.
+
+See [this additional conceptual guide](https://langchain-ai.github.io/langgraph/concepts/persistence/#replay) for related context on replaying.
+
+See see [this guide](../how-tos/human_in_the_loop/time-travel.ipynb) for a detailed how-to on doing time-travel!
+
+#### Forking
+
+![](./img/human_in_the_loop/forking.png)
+
+Sometimes we want to fork past actions of an agent, and explore different paths through the graph.
+
+`Editing`, as discussed above, is *exactly* how we do this for the *current* state of the graph! 
+
+But, what if we want to fork *past* states of the graph?
+
+For example, let's say we want to edit a particular checkpoint, `xxx`.
+
+We pass this `checkpoint_id` when we update the state of the graph.
+
+```python
+config = {"configurable": {"thread_id": "1", "checkpoint_id": "xxx"}}
+graph.update_state(config, {"state": "updated state"}, )
+```
+
+This creates a new forked checkpoint, `xxx-fork`, which we can then run the graph from.
+
+```python
+config = {'configurable': {'thread_id': '1', 'checkpoint_id': 'xxx-fork'}}
+for event in graph.stream(None, config, stream_mode="values"):
+    print(event)
+```
+
+See [this additional conceptual guide](https://langchain-ai.github.io/langgraph/concepts/persistence/#update-state) for related context on forking.
+
+See [this guide](../how-tos/human_in_the_loop/time-travel.ipynb) for a detailed how-to on doing time-travel!

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

@@ -0,0 +1,133 @@
+# How to add custom authentication
+
+!!! tip "Prerequisites"
+
+    This guide assumes familiarity with the following concepts:
+
+      *  [**Authentication & Access Control**](../../concepts/auth.md)
+      *  [**LangGraph Platform**](../../concepts/index.md#langgraph-platform)
+    
+    For a more guided walkthrough, see [**setting up custom authentication**](../../tutorials/auth/getting_started.md) tutorial.
+
+???+ note "Python only"
+  
+    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.
+
+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
+
+my_auth = Auth()
+
+@my_auth.authenticate
+async def authenticate(authorization: str) -> str:
+    token = authorization.split(" ", 1)[-1] # "Bearer <token>"
+    try:
+        # Verify token with your auth provider
+        user_id = await verify_token(token)
+        return user_id
+    except Exception:
+        raise Auth.exceptions.HTTPException(
+            status_code=401,
+            detail="Invalid token"
+        )
+
+# Optional: Add authorization rules
+@my_auth.on
+async def add_owner(
+    ctx: Auth.types.AuthContext,
+    value: dict,
+):
+    """Add owner to resource metadata and filter by owner."""
+    filters = {"owner": ctx.user.identity}
+    metadata = value.setdefault("metadata", {})
+    metadata.update(filters)
+    return filters
+```
+
+## 2. Update configuration
+
+In your `langgraph.json`, add the path to your auth file:
+
+```json hl_lines="7-9"
+{
+  "dependencies": ["."],
+  "graphs": {
+    "agent": "./agent.py:graph"
+  },
+  "env": ".env",
+  "auth": {
+    "path": "./auth.py:my_auth"
+  }
+}
+```
+
+## 3. Connect from the client
+
+Once you've set up authentication in your server, requests must include the the required authorization information based on your chosen scheme.
+Assuming you are using JWT token authentication, you could access your deployments using any of the following methods:
+
+=== "Python Client"
+
+    ```python
+    from langgraph_sdk import get_client
+
+    my_token = "your-token" # In practice, you would generate a signed token with your auth provider
+    client = get_client(
+        url="http://localhost:2024",
+        headers={"Authorization": f"Bearer {my_token}"}
+    )
+    threads = await client.threads.search()
+    ```
+
+=== "Python RemoteGraph"
+
+    ```python
+    from langgraph.pregel.remote import RemoteGraph
+    
+    my_token = "your-token" # In practice, you would generate a signed token with your auth provider
+    remote_graph = RemoteGraph(
+        "agent",
+        url="http://localhost:2024",
+        headers={"Authorization": f"Bearer {my_token}"}
+    )
+    threads = await remote_graph.ainvoke(...)
+    ```
+
+=== "JavaScript Client"
+
+    ```javascript
+    import { Client } from "@langchain/langgraph-sdk";
+
+    const my_token = "your-token"; // In practice, you would generate a signed token with your auth provider
+    const client = new Client({
+      apiUrl: "http://localhost:2024",
+      headers: { Authorization: `Bearer ${my_token}` },
+    });
+    const threads = await client.threads.search();
+    ```
+
+=== "JavaScript RemoteGraph"
+
+    ```javascript
+    import { RemoteGraph } from "@langchain/langgraph/remote";
+
+    const my_token = "your-token"; // In practice, you would generate a signed token with your auth provider
+    const remoteGraph = new RemoteGraph({
+      graphId: "agent",
+      url: "http://localhost:2024",
+      headers: { Authorization: `Bearer ${my_token}` },
+    });
+    const threads = await remoteGraph.invoke(...);
+    ```
+
+=== "CURL"
+
+    ```bash
+    curl -H "Authorization: Bearer ${your-token}" http://localhost:2024/threads
+    ```

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

@@ -0,0 +1,98 @@
+# How to document API authentication in OpenAPI
+
+This guide shows how to customize the OpenAPI security schema for your LangGraph Platform API documentation. A well-documented security schema helps API consumers understand how to authenticate with your API and even enables automatic client generation. See the [Authentication & Access Control conceptual guide](../../concepts/auth.md) for more details about LangGraph's authentication system.
+
+!!! note "Implementation vs Documentation"
+    This guide only covers how to document your security requirements in OpenAPI. To implement the actual authentication logic, see [How to add custom authentication](./custom_auth.md).
+
+This guide applies to all LangGraph Platform deployments (Cloud, BYOC, and self-hosted). It does not apply to usage of the LangGraph open source library if you are not using LangGraph Platform.
+
+## Default Schema
+
+The default security scheme varies by deployment type:
+
+=== "LangGraph Cloud"
+
+By default, LangGraph Cloud requires a LangSmith API key in the `x-api-key` header:
+
+```yaml
+components:
+  securitySchemes:
+    apiKeyAuth:
+      type: apiKey
+      in: header
+      name: x-api-key
+security:
+  - apiKeyAuth: []
+```
+
+When using one of the LangGraph SDK's, this can be inferred from environment variables.
+
+=== "Self-hosted"
+
+By default, self-hosted deployments have no security scheme. This means they are to be deployed only on a secured network or with authentication. To add custom authentication, see [How to add custom authentication](./custom_auth.md).
+
+## Custom Security Schema
+
+To customize the security schema in your OpenAPI documentation, add an `openapi` field to your `auth` configuration in `langgraph.json`. Remember that this only updates the API documentation - you must also implement the corresponding authentication logic as shown in [How to add custom authentication](./custom_auth.md).
+
+Note that LangGraph Platform does not provide authentication endpoints - you'll need to handle user authentication in your client application and pass the resulting credentials to the LangGraph API.
+
+=== "OAuth2 with Bearer Token"
+
+    ```json
+    {
+      "auth": {
+        "path": "./auth.py:my_auth",  // Implement auth logic here
+        "openapi": {
+          "securitySchemes": {
+            "OAuth2": {
+              "type": "oauth2",
+              "flows": {
+                "implicit": {
+                  "authorizationUrl": "https://your-auth-server.com/oauth/authorize",
+                  "scopes": {
+                    "me": "Read information about the current user",
+                    "threads": "Access to create and manage threads"
+                  }
+                }
+              }
+            }
+          },
+          "security": [
+            {"OAuth2": ["me", "threads"]}
+          ]
+        }
+      }
+    }
+    ```
+
+=== "API Key"
+
+    ```json
+    {
+      "auth": {
+        "path": "./auth.py:my_auth",  // Implement auth logic here
+        "openapi": {
+          "securitySchemes": {
+            "apiKeyAuth": {
+              "type": "apiKey",
+              "in": "header",
+              "name": "X-API-Key"
+            }
+          },
+          "security": [
+            {"apiKeyAuth": []}
+          ]
+        }
+      }
+    }
+    ```
+
+## Testing
+
+After updating your configuration:
+
+1. Deploy your application
+2. Visit `/docs` to see the updated OpenAPI documentation
+3. Try out the endpoints using credentials from your authentication server (make sure you've implemented the authentication logic first)

docs/docs/how-tos/command.ipynb

@@ -25,7 +25,7 @@
     "\n",
     "```python\n",
     "def my_node(state: State) -> Command[Literal[\"my_other_node\"]]:\n",
-    "    return GraphCommand(\n",
+    "    return Command(\n",
     "        # state update\n",
     "        update={\"foo\": \"bar\"},\n",
     "        # control flow\n",
@@ -144,7 +144,7 @@
    "id": "badc25eb-4876-482e-bb10-d763023cdaad",
    "metadata": {},
    "source": [
-    "We can now create the `StateGraph` with the above nodes. Notice that the graph doesn't have [conditional edges](../../concepts/low_level#conditional-edges) for routing! This is because control flow is defined with `GraphCommand` inside `node_a`."
+    "We can now create the `StateGraph` with the above nodes. Notice that the graph doesn't have [conditional edges](../../concepts/low_level#conditional-edges) for routing! This is because control flow is defined with `Command` inside `node_a`."
    ]
   },
   {
@@ -171,7 +171,7 @@
    "source": [
     "!!! important\n",
     "\n",
-    "    You might have noticed that we used `Command` as a return type annotation, e.g. `Command[Literal[\"node_b\", \"node_c\"]]`. This is necessary for the graph compilation and rendering, and tells LangGraph that `node_a` can navigate to `node_b` and `node_c`."
+    "    You might have noticed that we used `Command` as a return type annotation, e.g. `Command[Literal[\"node_b\", \"node_c\"]]`. This is necessary for the graph rendering and tells LangGraph that `node_a` can navigate to `node_b` and `node_c`."
    ]
   },
   {

docs/docs/how-tos/human_in_the_loop/breakpoints.ipynb

@@ -12,6 +12,14 @@
    "source": [
     "# How to add breakpoints\n",
     "\n",
+    "!!! tip \"Prerequisites\"\n",
+    "\n",
+    "    This guide assumes familiarity with the following concepts:\n",
+    "\n",
+    "    * [Breakpoints](../../../concepts/breakpoints)\n",
+    "    * [LangGraph Glossary](../../../concepts/low_level)\n",
+    "    \n",
+    "\n",
     "Human-in-the-loop (HIL) interactions are crucial for [agentic systems](https://langchain-ai.github.io/langgraph/concepts/agentic_concepts/#human-in-the-loop). [Breakpoints](https://langchain-ai.github.io/langgraph/concepts/low_level/#breakpoints) are a common HIL interaction pattern, allowing the graph to stop at specific steps and seek human approval before proceeding (e.g., for sensitive actions). \n",
     "\n",
     "Breakpoints are built on top of LangGraph [checkpoints](https://langchain-ai.github.io/langgraph/concepts/low_level/#checkpointer), which save the graph's state after each node execution. Checkpoints are saved in [threads](https://langchain-ai.github.io/langgraph/concepts/low_level/#threads) that preserve graph state and can be accessed after a graph has finished execution. This allows for graph execution to pause at specific points, await human approval, and then resume execution from the last checkpoint.\n",
@@ -467,7 +475,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.8"
+   "version": "3.11.4"
   }
  },
  "nbformat": 4,

docs/docs/how-tos/human_in_the_loop/dynamic_breakpoints.ipynb

@@ -1,24 +1,32 @@
 {
  "cells": [
   {
+   "attachments": {},
    "cell_type": "markdown",
-   "id": "ee54cde3-7e4d-43f4-b921-e7141ea0f19e",
-   "metadata": {},
-   "source": [
-    "# How to add dynamic breakpoints"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "607849c6-4b8c-4e06-ad9c-758bb5a08e86",
+   "id": "b7d5f6a5-9e59-43e4-a4b6-8ada6dace691",
    "metadata": {},
    "source": [
+    "# How to add dynamic breakpoints with `NodeInterrupt`\n",
+    "\n",
+    "!!! note\n",
+    "\n",
+    "    For **human-in-the-loop** workflows use the new [`interrupt()`](../../../reference/types/#langgraph.types.interrupt) function for **human-in-the-loop** workflows. Please review the [Human-in-the-loop conceptual guide](../../../concepts/human_in_the_loop) for more information about design patterns with `interrupt`.\n",
+    "\n",
+    "!!! tip \"Prerequisites\"\n",
+    "\n",
+    "    This guide assumes familiarity with the following concepts:\n",
+    "\n",
+    "    * [Breakpoints](../../../concepts/breakpoints)\n",
+    "    * [LangGraph Glossary](../../../concepts/low_level)\n",
+    "    \n",
+    "\n",
     "Human-in-the-loop (HIL) interactions are crucial for [agentic systems](https://langchain-ai.github.io/langgraph/concepts/agentic_concepts/#human-in-the-loop). [Breakpoints](https://langchain-ai.github.io/langgraph/concepts/low_level/#breakpoints) are a common HIL interaction pattern, allowing the graph to stop at specific steps and seek human approval before proceeding (e.g., for sensitive actions).\n",
     "\n",
     "In LangGraph you can add breakpoints before / after a node is executed. But oftentimes it may be helpful to **dynamically** interrupt the graph from inside a given node based on some condition. When doing so, it may also be helpful to include information about **why** that interrupt was raised.\n",
     "\n",
     "This guide shows how you can dynamically interrupt the graph using `NodeInterrupt` -- a special exception that can be raised from inside a node. Let's see it in action!\n",
     "\n",
+    "\n",
     "## Setup\n",
     "\n",
     "First, let's install the required packages"
@@ -430,7 +438,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.9"
+   "version": "3.11.4"
   }
  },
  "nbformat": 4,

docs/docs/how-tos/human_in_the_loop/edit-graph-state.ipynb

@@ -12,6 +12,12 @@
    "source": [
     "# How to edit graph state\n",
     "\n",
+    "!!! tip \"Prerequisites\"\n",
+    "\n",
+    "    * [Human-in-the-loop](../../../concepts/human_in_the_loop)\n",
+    "    * [Breakpoints](../../../concepts/breakpoints)\n",
+    "    * [LangGraph Glossary](../../../concepts/low_level)\n",
+    "\n",
     "Human-in-the-loop (HIL) interactions are crucial for [agentic systems](https://langchain-ai.github.io/langgraph/concepts/agentic_concepts/#human-in-the-loop). Manually updating the graph state a common HIL interaction pattern, allowing the human to edit actions (e.g., what tool is being called or how it is being called).\n",
     "\n",
     "We can implement this in LangGraph using a [breakpoint](https://langchain-ai.github.io/langgraph/how-tos/human_in_the_loop/breakpoints/): breakpoints allow us to interrupt graph execution before a specific step. At this breakpoint, we can manually update the graph state and then resume from that spot to continue.  \n",
@@ -554,7 +560,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.8"
+   "version": "3.11.4"
   }
  },
  "nbformat": 4,

docs/docs/how-tos/human_in_the_loop/time-travel.ipynb

@@ -7,6 +7,15 @@
    "source": [
     "# How to view and update past graph state\n",
     "\n",
+    "!!! tip \"Prerequisites\"\n",
+    "\n",
+    "    This guide assumes familiarity with the following concepts:\n",
+    "\n",
+    "    * [Time Travel](../../../concepts/time-travel)\n",
+    "    * [Breakpoints](../../../concepts/breakpoints)\n",
+    "    * [LangGraph Glossary](../../../concepts/low_level)\n",
+    "\n",
+    "\n",
     "Once you start [checkpointing](../../persistence) your graphs, you can easily **get** or **update** the state of the agent at any point in time. This permits a few things:\n",
     "\n",
     "1. You can surface a state during an interrupt to a user to let them accept an action.\n",
@@ -589,7 +598,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.9"
+   "version": "3.11.4"
   }
  },
  "nbformat": 4,

docs/docs/how-tos/index.md

@@ -30,7 +30,7 @@ These how-to guides show how to achieve that controllability.
 - [How to add thread-level persistence to subgraphs](subgraph-persistence.ipynb)
 - [How to add cross-thread persistence to your graph](cross-thread-persistence.ipynb)
 - [How to use Postgres checkpointer for persistence](persistence_postgres.ipynb)
-- [How to create a custom checkpointer using MongoDB](persistence_mongodb.ipynb)
+- [How to use MongoDB checkpointer for persistence](persistence_mongodb.ipynb)
 - [How to create a custom checkpointer using Redis](persistence_redis.ipynb)
 
 ### Memory
@@ -48,12 +48,24 @@ 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.
 
-- [How to add breakpoints](human_in_the_loop/breakpoints.ipynb)
-- [How to add dynamic breakpoints](human_in_the_loop/dynamic_breakpoints.ipynb)
-- [How to edit graph state](human_in_the_loop/edit-graph-state.ipynb)
-- [How to wait for user input](human_in_the_loop/wait-user-input.ipynb)
+
+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:
+
+- [How to add static breakpoints](human_in_the_loop/breakpoints.ipynb): Use for debugging purposes. For [**human-in-the-loop**](../concepts/human_in_the_loop.md) workflows, we recommend the [`interrupt` function][langgraph.types.interrupt] instead.
+- [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.
+
+### Time Travel
+
+[Time travel](../concepts/time-travel.md) allows you to replay past actions in your LangGraph application to explore alternative paths and debug issues. These how-to guides show how to use time travel in your graph.
+
 - [How to view and update past graph state](human_in_the_loop/time-travel.ipynb)
-- [How to review tool calls](human_in_the_loop/review-tool-calls.ipynb)
 
 ### Streaming
 
@@ -81,6 +93,7 @@ These how-to guides show common patterns for tool calling with LangGraph:
 - [How to handle tool calling errors](tool-calling-errors.ipynb)
 - [How to pass runtime values to tools](pass-run-time-values-to-tools.ipynb)
 - [How to pass config to tools](pass-config-to-tools.ipynb)
+- [How to update graph state from tools](update-state-from-tools.ipynb)
 - [How to handle large numbers of tools](many-tools.ipynb)
 
 ### Subgraphs
@@ -91,6 +104,16 @@ These how-to guides show common patterns for tool calling with LangGraph:
 - [How to view and update state in subgraphs](subgraphs-manage-state.ipynb)
 - [How to transform inputs and outputs of a subgraph](subgraph-transform-state.ipynb)
 
+### Multi-agent
+
+[Multi-agent systems](../concepts/multi_agent.md) are useful to break down complex LLM applications into multiple agents, each responsible for a different part of the application. These how-to guides show how to implement multi-agent systems in LangGraph:
+
+- [How to implement handoffs between agents](agent-handoffs.ipynb)
+- [How to build a multi-agent network](multi-agent-network.ipynb)
+- [How to add multi-turn conversation in a multi-agent application](multi-agent-multi-turn-convo.ipynb)
+
+See the [multi-agent tutorials](../tutorials/index.md#multi-agent-systems) for implementations of other multi-agent architectures.
+
 ### State Management
 
 - [How to use Pydantic model as state](state-model.ipynb)
@@ -157,6 +180,11 @@ LangGraph applications can be deployed using LangGraph Cloud, which provides a r
 - [How to deploy to a self-hosted environment](./deploy-self-hosted.md)
 - [How to interact with the deployment using RemoteGraph](./use-remote-graph.md)
 
+### Authentication & Access Control
+
+- [How to add custom authentication](./auth/custom_auth.md)
+- [How to update the security schema of your OpenAPI spec](./auth/openapi_security.md)
+
 ### Assistants
 
 [Assistants](../concepts/assistants.md) is a configured instance of a template.
@@ -225,6 +253,7 @@ LangGraph Studio is a built-in UI for visualizing, testing, and debugging your a
 - [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)
 
 ## Troubleshooting
 

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

@@ -6,8 +6,8 @@ This guide shows you how to connect your local agent to [LangGraph Studio](../co
 
 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
-- [Development Server](../concepts/langgraph_studio.md#dev-server): Python package, all platforms, no Docker
 
 In this guide we will cover how to use the development server as that is generally an easier and better experience.
 
@@ -22,8 +22,14 @@ See [this guide](../concepts/application_structure.md) for information on how to
 You will need to install [`langgraph-cli`](../cloud/reference/cli.md#langgraph-cli) (version `0.1.55` or higher).
 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.
+  
+
 ```shell
-pip install "langgraph-cli[inmem]==0.1.55"
+pip install -U "langgraph-cli[inmem]"
 ```
 
 ## Run the development server

docs/docs/how-tos/persistence_redis.ipynb

@@ -151,6 +151,7 @@
     "from langchain_core.runnables import RunnableConfig\n",
     "\n",
     "from langgraph.checkpoint.base import (\n",
+    "    WRITES_IDX_MAP,\n",
     "    BaseCheckpointSaver,\n",
     "    ChannelVersions,\n",
     "    Checkpoint,\n",
@@ -163,7 +164,7 @@
     "from redis import Redis\n",
     "from redis.asyncio import Redis as AsyncRedis\n",
     "\n",
-    "REDIS_KEY_SEPARATOR = \":\"\n",
+    "REDIS_KEY_SEPARATOR = \"$\"\n",
     "\n",
     "\n",
     "# Utilities shared by both RedisSaver and AsyncRedisSaver\n",
@@ -246,17 +247,6 @@
     "    return keys\n",
     "\n",
     "\n",
-    "def _dump_writes(serde: SerializerProtocol, writes: tuple[str, Any]) -> list[dict]:\n",
-    "    \"\"\"Serialize pending writes.\"\"\"\n",
-    "    serialized_writes = []\n",
-    "    for channel, value in writes:\n",
-    "        type_, serialized_value = serde.dumps_typed(value)\n",
-    "        serialized_writes.append(\n",
-    "            {\"channel\": channel, \"type\": type_, \"value\": serialized_value}\n",
-    "        )\n",
-    "    return serialized_writes\n",
-    "\n",
-    "\n",
     "def _load_writes(\n",
     "    serde: SerializerProtocol, task_id_to_data: dict[tuple[str, str], dict]\n",
     ") -> list[PendingWrite]:\n",
@@ -413,7 +403,7 @@
     "        config: RunnableConfig,\n",
     "        writes: List[Tuple[str, Any]],\n",
     "        task_id: str,\n",
-    "    ) -> RunnableConfig:\n",
+    "    ) -> None:\n",
     "        \"\"\"Store intermediate writes linked to a checkpoint.\n",
     "\n",
     "        Args:\n",
@@ -425,12 +415,23 @@
     "        checkpoint_ns = config[\"configurable\"][\"checkpoint_ns\"]\n",
     "        checkpoint_id = config[\"configurable\"][\"checkpoint_id\"]\n",
     "\n",
-    "        for idx, data in enumerate(_dump_writes(self.serde, writes)):\n",
+    "        for idx, (channel, value) in enumerate(writes):\n",
     "            key = _make_redis_checkpoint_writes_key(\n",
-    "                thread_id, checkpoint_ns, checkpoint_id, task_id, idx\n",
+    "                thread_id,\n",
+    "                checkpoint_ns,\n",
+    "                checkpoint_id,\n",
+    "                task_id,\n",
+    "                WRITES_IDX_MAP.get(channel, idx),\n",
     "            )\n",
-    "            self.conn.hset(key, mapping=data)\n",
-    "        return config\n",
+    "            type_, serialized_value = self.serde.dumps_typed(value)\n",
+    "            data = {\"channel\": channel, \"type\": type_, \"value\": serialized_value}\n",
+    "            if all(w[0] in WRITES_IDX_MAP for w in writes):\n",
+    "                # Use HSET which will overwrite existing values\n",
+    "                self.conn.hset(key, mapping=data)\n",
+    "            else:\n",
+    "                # Use HSETNX which will not overwrite existing values\n",
+    "                for field, value in data.items():\n",
+    "                    self.conn.hsetnx(key, field, value)\n",
     "\n",
     "    def get_tuple(self, config: RunnableConfig) -> Optional[CheckpointTuple]:\n",
     "        \"\"\"Get a checkpoint tuple from Redis.\n",
@@ -463,21 +464,8 @@
     "            checkpoint_id\n",
     "            or _parse_redis_checkpoint_key(checkpoint_key)[\"checkpoint_id\"]\n",
     "        )\n",
-    "        writes_key = _make_redis_checkpoint_writes_key(\n",
-    "            thread_id, checkpoint_ns, checkpoint_id, \"*\", None\n",
-    "        )\n",
-    "        matching_keys = self.conn.keys(pattern=writes_key)\n",
-    "        parsed_keys = [\n",
-    "            _parse_redis_checkpoint_writes_key(key.decode()) for key in matching_keys\n",
-    "        ]\n",
-    "        pending_writes = _load_writes(\n",
-    "            self.serde,\n",
-    "            {\n",
-    "                (parsed_key[\"task_id\"], parsed_key[\"idx\"]): self.conn.hgetall(key)\n",
-    "                for key, parsed_key in sorted(\n",
-    "                    zip(matching_keys, parsed_keys), key=lambda x: x[1][\"idx\"]\n",
-    "                )\n",
-    "            },\n",
+    "        pending_writes = self._load_pending_writes(\n",
+    "            thread_id, checkpoint_ns, checkpoint_id\n",
     "        )\n",
     "        return _parse_redis_checkpoint_data(\n",
     "            self.serde, checkpoint_key, checkpoint_data, pending_writes=pending_writes\n",
@@ -514,7 +502,37 @@
     "        for key in keys:\n",
     "            data = self.conn.hgetall(key)\n",
     "            if data and b\"checkpoint\" in data and b\"metadata\" in data:\n",
-    "                yield _parse_redis_checkpoint_data(self.serde, key.decode(), data)\n",
+    "                # load pending writes\n",
+    "                checkpoint_id = _parse_redis_checkpoint_key(key.decode())[\n",
+    "                    \"checkpoint_id\"\n",
+    "                ]\n",
+    "                pending_writes = self._load_pending_writes(\n",
+    "                    thread_id, checkpoint_ns, checkpoint_id\n",
+    "                )\n",
+    "                yield _parse_redis_checkpoint_data(\n",
+    "                    self.serde, key.decode(), data, pending_writes=pending_writes\n",
+    "                )\n",
+    "\n",
+    "    def _load_pending_writes(\n",
+    "        self, thread_id: str, checkpoint_ns: str, checkpoint_id: str\n",
+    "    ) -> List[PendingWrite]:\n",
+    "        writes_key = _make_redis_checkpoint_writes_key(\n",
+    "            thread_id, checkpoint_ns, checkpoint_id, \"*\", None\n",
+    "        )\n",
+    "        matching_keys = self.conn.keys(pattern=writes_key)\n",
+    "        parsed_keys = [\n",
+    "            _parse_redis_checkpoint_writes_key(key.decode()) for key in matching_keys\n",
+    "        ]\n",
+    "        pending_writes = _load_writes(\n",
+    "            self.serde,\n",
+    "            {\n",
+    "                (parsed_key[\"task_id\"], parsed_key[\"idx\"]): self.conn.hgetall(key)\n",
+    "                for key, parsed_key in sorted(\n",
+    "                    zip(matching_keys, parsed_keys), key=lambda x: x[1][\"idx\"]\n",
+    "                )\n",
+    "            },\n",
+    "        )\n",
+    "        return pending_writes\n",
     "\n",
     "    def _get_checkpoint_key(\n",
     "        self, conn, thread_id: str, checkpoint_ns: str, checkpoint_id: Optional[str]\n",
@@ -637,7 +655,7 @@
     "        config: RunnableConfig,\n",
     "        writes: List[Tuple[str, Any]],\n",
     "        task_id: str,\n",
-    "    ) -> RunnableConfig:\n",
+    "    ) -> None:\n",
     "        \"\"\"Store intermediate writes linked to a checkpoint asynchronously.\n",
     "\n",
     "        This method saves intermediate writes associated with a checkpoint to the database.\n",
@@ -651,12 +669,23 @@
     "        checkpoint_ns = config[\"configurable\"][\"checkpoint_ns\"]\n",
     "        checkpoint_id = config[\"configurable\"][\"checkpoint_id\"]\n",
     "\n",
-    "        for idx, data in enumerate(_dump_writes(self.serde, writes)):\n",
+    "        for idx, (channel, value) in enumerate(writes):\n",
     "            key = _make_redis_checkpoint_writes_key(\n",
-    "                thread_id, checkpoint_ns, checkpoint_id, task_id, idx\n",
+    "                thread_id,\n",
+    "                checkpoint_ns,\n",
+    "                checkpoint_id,\n",
+    "                task_id,\n",
+    "                WRITES_IDX_MAP.get(channel, idx),\n",
     "            )\n",
-    "            await self.conn.hset(key, mapping=data)\n",
-    "        return config\n",
+    "            type_, serialized_value = self.serde.dumps_typed(value)\n",
+    "            data = {\"channel\": channel, \"type\": type_, \"value\": serialized_value}\n",
+    "            if all(w[0] in WRITES_IDX_MAP for w in writes):\n",
+    "                # Use HSET which will overwrite existing values\n",
+    "                await self.conn.hset(key, mapping=data)\n",
+    "            else:\n",
+    "                # Use HSETNX which will not overwrite existing values\n",
+    "                for field, value in data.items():\n",
+    "                    await self.conn.hsetnx(key, field, value)\n",
     "\n",
     "    async def aget_tuple(self, config: RunnableConfig) -> Optional[CheckpointTuple]:\n",
     "        \"\"\"Get a checkpoint tuple from Redis asynchronously.\n",
@@ -688,21 +717,8 @@
     "            checkpoint_id\n",
     "            or _parse_redis_checkpoint_key(checkpoint_key)[\"checkpoint_id\"]\n",
     "        )\n",
-    "        writes_key = _make_redis_checkpoint_writes_key(\n",
-    "            thread_id, checkpoint_ns, checkpoint_id, \"*\", None\n",
-    "        )\n",
-    "        matching_keys = await self.conn.keys(pattern=writes_key)\n",
-    "        parsed_keys = [\n",
-    "            _parse_redis_checkpoint_writes_key(key.decode()) for key in matching_keys\n",
-    "        ]\n",
-    "        pending_writes = _load_writes(\n",
-    "            self.serde,\n",
-    "            {\n",
-    "                (parsed_key[\"task_id\"], parsed_key[\"idx\"]): await self.conn.hgetall(key)\n",
-    "                for key, parsed_key in sorted(\n",
-    "                    zip(matching_keys, parsed_keys), key=lambda x: x[1][\"idx\"]\n",
-    "                )\n",
-    "            },\n",
+    "        pending_writes = await self._aload_pending_writes(\n",
+    "            thread_id, checkpoint_ns, checkpoint_id\n",
     "        )\n",
     "        return _parse_redis_checkpoint_data(\n",
     "            self.serde, checkpoint_key, checkpoint_data, pending_writes=pending_writes\n",
@@ -738,7 +754,36 @@
     "        for key in keys:\n",
     "            data = await self.conn.hgetall(key)\n",
     "            if data and b\"checkpoint\" in data and b\"metadata\" in data:\n",
-    "                yield _parse_redis_checkpoint_data(self.serde, key.decode(), data)\n",
+    "                checkpoint_id = _parse_redis_checkpoint_key(key.decode())[\n",
+    "                    \"checkpoint_id\"\n",
+    "                ]\n",
+    "                pending_writes = await self._aload_pending_writes(\n",
+    "                    thread_id, checkpoint_ns, checkpoint_id\n",
+    "                )\n",
+    "                yield _parse_redis_checkpoint_data(\n",
+    "                    self.serde, key.decode(), data, pending_writes=pending_writes\n",
+    "                )\n",
+    "\n",
+    "    async def _aload_pending_writes(\n",
+    "        self, thread_id: str, checkpoint_ns: str, checkpoint_id: str\n",
+    "    ) -> List[PendingWrite]:\n",
+    "        writes_key = _make_redis_checkpoint_writes_key(\n",
+    "            thread_id, checkpoint_ns, checkpoint_id, \"*\", None\n",
+    "        )\n",
+    "        matching_keys = await self.conn.keys(pattern=writes_key)\n",
+    "        parsed_keys = [\n",
+    "            _parse_redis_checkpoint_writes_key(key.decode()) for key in matching_keys\n",
+    "        ]\n",
+    "        pending_writes = _load_writes(\n",
+    "            self.serde,\n",
+    "            {\n",
+    "                (parsed_key[\"task_id\"], parsed_key[\"idx\"]): await self.conn.hgetall(key)\n",
+    "                for key, parsed_key in sorted(\n",
+    "                    zip(matching_keys, parsed_keys), key=lambda x: x[1][\"idx\"]\n",
+    "                )\n",
+    "            },\n",
+    "        )\n",
+    "        return pending_writes\n",
     "\n",
     "    async def _aget_checkpoint_key(\n",
     "        self, conn, thread_id: str, checkpoint_ns: str, checkpoint_id: Optional[str]\n",
@@ -1042,7 +1087,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.4"
+   "version": "3.12.3"
   }
  },
  "nbformat": 4,

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

@@ -225,9 +225,19 @@
     "# Define the function that responds to the user\n",
     "def respond(state: AgentState):\n",
     "    # Construct the final answer from the arguments of the last tool call\n",
-    "    response = WeatherResponse(**state[\"messages\"][-1].tool_calls[0][\"args\"])\n",
+    "    weather_tool_call = state[\"messages\"][-1].tool_calls[0]\n",
+    "    response = WeatherResponse(**weather_tool_call[\"args\"])\n",
+    "    # Since we're using tool calling to return structured output,\n",
+    "    # we need to add  a tool message corresponding to the WeatherResponse tool call,\n",
+    "    # This is due to LLM providers' requirement that AI messages with tool calls\n",
+    "    # need to be followed by a tool message for each tool call\n",
+    "    tool_message = {\n",
+    "        \"type\": \"tool\",\n",
+    "        \"content\": \"Here is your structured response\",\n",
+    "        \"tool_call_id\": weather_tool_call[\"id\"],\n",
+    "    }\n",
     "    # We return the final answer\n",
-    "    return {\"final_response\": response}\n",
+    "    return {\"final_response\": response, \"messages\": [tool_message]}\n",
     "\n",
     "\n",
     "# Define the function that determines whether to continue or not\n",
@@ -466,7 +476,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.4"
+   "version": "3.12.3"
   }
  },
  "nbformat": 4,

docs/docs/how-tos/tool-calling.ipynb

@@ -6,7 +6,7 @@
    "source": [
     "# How to call tools using ToolNode\n",
     "\n",
-    "This guide covers how to use LangGraph's prebuilt [`ToolNode`](https://langchain-ai.github.io/langgraph/reference/prebuilt/#toolnode) for tool calling.\n",
+    "This guide covers how to use LangGraph's prebuilt [`ToolNode`](https://langchain-ai.github.io/langgraph/reference/prebuilt/#langgraph.prebuilt.tool_node.ToolNode) for tool calling.\n",
     "\n",
     "`ToolNode` is a LangChain Runnable that takes graph state (with a list of messages) as input and outputs state update with the result of tool calls. It is designed to work well out-of-box with LangGraph's prebuilt [ReAct agent](https://langchain-ai.github.io/langgraph/how-tos/create-react-agent/), but can also work with any `StateGraph` as long as its state has a `messages` key with an appropriate reducer (see [`MessagesState`](https://github.com/langchain-ai/langgraph/blob/e3ef9adac7395e5c0943c22bbc8a4a856b103aa3/libs/langgraph/langgraph/graph/message.py#L150))."
    ]

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

@@ -0,0 +1,381 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "7c58c957-83d8-44ff-8580-a9b3dd39a0a9",
+   "metadata": {},
+   "source": [
+    "# How to update graph state from tools"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "95f30587-8dd2-40be-920d-59539089c09f",
+   "metadata": {},
+   "source": [
+    "!!! info \"Prerequisites\"\n",
+    "    This guide assumes familiarity with the following:\n",
+    "    \n",
+    "    - [Command](../../concepts/low_level/#command)\n",
+    "\n",
+    "A common use case is updating graph state from inside a tool. For example, in a customer support application you might want to look up customer account number or ID in the beginning of the conversation. To update the graph state from the tool, you can return `Command(update={\"my_custom_key\": \"foo\", \"messages\": [...]})` from the tool:\n",
+    "\n",
+    "```python\n",
+    "@tool\n",
+    "def lookup_user_info(tool_call_id: Annotated[str, InjectedToolCallId], config: RunnableConfig):\n",
+    "    \"\"\"Use this to look up user information to better assist them with their questions.\"\"\"\n",
+    "    user_info = get_user_info(config)\n",
+    "    return Command(\n",
+    "        update={\n",
+    "            # update the state keys\n",
+    "            \"user_info\": user_info,\n",
+    "            # update the message history\n",
+    "            \"messages\": [ToolMessage(\"Successfully looked up user information\", tool_call_id=tool_call_id)]\n",
+    "        }\n",
+    "    )\n",
+    "```\n",
+    "\n",
+    "!!! important\n",
+    "\n",
+    "    If you want to use tools that return `Command` and update graph state, you can either use prebuilt [`create_react_agent`][langgraph.prebuilt.chat_agent_executor.create_react_agent] / [`ToolNode`][langgraph.prebuilt.tool_node.ToolNode] components, or implement your own tool-executing node that collects `Command` objects returned by the tools and returns a list of them, e.g.:\n",
+    "    \n",
+    "    ```python\n",
+    "    def call_tools(state):\n",
+    "        ...\n",
+    "        commands = [tools_by_name[tool_call[\"name\"]].invoke(tool_call) for tool_call in tool_calls]\n",
+    "        return commands\n",
+    "    ```\n",
+    "\n",
+    "This guide shows how you can do this using LangGraph's prebuilt components ([`create_react_agent`][langgraph.prebuilt.chat_agent_executor.create_react_agent] / [`ToolNode`][langgraph.prebuilt.tool_node.ToolNode]).\n",
+    "\n",
+    "!!! note\n",
+    "\n",
+    "    Support for tools that return [`Command`][langgraph.types.Command] was added in LangGraph `v0.2.59`.\n",
+    "\n",
+    "## Setup\n",
+    "\n",
+    "First, let's install the required packages and set our API keys:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "64500eca-1cdc-43d9-9401-f4cd9999881f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%%capture --no-stderr\n",
+    "%pip install -U langgraph langchain-openai"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "a3f92fb2-9175-47fa-9c7d-ad5f44bfd20e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Please provide your OPENAI_API_KEY ········\n"
+     ]
+    }
+   ],
+   "source": [
+    "import os\n",
+    "import getpass\n",
+    "\n",
+    "\n",
+    "def _set_if_undefined(var: str):\n",
+    "    if not os.environ.get(var):\n",
+    "        os.environ[var] = getpass.getpass(f\"Please provide your {var}\")\n",
+    "\n",
+    "\n",
+    "_set_if_undefined(\"OPENAI_API_KEY\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "caf6ff9f-c1e6-499e-a230-9fa231ea7d2f",
+   "metadata": {},
+   "source": [
+    "<div class=\"admonition tip\">\n",
+    "    <p class=\"admonition-title\">Set up <a href=\"https://smith.langchain.com\">LangSmith</a> for LangGraph development</p>\n",
+    "    <p style=\"padding-top: 5px;\">\n",
+    "        Sign up for LangSmith to quickly spot issues and improve the performance of your LangGraph projects. LangSmith lets you use trace data to debug, test, and monitor your LLM apps built with LangGraph — read more about how to get started <a href=\"https://docs.smith.langchain.com\">here</a>. \n",
+    "    </p>\n",
+    "</div>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "10e9a9c6-fa3f-416c-bac0-3e58d7259908",
+   "metadata": {},
+   "source": [
+    "Let's create a simple ReAct style agent that can look up user information and personalize the response based on the user info."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4255b9b9-cf67-4cc3-8018-1708f5dfcfd2",
+   "metadata": {},
+   "source": [
+    "## Define tool"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7de6b010-aab1-4fe8-8251-907fcae78583",
+   "metadata": {},
+   "source": [
+    "First, let's define the tool that we'll be using to look up user information. We'll use a naive implementation that simply looks user information up using a dictionary:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8d070c9f-6e61-4724-85dc-ac4531b9c79a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "USER_INFO = [\n",
+    "    {\"user_id\": \"1\", \"name\": \"Bob Dylan\", \"location\": \"New York, NY\"},\n",
+    "    {\"user_id\": \"2\", \"name\": \"Taylor Swift\", \"location\": \"Beverly Hills, CA\"},\n",
+    "]\n",
+    "\n",
+    "USER_ID_TO_USER_INFO = {info[\"user_id\"]: info for info in USER_INFO}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "08d1ecca-ee57-4e97-b8d0-e09de85337d4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langgraph.prebuilt.chat_agent_executor import AgentState\n",
+    "from langgraph.types import Command\n",
+    "from langchain_core.tools import tool\n",
+    "from langchain_core.tools.base import InjectedToolCallId\n",
+    "from langchain_core.messages import ToolMessage\n",
+    "from langchain_core.runnables import RunnableConfig\n",
+    "\n",
+    "from typing_extensions import Any, Annotated\n",
+    "\n",
+    "\n",
+    "class State(AgentState):\n",
+    "    # updated by the tool\n",
+    "    user_info: dict[str, Any]\n",
+    "\n",
+    "\n",
+    "@tool\n",
+    "def lookup_user_info(\n",
+    "    tool_call_id: Annotated[str, InjectedToolCallId], config: RunnableConfig\n",
+    "):\n",
+    "    \"\"\"Use this to look up user information to better assist them with their questions.\"\"\"\n",
+    "    user_id = config.get(\"configurable\", {}).get(\"user_id\")\n",
+    "    if user_id is None:\n",
+    "        raise ValueError(\"Please provide user ID\")\n",
+    "\n",
+    "    if user_id not in USER_ID_TO_USER_INFO:\n",
+    "        raise ValueError(f\"User '{user_id}' not found\")\n",
+    "\n",
+    "    user_info = USER_ID_TO_USER_INFO[user_id]\n",
+    "    return Command(\n",
+    "        update={\n",
+    "            # update the state keys\n",
+    "            \"user_info\": user_info,\n",
+    "            # update the message history\n",
+    "            \"messages\": [\n",
+    "                ToolMessage(\n",
+    "                    \"Successfully looked up user information\", tool_call_id=tool_call_id\n",
+    "                )\n",
+    "            ],\n",
+    "        }\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b99e5f24-5e5e-4a34-baae-467182675bb5",
+   "metadata": {},
+   "source": [
+    "## Define prompt"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "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:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "c553d062-d145-4145-84bd-9b798f7c95c2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def state_modifier(state: State):\n",
+    "    user_info = state.get(\"user_info\")\n",
+    "    if user_info is None:\n",
+    "        return state[\"messages\"]\n",
+    "\n",
+    "    system_msg = (\n",
+    "        f\"User name is {user_info['name']}. User lives in {user_info['location']}\"\n",
+    "    )\n",
+    "    return [{\"role\": \"system\", \"content\": system_msg}] + state[\"messages\"]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c5acdd5d-68be-466b-9c21-46cbed91d2bc",
+   "metadata": {},
+   "source": [
+    "## Define graph"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "afb65028-0359-46c8-b09c-ffc90180f759",
+   "metadata": {},
+   "source": [
+    "Finally, let's combine this into a single graph using the prebuilt `create_react_agent`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "2d59db29-fd51-4d29-9854-21763a4855e3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langgraph.prebuilt import create_react_agent\n",
+    "from langchain_openai import ChatOpenAI\n",
+    "\n",
+    "model = ChatOpenAI(model=\"gpt-4o\")\n",
+    "\n",
+    "agent = create_react_agent(\n",
+    "    model,\n",
+    "    # pass the tool that can update state\n",
+    "    [lookup_user_info],\n",
+    "    state_schema=State,\n",
+    "    # pass dynamic prompt function\n",
+    "    state_modifier=state_modifier,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0782b8ab-a603-47b8-9a76-77f593402678",
+   "metadata": {},
+   "source": [
+    "## Use it!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6165e153-ab28-4404-adea-796c7bd0701b",
+   "metadata": {},
+   "source": [
+    "Let's now try running our agent. We'll need to provide user ID in the config so that our tool knows what information to look up:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "de34a58b-1765-4b63-a232-d46790aff884",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'agent': {'messages': [AIMessage(content='', additional_kwargs={'tool_calls': [{'id': 'call_7LSUh6ZDvGJAUvlWvXiCK4Gf', 'function': {'arguments': '{}', 'name': 'lookup_user_info'}, 'type': 'function'}], 'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 11, 'prompt_tokens': 56, 'total_tokens': 67, 'completion_tokens_details': {'accepted_prediction_tokens': 0, 'audio_tokens': 0, 'reasoning_tokens': 0, 'rejected_prediction_tokens': 0}, 'prompt_tokens_details': {'audio_tokens': 0, 'cached_tokens': 0}}, 'model_name': 'gpt-4o-2024-08-06', 'system_fingerprint': 'fp_9d50cd990b', 'finish_reason': 'tool_calls', 'logprobs': None}, id='run-57eeb216-e35d-4501-aaac-b5c6b26fb17c-0', tool_calls=[{'name': 'lookup_user_info', 'args': {}, 'id': 'call_7LSUh6ZDvGJAUvlWvXiCK4Gf', 'type': 'tool_call'}], usage_metadata={'input_tokens': 56, 'output_tokens': 11, 'total_tokens': 67, 'input_token_details': {'audio': 0, 'cache_read': 0}, 'output_token_details': {'audio': 0, 'reasoning': 0}})]}}\n",
+      "\n",
+      "\n",
+      "{'tools': {'user_info': {'user_id': '1', 'name': 'Bob Dylan', 'location': 'New York, NY'}, 'messages': [ToolMessage(content='Successfully looked up user information', name='lookup_user_info', id='168d8ff8-b021-4c8b-a11a-3b50c30a072c', tool_call_id='call_7LSUh6ZDvGJAUvlWvXiCK4Gf')]}}\n",
+      "\n",
+      "\n",
+      "{'agent': {'messages': [AIMessage(content=\"Hi Bob! Since you're in New York, NY, there are plenty of exciting things to do over the weekend. Here are some suggestions:\\n\\n1. **Explore Central Park**: Take a leisurely walk, rent a bike, or have a picnic in this iconic park.\\n\\n2. **Visit a Museum**: Check out The Metropolitan Museum of Art or the Museum of Modern Art (MoMA) for an enriching cultural experience.\\n\\n3. **Broadway Show**: Catch a Broadway show or an off-Broadway performance for some world-class entertainment.\\n\\n4. **Food Tour**: Explore different neighborhoods like Greenwich Village or Williamsburg for diverse culinary experiences.\\n\\n5. **Brooklyn Bridge Walk**: Take a walk across the Brooklyn Bridge for stunning views of the city skyline.\\n\\n6. **Visit a Rooftop Bar**: Enjoy a drink with a view at one of New York’s many rooftop bars.\\n\\n7. **Explore a New Neighborhood**: Discover the unique charm of areas like SoHo, Chelsea, or Astoria.\\n\\n8. **Live Music**: Check out live music venues for a night of great performances.\\n\\n9. **Art Galleries**: Visit some of the smaller art galleries around Chelsea or the Lower East Side.\\n\\n10. **Attend a Local Event**: Look up any local events or festivals happening this weekend.\\n\\nFeel free to let me know if you want more details on any of these activities!\", additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 285, 'prompt_tokens': 95, 'total_tokens': 380, 'completion_tokens_details': {'accepted_prediction_tokens': 0, 'audio_tokens': 0, 'reasoning_tokens': 0, 'rejected_prediction_tokens': 0}, 'prompt_tokens_details': {'audio_tokens': 0, 'cached_tokens': 0}}, 'model_name': 'gpt-4o-2024-08-06', 'system_fingerprint': 'fp_9d50cd990b', 'finish_reason': 'stop', 'logprobs': None}, id='run-f13ce15b-02b6-40e6-8264-c4d9edd0d03a-0', usage_metadata={'input_tokens': 95, 'output_tokens': 285, 'total_tokens': 380, 'input_token_details': {'audio': 0, 'cache_read': 0}, 'output_token_details': {'audio': 0, 'reasoning': 0}})]}}\n",
+      "\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "for chunk in agent.stream(\n",
+    "    {\"messages\": [(\"user\", \"hi, what should i do this weekend?\")]},\n",
+    "    # provide user ID in the config\n",
+    "    {\"configurable\": {\"user_id\": \"1\"}},\n",
+    "):\n",
+    "    print(chunk)\n",
+    "    print(\"\\n\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d9b2281f-269c-41dd-b6b2-4c743f11ffc9",
+   "metadata": {},
+   "source": [
+    "We can see that the model correctly recommended some New York activities for Bob Dylan! Let's try getting recommendations for Taylor Swift:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "9d71af94-572a-4961-88a7-665e792cf96a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'agent': {'messages': [AIMessage(content='', additional_kwargs={'tool_calls': [{'id': 'call_5HLtJtzcgmKbtmK6By21wW5Y', 'function': {'arguments': '{}', 'name': 'lookup_user_info'}, 'type': 'function'}], 'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 11, 'prompt_tokens': 56, 'total_tokens': 67, 'completion_tokens_details': {'accepted_prediction_tokens': 0, 'audio_tokens': 0, 'reasoning_tokens': 0, 'rejected_prediction_tokens': 0}, 'prompt_tokens_details': {'audio_tokens': 0, 'cached_tokens': 0}}, 'model_name': 'gpt-4o-2024-08-06', 'system_fingerprint': 'fp_c7ca0ebaca', 'finish_reason': 'tool_calls', 'logprobs': None}, id='run-bacacd7d-76cc-4f6b-9e9b-d9e6f00b9391-0', tool_calls=[{'name': 'lookup_user_info', 'args': {}, 'id': 'call_5HLtJtzcgmKbtmK6By21wW5Y', 'type': 'tool_call'}], usage_metadata={'input_tokens': 56, 'output_tokens': 11, 'total_tokens': 67, 'input_token_details': {'audio': 0, 'cache_read': 0}, 'output_token_details': {'audio': 0, 'reasoning': 0}})]}}\n",
+      "\n",
+      "\n",
+      "{'tools': {'user_info': {'user_id': '2', 'name': 'Taylor Swift', 'location': 'Beverly Hills, CA'}, 'messages': [ToolMessage(content='Successfully looked up user information', name='lookup_user_info', id='d81ef31e-6d77-4f13-ae86-e2e6ba567e3d', tool_call_id='call_5HLtJtzcgmKbtmK6By21wW5Y')]}}\n",
+      "\n",
+      "\n",
+      "{'agent': {'messages': [AIMessage(content=\"Hi Taylor! Since you're in Beverly Hills, here are a few suggestions for a fun weekend:\\n\\n1. **Hiking at Runyon Canyon**: Enjoy a scenic hike with beautiful views of Los Angeles. It's a great way to get some exercise and enjoy the outdoors.\\n\\n2. **Visit Rodeo Drive**: Spend some time shopping or window shopping at the famous Rodeo Drive. You might even spot some celebrities!\\n\\n3. **Explore the Getty Center**: Check out the art collections and beautiful gardens at the Getty Center. The architecture and views are stunning.\\n\\n4. **Relax at a Spa**: Treat yourself to a relaxing day at one of Beverly Hills' luxurious spas.\\n\\n5. **Dining Out**: Try a new restaurant or visit your favorite spot for a delicious meal. Beverly Hills has a fantastic dining scene.\\n\\n6. **Attend a Local Event**: Check out any local events or concerts happening this weekend. Beverly Hills often hosts exciting events.\\n\\nEnjoy your weekend!\", additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 198, 'prompt_tokens': 95, 'total_tokens': 293, 'completion_tokens_details': {'accepted_prediction_tokens': 0, 'audio_tokens': 0, 'reasoning_tokens': 0, 'rejected_prediction_tokens': 0}, 'prompt_tokens_details': {'audio_tokens': 0, 'cached_tokens': 0}}, 'model_name': 'gpt-4o-2024-08-06', 'system_fingerprint': 'fp_c7ca0ebaca', 'finish_reason': 'stop', 'logprobs': None}, id='run-2057df76-f192-4c69-a66a-1f0a86bf5d66-0', usage_metadata={'input_tokens': 95, 'output_tokens': 198, 'total_tokens': 293, 'input_token_details': {'audio': 0, 'cache_read': 0}, 'output_token_details': {'audio': 0, 'reasoning': 0}})]}}\n",
+      "\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "for chunk in agent.stream(\n",
+    "    {\"messages\": [(\"user\", \"hi, what should i do this weekend?\")]},\n",
+    "    {\"configurable\": {\"user_id\": \"2\"}},\n",
+    "):\n",
+    "    print(chunk)\n",
+    "    print(\"\\n\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/docs/tutorials/auth/add_auth_server.md

@@ -0,0 +1,291 @@
+# Connecting an Authentication Provider (Part 3/3)
+
+!!! note "This is part 3 of our authentication series:"
+
+    1. [Basic Authentication](getting_started.md) - Control who can access your bot
+    2. [Resource Authorization](resource_auth.md) - Let users have private conversations
+    3. Production Auth (you are here) - Add real user accounts and validate using OAuth2
+
+In the [Making Conversations Private](resource_auth.md) tutorial, we added [resource authorization](../../concepts/auth.md#resource-authorization) to give users private conversations. However, we were still using hard-coded tokens for authentication, which is not secure. Now we'll replace those tokens with real user accounts using [OAuth2](../../concepts/auth.md#oauth2-authentication).
+
+We'll keep the same [`Auth`](../../cloud/reference/sdk/python_sdk_ref.md#langgraph_sdk.auth.Auth) object and [resource-level access control](../../concepts/auth.md#resource-level-access-control), but upgrade our authentication to use Supabase as our identity provider. While we use Supabase in this tutorial, the concepts apply to any OAuth2 provider. You'll learn how to:
+
+1. Replace test tokens with real [JWT tokens](../../concepts/auth.md#jwt-tokens)
+2. Integrate with OAuth2 providers for secure user authentication
+3. Handle user sessions and metadata while maintaining our existing authorization logic
+
+## Requirements
+
+You will need to set up a Supabase project to use its authentication server for this tutorial. You can do so [here](https://supabase.com/dashboard).
+
+## Background
+
+OAuth2 involves three main roles:
+
+1. **Authorization server**: The identity provider (e.g., Supabase, Auth0, Google) that handles user authentication and issues tokens
+2. **Application backend**: Your LangGraph application. This validates tokens and serves protected resources (conversation data)
+3. **Client application**: The web or mobile app where users interact with your service
+
+A standard OAuth2 flow works something like this:
+
+
+```mermaid
+sequenceDiagram
+    participant User
+    participant Client
+    participant AuthServer
+    participant LangGraph Backend
+
+    User->>Client: Initiate login
+    User->>AuthServer: Enter credentials
+    AuthServer->>Client: Send tokens
+    Client->>LangGraph Backend: Request with token
+    LangGraph Backend->>AuthServer: Validate token
+    AuthServer->>LangGraph Backend: Token valid
+    LangGraph Backend->>Client: Serve request (e.g., run agent or graph)
+```
+
+In the following example, we'll use Supabase as our auth server. The LangGraph application will provide the backend for your app, and we will write test code for the client app.
+Let's get started!
+
+## Setting Up Authentication Provider {#setup-auth-provider}
+
+First, let's install the required dependencies. Start in your `custom-auth` directory and ensure you have the `langgraph-cli` installed:
+
+```bash
+cd custom-auth
+pip install -U "langgraph-cli[inmem]"
+```
+
+Next, we'll need to fech the URL of our auth server and the private key for authentication.
+Since we're using Supabase for this, we can do this in the Supabase dashboard:
+
+1. In the left sidebar, click on t️⚙ Project Settings" and then click "API"
+2. Copy your project URL and add it to your `.env` file
+
+```shell
+echo "SUPABASE_URL=your-project-url" >> .env
+```
+3. Next, copy your service role secret key and add it to your `.env` file
+```shell
+echo "SUPABASE_SERVICE_KEY=your-service-role-key" >> .env
+```
+4. Finally, copy your "anon public" key and note it down. This will be used later when we set up our client code.
+
+```bash
+SUPABASE_URL=your-project-url
+SUPABASE_SERVICE_KEY=your-service-role-key
+```
+
+## Implementing Token Validation
+
+In the previous tutorials, we used the [`Auth`](../../cloud/reference/sdk/python_sdk_ref.md#langgraph_sdk.auth.Auth) object to:
+
+1. Validate hard-coded tokens in the [authentication tutorial](getting_started.md)
+2. Add resource ownership in the [authorization tutorial](resource_auth.md)
+
+Now we'll upgrade our authentication to validate real JWT tokens from Supabase. The key changes will all be in the [`@auth.authenticate`](../../cloud/reference/sdk/python_sdk_ref.md#langgraph_sdk.auth.Auth.authenticate) decorated function:
+
+1. Instead of checking against a hard-coded list of tokens, we'll make an HTTP request to Supabase to validate the token
+2. We'll extract real user information (ID, email) from the validated token
+
+And we'll keep our existing resource authorization logic unchanged
+
+Let's update `src/security/auth.py` to implement this:
+
+```python hl_lines="8-9 20-30" title="src/security/auth.py"
+import os
+import httpx
+from langgraph_sdk import Auth
+
+auth = Auth()
+
+# This is loaded from the `.env` file you created above
+SUPABASE_URL = os.environ["SUPABASE_URL"]
+SUPABASE_SERVICE_KEY = os.environ["SUPABASE_SERVICE_KEY"]
+
+
+@auth.authenticate
+async def get_current_user(authorization: str | None):
+    """Validate JWT tokens and extract user information."""
+    assert authorization
+    scheme, token = authorization.split()
+    assert scheme.lower() == "bearer"
+
+    try:
+        # Verify token with auth provider
+        async with httpx.AsyncClient() as client:
+            response = await client.get(
+                f"{SUPABASE_URL}/auth/v1/user",
+                headers={
+                    "Authorization": authorization,
+                    "apiKey": SUPABASE_SERVICE_KEY,
+                },
+            )
+            assert response.status_code == 200
+            user = response.json()
+            return {
+                "identity": user["id"],  # Unique user identifier
+                "email": user["email"],
+                "is_authenticated": True,
+            }
+    except Exception as e:
+        raise Auth.exceptions.HTTPException(status_code=401, detail=str(e))
+
+# ... the rest is the same as before
+
+# Keep our resource authorization from the previous tutorial
+@auth.on
+async def add_owner(ctx, value):
+    """Make resources private to their creator using resource metadata."""
+    filters = {"owner": ctx.user.identity}
+    metadata = value.setdefault("metadata", {})
+    metadata.update(filters)
+    return filters
+```
+
+The most important change is that we're now validating tokens with a real authentication server. Our authentication handler has the private key for our Supabase project, which we can use to validate the user's token and extract their information.
+
+Let's test this with a real user account!
+
+## Testing Authentication Flow
+
+Let's test out our new authentication flow. You can run the following code in a file or notebook. You will need to provide:
+
+- A valid email address
+- A Supabase project URL (from [above](#setup-auth-provider))
+- A Supabase anon **public key** (also from [above](#setup-auth-provider))
+
+```python
+import os
+import httpx
+from getpass import getpass
+from langgraph_sdk import get_client
+
+
+# Get email from command line
+email = getpass("Enter your email: ")
+base_email = email.split("@")
+password = "secure-password"  # CHANGEME
+email1 = f"{base_email[0]}+1@{base_email[1]}"
+email2 = f"{base_email[0]}+2@{base_email[1]}"
+
+SUPABASE_URL = os.environ.get("SUPABASE_URL")
+if not SUPABASE_URL:
+    SUPABASE_URL = getpass("Enter your Supabase project URL: ")
+
+# This is your PUBLIC anon key (which is safe to use client-side)
+# Do NOT mistake this for the secret service role key
+SUPABASE_ANON_KEY = os.environ.get("SUPABASE_ANON_KEY")
+if not SUPABASE_ANON_KEY:
+    SUPABASE_ANON_KEY = getpass("Enter your public Supabase anon  key: ")
+
+
+async def sign_up(email: str, password: str):
+    """Create a new user account."""
+    async with httpx.AsyncClient() as client:
+        response = await client.post(
+            f"{SUPABASE_URL}/auth/v1/signup",
+            json={"email": email, "password": password},
+            headers={"apiKey": SUPABASE_ANON_KEY},
+        )
+        assert response.status_code == 200
+        return response.json()
+
+# Create two test users
+print(f"Creating test users: {email1} and {email2}")
+await sign_up(email1, password)
+await sign_up(email2, password)
+```
+
+Then run the code.
+
+!!! tip "About test emails"
+    We'll create two test accounts by adding "+1" and "+2" to your email. For example, if you use "myemail@gmail.com", we'll create "myemail+1@gmail.com" and "myemail+2@gmail.com". All emails will be delivered to your original address.
+
+⚠️ Before continuing: Check your email and click both confirmation links. Supabase will will reject `/login` requests until after you have confirmed your users' email.
+
+Now let's test that users can only see their own data. Make sure the server is running (run `langgraph dev`) before proceeding. The following snippet requires the "anon public" key that you copied from the Supabase dashboard while [setting up the auth provider](#setup-auth-provider) previously. 
+
+```python
+async def login(email: str, password: str):
+    """Get an access token for an existing user."""
+    async with httpx.AsyncClient() as client:
+        response = await client.post(
+            f"{SUPABASE_URL}/auth/v1/token?grant_type=password",
+            json={
+                "email": email,
+                "password": password
+            },
+            headers={
+                "apikey": SUPABASE_ANON_KEY,
+                "Content-Type": "application/json"
+            },
+        )
+        assert response.status_code == 200
+        return response.json()["access_token"]
+
+
+# Log in as user 1
+user1_token = await login(email1, password)
+user1_client = get_client(
+    url="http://localhost:2024", headers={"Authorization": f"Bearer {user1_token}"}
+)
+
+# Create a thread as user 1
+thread = await user1_client.threads.create()
+print(f"✅ User 1 created thread: {thread['thread_id']}")
+
+# Try to access without a token
+unauthenticated_client = get_client(url="http://localhost:2024")
+try:
+    await unauthenticated_client.threads.create()
+    print("❌ Unauthenticated access should fail!")
+except Exception as e:
+    print("✅ Unauthenticated access blocked:", e)
+
+# Try to access user 1's thread as user 2
+user2_token = await login(email2, password)
+user2_client = get_client(
+    url="http://localhost:2024", headers={"Authorization": f"Bearer {user2_token}"}
+)
+
+try:
+    await user2_client.threads.get(thread["thread_id"])
+    print("❌ User 2 shouldn't see User 1's thread!")
+except Exception as e:
+    print("✅ User 2 blocked from User 1's thread:", e)
+```
+The output should look like this:
+
+```shell
+✅ User 1 created thread: d6af3754-95df-4176-aa10-dbd8dca40f1a
+✅ Unauthenticated access blocked: Client error '403 Forbidden' for url 'http://localhost:2024/threads'
+✅ User 2 blocked from User 1's thread: Client error '404 Not Found' for url 'http://localhost:2024/threads/d6af3754-95df-4176-aa10-dbd8dca40f1a'
+```
+
+Perfect! Our authentication and authorization are working together:
+1. Users must log in to access the bot
+2. Each user can only see their own threads
+
+All our users are managed by the Supabase auth provider, so we don't need to implement any additional user management logic.
+
+## Congratulations! 🎉
+
+You've successfully built a production-ready authentication system for your LangGraph application! Let's review what you've accomplished:
+
+1. Set up an authentication provider (Supabase in this case)
+2. Added real user accounts with email/password authentication
+3. Integrated JWT token validation into your LangGraph server
+4. Implemented proper authorization to ensure users can only access their own data
+5. Created a foundation that's ready to handle your next authentication challenge 🚀
+
+This completes our authentication tutorial series. You now have the building blocks for a secure, production-ready LangGraph application.
+
+## What's Next?
+
+Now that you have production authentication, consider:
+
+1. Building a web UI with your preferred framework (see the [Custom Auth](https://github.com/langchain-ai/custom-auth) template for an example)
+2. Learn more about the other aspects of authentication and authorization in the [conceptual guide on authentication](../../concepts/auth.md).
+3. Customize your handlers and setup further after reading the [reference docs](../../cloud/reference/sdk/python_sdk_ref.md#langgraph_sdk.auth.Auth).

docs/docs/tutorials/auth/getting_started.md

@@ -0,0 +1,185 @@
+# Setting up Custom Authentication (Part 1/3)
+
+!!! note "This is part 1 of our authentication series:"
+
+    1. Basic Authentication (you are here) - Control who can access your bot
+    2. [Resource Authorization](resource_auth.md) - Let users have private conversations
+    3. [Production Auth](add_auth_server.md) - Add real user accounts and validate using OAuth2
+
+!!! tip "Prerequisites"
+
+    This guide assumes basic familiarity with the following concepts:
+
+      *  [**Authentication & Access Control**](../../concepts/auth.md)
+      *  [**LangGraph Platform**](../../concepts/index.md#langgraph-platform)
+
+!!! note "Python only"
+
+    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.
+
+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
+
+First, let's create a new chatbot using the LangGraph starter template:
+
+```bash
+pip install -U "langgraph-cli[inmem]"
+langgraph new --template=new-langgraph-project-python custom-auth
+cd custom-auth
+```
+
+The template gives us a placeholder LangGraph app. Let's try it out by installing the local dependencies and running the development server.
+```shell
+pip install -e .
+langgraph dev
+```
+If everything works, the server should start and open the studio in your browser.
+
+> - 🚀 API: http://127.0.0.1:2024
+> - 🎨 Studio UI: https://smith.langchain.com/studio/?baseUrl=http://127.0.0.1:2024
+> - 📚 API Docs: http://127.0.0.1:2024/docs
+> 
+> This in-memory server is designed for development and testing.
+> For production use, please use LangGraph Cloud.
+
+The graph should run, and if you were to self-host this on the public internet, anyone could access it!
+
+![No auth](./img/no_auth.png)
+
+Now that we've seen the base LangGraph app, let's add authentication to it! 
+
+???+ tip "Placeholder token"
+    
+    In part 1, we will start with a hard-coded token for illustration purposes.
+    We will get to a "production-ready" authentication scheme in part 3, after mastering the basics.
+
+
+## Adding Authentication
+
+The [`Auth`](../../cloud/reference/sdk/python_sdk_ref.md#langgraph_sdk.auth.Auth) object lets you register an authentication function that the LangGraph platform will run on every request. This function receives each request and decides whether to accept or reject.
+
+Create a new file `src/security/auth.py`. This is where our code will live to check if users are allowed to access our bot:
+
+```python hl_lines="10 15-16" title="src/security/auth.py"
+from langgraph_sdk import Auth
+
+# This is our toy user database. Do not do this in production
+VALID_TOKENS = {
+    "user1-token": {"id": "user1", "name": "Alice"},
+    "user2-token": {"id": "user2", "name": "Bob"},
+}
+
+# The "Auth" object is a container that LangGraph will use to mark our authentication function
+auth = Auth()
+
+
+# The `authenticate` decorator tells LangGraph to call this function as middleware
+# for every request. This will determine whether the request is allowed or not
+@auth.authenticate
+async def get_current_user(authorization: str | None) -> Auth.types.MinimalUserDict:
+    """Check if the user's token is valid."""
+    assert authorization
+    scheme, token = authorization.split()
+    assert scheme.lower() == "bearer"
+    # Check if token is valid
+    if token not in VALID_TOKENS:
+        raise Auth.exceptions.HTTPException(status_code=401, detail="Invalid token")
+
+    # Return user info if valid
+    user_data = VALID_TOKENS[token]
+    return {
+        "identity": user_data["id"],
+    }
+```
+
+Notice that our [authentication](../../cloud/reference/sdk/python_sdk_ref.md#langgraph_sdk.auth.Auth.authenticate) handler does two important things:
+
+1. Checks if a valid token is provided in the request's [Authorization header](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Authorization)
+2. Returns the user's [identity](../../cloud/reference/sdk/python_sdk_ref.md#langgraph_sdk.auth.types.MinimalUserDict)
+
+Now tell LangGraph to use our authentication by adding the following to the [`langgraph.json`](../../cloud/reference/cli.md#configuration-file) configuration:
+
+```json hl_lines="7-9" title="langgraph.json"
+{
+  "dependencies": ["."],
+  "graphs": {
+    "agent": "./src/agent/graph.py:graph"
+  },
+  "env": ".env",
+  "auth": {
+    "path": "src/security/auth.py:auth"
+  }
+}
+```
+
+## Testing Our "Secure" Bot
+
+Let's start the server again to test everything out!
+
+```bash
+langgraph dev --no-browser
+```
+
+??? note "Custom auth in the studio"
+
+    If you didn't add the `--no-browser`, the studio UI will open in the browser. You may wonder, how is the studio able to still connect to our server? By default, we also permit access from the LangGraph studio, even when using custom auth. This makes it easier to develop and test your bot in the studio. You can remove this alternative authentication option by
+    setting `disable_studio_auth: "true"` in your auth configuration:
+    ```json
+    {
+        "auth": {
+            "path": "src/security/auth.py:auth",
+            "disable_studio_auth": "true"
+        }
+    }
+    ```
+
+Now let's try to chat with our bot. If we've implemented authentication correctly, we should only be able to access the bot if we provide a valid token in the request header. Users will still, however, be able to access each other's resources until we add [resource authorization handlers](../../concepts/auth.md#resource-authorization) in the next section of our tutorial.
+
+![Authentication, no authorization handlers](./img/authentication.png)
+
+Run the following code in a file or notebook:
+
+```python
+from langgraph_sdk import get_client
+
+# Try without a token (should fail)
+client = get_client(url="http://localhost:2024")
+try:
+    thread = await client.threads.create()
+    print("❌ Should have failed without token!")
+except Exception as e:
+    print("✅ Correctly blocked access:", e)
+
+# Try with a valid token
+client = get_client(
+    url="http://localhost:2024", headers={"Authorization": "Bearer user1-token"}
+)
+
+# Create a thread and chat
+thread = await client.threads.create()
+print(f"✅ Created thread as Alice: {thread['thread_id']}")
+
+response = await client.runs.create(
+    thread_id=thread["thread_id"],
+    assistant_id="agent",
+    input={"messages": [{"role": "user", "content": "Hello!"}]},
+)
+print("✅ Bot responded:")
+print(response)
+```
+
+You should see that:
+
+1. Without a valid token, we can't access the bot
+2. With a valid token, we can create threads and chat
+
+Congratulations! You've built a chatbot that only lets "authenticated" users access it. While this system doesn't (yet) implement a production-ready security scheme, we've learned the basic mechanics of how to control access to our bot. In the next tutorial, we'll learn how to give each user their own private conversations.
+
+## What's Next?
+
+Now that you can control who accesses your bot, you might want to:
+
+1. Continue the tutorial by going to [Making Conversations Private (Part 2/3)](resource_auth.md) to learn about resource authorization.
+2. Read more about [authentication concepts](../../concepts/auth.md).
+3. Check out the [API reference](../../cloud/reference/sdk/python_sdk_ref.md) for more authentication details.

docs/docs/tutorials/auth/resource_auth.md

@@ -0,0 +1,333 @@
+# Making Conversations Private (Part 2/3)
+
+!!! note "This is part 2 of our authentication series:" 
+
+    1. [Basic Authentication](getting_started.md) - Control who can access your bot 
+    2. Resource Authorization (you are here) - Let users have private conversations
+    3. [Production Auth](add_auth_server.md) - Add real user accounts and validate using OAuth2
+
+In this tutorial, we will extend our chatbot to give each user their own private conversations. We'll add [resource-level access control](../../concepts/auth.md#resource-level-access-control) so users can only see their own threads.
+
+![Authorization handlers](./img/authorization.png)
+
+???+ tip "Placeholder token"
+    
+    As we did in [part 1](getting_started.md), for this section, we will use a hard-coded token for illustration purposes.
+    We will get to a "production-ready" authentication scheme in part 3, after mastering the basics.
+
+## Understanding Resource Authorization
+
+In the last tutorial, we controlled who could access our bot. But right now, any authenticated user can see everyone else's conversations! Let's fix that by adding [resource authorization](../../concepts/auth.md#resource-authorization).
+
+First, make sure you have completed the [Basic Authentication](getting_started.md) tutorial and that your secure bot can be run without errors:
+
+```bash
+cd custom-auth
+pip install -e .
+langgraph dev --no-browser
+```
+
+> - 🚀 API: http://127.0.0.1:2024
+> - 🎨 Studio UI: https://smith.langchain.com/studio/?baseUrl=http://127.0.0.1:2024
+> - 📚 API Docs: http://127.0.0.1:2024/docs
+
+## Adding Resource Authorization
+
+Recall that in the last tutorial, the [`Auth`](../../cloud/reference/sdk/python_sdk_ref.md#langgraph_sdk.auth.Auth) object let us register an [authentication function](../../concepts/auth.md#authentication), which the LangGraph platform uses to validate the bearer tokens in incoming requests. Now we'll use it to register an **authorization** handler.
+
+Authorization handlers are functions that run **after** authentication succeeds. These handlers can add [metadata](../../concepts/auth.md#resource-metadata) to resources (like who owns them) and filter what each user can see.
+
+Let's update our `src/security/auth.py` and add one authorization handler that is run on every request:
+
+```python hl_lines="29-39" title="src/security/auth.py"
+from langgraph_sdk import Auth
+
+# Keep our test users from the previous tutorial
+VALID_TOKENS = {
+    "user1-token": {"id": "user1", "name": "Alice"},
+    "user2-token": {"id": "user2", "name": "Bob"},
+}
+
+auth = Auth()
+
+
+@auth.authenticate
+async def get_current_user(authorization: str | None) -> Auth.types.MinimalUserDict:
+    """Our authentication handler from the previous tutorial."""
+    assert authorization
+    scheme, token = authorization.split()
+    assert scheme.lower() == "bearer"
+
+    if token not in VALID_TOKENS:
+        raise Auth.exceptions.HTTPException(status_code=401, detail="Invalid token")
+
+    user_data = VALID_TOKENS[token]
+    return {
+        "identity": user_data["id"],
+    }
+
+
+@auth.on
+async def add_owner(
+    ctx: Auth.types.AuthContext,  # Contains info about the current user
+    value: dict,  # The resource being created/accessed
+):
+    """Make resources private to their creator."""
+    # Examples:
+    # ctx: AuthContext(
+    #     permissions=[],
+    #     user=ProxyUser(
+    #         identity='user1',
+    #         is_authenticated=True,
+    #         display_name='user1'
+    #     ),
+    #     resource='threads',
+    #     action='create_run'
+    # )
+    # value: 
+    # {
+    #     'thread_id': UUID('1e1b2733-303f-4dcd-9620-02d370287d72'),
+    #     'assistant_id': UUID('fe096781-5601-53d2-b2f6-0d3403f7e9ca'),
+    #     'run_id': UUID('1efbe268-1627-66d4-aa8d-b956b0f02a41'),
+    #     'status': 'pending',
+    #     'metadata': {},
+    #     'prevent_insert_if_inflight': True,
+    #     'multitask_strategy': 'reject',
+    #     'if_not_exists': 'reject',
+    #     'after_seconds': 0,
+    #     'kwargs': {
+    #         'input': {'messages': [{'role': 'user', 'content': 'Hello!'}]},
+    #         'command': None,
+    #         'config': {
+    #             'configurable': {
+    #                 'langgraph_auth_user': ... Your user object...
+    #                 'langgraph_auth_user_id': 'user1'
+    #             }
+    #         },
+    #         'stream_mode': ['values'],
+    #         'interrupt_before': None,
+    #         'interrupt_after': None,
+    #         'webhook': None,
+    #         'feedback_keys': None,
+    #         'temporary': False,
+    #         'subgraphs': False
+    #     }
+    # }
+
+    # Do 2 things:
+    # 1. Add the user's ID to the resource's metadata. Each LangGraph resource has a `metadata` dict that persists with the resource.
+    # this metadata is useful for filtering in read and update operations
+    # 2. Return a filter that lets users only see their own resources
+    filters = {"owner": ctx.user.identity}
+    metadata = value.setdefault("metadata", {})
+    metadata.update(filters)
+
+    # Only let users see their own resources
+    return filters
+```
+
+The handler receives two parameters:
+
+1. `ctx` ([AuthContext](../../cloud/reference/sdk/python_sdk_ref.md#langgraph_sdk.auth.types.AuthContext)): contains info about the current `user`, the user's `permissions`, the `resource` ("threads", "crons", "assistants"), and the `action` being taken ("create", "read", "update", "delete", "search", "create_run")
+2. `value` (`dict`): data that is being created or accessed. The contents of this dict depend on the resource and action being accessed. See [adding scoped authorization handlers](#scoped-authorization) below for information on how to get more tightly scoped access control.
+
+Notice that our simple handler does two things:
+
+1. Adds the user's ID to the resource's metadata.
+2. Returns a metadata filter so users only see resources they own.
+
+## Testing Private Conversations
+
+Let's test our authorization. If we have set things up correctly, we should expect to see all ✅ messages. Be sure to have your development server running (run `langgraph dev`):
+
+```python
+from langgraph_sdk import get_client
+
+# Create clients for both users
+alice = get_client(
+    url="http://localhost:2024",
+    headers={"Authorization": "Bearer user1-token"}
+)
+
+bob = get_client(
+    url="http://localhost:2024",
+    headers={"Authorization": "Bearer user2-token"}
+)
+
+# Alice creates an assistant
+alice_assistant = await alice.assistants.create()
+print(f"✅ Alice created assistant: {alice_assistant['assistant_id']}")
+
+# Alice creates a thread and chats
+alice_thread = await alice.threads.create()
+print(f"✅ Alice created thread: {alice_thread['thread_id']}")
+
+await alice.runs.create(
+    thread_id=alice_thread["thread_id"],
+    assistant_id="agent",
+    input={"messages": [{"role": "user", "content": "Hi, this is Alice's private chat"}]}
+)
+
+# Bob tries to access Alice's thread
+try:
+    await bob.threads.get(alice_thread["thread_id"])
+    print("❌ Bob shouldn't see Alice's thread!")
+except Exception as e:
+    print("✅ Bob correctly denied access:", e)
+
+# Bob creates his own thread
+bob_thread = await bob.threads.create()
+await bob.runs.create(
+    thread_id=bob_thread["thread_id"],
+    assistant_id="agent",
+    input={"messages": [{"role": "user", "content": "Hi, this is Bob's private chat"}]}
+)
+print(f"✅ Bob created his own thread: {bob_thread['thread_id']}")
+
+# List threads - each user only sees their own
+alice_threads = await alice.threads.search()
+bob_threads = await bob.threads.search()
+print(f"✅ Alice sees {len(alice_threads)} thread")
+print(f"✅ Bob sees {len(bob_threads)} thread")
+```
+
+Run the test code and you should see output like this:
+
+```bash
+✅ Alice created assistant: fc50fb08-78da-45a9-93cc-1d3928a3fc37
+✅ Alice created thread: 533179b7-05bc-4d48-b47a-a83cbdb5781d
+✅ Bob correctly denied access: Client error '404 Not Found' for url 'http://localhost:2024/threads/533179b7-05bc-4d48-b47a-a83cbdb5781d'
+For more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/404
+✅ Bob created his own thread: 437c36ed-dd45-4a1e-b484-28ba6eca8819
+✅ Alice sees 1 thread
+✅ Bob sees 1 thread
+```
+
+This means:
+
+1. Each user can create and chat in their own threads
+2. Users can't see each other's threads
+3. Listing threads only shows your own
+
+## Adding scoped authorization handlers {#scoped-authorization}
+
+The broad `@auth.on` handler matches on all [authorization events](../../concepts/auth.md#authorization-events). This is concise, but it means the contents of the `value` dict are not well-scoped, and we apply the same user-level access control to every resource. If we want to be more fine-grained, we can also control specific actions on resources.
+
+Update `src/security/auth.py` to add handlers for specific resource types:
+
+```python
+# Keep our previous handlers...
+
+from langgraph_sdk import Auth
+
+@auth.on.threads.create
+async def on_thread_create(
+    ctx: Auth.types.AuthContext,
+    value: Auth.types.on.threads.create.value,
+):
+    """Add owner when creating threads.
+    
+    This handler runs when creating new threads and does two things:
+    1. Sets metadata on the thread being created to track ownership
+    2. Returns a filter that ensures only the creator can access it
+    """
+    # Example value:
+    #  {'thread_id': UUID('99b045bc-b90b-41a8-b882-dabc541cf740'), 'metadata': {}, 'if_exists': 'raise'}
+
+    # Add owner metadata to the thread being created
+    # This metadata is stored with the thread and persists
+    metadata = value.setdefault("metadata", {})
+    metadata["owner"] = ctx.user.identity
+    
+    
+    # Return filter to restrict access to just the creator
+    return {"owner": ctx.user.identity}
+
+@auth.on.threads.read
+async def on_thread_read(
+    ctx: Auth.types.AuthContext,
+    value: Auth.types.on.threads.read.value,
+):
+    """Only let users read their own threads.
+    
+    This handler runs on read operations. We don't need to set
+    metadata since the thread already exists - we just need to
+    return a filter to ensure users can only see their own threads.
+    """
+    return {"owner": ctx.user.identity}
+
+@auth.on.assistants
+async def on_assistants(
+    ctx: Auth.types.AuthContext,
+    value: Auth.types.on.assistants.value,
+):
+    # For illustration purposes, we will deny all requests
+    # that touch the assistants resource
+    # Example value:
+    # {
+    #     'assistant_id': UUID('63ba56c3-b074-4212-96e2-cc333bbc4eb4'),
+    #     'graph_id': 'agent',
+    #     'config': {},
+    #     'metadata': {},
+    #     'name': 'Untitled'
+    # }
+    raise Auth.exceptions.HTTPException(
+        status_code=403,
+        detail="User lacks the required permissions.",
+    )
+```
+
+Notice that instead of one global handler, we now have specific handlers for:
+
+1. Creating threads
+2. Reading threads
+3. Accessing assistants
+
+The first three of these match specific **actions** on each resource (see [resource actions](../../concepts/auth.md#resource-actions)), while the last one (`@auth.on.assistants`) matches _any_ action on the `assistants` resource. For each request, LangGraph will run the most specific handler that matches the resource and action being accessed. This means that the four handlers above will run rather than the broadly scoped "`@auth.on`" handler.
+
+Try adding the following test code to your test file:
+
+```python
+# ... Same as before
+# Try creating an assistant. This should fail
+try:
+    await alice.assistants.create("agent")
+    print("❌ Alice shouldn't be able to create assistants!")
+except Exception as e:
+    print("✅ Alice correctly denied access:", e)
+
+# Try searching for assistants. This also should fail
+try:
+    await alice.assistants.search()
+    print("❌ Alice shouldn't be able to search assistants!")
+except Exception as e:
+    print("✅ Alice correctly denied access to searching assistants:", e)
+
+# Alice can still create threads
+alice_thread = await alice.threads.create()
+print(f"✅ Alice created thread: {alice_thread['thread_id']}")
+```
+
+And then run the test code again:
+
+```bash
+✅ Alice created thread: dcea5cd8-eb70-4a01-a4b6-643b14e8f754
+✅ Bob correctly denied access: Client error '404 Not Found' for url 'http://localhost:2024/threads/dcea5cd8-eb70-4a01-a4b6-643b14e8f754'
+For more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/404
+✅ Bob created his own thread: 400f8d41-e946-429f-8f93-4fe395bc3eed
+✅ Alice sees 1 thread
+✅ Bob sees 1 thread
+✅ Alice correctly denied access:
+For more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/500
+✅ Alice correctly denied access to searching assistants:
+```
+
+Congratulations! You've built a chatbot where each user has their own private conversations. While this system uses simple token-based authentication, the authorization patterns we've learned will work with implementing any real authentication system. In the next tutorial, we'll replace our test users with real user accounts using OAuth2.
+
+## What's Next?
+
+Now that you can control access to resources, you might want to:
+
+1. Move on to [Production Auth](add_auth_server.md) to add real user accounts
+2. Read more about [authorization patterns](../../concepts/auth.md#authorization)
+3. Check out the [API reference](../../cloud/reference/sdk/python_sdk_ref.md#langgraph_sdk.auth.Auth) for details about the interfaces and methods used in this tutorial