langchain 1.0.1__py3-none-any.whl → 1.0.3__py3-none-any.whl

langchain/__init__.py

@@ -1,3 +1,3 @@
 """Main entrypoint into LangChain."""
 
-__version__ = "1.0.1"
+__version__ = "1.0.3"

langchain/agents/factory.py

@@ -11,6 +11,7 @@ from langchain_core.tools import BaseTool
 from langgraph._internal._runnable import RunnableCallable
 from langgraph.constants import END, START
 from langgraph.graph.state import StateGraph
+from langgraph.prebuilt.tool_node import ToolCallWithContext, ToolNode
 from langgraph.runtime import Runtime  # noqa: TC002
 from langgraph.types import Command, Send
 from langgraph.typing import ContextT  # noqa: TC002
@@ -33,11 +34,11 @@ from langchain.agents.structured_output import (
     ProviderStrategy,
     ProviderStrategyBinding,
     ResponseFormat,
+    StructuredOutputError,
     StructuredOutputValidationError,
     ToolStrategy,
 )
 from langchain.chat_models import init_chat_model
-from langchain.tools.tool_node import ToolCallWithContext, _ToolNode
 
 if TYPE_CHECKING:
     from collections.abc import Awaitable, Callable, Sequence
@@ -48,7 +49,7 @@ if TYPE_CHECKING:
     from langgraph.store.base import BaseStore
     from langgraph.types import Checkpointer
 
-    from langchain.tools.tool_node import ToolCallRequest, ToolCallWrapper
+    from langchain.agents.middleware.types import ToolCallRequest, ToolCallWrapper
 
 STRUCTURED_OUTPUT_ERROR_TEMPLATE = "Error: {error}\n Please fix your mistakes."
 
@@ -529,44 +530,65 @@ def create_agent(  # noqa: PLR0915
 
     Args:
         model: The language model for the agent. Can be a string identifier
-            (e.g., `"openai:gpt-4"`) or a chat model instance (e.g., `ChatOpenAI()`).
+            (e.g., `"openai:gpt-4"`) or a direct chat model instance (e.g.,
+            [`ChatOpenAI`][langchain_openai.ChatOpenAI] or other another
+            [chat model](https://docs.langchain.com/oss/python/integrations/chat)).
+
             For a full list of supported model strings, see
             [`init_chat_model`][langchain.chat_models.init_chat_model(model_provider)].
-        tools: A list of tools, `dicts`, or `Callable`. If `None` or an empty list,
-            the agent will consist of a model node without a tool calling loop.
-        system_prompt: An optional system prompt for the LLM. Prompts are converted to a
-            `SystemMessage` and added to the beginning of the message list.
+        tools: A list of tools, `dicts`, or `Callable`.
+
+            If `None` or an empty list, the agent will consist of a model node without a
+            tool calling loop.
+        system_prompt: An optional system prompt for the LLM.
+
+            Prompts are converted to a
+            [`SystemMessage`][langchain.messages.SystemMessage] and added to the
+            beginning of the message list.
         middleware: A sequence of middleware instances to apply to the agent.
-            Middleware can intercept and modify agent behavior at various stages.
+
+            Middleware can intercept and modify agent behavior at various stages. See
+            the [full guide](https://docs.langchain.com/oss/python/langchain/middleware).
         response_format: An optional configuration for structured responses.
+
             Can be a `ToolStrategy`, `ProviderStrategy`, or a Pydantic model class.
+
             If provided, the agent will handle structured output during the
             conversation flow. Raw schemas will be wrapped in an appropriate strategy
             based on model capabilities.
         state_schema: An optional `TypedDict` schema that extends `AgentState`.
+
             When provided, this schema is used instead of `AgentState` as the base
             schema for merging with middleware state schemas. This allows users to
             add custom state fields without needing to create custom middleware.
-            Generally, it's recommended to use state_schema extensions via middleware
+            Generally, it's recommended to use `state_schema` extensions via middleware
             to keep relevant extensions scoped to corresponding hooks / tools.
+
             The schema must be a subclass of `AgentState[ResponseT]`.
         context_schema: An optional schema for runtime context.
-        checkpointer: An optional checkpoint saver object. This is used for persisting
-            the state of the graph (e.g., as chat memory) for a single thread
-            (e.g., a single conversation).
-        store: An optional store object. This is used for persisting data
-            across multiple threads (e.g., multiple conversations / users).
+        checkpointer: An optional checkpoint saver object.
+
+            Used for persisting the state of the graph (e.g., as chat memory) for a
+            single thread (e.g., a single conversation).
+        store: An optional store object.
+
+            Used for persisting data across multiple threads (e.g., multiple
+            conversations / users).
         interrupt_before: An optional list of node names to interrupt before.
+
             Useful if you want to add a user confirmation or other interrupt
             before taking an action.
         interrupt_after: An optional list of node names to interrupt after.
+
             Useful if you want to return directly or run additional processing
             on an output.
-        debug: Whether to enable verbose logging for graph execution. When enabled,
-            prints detailed information about each node execution, state updates,
-            and transitions during agent runtime. Useful for debugging middleware
-            behavior and understanding agent execution flow.
+        debug: Whether to enable verbose logging for graph execution.
+
+            When enabled, prints detailed information about each node execution, state
+            updates, and transitions during agent runtime. Useful for debugging
+            middleware behavior and understanding agent execution flow.
         name: An optional name for the `CompiledStateGraph`.
+
             This name will be automatically used when adding the agent graph to
             another graph as a subgraph node - particularly useful for building
             multi-agent systems.
@@ -576,11 +598,12 @@ def create_agent(  # noqa: PLR0915
         A compiled `StateGraph` that can be used for chat interactions.
 
     The agent node calls the language model with the messages list (after applying
-    the system prompt). If the resulting `AIMessage` contains `tool_calls`, the graph
-    will then call the tools. The tools node executes the tools and adds the responses
-    to the messages list as `ToolMessage` objects. The agent node then calls the
-    language model again. The process repeats until no more `tool_calls` are
-    present in the response. The agent then returns the full list of messages.
+    the system prompt). If the resulting [`AIMessage`][langchain.messages.AIMessage]
+    contains `tool_calls`, the graph will then call the tools. The tools node executes
+    the tools and adds the responses to the messages list as
+    [`ToolMessage`][langchain.messages.ToolMessage] objects. The agent node then calls
+    the language model again. The process repeats until no more `tool_calls` are present
+    in the response. The agent then returns the full list of messages.
 
     Example:
         ```python
@@ -675,7 +698,7 @@ def create_agent(  # noqa: PLR0915
         awrap_tool_call_wrapper = _chain_async_tool_call_wrappers(async_wrappers)
 
     # Setup tools
-    tool_node: _ToolNode | None = None
+    tool_node: ToolNode | None = None
     # Extract built-in provider tools (dict format) and regular tools (BaseTool/callables)
     built_in_tools = [t for t in tools if isinstance(t, dict)]
     regular_tools = [t for t in tools if not isinstance(t, dict)]
@@ -685,7 +708,7 @@ def create_agent(  # noqa: PLR0915
 
     # Only create ToolNode if we have client-side tools
     tool_node = (
-        _ToolNode(
+        ToolNode(
             tools=available_tools,
             wrap_tool_call=wrap_tool_call_wrapper,
             awrap_tool_call=awrap_tool_call_wrapper,
@@ -797,8 +820,16 @@ def create_agent(  # noqa: PLR0915
                 provider_strategy_binding = ProviderStrategyBinding.from_schema_spec(
                     effective_response_format.schema_spec
                 )
-                structured_response = provider_strategy_binding.parse(output)
-                return {"messages": [output], "structured_response": structured_response}
+                try:
+                    structured_response = provider_strategy_binding.parse(output)
+                except Exception as exc:  # noqa: BLE001
+                    schema_name = getattr(
+                        effective_response_format.schema_spec.schema, "__name__", "response_format"
+                    )
+                    validation_error = StructuredOutputValidationError(schema_name, exc, output)
+                    raise validation_error
+                else:
+                    return {"messages": [output], "structured_response": structured_response}
             return {"messages": [output]}
 
         # Handle structured output with tool strategy
@@ -812,11 +843,11 @@ def create_agent(  # noqa: PLR0915
             ]
 
             if structured_tool_calls:
-                exception: Exception | None = None
+                exception: StructuredOutputError | None = None
                 if len(structured_tool_calls) > 1:
                     # Handle multiple structured outputs error
                     tool_names = [tc["name"] for tc in structured_tool_calls]
-                    exception = MultipleStructuredOutputsError(tool_names)
+                    exception = MultipleStructuredOutputsError(tool_names, output)
                     should_retry, error_message = _handle_structured_output_error(
                         exception, effective_response_format
                     )
@@ -858,7 +889,7 @@ def create_agent(  # noqa: PLR0915
                         "structured_response": structured_response,
                     }
                 except Exception as exc:  # noqa: BLE001
-                    exception = StructuredOutputValidationError(tool_call["name"], exc)
+                    exception = StructuredOutputValidationError(tool_call["name"], exc, output)
                     should_retry, error_message = _handle_structured_output_error(
                         exception, effective_response_format
                     )
@@ -1491,7 +1522,7 @@ def _make_model_to_model_edge(
 
 def _make_tools_to_model_edge(
     *,
-    tool_node: _ToolNode,
+    tool_node: ToolNode,
     model_destination: str,
     structured_output_tools: dict[str, OutputToolBinding],
     end_destination: str,

langchain/agents/middleware/context_editing.py

@@ -182,7 +182,7 @@ class ClearToolUsesEdit(ContextEdit):
 
 
 class ContextEditingMiddleware(AgentMiddleware):
-    """Middleware that automatically prunes tool results to manage context size.
+    """Automatically prunes tool results to manage context size.
 
     The middleware applies a sequence of edits when the total input token count
     exceeds configured thresholds. Currently the `ClearToolUsesEdit` strategy is

langchain/agents/middleware/model_call_limit.py

@@ -87,7 +87,7 @@ class ModelCallLimitExceededError(Exception):
 
 
 class ModelCallLimitMiddleware(AgentMiddleware[ModelCallLimitState, Any]):
-    """Middleware that tracks model call counts and enforces limits.
+    """Tracks model call counts and enforces limits.
 
     This middleware monitors the number of model calls made during agent execution
     and can terminate the agent when specified limits are reached. It supports

langchain/agents/middleware/model_fallback.py

@@ -31,7 +31,7 @@ class ModelFallbackMiddleware(AgentMiddleware):
 
         fallback = ModelFallbackMiddleware(
             "openai:gpt-4o-mini",  # Try first on error
-            "anthropic:claude-3-5-sonnet-20241022",  # Then this
+            "anthropic:claude-sonnet-4-5-20250929",  # Then this
         )
 
         agent = create_agent(

langchain/agents/middleware/shell_tool.py

@@ -45,7 +45,7 @@ if TYPE_CHECKING:
     from langgraph.runtime import Runtime
     from langgraph.types import Command
 
-    from langchain.tools.tool_node import ToolCallRequest
+    from langchain.agents.middleware.types import ToolCallRequest
 
 LOGGER = logging.getLogger(__name__)
 _DONE_MARKER_PREFIX = "__LC_SHELL_DONE__"

langchain/agents/middleware/summarization.py

@@ -60,7 +60,7 @@ _SEARCH_RANGE_FOR_TOOL_PAIRS = 5
 
 
 class SummarizationMiddleware(AgentMiddleware):
-    """Middleware that summarizes conversation history when token limits are approached.
+    """Summarizes conversation history when token limits are approached.
 
     This middleware monitors message token counts and automatically summarizes older
     messages when a threshold is reached, preserving recent messages and maintaining

langchain/agents/middleware/tool_call_limit.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Annotated, Any, Literal
 
-from langchain_core.messages import AIMessage, AnyMessage, HumanMessage
+from langchain_core.messages import AIMessage
 from langgraph.channels.untracked_value import UntrackedValue
 from typing_extensions import NotRequired
 
@@ -33,53 +33,6 @@ class ToolCallLimitState(AgentState):
     run_tool_call_count: NotRequired[Annotated[dict[str, int], UntrackedValue, PrivateStateAttr]]
 
 
-def _count_tool_calls_in_messages(messages: list[AnyMessage], tool_name: str | None = None) -> int:
-    """Count tool calls in a list of messages.
-
-    Args:
-        messages: List of messages to count tool calls in.
-        tool_name: If specified, only count calls to this specific tool.
-            If `None`, count all tool calls.
-
-    Returns:
-        The total number of tool calls (optionally filtered by tool_name).
-    """
-    count = 0
-    for message in messages:
-        if isinstance(message, AIMessage) and message.tool_calls:
-            if tool_name is None:
-                # Count all tool calls
-                count += len(message.tool_calls)
-            else:
-                # Count only calls to the specified tool
-                count += sum(1 for tc in message.tool_calls if tc["name"] == tool_name)
-    return count
-
-
-def _get_run_messages(messages: list[AnyMessage]) -> list[AnyMessage]:
-    """Get messages from the current run (after the last HumanMessage).
-
-    Args:
-        messages: Full list of messages.
-
-    Returns:
-        Messages from the current run (after last HumanMessage).
-    """
-    # Find the last HumanMessage
-    last_human_index = -1
-    for i in range(len(messages) - 1, -1, -1):
-        if isinstance(messages[i], HumanMessage):
-            last_human_index = i
-            break
-
-    # If no HumanMessage found, return all messages
-    if last_human_index == -1:
-        return messages
-
-    # Return messages after the last HumanMessage
-    return messages[last_human_index + 1 :]
-
-
 def _build_tool_limit_exceeded_message(
     thread_count: int,
     run_count: int,
@@ -146,7 +99,7 @@ class ToolCallLimitExceededError(Exception):
 
 
 class ToolCallLimitMiddleware(AgentMiddleware[ToolCallLimitState, Any]):
-    """Middleware that tracks tool call counts and enforces limits.
+    """Tracks tool call counts and enforces limits.
 
     This middleware monitors the number of tool calls made during agent execution
     and can terminate the agent when specified limits are reached. It supports

langchain/agents/middleware/tool_emulator.py

@@ -15,12 +15,12 @@ if TYPE_CHECKING:
 
     from langgraph.types import Command
 
+    from langchain.agents.middleware.types import ToolCallRequest
     from langchain.tools import BaseTool
-    from langchain.tools.tool_node import ToolCallRequest
 
 
 class LLMToolEmulator(AgentMiddleware):
-    """Middleware that emulates specified tools using an LLM instead of executing them.
+    """Emulates specified tools using an LLM instead of executing them.
 
     This middleware allows selective emulation of tools for testing purposes.
     By default (when tools=None), all tools are emulated. You can specify which
@@ -47,9 +47,7 @@ class LLMToolEmulator(AgentMiddleware):
 
         Use a custom model for emulation:
         ```python
-        middleware = LLMToolEmulator(
-            tools=["get_weather"], model="anthropic:claude-3-5-sonnet-latest"
-        )
+        middleware = LLMToolEmulator(tools=["get_weather"], model="anthropic:claude-sonnet-4-5")
         ```
 
         Emulate specific tools by passing tool instances:
@@ -71,7 +69,7 @@ class LLMToolEmulator(AgentMiddleware):
                 If None (default), ALL tools will be emulated.
                 If empty list, no tools will be emulated.
             model: Model to use for emulation.
-                Defaults to "anthropic:claude-3-5-sonnet-latest".
+                Defaults to "anthropic:claude-sonnet-4-5".
                 Can be a model identifier string or BaseChatModel instance.
         """
         super().__init__()
@@ -91,7 +89,7 @@ class LLMToolEmulator(AgentMiddleware):
 
         # Initialize emulator model
         if model is None:
-            self.model = init_chat_model("anthropic:claude-3-5-sonnet-latest", temperature=1)
+            self.model = init_chat_model("anthropic:claude-sonnet-4-5", temperature=1)
         elif isinstance(model, BaseChatModel):
             self.model = model
         else:

langchain/agents/middleware/tool_retry.py

@@ -16,8 +16,8 @@ if TYPE_CHECKING:
 
     from langgraph.types import Command
 
+    from langchain.agents.middleware.types import ToolCallRequest
     from langchain.tools import BaseTool
-    from langchain.tools.tool_node import ToolCallRequest
 
 
 class ToolRetryMiddleware(AgentMiddleware):

langchain/agents/middleware/types.py

@@ -19,14 +19,13 @@ from typing import (
 if TYPE_CHECKING:
     from collections.abc import Awaitable
 
-    from langchain.tools.tool_node import ToolCallRequest
-
 # Needed as top level import for Pydantic schema generation on AgentState
 from typing import TypeAlias
 
 from langchain_core.messages import AIMessage, AnyMessage, BaseMessage, ToolMessage  # noqa: TC002
 from langgraph.channels.ephemeral_value import EphemeralValue
 from langgraph.graph.message import add_messages
+from langgraph.prebuilt.tool_node import ToolCallRequest, ToolCallWrapper
 from langgraph.types import Command  # noqa: TC002
 from langgraph.typing import ContextT
 from typing_extensions import NotRequired, Required, TypedDict, TypeVar, Unpack
@@ -45,6 +44,8 @@ __all__ = [
     "ModelRequest",
     "ModelResponse",
     "OmitFromSchema",
+    "ToolCallRequest",
+    "ToolCallWrapper",
     "after_agent",
     "after_model",
     "before_agent",

langchain/agents/structured_output.py

@@ -34,17 +34,21 @@ SchemaKind = Literal["pydantic", "dataclass", "typeddict", "json_schema"]
 class StructuredOutputError(Exception):
     """Base class for structured output errors."""
 
+    ai_message: AIMessage
+
 
 class MultipleStructuredOutputsError(StructuredOutputError):
     """Raised when model returns multiple structured output tool calls when only one is expected."""
 
-    def __init__(self, tool_names: list[str]) -> None:
+    def __init__(self, tool_names: list[str], ai_message: AIMessage) -> None:
         """Initialize `MultipleStructuredOutputsError`.
 
         Args:
             tool_names: The names of the tools called for structured output.
+            ai_message: The AI message that contained the invalid multiple tool calls.
         """
         self.tool_names = tool_names
+        self.ai_message = ai_message
 
         super().__init__(
             "Model incorrectly returned multiple structured responses "
@@ -55,15 +59,17 @@ class MultipleStructuredOutputsError(StructuredOutputError):
 class StructuredOutputValidationError(StructuredOutputError):
     """Raised when structured output tool call arguments fail to parse according to the schema."""
 
-    def __init__(self, tool_name: str, source: Exception) -> None:
+    def __init__(self, tool_name: str, source: Exception, ai_message: AIMessage) -> None:
         """Initialize `StructuredOutputValidationError`.
 
         Args:
             tool_name: The name of the tool that failed.
             source: The exception that occurred.
+            ai_message: The AI message that contained the invalid structured output.
         """
         self.tool_name = tool_name
         self.source = source
+        self.ai_message = ai_message
         super().__init__(f"Failed to parse structured output for tool '{tool_name}': {source}.")
 
 

langchain/chat_models/base.py

@@ -64,26 +64,34 @@ def init_chat_model(
     config_prefix: str | None = None,
     **kwargs: Any,
 ) -> BaseChatModel | _ConfigurableModel:
-    """Initialize a chat model in a single line using the model's name and provider.
+    """Initialize a chat model from any supported provider using a unified interface.
+
+    **Two main use cases:**
+
+    1. **Fixed model** – specify the model upfront and get a ready-to-use chat model.
+    2. **Configurable model** – choose to specify parameters (including model name) at
+        runtime via `config`. Makes it easy to switch between models/providers without
+        changing your code
 
     !!! note
-        Requires the integration package for your model provider to be installed.
+        Requires the integration package for the chosen model provider to be installed.
 
         See the `model_provider` parameter below for specific package names
         (e.g., `pip install langchain-openai`).
 
         Refer to the [provider integration's API reference](https://docs.langchain.com/oss/python/integrations/providers)
-        for supported model parameters.
+        for supported model parameters to use as `**kwargs`.
 
     Args:
         model: The name of the model, e.g. `'o3-mini'`, `'claude-sonnet-4-5'`.
 
-            You can also specify model and model provider in a single argument using:
-
+            You can also specify model and model provider in a single argument using
             `'{model_provider}:{model}'` format, e.g. `'openai:o1'`.
         model_provider: The model provider if not specified as part of the model arg
-            (see above). Supported `model_provider` values and the corresponding
-            integration package are:
+            (see above).
+
+            Supported `model_provider` values and the corresponding integration package
+            are:
 
             - `openai`                  -> [`langchain-openai`](https://docs.langchain.com/oss/python/integrations/providers/openai)
             - `anthropic`               -> [`langchain-anthropic`](https://docs.langchain.com/oss/python/integrations/providers/anthropic)
@@ -120,27 +128,36 @@ def init_chat_model(
             - `deepseek...`                       -> `deepseek`
             - `grok...`                           -> `xai`
             - `sonar...`                          -> `perplexity`
-        configurable_fields: Which model parameters are configurable:
+        configurable_fields: Which model parameters are configurable at runtime:
 
-            - `None`: No configurable fields.
+            - `None`: No configurable fields (i.e., a fixed model).
             - `'any'`: All fields are configurable. **See security note below.**
             - `list[str] | Tuple[str, ...]`: Specified fields are configurable.
 
-            Fields are assumed to have `config_prefix` stripped if there is a
-            `config_prefix`. If model is specified, then defaults to `None`. If model is
-            not specified, then defaults to `("model", "model_provider")`.
+            Fields are assumed to have `config_prefix` stripped if a `config_prefix` is
+            specified.
+
+            If `model` is specified, then defaults to `None`.
+
+            If `model` is not specified, then defaults to `("model", "model_provider")`.
 
             !!! warning "Security note"
                 Setting `configurable_fields="any"` means fields like `api_key`,
-                `base_url`, etc. can be altered at runtime, potentially redirecting
-                model requests to a different service/user. Make sure that if you're
-                accepting untrusted configurations that you enumerate the
-                `configurable_fields=(...)` explicitly.
-
-        config_prefix: If `'config_prefix'` is a non-empty string then model will be
-            configurable at runtime via the
-            `config["configurable"]["{config_prefix}_{param}"]` keys. If
-            `'config_prefix'` is an empty string then model will be configurable via
+                `base_url`, etc., can be altered at runtime, potentially redirecting
+                model requests to a different service/user.
+
+                Make sure that if you're accepting untrusted configurations that you
+                enumerate the `configurable_fields=(...)` explicitly.
+
+        config_prefix: Optional prefix for configuration keys.
+
+            Useful when you have multiple configurable models in the same application.
+
+            If `'config_prefix'` is a non-empty string then `model` will be configurable
+            at runtime via the `config["configurable"]["{config_prefix}_{param}"]` keys.
+            See examples below.
+
+            If `'config_prefix'` is an empty string then model will be configurable via
             `config["configurable"]["{param}"]`.
         **kwargs: Additional model-specific keyword args to pass to the underlying
             chat model's `__init__` method. Common parameters include:
@@ -150,10 +167,13 @@ def init_chat_model(
             - `timeout`: Maximum time (in seconds) to wait for a response.
             - `max_retries`: Maximum number of retry attempts for failed requests.
             - `base_url`: Custom API endpoint URL.
-            - `rate_limiter`: A `BaseRateLimiter` instance to control request rate.
+            - `rate_limiter`: A
+                [`BaseRateLimiter`][langchain_core.rate_limiters.BaseRateLimiter]
+                instance to control request rate.
 
-            Refer to the specific model provider's documentation for all available
-            parameters.
+            Refer to the specific model provider's
+            [integration reference](https://reference.langchain.com/python/integrations/)
+            for all available parameters.
 
     Returns:
         A `BaseChatModel` corresponding to the `model_name` and `model_provider`
@@ -165,32 +185,34 @@ def init_chat_model(
         ValueError: If `model_provider` cannot be inferred or isn't supported.
         ImportError: If the model provider integration package is not installed.
 
-    ???+ note "Initialize a non-configurable model"
+    ???+ example "Initialize a non-configurable model"
 
         ```python
         # pip install langchain langchain-openai langchain-anthropic langchain-google-vertexai
+
         from langchain.chat_models import init_chat_model
 
         o3_mini = init_chat_model("openai:o3-mini", temperature=0)
         claude_sonnet = init_chat_model("anthropic:claude-sonnet-4-5", temperature=0)
-        gemini_2_flash = init_chat_model("google_vertexai:gemini-2.5-flash", temperature=0)
+        gemini_2-5_flash = init_chat_model("google_vertexai:gemini-2.5-flash", temperature=0)
 
         o3_mini.invoke("what's your name")
         claude_sonnet.invoke("what's your name")
-        gemini_2_flash.invoke("what's your name")
+        gemini_2-5_flash.invoke("what's your name")
         ```
 
-    ??? note "Partially configurable model with no default"
+    ??? example "Partially configurable model with no default"
 
         ```python
         # pip install langchain langchain-openai langchain-anthropic
+
         from langchain.chat_models import init_chat_model
 
-        # We don't need to specify configurable=True if a model isn't specified.
+        # (We don't need to specify configurable=True if a model isn't specified.)
         configurable_model = init_chat_model(temperature=0)
 
         configurable_model.invoke("what's your name", config={"configurable": {"model": "gpt-4o"}})
-        # GPT-4o response
+        # Use GPT-4o to generate the response
 
         configurable_model.invoke(
             "what's your name",
@@ -198,10 +220,11 @@ def init_chat_model(
         )
         ```
 
-    ??? note "Fully configurable model with a default"
+    ??? example "Fully configurable model with a default"
 
         ```python
         # pip install langchain langchain-openai langchain-anthropic
+
         from langchain.chat_models import init_chat_model
 
         configurable_model_with_default = init_chat_model(
@@ -212,7 +235,7 @@ def init_chat_model(
         )
 
         configurable_model_with_default.invoke("what's your name")
-        # GPT-4o response with temperature 0
+        # GPT-4o response with temperature 0 (as set in default)
 
         configurable_model_with_default.invoke(
             "what's your name",
@@ -223,15 +246,17 @@ def init_chat_model(
                 }
             },
         )
+        # Override default to use Sonnet 4.5 with temperature 0.6 to generate response
         ```
 
-    ??? note "Bind tools to a configurable model"
+    ??? example "Bind tools to a configurable model"
 
         You can call any chat model declarative methods on a configurable model in the
         same way that you would with a normal model:
 
         ```python
         # pip install langchain langchain-openai langchain-anthropic
+
         from langchain.chat_models import init_chat_model
         from pydantic import BaseModel, Field
 
@@ -261,11 +286,13 @@ def init_chat_model(
         configurable_model_with_tools.invoke(
             "Which city is hotter today and which is bigger: LA or NY?"
         )
+        # Use GPT-4o
 
         configurable_model_with_tools.invoke(
             "Which city is hotter today and which is bigger: LA or NY?",
             config={"configurable": {"model": "claude-sonnet-4-5"}},
         )
+        # Use Sonnet 4.5
         ```
 
     """  # noqa: E501