Update docs/docs/agents/models.md

Co-authored-by: Lauren Hirata Singh <lauren@langchain.dev>

docs/_scripts/notebook_hooks.py

@@ -310,12 +310,6 @@ def _highlight_code_blocks(markdown: str) -> str:
     return markdown
 
 
-TARGET_LANGUAGE = os.environ.get("TARGET_LANGUAGE", "python")
-
-if TARGET_LANGUAGE not in {"python", "js"}:
-    raise ValueError(f"TARGET_LANGUAGE must be 'python' or 'js', got {TARGET_LANGUAGE}")
-
-
 def _on_page_markdown_with_config(
     markdown: str,
     page: Page,
@@ -338,15 +332,16 @@ def _on_page_markdown_with_config(
     markdown = _highlight_code_blocks(markdown)
 
     # Apply conditional rendering for code blocks
-    markdown = _apply_conditional_rendering(markdown, TARGET_LANGUAGE)
-    if TARGET_LANGUAGE == "js":
+    target_language = kwargs.get("target_language", "python")
+    markdown = _apply_conditional_rendering(markdown, target_language)
+    if target_language == "js":
         markdown = _resolve_cross_references(markdown, JS_LINK_MAP)
-    elif TARGET_LANGUAGE == "python":
+    elif target_language == "python":
         # Via a dedicated plugin
         pass
     else:
         raise ValueError(
-            f"Unsupported target language: {TARGET_LANGUAGE}. "
+            f"Unsupported target language: {target_language}. "
             "Supported languages are 'python' and 'js'."
         )
 

docs/docs/agents/context.md

@@ -8,7 +8,7 @@ Context includes *any* data outside the message list that can shape behavior. Th
 - Internal state updated during a multi-step reasoning process.
 - Persistent memory or facts from previous interactions.
 
-LangGraph provides **three** primary ways to manage context:
+LangGraph provides **three** primary ways to supply context:
 
 | Type                                                                         | Description                                   | Mutable? | Lifetime                |
 |------------------------------------------------------------------------------|-----------------------------------------------|----------|-------------------------|
@@ -18,21 +18,14 @@ LangGraph provides **three** primary ways to manage context:
 
 ### Runtime Context
 
-Runtime context is for immutable data like user metadata, tools, db connections, etc. Use this when you have values that don't change mid-run.
+!!! note "`config['configurable']` -> `runtime.context`"
 
-!!! version-added "New in LangGraph v0.6: `Runtime.context` replaces `config['configurable']`"
+    In LangGraph < v1.0, static runtime context was passed via the `config['configurable']` key, paired with a `config_schema` argument
+    to `StateGraph` or `Pregel`. This is now deprecated and will be removed in v2.0.
 
-    The `Runtime` object is recommended to access static context and runtime-specific information like the store and stream writer.
+    As of LangGraph v1.0, the Runtime object is recommended to access static context and runtime-specific information like the store and stream writer.
 
-!!! note 
-
-    Runtime context refers to local context: data and dependencies your code needs to run. It does not refer to:
-
-    * The LLM context, which is the data passed into the LLM's prompt.
-    * The "context window", which is the maximum number of tokens that can be passed to the LLM.
-
-    You likely want to use the local context to optimize the LLM's context window. For example, you
-    could use a user id to fetch a user's name and information from a database to populate the context window with relevant memories.
+Runtime context is for immutable data like user metadata or API keys. Use this when you have values that don't change mid-run.
 
 Specify static context via the `context` argument to `invoke` / `stream`, which is reserved for this purpose:
 

docs/docs/agents/models.md

@@ -70,6 +70,104 @@ When using `create_react_agent` you can specify the model by its name string, wh
       )
       ```
 
+### Dynamic model selection
+
+Pass a callable function to `create_react_agent` to dynamically select the model at runtime. This is useful for scenarios where you want to choose a model based on user input, configuration settings, or other runtime conditions.
+
+The selector function must return an instance of a `BaseChatModel`. If you're using tools, you must bind the tools to the model within the selector function.
+
+```python
+openai_model = init_chat_model("openai:gpt-4o")
+anthropic_model = init_chat_model("anthropic:claude-sonnet-4-20250514")
+
+# highlight-next-line
+def select_model(state, runtime: Runtime[CustomContext]) -> BaseChatModel:
+   if runtime.context.provider == "anthropic":
+      model = anthropic_model
+   elif runtime.context.provider == "openai":
+      model = openai_model
+   else:
+      raise ValueError(f"Unsupported provider: {runtime.context.provider}")
+   # With dynamic model selection, you must bind tools explicitly
+   # highlight-next-line
+   return model.bind_tools(tools_to_use)
+
+agent = create_react_agent(
+   # highlight-next-line
+   select_model, 
+   tools=all_known_tools
+)
+```
+
+!!! version-added "New in LangGraph v0.6"
+
+
+??? example "Extended example: dynamically select model and tools"
+
+      ```python
+      from dataclasses import dataclass
+      from typing import Literal
+      from langchain.chat_models import init_chat_model
+      from langchain_core.language_models import BaseChatModel
+      from langchain_core.tools import tool
+      from langgraph.prebuilt import create_react_agent
+      from langgraph.prebuilt.chat_agent_executor import AgentState
+      from langgraph.runtime import Runtime
+
+      # Define the runtime context
+      @dataclass
+      class CustomContext:
+          provider: Literal["anthropic", "openai"]
+
+      @tool
+      def weather() -> str:
+          """Returns the current weather conditions."""
+          return "It's nice and sunny."
+
+      # Initialize models
+      openai_model = init_chat_model("openai:gpt-4o")
+      anthropic_model = init_chat_model("anthropic:claude-sonnet-4-20250514")
+
+      @dataclass
+      class CustomContext:
+         provider: Literal["anthropic", "openai"]
+
+      # Initialize models
+      openai_model = init_chat_model("openai:gpt-4o")
+      anthropic_model = init_chat_model("anthropic:claude-sonnet-4-20250514")
+
+      # Selector function for model choice
+      def select_model(state: AgentState, runtime: Runtime[CustomContext]) -> BaseChatModel:
+         if runtime.context.provider == "anthropic":
+            model = anthropic_model
+         elif runtime.context.provider == "openai":
+            model = openai_model
+         else:
+            raise ValueError(f"Unsupported provider: {runtime.context.provider}")
+        
+         # With dynamic model selection, you must bind tools explicitly
+         return model.bind_tools([weather])  
+
+      # Create agent with dynamic model selection
+      agent = create_react_agent(select_model, tools=[weather])
+
+      # Invoke with context to select model
+      output = agent.invoke(
+         {
+            "messages": [
+               {
+                  "role": "user",
+                  "content": "Which model is handling this?",
+               }
+            ]
+         },
+         context=CustomContext(provider="openai"),
+      )
+
+      print(output["messages"][-1].text())
+      ```
+
+
 ## Advanced model configuration
 
 ### Disable streaming

docs/docs/cloud/reference/langgraph_server_changelog.md

@@ -4,9 +4,6 @@
 
 ---
 
-## v0.2.109 (2025-07-28)
-- Fixed an issue where missing config schema occurred when `config_type` was not set.
-
 ## v0.2.108 (2025-07-28)
 - Added compatibility for langgraph v0.6, including new context API support and a migration to enhance context handling in assistant operations.
 

docs/docs/concepts/human_in_the_loop.md

@@ -28,7 +28,7 @@ To review, edit, and approve tool calls in an agent or workflow, [use LangGraph'
     There are two ways to pause a graph:
 
     - [Dynamic interrupts](../how-tos/human_in_the_loop/add-human-in-the-loop.md#pause-using-interrupt): Use `interrupt` to pause a graph from inside a specific node, based on the current state of the graph.
-    - [Static interrupts](../how-tos/human_in_the_loop/add-human-in-the-loop.md#debug-with-interrupts): Use `interrupt_before` and `interrupt_after` to pause the graph at pre-defined points, either before or after a node executes.
+    - [Static interrupts](../how-tos/human_in_the_loop/add-human-in-the-loop.md#debug-with-interrupts): Use `interrupt_before` and `interrupt_after` to pause the graph at defined points, either before or after a node executes.
 
     <figure markdown="1">
     ![image](./img/breakpoints.png){: style="max-height:400px"}

docs/docs/how-tos/human_in_the_loop/add-human-in-the-loop.md

@@ -128,7 +128,7 @@ print(graph.invoke(Command(resume="Edited text"), config=config)) # (7)!
 
 !!! tip "New in 0.4.0"
 
-      `__interrupt__` is a special key that will be returned when running the graph if the graph is interrupted. Support for `__interrupt__` in `invoke` and `ainvoke` has been added in version 0.4.0. If you're on an older version, you will only see `__interrupt__` in the result if you use `stream` or `astream`. You can also use `graph.get_state(thread_id)` to get the interrupt value(s).
+      `__interrupt__` is a special key that will be returned when running the graph if the graph is interrupted. Support for `__interrupt__` in `invoke` and `ainvoke` has been added in version 0.4.0. If you're on an older version, you will only see `__interrupt__` in the result if you use `stream` or `astream`. You can also use `graph.get_state(thread_id)` to get the interrupt value.
 
 !!! warning
 
@@ -145,67 +145,19 @@ To resume execution, use the [`Command`][langgraph.types.Command] primitive, whi
 graph.invoke(Command(resume={"age": "25"}), thread_config)
 ```
 
-## Resuming Multiple interrupts
+### Resume multiple interrupts with one invocation
 
-When nodes with interrupt conditions are run in parallel, it's possible to have multiple interrupts in the task queue.
-For example, the following graph has two nodes run in parallel that require human input:
-
-<figure markdown="1">
-![image](../assets/human_in_loop_parallel.png){: style="max-height:400px"}
-</figure>
-
-Once your graph has been interrupted and is stalled, you can resume all the interrupts at once with `Command.resume`, passing a dictionary mapping of interrupt ids to resume values.
+If you have multiple interrupts in the task queue, you can use `Command.resume` with a dictionary mapping of interrupt ids to resume with a single `invoke` / `stream` call.
 
+For example, once your graph has been interrupted (multiple times, theoretically) and is stalled:
 
 ```python
-from typing import TypedDict
-import uuid
-from langchain_core.runnables import RunnableConfig
-from langgraph.checkpoint.memory import InMemorySaver
-from langgraph.constants import START
-from langgraph.graph import StateGraph
-from langgraph.types import interrupt, Command
-
-
-class State(TypedDict):
-    text_1: str
-    text_2: str
-
-
-def human_node_1(state: State):
-    value = interrupt({"text_to_revise": state["text_1"]})
-    return {"text_1": value}
-
-
-def human_node_2(state: State):
-    value = interrupt({"text_to_revise": state["text_2"]})
-    return {"text_2": value}
-
-
-graph_builder = StateGraph(State)
-graph_builder.add_node("human_node_1", human_node_1)
-graph_builder.add_node("human_node_2", human_node_2)
-
-# Add both nodes in parallel from START
-graph_builder.add_edge(START, "human_node_1")
-graph_builder.add_edge(START, "human_node_2")
-
-checkpointer = InMemorySaver()
-graph = graph_builder.compile(checkpointer=checkpointer)
-
-thread_id = str(uuid.uuid4())
-config: RunnableConfig = {"configurable": {"thread_id": thread_id}}
-result = graph.invoke(
-    {"text_1": "original text 1", "text_2": "original text 2"}, config=config
-)
-
-# Resume with mapping of interrupt IDs to values
 resume_map = {
-    i.id: f"edited text for {i.value['text_to_revise']}"
-    for i in result["__interrupt__"]
+    i.id: f"human input for prompt {i.value}"
+    for i in parent.get_state(thread_config).interrupts
 }
-print(graph.invoke(Command(resume=resume_map), config=config))
-# > {'text_1': 'edited text for original text 1', 'text_2': 'edited text for original text 2'}
+
+parent_graph.invoke(Command(resume=resume_map), config=thread_config)
 ```
 
 ## Common patterns
@@ -1075,7 +1027,7 @@ def node_in_parent_graph(state: State):
     {'parent_node': {'state_counter': 1}}
     ```
 
-### Using multiple interrupts in a single node
+### Using multiple interrupts
 
 Using multiple interrupts within a **single** node can be helpful for patterns like [validating human input](#validate-human-input). However, using multiple interrupts in the same node can lead to unexpected behavior if not handled carefully.
 

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

@@ -66,6 +66,108 @@ agent = create_react_agent(
 agent.invoke({"messages": [{"role": "user", "content": "what's 42 x 7?"}]})
 ```
 
+### Dynamically select tools
+
+Configure tool availability at runtime based on context:
+
+```python
+from langgraph.runtime import Runtime
+
+@dataclass
+class CustomContext:
+    tools: list[Literal["weather", "compass"]]
+    
+# highlight-next-line
+def configure_model(state: AgentState, runtime: Runtime[CustomContext]):
+    """Configure the model with tools based on runtime context."""
+    selected_tools = [
+        tool
+        for tool in [weather, compass]
+        if tool.name in runtime.context.tools
+    ]
+    return model.bind_tools(selected_tools)
+
+
+agent = create_react_agent(
+    # Dynamically configure the model with tools based on runtime context
+    # highlight-next-line
+    configure_model,
+    # Initialize with all tools available
+    # highlight-next-line
+    tools=[weather, compass]
+)
+```
+
+!!! version-added "Supported with langgraph>=0.6"
+
+??? example "Extended example: dynamically select tools based on context"
+
+    ```python
+    from dataclasses import dataclass
+    from typing import Literal
+
+    from langchain.chat_models import init_chat_model
+    from langchain_core.tools import tool
+
+    from langgraph.prebuilt import create_react_agent
+    from langgraph.prebuilt.chat_agent_executor import AgentState
+    from langgraph.runtime import Runtime
+
+
+    @dataclass
+    class CustomContext:
+        tools: list[Literal["weather", "compass"]]
+
+
+    @tool
+    def weather() -> str:
+        """Returns the current weather conditions."""
+        return "It's nice and sunny."
+
+
+    @tool
+    def compass() -> str:
+        """Returns the direction the user is facing."""
+        return "North"
+
+    model = init_chat_model("anthropic:claude-sonnet-4-20250514")
+
+    # highlight-next-line
+    def configure_model(state: AgentState, runtime: Runtime[CustomContext]):
+        """Configure the model with tools based on runtime context."""
+        selected_tools = [
+            tool
+            for tool in [weather, compass]
+            if tool.name in runtime.context.tools
+        ]
+        return model.bind_tools(selected_tools)
+
+
+    agent = create_react_agent(
+        # Dynamically configure the model with tools based on runtime context
+        # highlight-next-line
+        configure_model,
+        # Initialize with all tools available
+        # highlight-next-line
+        tools=[weather, compass]
+    )
+
+    output = agent.invoke(
+        {
+            "messages": [
+                {
+                    "role": "user",
+                    "content": "Who are you and what tools do you have access to?",
+                }
+            ]
+        },
+        # highlight-next-line
+        context=CustomContext(tools=["weather"]),  # Only enable the weather tool
+    )
+
+    print(output["messages"][-1].text())
+    ```
+
 ## Use in a workflow
 
 If you are writing a custom workflow, you will need to: