langchain 1.0.4__py3-none-any.whl → 1.2.3__py3-none-any.whl

langchain/agents/structured_output.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import json
 import uuid
 from dataclasses import dataclass, is_dataclass
 from types import UnionType
@@ -128,7 +129,7 @@ class _SchemaSpec(Generic[SchemaT]):
     json_schema: dict[str, Any]
     """JSON schema associated with the schema."""
 
-    strict: bool = False
+    strict: bool | None = None
     """Whether to enforce strict validation of the schema."""
 
     def __init__(
@@ -137,7 +138,7 @@ class _SchemaSpec(Generic[SchemaT]):
         *,
         name: str | None = None,
         description: str | None = None,
-        strict: bool = False,
+        strict: bool | None = None,
     ) -> None:
         """Initialize SchemaSpec with schema and optional parameters."""
         self.schema = schema
@@ -227,7 +228,7 @@ class ToolStrategy(Generic[SchemaT]):
 
         def _iter_variants(schema: Any) -> Iterable[Any]:
             """Yield leaf variants from Union and JSON Schema oneOf."""
-            if get_origin(schema) in (UnionType, Union):
+            if get_origin(schema) in {UnionType, Union}:
                 for arg in get_args(schema):
                     yield from _iter_variants(arg)
                 return
@@ -255,21 +256,32 @@ class ProviderStrategy(Generic[SchemaT]):
     def __init__(
         self,
         schema: type[SchemaT],
+        *,
+        strict: bool | None = None,
     ) -> None:
-        """Initialize ProviderStrategy with schema."""
+        """Initialize ProviderStrategy with schema.
+
+        Args:
+            schema: Schema to enforce via the provider's native structured output.
+            strict: Whether to request strict provider-side schema enforcement.
+        """
         self.schema = schema
-        self.schema_spec = _SchemaSpec(schema)
+        self.schema_spec = _SchemaSpec(schema, strict=strict)
 
     def to_model_kwargs(self) -> dict[str, Any]:
         """Convert to kwargs to bind to a model to force structured output."""
         # OpenAI:
         # - see https://platform.openai.com/docs/guides/structured-outputs
-        response_format = {
+        json_schema: dict[str, Any] = {
+            "name": self.schema_spec.name,
+            "schema": self.schema_spec.json_schema,
+        }
+        if self.schema_spec.strict:
+            json_schema["strict"] = True
+
+        response_format: dict[str, Any] = {
             "type": "json_schema",
-            "json_schema": {
-                "name": self.schema_spec.name,
-                "schema": self.schema_spec.json_schema,
-            },
+            "json_schema": json_schema,
         }
         return {"response_format": response_format}
 
@@ -374,8 +386,6 @@ class ProviderStrategyBinding(Generic[SchemaT]):
         # Extract text content from AIMessage and parse as JSON
         raw_text = self._extract_text_content_from_message(response)
 
-        import json
-
         try:
             data = json.loads(raw_text)
         except Exception as e:

langchain/chat_models/__init__.py

@@ -1,10 +1,4 @@
-"""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
+"""Entrypoint to using [chat models](https://docs.langchain.com/oss/python/langchain/models) in LangChain."""  # noqa: E501
 
 from langchain_core.language_models import BaseChatModel
 

langchain/chat_models/base.py

@@ -2,17 +2,27 @@
 
 from __future__ import annotations
 
+import functools
+import importlib
 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
+from langchain_core.prompt_values import ChatPromptValueConcrete, StringPromptValue
 from langchain_core.runnables import Runnable, RunnableConfig, ensure_config
 from typing_extensions import override
 
 if TYPE_CHECKING:
     from collections.abc import AsyncIterator, Callable, Iterator, Sequence
+    from types import ModuleType
 
     from langchain_core.runnables.schema import StreamEvent
     from langchain_core.tools import BaseTool
@@ -20,6 +30,127 @@ if TYPE_CHECKING:
     from pydantic import BaseModel
 
 
+def _call(cls: type[BaseChatModel], **kwargs: Any) -> BaseChatModel:
+    # TODO: replace with operator.call when lower bounding to Python 3.11
+    return cls(**kwargs)
+
+
+_SUPPORTED_PROVIDERS: dict[str, tuple[str, str, Callable[..., BaseChatModel]]] = {
+    "anthropic": ("langchain_anthropic", "ChatAnthropic", _call),
+    "azure_ai": ("langchain_azure_ai.chat_models", "AzureAIChatCompletionsModel", _call),
+    "azure_openai": ("langchain_openai", "AzureChatOpenAI", _call),
+    "bedrock": ("langchain_aws", "ChatBedrock", _call),
+    "bedrock_converse": ("langchain_aws", "ChatBedrockConverse", _call),
+    "cohere": ("langchain_cohere", "ChatCohere", _call),
+    "deepseek": ("langchain_deepseek", "ChatDeepSeek", _call),
+    "fireworks": ("langchain_fireworks", "ChatFireworks", _call),
+    "google_anthropic_vertex": (
+        "langchain_google_vertexai.model_garden",
+        "ChatAnthropicVertex",
+        _call,
+    ),
+    "google_genai": ("langchain_google_genai", "ChatGoogleGenerativeAI", _call),
+    "google_vertexai": ("langchain_google_vertexai", "ChatVertexAI", _call),
+    "groq": ("langchain_groq", "ChatGroq", _call),
+    "huggingface": (
+        "langchain_huggingface",
+        "ChatHuggingFace",
+        lambda cls, model, **kwargs: cls.from_model_id(model_id=model, **kwargs),
+    ),
+    "ibm": (
+        "langchain_ibm",
+        "ChatWatsonx",
+        lambda cls, model, **kwargs: cls(model_id=model, **kwargs),
+    ),
+    "mistralai": ("langchain_mistralai", "ChatMistralAI", _call),
+    "nvidia": ("langchain_nvidia_ai_endpoints", "ChatNVIDIA", _call),
+    "ollama": ("langchain_ollama", "ChatOllama", _call),
+    "openai": ("langchain_openai", "ChatOpenAI", _call),
+    "perplexity": ("langchain_perplexity", "ChatPerplexity", _call),
+    "together": ("langchain_together", "ChatTogether", _call),
+    "upstage": ("langchain_upstage", "ChatUpstage", _call),
+    "xai": ("langchain_xai", "ChatXAI", _call),
+}
+"""Registry mapping provider names to their import configuration.
+
+Each entry maps a provider key to a tuple of:
+
+- `module_path`: The Python module path containing the chat model class.
+
+    This may be a submodule (e.g., `'langchain_azure_ai.chat_models'`) if the class is
+    not exported from the package root.
+- `class_name`: The name of the chat model class to import.
+- `creator_func`: A callable that instantiates the class with provided kwargs.
+"""
+
+
+def _import_module(module: str) -> ModuleType:
+    """Import a module by name.
+
+    Args:
+        module: The fully qualified module name to import (e.g., `'langchain_openai'`).
+
+    Returns:
+        The imported module.
+
+    Raises:
+        ImportError: If the module cannot be imported, with a message suggesting
+            the pip package to install.
+    """
+    try:
+        return importlib.import_module(module)
+    except ImportError as e:
+        # Extract package name from module path (e.g., "langchain_azure_ai.chat_models"
+        # becomes "langchain-azure-ai")
+        pkg = module.split(".", maxsplit=1)[0].replace("_", "-")
+        msg = f"Could not import {pkg} python package. Please install it with `pip install {pkg}`"
+        raise ImportError(msg) from e
+
+
+@functools.lru_cache(maxsize=len(_SUPPORTED_PROVIDERS))
+def _get_chat_model_creator(
+    provider: str,
+) -> Callable[..., BaseChatModel]:
+    """Return a factory function that creates a chat model for the given provider.
+
+    This function is cached to avoid repeated module imports.
+
+    Args:
+        provider: The name of the model provider (e.g., `'openai'`, `'anthropic'`).
+
+            Must be a key in `_SUPPORTED_PROVIDERS`.
+
+    Returns:
+        A callable that accepts model kwargs and returns a `BaseChatModel` instance for
+            the specified provider.
+
+    Raises:
+        ValueError: If the provider is not in `_SUPPORTED_PROVIDERS`.
+        ImportError: If the provider's integration package is not installed.
+    """
+    if provider not in _SUPPORTED_PROVIDERS:
+        supported = ", ".join(_SUPPORTED_PROVIDERS.keys())
+        msg = f"Unsupported {provider=}.\n\nSupported model providers are: {supported}"
+        raise ValueError(msg)
+
+    pkg, class_name, creator_func = _SUPPORTED_PROVIDERS[provider]
+    try:
+        module = _import_module(pkg)
+    except ImportError as e:
+        if provider != "ollama":
+            raise
+        # For backwards compatibility
+        try:
+            module = _import_module("langchain_community.chat_models")
+        except ImportError:
+            # If both langchain-ollama and langchain-community aren't available,
+            # raise an error related to langchain-ollama
+            raise e from None
+
+    cls = getattr(module, class_name)
+    return functools.partial(creator_func, cls=cls)
+
+
 @overload
 def init_chat_model(
     model: str,
@@ -73,7 +204,7 @@ def init_chat_model(
         runtime via `config`. Makes it easy to switch between models/providers without
         changing your code
 
-    !!! note
+    !!! note "Installation requirements"
         Requires the integration package for the chosen model provider to be installed.
 
         See the `model_provider` parameter below for specific package names
@@ -83,10 +214,23 @@ def init_chat_model(
         for supported model parameters to use as `**kwargs`.
 
     Args:
-        model: The name or ID of the model, e.g. `'o3-mini'`, `'claude-sonnet-4-5-20250929'`.
+        model: The model name, optionally prefixed with provider (e.g., `'openai:gpt-4o'`).
+
+            Will attempt to infer `model_provider` from model if not specified.
+
+            The following providers will be inferred based on these model prefixes:
 
-            You can also specify model and model provider in a single argument using
-            `'{model_provider}:{model}'` format, e.g. `'openai:o1'`.
+            - `gpt-...` | `o1...` | `o3...`       -> `openai`
+            - `claude...`                         -> `anthropic`
+            - `amazon...`                         -> `bedrock`
+            - `gemini...`                         -> `google_vertexai`
+            - `command...`                        -> `cohere`
+            - `accounts/fireworks...`             -> `fireworks`
+            - `mistral...`                        -> `mistralai`
+            - `deepseek...`                       -> `deepseek`
+            - `grok...`                           -> `xai`
+            - `sonar...`                          -> `perplexity`
+            - `solar...`                          -> `upstage`
         model_provider: The model provider if not specified as part of the model arg
             (see above).
 
@@ -110,24 +254,12 @@ def init_chat_model(
             - `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)
+            - `ibm`                     -> [`langchain-ibm`](https://docs.langchain.com/oss/python/integrations/providers/ibm)
             - `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)
+            - `upstage`                 -> [`langchain-upstage`](https://docs.langchain.com/oss/python/integrations/providers/upstage)
 
-            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 at runtime:
 
             - `None`: No configurable fields (i.e., a fixed model).
@@ -142,6 +274,7 @@ def init_chat_model(
             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.
@@ -331,195 +464,108 @@ def _init_chat_model_helper(
     **kwargs: Any,
 ) -> BaseChatModel:
     model, model_provider = _parse_model(model, model_provider)
-    if model_provider == "openai":
-        _check_pkg("langchain_openai")
-        from langchain_openai import ChatOpenAI
-
-        return ChatOpenAI(model=model, **kwargs)
-    if model_provider == "anthropic":
-        _check_pkg("langchain_anthropic")
-        from langchain_anthropic import ChatAnthropic
-
-        return ChatAnthropic(model=model, **kwargs)  # type: ignore[call-arg,unused-ignore]
-    if model_provider == "azure_openai":
-        _check_pkg("langchain_openai")
-        from langchain_openai import AzureChatOpenAI
-
-        return AzureChatOpenAI(model=model, **kwargs)
-    if model_provider == "azure_ai":
-        _check_pkg("langchain_azure_ai")
-        from langchain_azure_ai.chat_models import AzureAIChatCompletionsModel
-
-        return AzureAIChatCompletionsModel(model=model, **kwargs)
-    if model_provider == "cohere":
-        _check_pkg("langchain_cohere")
-        from langchain_cohere import ChatCohere
-
-        return ChatCohere(model=model, **kwargs)
-    if model_provider == "google_vertexai":
-        _check_pkg("langchain_google_vertexai")
-        from langchain_google_vertexai import ChatVertexAI
-
-        return ChatVertexAI(model=model, **kwargs)
-    if model_provider == "google_genai":
-        _check_pkg("langchain_google_genai")
-        from langchain_google_genai import ChatGoogleGenerativeAI
-
-        return ChatGoogleGenerativeAI(model=model, **kwargs)
-    if model_provider == "fireworks":
-        _check_pkg("langchain_fireworks")
-        from langchain_fireworks import ChatFireworks
-
-        return ChatFireworks(model=model, **kwargs)
-    if model_provider == "ollama":
-        try:
-            _check_pkg("langchain_ollama")
-            from langchain_ollama import ChatOllama
-        except ImportError:
-            # For backwards compatibility
-            try:
-                _check_pkg("langchain_community")
-                from langchain_community.chat_models import ChatOllama
-            except ImportError:
-                # If both langchain-ollama and langchain-community aren't available,
-                # raise an error related to langchain-ollama
-                _check_pkg("langchain_ollama")
-
-        return ChatOllama(model=model, **kwargs)
-    if model_provider == "together":
-        _check_pkg("langchain_together")
-        from langchain_together import ChatTogether
-
-        return ChatTogether(model=model, **kwargs)
-    if model_provider == "mistralai":
-        _check_pkg("langchain_mistralai")
-        from langchain_mistralai import ChatMistralAI
-
-        return ChatMistralAI(model=model, **kwargs)  # type: ignore[call-arg,unused-ignore]
-    if model_provider == "huggingface":
-        _check_pkg("langchain_huggingface")
-        from langchain_huggingface import ChatHuggingFace
-
-        return ChatHuggingFace(model_id=model, **kwargs)
-    if model_provider == "groq":
-        _check_pkg("langchain_groq")
-        from langchain_groq import ChatGroq
-
-        return ChatGroq(model=model, **kwargs)
-    if model_provider == "bedrock":
-        _check_pkg("langchain_aws")
-        from langchain_aws import ChatBedrock
-
-        return ChatBedrock(model_id=model, **kwargs)
-    if model_provider == "bedrock_converse":
-        _check_pkg("langchain_aws")
-        from langchain_aws import ChatBedrockConverse
-
-        return ChatBedrockConverse(model=model, **kwargs)
-    if model_provider == "google_anthropic_vertex":
-        _check_pkg("langchain_google_vertexai")
-        from langchain_google_vertexai.model_garden import ChatAnthropicVertex
-
-        return ChatAnthropicVertex(model=model, **kwargs)
-    if model_provider == "deepseek":
-        _check_pkg("langchain_deepseek", pkg_kebab="langchain-deepseek")
-        from langchain_deepseek import ChatDeepSeek
-
-        return ChatDeepSeek(model=model, **kwargs)
-    if model_provider == "nvidia":
-        _check_pkg("langchain_nvidia_ai_endpoints")
-        from langchain_nvidia_ai_endpoints import ChatNVIDIA
-
-        return ChatNVIDIA(model=model, **kwargs)
-    if model_provider == "ibm":
-        _check_pkg("langchain_ibm")
-        from langchain_ibm import ChatWatsonx
-
-        return ChatWatsonx(model_id=model, **kwargs)
-    if model_provider == "xai":
-        _check_pkg("langchain_xai")
-        from langchain_xai import ChatXAI
-
-        return ChatXAI(model=model, **kwargs)
-    if model_provider == "perplexity":
-        _check_pkg("langchain_perplexity")
-        from langchain_perplexity import ChatPerplexity
-
-        return ChatPerplexity(model=model, **kwargs)
-    supported = ", ".join(_SUPPORTED_PROVIDERS)
-    msg = f"Unsupported {model_provider=}.\n\nSupported model providers are: {supported}"
-    raise ValueError(msg)
-
-
-_SUPPORTED_PROVIDERS = {
-    "openai",
-    "anthropic",
-    "azure_openai",
-    "azure_ai",
-    "cohere",
-    "google_vertexai",
-    "google_genai",
-    "fireworks",
-    "ollama",
-    "together",
-    "mistralai",
-    "huggingface",
-    "groq",
-    "bedrock",
-    "bedrock_converse",
-    "google_anthropic_vertex",
-    "deepseek",
-    "ibm",
-    "xai",
-    "perplexity",
-}
+    creator_func = _get_chat_model_creator(model_provider)
+    return creator_func(model=model, **kwargs)
 
 
 def _attempt_infer_model_provider(model_name: str) -> str | None:
-    if any(model_name.startswith(pre) for pre in ("gpt-", "o1", "o3")):
+    """Attempt to infer model provider from model name.
+
+    Args:
+        model_name: The name of the model to infer provider for.
+
+    Returns:
+        The inferred provider name, or `None` if no provider could be inferred.
+    """
+    model_lower = model_name.lower()
+
+    # OpenAI models (including newer models and aliases)
+    if any(
+        model_lower.startswith(pre)
+        for pre in (
+            "gpt-",
+            "o1",
+            "o3",
+            "chatgpt",
+            "text-davinci",
+        )
+    ):
         return "openai"
-    if model_name.startswith("claude"):
+
+    # Anthropic models
+    if model_lower.startswith("claude"):
         return "anthropic"
-    if model_name.startswith("command"):
+
+    # Cohere models
+    if model_lower.startswith("command"):
         return "cohere"
+
+    # Fireworks models
     if model_name.startswith("accounts/fireworks"):
         return "fireworks"
-    if model_name.startswith("gemini"):
+
+    # Google models
+    if model_lower.startswith("gemini"):
         return "google_vertexai"
-    if model_name.startswith("amazon."):
+
+    # AWS Bedrock models
+    if model_name.startswith("amazon.") or model_lower.startswith(("anthropic.", "meta.")):
         return "bedrock"
-    if model_name.startswith("mistral"):
+
+    # Mistral models
+    if model_lower.startswith(("mistral", "mixtral")):
         return "mistralai"
-    if model_name.startswith("deepseek"):
+
+    # DeepSeek models
+    if model_lower.startswith("deepseek"):
         return "deepseek"
-    if model_name.startswith("grok"):
+
+    # xAI models
+    if model_lower.startswith("grok"):
         return "xai"
-    if model_name.startswith("sonar"):
+
+    # Perplexity models
+    if model_lower.startswith("sonar"):
         return "perplexity"
+
+    # Upstage models
+    if model_lower.startswith("solar"):
+        return "upstage"
+
     return None
 
 
 def _parse_model(model: str, model_provider: str | None) -> tuple[str, str]:
-    if not model_provider and ":" in model and model.split(":")[0] in _SUPPORTED_PROVIDERS:
-        model_provider = model.split(":")[0]
+    """Parse model name and provider, inferring provider if necessary."""
+    # Handle provider:model format
+    if (
+        not model_provider
+        and ":" in model
+        and model.split(":", maxsplit=1)[0] in _SUPPORTED_PROVIDERS
+    ):
+        model_provider = model.split(":", maxsplit=1)[0]
         model = ":".join(model.split(":")[1:])
+
+    # Attempt to infer provider if not specified
     model_provider = model_provider or _attempt_infer_model_provider(model)
+
     if not model_provider:
+        # Enhanced error message with suggestions
+        supported_list = ", ".join(sorted(_SUPPORTED_PROVIDERS))
         msg = (
-            f"Unable to infer model provider for {model=}, please specify model_provider directly."
+            f"Unable to infer model provider for {model=}. "
+            f"Please specify 'model_provider' directly.\n\n"
+            f"Supported providers: {supported_list}\n\n"
+            f"For help with specific providers, see: "
+            f"https://docs.langchain.com/oss/python/integrations/providers"
         )
         raise ValueError(msg)
+
+    # Normalize provider name
     model_provider = model_provider.replace("-", "_").lower()
     return model, model_provider
 
 
-def _check_pkg(pkg: str, *, pkg_kebab: str | None = None) -> None:
-    if not util.find_spec(pkg):
-        pkg_kebab = pkg_kebab if pkg_kebab is not None else pkg.replace("_", "-")
-        msg = f"Unable to import {pkg}. Please install with `pip install -U {pkg_kebab}`"
-        raise ImportError(msg)
-
-
 def _remove_prefix(s: str, prefix: str) -> str:
     return s.removeprefix(prefix)
 
@@ -538,7 +584,7 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
     ) -> None:
         self._default_config: dict = default_config or {}
         self._configurable_fields: Literal["any"] | list[str] = (
-            configurable_fields if configurable_fields == "any" else list(configurable_fields)
+            "any" if configurable_fields == "any" else list(configurable_fields)
         )
         self._config_prefix = (
             config_prefix + "_"
@@ -602,8 +648,10 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
         config: RunnableConfig | None = None,
         **kwargs: Any,
     ) -> _ConfigurableModel:
-        """Bind config to a Runnable, returning a new Runnable."""
+        """Bind config to a `Runnable`, returning a new `Runnable`."""
         config = RunnableConfig(**(config or {}), **cast("RunnableConfig", kwargs))
+        # Ensure config is not None after creation
+        config = ensure_config(config)
         model_params = self._model_params(config)
         remaining_config = {k: v for k, v in config.items() if k != "configurable"}
         remaining_config["configurable"] = {
@@ -630,10 +678,9 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
         )
 
     @property
+    @override
     def InputType(self) -> TypeAlias:
         """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
         # for a much better schema.
@@ -814,6 +861,7 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
             yield x
 
     @overload
+    @override
     def astream_log(
         self,
         input: Any,
@@ -831,6 +879,7 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
     ) -> AsyncIterator[RunLogPatch]: ...
 
     @overload
+    @override
     def astream_log(
         self,
         input: Any,

langchain/embeddings/__init__.py

@@ -1,10 +1,5 @@
 """Embeddings models.
 
-!!! warning "Reference docs"
-    This page contains **reference documentation** for Embeddings. See
-    [the docs](https://docs.langchain.com/oss/python/langchain/retrieval#embedding-models)
-    for conceptual guides, tutorials, and examples on using Embeddings.
-
 !!! warning "Modules moved"
     With the release of `langchain 1.0.0`, several embeddings modules were moved to
     `langchain-classic`, such as `CacheBackedEmbeddings` and all community