langchain 1.0.0a12__py3-none-any.whl → 1.0.4__py3-none-any.whl

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:
-        """Initialize MultipleStructuredOutputsError.
+    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:
-        """Initialize StructuredOutputValidationError.
+    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}.")
 
 
@@ -73,8 +79,9 @@ def _parse_with_schema(
     """Parse data using for any supported schema type.
 
     Args:
-        schema: The schema type (Pydantic model, dataclass, or TypedDict)
-        schema_kind: One of "pydantic", "dataclass", "typeddict", or "json_schema"
+        schema: The schema type (Pydantic model, `dataclass`, or `TypedDict`)
+        schema_kind: One of `"pydantic"`, `"dataclass"`, `"typeddict"`, or
+            `"json_schema"`
         data: The data to parse
 
     Returns:
@@ -99,13 +106,14 @@ class _SchemaSpec(Generic[SchemaT]):
     """Describes a structured output schema."""
 
     schema: type[SchemaT]
-    """The schema for the response, can be a Pydantic model, dataclass, TypedDict,
+    """The schema for the response, can be a Pydantic model, `dataclass`, `TypedDict`,
     or JSON schema dict."""
 
     name: str
     """Name of the schema, used for tool calling.
 
-    If not provided, the name will be the model name or "response_format" if it's a JSON schema.
+    If not provided, the name will be the model name or `"response_format"` if it's a
+    JSON schema.
     """
 
     description: str
@@ -186,14 +194,15 @@ class ToolStrategy(Generic[SchemaT]):
     handle_errors: (
         bool | str | type[Exception] | tuple[type[Exception], ...] | Callable[[Exception], str]
     )
-    """Error handling strategy for structured output via ToolStrategy. Default is True.
-
-    - True: Catch all errors with default error template
-    - str: Catch all errors with this custom message
-    - type[Exception]: Only catch this exception type with default message
-    - tuple[type[Exception], ...]: Only catch these exception types with default message
-    - Callable[[Exception], str]: Custom function that returns error message
-    - False: No retry, let exceptions propagate
+    """Error handling strategy for structured output via `ToolStrategy`.
+
+    - `True`: Catch all errors with default error template
+    - `str`: Catch all errors with this custom message
+    - `type[Exception]`: Only catch this exception type with default message
+    - `tuple[type[Exception], ...]`: Only catch these exception types with default
+        message
+    - `Callable[[Exception], str]`: Custom function that returns error message
+    - `False`: No retry, let exceptions propagate
     """
 
     def __init__(
@@ -207,9 +216,10 @@ class ToolStrategy(Generic[SchemaT]):
         | tuple[type[Exception], ...]
         | Callable[[Exception], str] = True,
     ) -> None:
-        """Initialize ToolStrategy.
+        """Initialize `ToolStrategy`.
 
-        Initialize ToolStrategy with schemas, tool message content, and error handling strategy.
+        Initialize `ToolStrategy` with schemas, tool message content, and error handling
+        strategy.
         """
         self.schema = schema
         self.tool_message_content = tool_message_content
@@ -285,13 +295,13 @@ class OutputToolBinding(Generic[SchemaT]):
 
     @classmethod
     def from_schema_spec(cls, schema_spec: _SchemaSpec[SchemaT]) -> Self:
-        """Create an OutputToolBinding instance from a SchemaSpec.
+        """Create an `OutputToolBinding` instance from a `SchemaSpec`.
 
         Args:
-            schema_spec: The SchemaSpec to convert
+            schema_spec: The `SchemaSpec` to convert
 
         Returns:
-            An OutputToolBinding instance with the appropriate tool created
+            An `OutputToolBinding` instance with the appropriate tool created
         """
         return cls(
             schema=schema_spec.schema,
@@ -329,20 +339,20 @@ class ProviderStrategyBinding(Generic[SchemaT]):
 
     schema: type[SchemaT]
     """The original schema provided for structured output
-    (Pydantic model, dataclass, TypedDict, or JSON schema dict)."""
+    (Pydantic model, `dataclass`, `TypedDict`, or JSON schema dict)."""
 
     schema_kind: SchemaKind
     """Classification of the schema type for proper response construction."""
 
     @classmethod
     def from_schema_spec(cls, schema_spec: _SchemaSpec[SchemaT]) -> Self:
-        """Create a ProviderStrategyBinding instance from a SchemaSpec.
+        """Create a `ProviderStrategyBinding` instance from a `SchemaSpec`.
 
         Args:
-            schema_spec: The SchemaSpec to convert
+            schema_spec: The `SchemaSpec` to convert
 
         Returns:
-            A ProviderStrategyBinding instance for parsing native structured output
+            A `ProviderStrategyBinding` instance for parsing native structured output
         """
         return cls(
             schema=schema_spec.schema,
@@ -350,10 +360,10 @@ class ProviderStrategyBinding(Generic[SchemaT]):
         )
 
     def parse(self, response: AIMessage) -> SchemaT:
-        """Parse AIMessage content according to the schema.
+        """Parse `AIMessage` content according to the schema.
 
         Args:
-            response: The AI message containing the structured output
+            response: The `AIMessage` containing the structured output
 
         Returns:
             The parsed response according to the schema

langchain/chat_models/__init__.py

@@ -1,4 +1,10 @@
-"""Chat models."""
+"""Entrypoint to using [chat models](https://docs.langchain.com/oss/python/langchain/models) in LangChain.
+
+!!! warning "Reference docs"
+    This page contains **reference documentation** for chat models. See
+    [the docs](https://docs.langchain.com/oss/python/langchain/models) for conceptual
+    guides, tutorials, and examples on using chat models.
+"""  # noqa: E501
 
 from langchain_core.language_models import BaseChatModel
 

langchain/chat_models/base.py

@@ -4,14 +4,7 @@ from __future__ import annotations
 
 import warnings
 from importlib import util
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Literal,
-    TypeAlias,
-    cast,
-    overload,
-)
+from typing import TYPE_CHECKING, Any, Literal, TypeAlias, cast, overload
 
 from langchain_core.language_models import BaseChatModel, LanguageModelInput
 from langchain_core.messages import AIMessage, AnyMessage
@@ -32,7 +25,7 @@ def init_chat_model(
     model: str,
     *,
     model_provider: str | None = None,
-    configurable_fields: Literal[None] = None,
+    configurable_fields: None = None,
     config_prefix: str | None = None,
     **kwargs: Any,
 ) -> BaseChatModel: ...
@@ -40,10 +33,10 @@ def init_chat_model(
 
 @overload
 def init_chat_model(
-    model: Literal[None] = None,
+    model: None = None,
     *,
     model_provider: str | None = None,
-    configurable_fields: Literal[None] = None,
+    configurable_fields: None = None,
     config_prefix: str | None = None,
     **kwargs: Any,
 ) -> _ConfigurableModel: ...
@@ -71,224 +64,236 @@ def init_chat_model(
     config_prefix: str | None = None,
     **kwargs: Any,
 ) -> BaseChatModel | _ConfigurableModel:
-    """Initialize a ChatModel from the model name and provider.
+    """Initialize a chat model from any supported provider using a unified interface.
 
-    **Note:** Must have the integration package corresponding to the model provider
-    installed.
+    **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 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 to use as `**kwargs`.
 
     Args:
-        model: The name of the model, e.g. "o3-mini", "claude-3-5-sonnet-latest". 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 model arg (see
-            above). Supported model_provider values and the corresponding integration
-            package are:
-
-            - 'openai'              -> langchain-openai
-            - 'anthropic'           -> langchain-anthropic
-            - 'azure_openai'        -> langchain-openai
-            - 'azure_ai'            -> langchain-azure-ai
-            - 'google_vertexai'     -> langchain-google-vertexai
-            - 'google_genai'        -> langchain-google-genai
-            - 'bedrock'             -> langchain-aws
-            - 'bedrock_converse'    -> langchain-aws
-            - 'cohere'              -> langchain-cohere
-            - 'fireworks'           -> langchain-fireworks
-            - 'together'            -> langchain-together
-            - 'mistralai'           -> langchain-mistralai
-            - 'huggingface'         -> langchain-huggingface
-            - 'groq'                -> langchain-groq
-            - 'ollama'              -> langchain-ollama
-            - 'google_anthropic_vertex'    -> langchain-google-vertexai
-            - 'deepseek'            -> langchain-deepseek
-            - 'ibm'                 -> langchain-ibm
-            - 'nvidia'              -> langchain-nvidia-ai-endpoints
-            - 'xai'                 -> langchain-xai
-            - 'perplexity'          -> langchain-perplexity
-
-            Will attempt to infer model_provider from model if not specified. The
+        model: The name or ID of the model, e.g. `'o3-mini'`, `'claude-sonnet-4-5-20250929'`.
+
+            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:
+
+            - `openai`                  -> [`langchain-openai`](https://docs.langchain.com/oss/python/integrations/providers/openai)
+            - `anthropic`               -> [`langchain-anthropic`](https://docs.langchain.com/oss/python/integrations/providers/anthropic)
+            - `azure_openai`            -> [`langchain-openai`](https://docs.langchain.com/oss/python/integrations/providers/openai)
+            - `azure_ai`                -> [`langchain-azure-ai`](https://docs.langchain.com/oss/python/integrations/providers/microsoft)
+            - `google_vertexai`         -> [`langchain-google-vertexai`](https://docs.langchain.com/oss/python/integrations/providers/google)
+            - `google_genai`            -> [`langchain-google-genai`](https://docs.langchain.com/oss/python/integrations/providers/google)
+            - `bedrock`                 -> [`langchain-aws`](https://docs.langchain.com/oss/python/integrations/providers/aws)
+            - `bedrock_converse`        -> [`langchain-aws`](https://docs.langchain.com/oss/python/integrations/providers/aws)
+            - `cohere`                  -> [`langchain-cohere`](https://docs.langchain.com/oss/python/integrations/providers/cohere)
+            - `fireworks`               -> [`langchain-fireworks`](https://docs.langchain.com/oss/python/integrations/providers/fireworks)
+            - `together`                -> [`langchain-together`](https://docs.langchain.com/oss/python/integrations/providers/together)
+            - `mistralai`               -> [`langchain-mistralai`](https://docs.langchain.com/oss/python/integrations/providers/mistralai)
+            - `huggingface`             -> [`langchain-huggingface`](https://docs.langchain.com/oss/python/integrations/providers/huggingface)
+            - `groq`                    -> [`langchain-groq`](https://docs.langchain.com/oss/python/integrations/providers/groq)
+            - `ollama`                  -> [`langchain-ollama`](https://docs.langchain.com/oss/python/integrations/providers/ollama)
+            - `google_anthropic_vertex` -> [`langchain-google-vertexai`](https://docs.langchain.com/oss/python/integrations/providers/google)
+            - `deepseek`                -> [`langchain-deepseek`](https://docs.langchain.com/oss/python/integrations/providers/deepseek)
+            - `ibm`                     -> [`langchain-ibm`](https://docs.langchain.com/oss/python/integrations/providers/deepseek)
+            - `nvidia`                  -> [`langchain-nvidia-ai-endpoints`](https://docs.langchain.com/oss/python/integrations/providers/nvidia)
+            - `xai`                     -> [`langchain-xai`](https://docs.langchain.com/oss/python/integrations/providers/xai)
+            - `perplexity`              -> [`langchain-perplexity`](https://docs.langchain.com/oss/python/integrations/providers/perplexity)
+
+            Will attempt to infer `model_provider` from model if not specified. The
             following providers will be inferred based on these model prefixes:
 
-            - 'gpt-...' | 'o1...' | 'o3...'     -> 'openai'
-            - 'claude...'                       -> 'anthropic'
-            - 'amazon....'                      -> 'bedrock'
-            - 'gemini...'                       -> 'google_vertexai'
-            - 'command...'                      -> 'cohere'
-            - 'accounts/fireworks...'           -> 'fireworks'
-            - 'mistral...'                      -> 'mistralai'
-            - 'deepseek...'                     -> 'deepseek'
-            - 'grok...'                         -> 'xai'
-            - 'sonar...'                        -> 'perplexity'
-        configurable_fields: Which model parameters are
-            configurable:
-
-            - None: No configurable fields.
-            - "any": All fields are configurable. *See Security Note below.*
-            - Union[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")``.
-
-            ***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
-            ``config["configurable"]["{param}"]``.
-        kwargs: Additional model-specific keyword args to pass to
-            ``<<selected ChatModel>>.__init__(model=model_name, **kwargs)``. Examples
-            include:
-                * temperature: Model temperature.
-                * max_tokens: Max output tokens.
-                * timeout: The maximum time (in seconds) to wait for a response from the model
-                    before canceling the request.
-                * max_retries: The maximum number of attempts the system will make to resend a
-                    request if it fails due to issues like network timeouts or rate limits.
-                * base_url: The URL of the API endpoint where requests are sent.
-                * rate_limiter: A ``BaseRateLimiter`` to space out requests to avoid exceeding
-                    rate limits.
+            - `gpt-...` | `o1...` | `o3...`       -> `openai`
+            - `claude...`                         -> `anthropic`
+            - `amazon...`                         -> `bedrock`
+            - `gemini...`                         -> `google_vertexai`
+            - `command...`                        -> `cohere`
+            - `accounts/fireworks...`             -> `fireworks`
+            - `mistral...`                        -> `mistralai`
+            - `deepseek...`                       -> `deepseek`
+            - `grok...`                           -> `xai`
+            - `sonar...`                          -> `perplexity`
+        configurable_fields: Which model parameters are configurable at runtime:
 
-    Returns:
-        A BaseChatModel corresponding to the model_name and model_provider specified if
-        configurability is inferred to be False. If configurable, a chat model emulator
-        that initializes the underlying model at runtime once a config is passed in.
+            - `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.
 
-    Raises:
-        ValueError: If model_provider cannot be inferred or isn't supported.
-        ImportError: If the model provider integration package is not installed.
+            Fields are assumed to have `config_prefix` stripped if a `config_prefix` is
+            specified.
 
-    ??? note "Init non-configurable model"
-        :open:
+            If `model` is specified, then defaults to `None`.
 
-        .. code-block:: python
+            If `model` is not specified, then defaults to `("model", "model_provider")`.
 
-            # pip install langchain langchain-openai langchain-anthropic langchain-google-vertexai
-            from langchain.chat_models import init_chat_model
+            !!! 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.
 
-            o3_mini = init_chat_model("openai:o3-mini", temperature=0)
-            claude_sonnet = init_chat_model("anthropic:claude-3-5-sonnet-latest", temperature=0)
-            gemini_2_flash = init_chat_model("google_vertexai:gemini-2.5-flash", temperature=0)
+                Make sure that if you're accepting untrusted configurations that you
+                enumerate the `configurable_fields=(...)` explicitly.
 
-            o3_mini.invoke("what's your name")
-            claude_sonnet.invoke("what's your name")
-            gemini_2_flash.invoke("what's your name")
+        config_prefix: Optional prefix for configuration keys.
 
+            Useful when you have multiple configurable models in the same application.
 
-    ??? note "Partially configurable model with no default"
+            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.
 
-        .. code-block:: python
+            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:
 
-            # pip install langchain langchain-openai langchain-anthropic
-            from langchain.chat_models import init_chat_model
+            - `temperature`: Model temperature for controlling randomness.
+            - `max_tokens`: Maximum number of output tokens.
+            - `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`][langchain_core.rate_limiters.BaseRateLimiter]
+                instance to control request rate.
 
-            # We don't need to specify configurable=True if a model isn't specified.
-            configurable_model = init_chat_model(temperature=0)
+            Refer to the specific model provider's
+            [integration reference](https://reference.langchain.com/python/integrations/)
+            for all available parameters.
 
-            configurable_model.invoke(
-                "what's your name", config={"configurable": {"model": "gpt-4o"}}
-            )
-            # GPT-4o response
+    Returns:
+        A `BaseChatModel` corresponding to the `model_name` and `model_provider`
+            specified if configurability is inferred to be `False`. If configurable, a
+            chat model emulator that initializes the underlying model at runtime once a
+            config is passed in.
 
-            configurable_model.invoke(
-                "what's your name", config={"configurable": {"model": "claude-3-5-sonnet-latest"}}
-            )
-            # claude-3.5 sonnet response
+    Raises:
+        ValueError: If `model_provider` cannot be inferred or isn't supported.
+        ImportError: If the model provider integration package is not installed.
 
-    ??? note "Fully configurable model with a default"
+    ???+ example "Initialize a non-configurable model"
 
-        .. code-block:: python
+        ```python
+        # pip install langchain langchain-openai langchain-anthropic langchain-google-vertexai
 
-            # pip install langchain langchain-openai langchain-anthropic
-            from langchain.chat_models import init_chat_model
+        from langchain.chat_models import init_chat_model
 
-            configurable_model_with_default = init_chat_model(
-                "openai:gpt-4o",
-                configurable_fields="any",  # this allows us to configure other params like temperature, max_tokens, etc at runtime.
-                config_prefix="foo",
-                temperature=0,
-            )
+        o3_mini = init_chat_model("openai:o3-mini", temperature=0)
+        claude_sonnet = init_chat_model("anthropic:claude-sonnet-4-5-20250929", temperature=0)
+        gemini_2-5_flash = init_chat_model("google_vertexai:gemini-2.5-flash", temperature=0)
 
-            configurable_model_with_default.invoke("what's your name")
-            # GPT-4o response with temperature 0
-
-            configurable_model_with_default.invoke(
-                "what's your name",
-                config={
-                    "configurable": {
-                        "foo_model": "anthropic:claude-3-5-sonnet-latest",
-                        "foo_temperature": 0.6,
-                    }
-                },
-            )
-            # Claude-3.5 sonnet response with temperature 0.6
+        o3_mini.invoke("what's your name")
+        claude_sonnet.invoke("what's your name")
+        gemini_2-5_flash.invoke("what's your name")
+        ```
 
-    ??? note "Bind tools to a configurable model"
+    ??? example "Partially configurable model with no default"
 
-        You can call any ChatModel 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
 
-        .. code-block:: python
+        from langchain.chat_models import init_chat_model
 
-            # pip install langchain langchain-openai langchain-anthropic
-            from langchain.chat_models import init_chat_model
-            from pydantic import BaseModel, Field
+        # (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"}})
+        # Use GPT-4o to generate the response
 
-            class GetWeather(BaseModel):
-                '''Get the current weather in a given location'''
+        configurable_model.invoke(
+            "what's your name",
+            config={"configurable": {"model": "claude-sonnet-4-5-20250929"}},
+        )
+        ```
 
-                location: str = Field(..., description="The city and state, e.g. San Francisco, CA")
+    ??? example "Fully configurable model with a default"
 
+        ```python
+        # pip install langchain langchain-openai langchain-anthropic
 
-            class GetPopulation(BaseModel):
-                '''Get the current population in a given location'''
+        from langchain.chat_models import init_chat_model
 
-                location: str = Field(..., description="The city and state, e.g. San Francisco, CA")
+        configurable_model_with_default = init_chat_model(
+            "openai:gpt-4o",
+            configurable_fields="any",  # This allows us to configure other params like temperature, max_tokens, etc at runtime.
+            config_prefix="foo",
+            temperature=0,
+        )
 
+        configurable_model_with_default.invoke("what's your name")
+        # GPT-4o response with temperature 0 (as set in default)
+
+        configurable_model_with_default.invoke(
+            "what's your name",
+            config={
+                "configurable": {
+                    "foo_model": "anthropic:claude-sonnet-4-5-20250929",
+                    "foo_temperature": 0.6,
+                }
+            },
+        )
+        # Override default to use Sonnet 4.5 with temperature 0.6 to generate response
+        ```
 
-            configurable_model = init_chat_model(
-                "gpt-4o", configurable_fields=("model", "model_provider"), temperature=0
-            )
+    ??? example "Bind tools to a configurable model"
 
-            configurable_model_with_tools = configurable_model.bind_tools(
-                [GetWeather, GetPopulation]
-            )
-            configurable_model_with_tools.invoke(
-                "Which city is hotter today and which is bigger: LA or NY?"
-            )
-            # GPT-4o response with tool calls
+        You can call any chat model declarative methods on a configurable model in the
+        same way that you would with a normal model:
 
-            configurable_model_with_tools.invoke(
-                "Which city is hotter today and which is bigger: LA or NY?",
-                config={"configurable": {"model": "claude-3-5-sonnet-latest"}},
-            )
-            # Claude-3.5 sonnet response with tools
+        ```python
+        # pip install langchain langchain-openai langchain-anthropic
+
+        from langchain.chat_models import init_chat_model
+        from pydantic import BaseModel, Field
 
-    !!! version-added "Added in version 0.2.7"
 
-    !!! warning "Behavior changed in 0.2.8"
-        Support for ``configurable_fields`` and ``config_prefix`` added.
+        class GetWeather(BaseModel):
+            '''Get the current weather in a given location'''
 
-    !!! warning "Behavior changed in 0.2.12"
-        Support for Ollama via langchain-ollama package added
-        (langchain_ollama.ChatOllama). Previously,
-        the now-deprecated langchain-community version of Ollama was imported
-        (langchain_community.chat_models.ChatOllama).
+            location: str = Field(..., description="The city and state, e.g. San Francisco, CA")
 
-        Support for AWS Bedrock models via the Converse API added
-        (model_provider="bedrock_converse").
 
-    !!! warning "Behavior changed in 0.3.5"
-        Out of beta.
+        class GetPopulation(BaseModel):
+            '''Get the current population in a given location'''
 
-    !!! warning "Behavior changed in 0.3.19"
-        Support for Deepseek, IBM, Nvidia, and xAI models added.
+            location: str = Field(..., description="The city and state, e.g. San Francisco, CA")
+
+
+        configurable_model = init_chat_model(
+            "gpt-4o", configurable_fields=("model", "model_provider"), temperature=0
+        )
+
+        configurable_model_with_tools = configurable_model.bind_tools(
+            [
+                GetWeather,
+                GetPopulation,
+            ]
+        )
+        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-20250929"}},
+        )
+        # Use Sonnet 4.5
+        ```
 
     """  # noqa: E501
     if not model and not configurable_fields:
@@ -626,11 +631,8 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
 
     @property
     def InputType(self) -> TypeAlias:
-        """Get the input type for this runnable."""
-        from langchain_core.prompt_values import (
-            ChatPromptValueConcrete,
-            StringPromptValue,
-        )
+        """Get the input type for this `Runnable`."""
+        from langchain_core.prompt_values import ChatPromptValueConcrete, StringPromptValue
 
         # This is a version of LanguageModelInput which replaces the abstract
         # base class BaseMessage with a union of its subclasses, which makes