Update docs/docs/agents/models.md

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

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/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: