langchain 1.0.0a11__py3-none-any.whl → 1.0.0a13__py3-none-any.whl

langchain/chat_models/base.py

@@ -32,7 +32,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 +40,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: ...
@@ -73,8 +73,9 @@ def init_chat_model(
 ) -> BaseChatModel | _ConfigurableModel:
     """Initialize a ChatModel from the model name and provider.
 
-    **Note:** Must have the integration package corresponding to the model provider
-    installed.
+    !!! note
+        Must have the integration package corresponding to the model provider
+        installed.
 
     Args:
         model: The name of the model, e.g. "o3-mini", "claude-3-5-sonnet-latest". You can
@@ -128,21 +129,21 @@ def init_chat_model(
 
             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")``.
+            not specified, then defaults to `("model", "model_provider")`.
 
-            ***Security Note***: Setting ``configurable_fields="any"`` means fields like
+            **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.
+            `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["configurable"]["{config_prefix}_{param}"]` keys. If
             config_prefix is an empty string then model will be configurable via
-            ``config["configurable"]["{param}"]``.
+            `config["configurable"]["{param}"]`.
         kwargs: Additional model-specific keyword args to pass to
-            ``<<selected ChatModel>>.__init__(model=model_name, **kwargs)``. Examples
+            `<<selected ChatModel>>.__init__(model=model_name, **kwargs)`. Examples
             include:
                 * temperature: Model temperature.
                 * max_tokens: Max output tokens.
@@ -151,7 +152,7 @@ def init_chat_model(
                 * 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_limiter: A `BaseRateLimiter` to space out requests to avoid exceeding
                     rate limits.
 
     Returns:
@@ -163,117 +164,111 @@ 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 "Init non-configurable model"
-        :open:
+    ???+ note "Init non-configurable model"
 
-        .. code-block:: python
+        ```python
+        # pip install langchain langchain-openai langchain-anthropic langchain-google-vertexai
+        from langchain.chat_models import init_chat_model
 
-            # 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-3-5-sonnet-latest", temperature=0)
-            gemini_2_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")
+        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)
 
+        o3_mini.invoke("what's your name")
+        claude_sonnet.invoke("what's your name")
+        gemini_2_flash.invoke("what's your name")
+        ```
 
     ??? note "Partially configurable model with no default"
 
-        .. code-block:: python
+        ```python
+        # pip install langchain langchain-openai langchain-anthropic
+        from langchain.chat_models import init_chat_model
 
-            # 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.
+        configurable_model = init_chat_model(temperature=0)
 
-            # 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
 
-            configurable_model.invoke(
-                "what's your name", config={"configurable": {"model": "gpt-4o"}}
-            )
-            # GPT-4o response
-
-            configurable_model.invoke(
-                "what's your name", config={"configurable": {"model": "claude-3-5-sonnet-latest"}}
-            )
-            # claude-3.5 sonnet response
+        configurable_model.invoke(
+            "what's your name", config={"configurable": {"model": "claude-3-5-sonnet-latest"}}
+        )
+        # claude-3.5 sonnet response
+        ```
 
     ??? note "Fully configurable model with a default"
 
-        .. code-block:: python
-
-            # pip install langchain langchain-openai langchain-anthropic
-            from langchain.chat_models import init_chat_model
+        ```python
+        # pip install langchain langchain-openai langchain-anthropic
+        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,
-            )
+        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
-
-            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
+        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
+        ```
 
     ??? note "Bind tools to a configurable model"
 
         You can call any ChatModel declarative methods on a configurable model in the
         same way that you would with a normal model.
 
-        .. code-block:: python
-
-            # pip install langchain langchain-openai langchain-anthropic
-            from langchain.chat_models import init_chat_model
-            from pydantic import BaseModel, Field
+        ```python
+        # pip install langchain langchain-openai langchain-anthropic
+        from langchain.chat_models import init_chat_model
+        from pydantic import BaseModel, Field
 
 
-            class GetWeather(BaseModel):
-                '''Get the current weather in a given location'''
+        class GetWeather(BaseModel):
+            '''Get the current weather in a given location'''
 
-                location: str = Field(..., description="The city and state, e.g. San Francisco, CA")
+            location: str = Field(..., description="The city and state, e.g. San Francisco, CA")
 
 
-            class GetPopulation(BaseModel):
-                '''Get the current population in a given location'''
+        class GetPopulation(BaseModel):
+            '''Get the current population in a given location'''
 
-                location: str = Field(..., description="The city and state, e.g. San Francisco, CA")
+            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 = 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?"
-            )
-            # GPT-4o response with tool calls
+        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
 
-            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
+        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
+        ```
 
     !!! version-added "Added in version 0.2.7"
 
     !!! warning "Behavior changed in 0.2.8"
-        Support for ``configurable_fields`` and ``config_prefix`` added.
+        Support for `configurable_fields` and `config_prefix` added.
 
     !!! warning "Behavior changed in 0.2.12"
         Support for Ollama via langchain-ollama package added
@@ -626,7 +621,7 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
 
     @property
     def InputType(self) -> TypeAlias:
-        """Get the input type for this runnable."""
+        """Get the input type for this `Runnable`."""
         from langchain_core.prompt_values import (
             ChatPromptValueConcrete,
             StringPromptValue,

langchain/embeddings/base.py

@@ -35,13 +35,13 @@ def _parse_model_string(model_name: str) -> tuple[str, str]:
     Returns:
         A tuple of (provider, model_name)
 
-    .. code-block:: python
+    ```python
+    _parse_model_string("openai:text-embedding-3-small")
+    # Returns: ("openai", "text-embedding-3-small")
 
-        _parse_model_string("openai:text-embedding-3-small")
-        # Returns: ("openai", "text-embedding-3-small")
-
-        _parse_model_string("bedrock:amazon.titan-embed-text-v1")
-        # Returns: ("bedrock", "amazon.titan-embed-text-v1")
+    _parse_model_string("bedrock:amazon.titan-embed-text-v1")
+    # Returns: ("bedrock", "amazon.titan-embed-text-v1")
+    ```
 
     Raises:
         ValueError: If the model string is not in the correct format or
@@ -128,8 +128,9 @@ def init_embeddings(
 ) -> Embeddings:
     """Initialize an embeddings model from a model name and optional provider.
 
-    **Note:** Must have the integration package corresponding to the model provider
-    installed.
+    !!! note
+        Must have the integration package corresponding to the model provider
+        installed.
 
     Args:
         model: Name of the model to use. Can be either:
@@ -151,21 +152,20 @@ def init_embeddings(
         ValueError: If the model provider is not supported or cannot be determined
         ImportError: If the required provider package is not installed
 
-    ??? note "Example Usage"
-        :open:
-
-        .. code-block:: python
+    ???+ note "Example Usage"
 
-            # Using a model string
-            model = init_embeddings("openai:text-embedding-3-small")
-            model.embed_query("Hello, world!")
+        ```python
+        # Using a model string
+        model = init_embeddings("openai:text-embedding-3-small")
+        model.embed_query("Hello, world!")
 
-            # Using explicit provider
-            model = init_embeddings(model="text-embedding-3-small", provider="openai")
-            model.embed_documents(["Hello, world!", "Goodbye, world!"])
+        # Using explicit provider
+        model = init_embeddings(model="text-embedding-3-small", provider="openai")
+        model.embed_documents(["Hello, world!", "Goodbye, world!"])
 
-            # With additional parameters
-            model = init_embeddings("openai:text-embedding-3-small", api_key="sk-...")
+        # With additional parameters
+        model = init_embeddings("openai:text-embedding-3-small", api_key="sk-...")
+        ```
 
     !!! version-added "Added in version 0.3.9"
 

langchain/embeddings/cache.py

@@ -49,10 +49,10 @@ def _make_default_key_encoder(namespace: str, algorithm: str) -> Callable[[str],
     Args:
         namespace: Prefix that segregates keys from different embedding models.
         algorithm:
-           * ``'sha1'`` - fast but not collision-resistant
-           * ``'blake2b'`` - cryptographically strong, faster than SHA-1
-           * ``'sha256'`` - cryptographically strong, slower than SHA-1
-           * ``'sha512'`` - cryptographically strong, slower than SHA-1
+           * `'sha1'` - fast but not collision-resistant
+           * `'blake2b'` - cryptographically strong, faster than SHA-1
+           * `'sha256'` - cryptographically strong, slower than SHA-1
+           * `'sha512'` - cryptographically strong, slower than SHA-1
 
     Returns:
         A function that encodes a key using the specified algorithm.
@@ -122,24 +122,24 @@ class CacheBackedEmbeddings(Embeddings):
     embeddings too, pass in a query_embedding_store to constructor.
 
     Examples:
-        .. code-block: python
+        ```python
+        from langchain.embeddings import CacheBackedEmbeddings
+        from langchain.storage import LocalFileStore
+        from langchain_community.embeddings import OpenAIEmbeddings
 
-            from langchain.embeddings import CacheBackedEmbeddings
-            from langchain.storage import LocalFileStore
-            from langchain_community.embeddings import OpenAIEmbeddings
+        store = LocalFileStore("./my_cache")
 
-            store = LocalFileStore('./my_cache')
-
-            underlying_embedder = OpenAIEmbeddings()
-            embedder = CacheBackedEmbeddings.from_bytes_store(
-                underlying_embedder, store, namespace=underlying_embedder.model
-            )
+        underlying_embedder = OpenAIEmbeddings()
+        embedder = CacheBackedEmbeddings.from_bytes_store(
+            underlying_embedder, store, namespace=underlying_embedder.model
+        )
 
-            # Embedding is computed and cached
-            embeddings = embedder.embed_documents(["hello", "goodbye"])
+        # Embedding is computed and cached
+        embeddings = embedder.embed_documents(["hello", "goodbye"])
 
-            # Embeddings are retrieved from the cache, no computation is done
-            embeddings = embedder.embed_documents(["hello", "goodbye"])
+        # Embeddings are retrieved from the cache, no computation is done
+        embeddings = embedder.embed_documents(["hello", "goodbye"])
+        ```
     """
 
     def __init__(
@@ -157,7 +157,7 @@ class CacheBackedEmbeddings(Embeddings):
             document_embedding_store: The store to use for caching document embeddings.
             batch_size: The number of documents to embed between store updates.
             query_embedding_store: The store to use for caching query embeddings.
-                If ``None``, query embeddings are not cached.
+                If `None`, query embeddings are not cached.
         """
         super().__init__()
         self.document_embedding_store = document_embedding_store
@@ -235,7 +235,7 @@ class CacheBackedEmbeddings(Embeddings):
         """Embed query text.
 
         By default, this method does not cache queries. To enable caching, set the
-        ``cache_query`` parameter to ``True`` when initializing the embedder.
+        `cache_query` parameter to `True` when initializing the embedder.
 
         Args:
             text: The text to embed.
@@ -258,7 +258,7 @@ class CacheBackedEmbeddings(Embeddings):
         """Embed query text.
 
         By default, this method does not cache queries. To enable caching, set the
-        ``cache_query`` parameter to ``True`` when initializing the embedder.
+        `cache_query` parameter to `True` when initializing the embedder.
 
         Args:
             text: The text to embed.

langchain/messages/__init__.py

@@ -7,6 +7,7 @@ from langchain_core.messages import (
     HumanMessage,
     InvalidToolCall,
     MessageLikeRepresentation,
+    RemoveMessage,
     SystemMessage,
     ToolCall,
     ToolCallChunk,
@@ -21,6 +22,7 @@ __all__ = [
     "HumanMessage",
     "InvalidToolCall",
     "MessageLikeRepresentation",
+    "RemoveMessage",
     "SystemMessage",
     "ToolCall",
     "ToolCallChunk",

langchain/storage/encoder_backed.py

@@ -17,39 +17,38 @@ class EncoderBackedStore(BaseStore[K, V]):
 
     Examples that uses JSON for encoding/decoding:
 
-    .. code-block:: python
+    ```python
+    import json
 
-        import json
 
+    def key_encoder(key: int) -> str:
+        return json.dumps(key)
 
-        def key_encoder(key: int) -> str:
-            return json.dumps(key)
 
+    def value_serializer(value: float) -> str:
+        return json.dumps(value)
 
-        def value_serializer(value: float) -> str:
-            return json.dumps(value)
 
+    def value_deserializer(serialized_value: str) -> float:
+        return json.loads(serialized_value)
 
-        def value_deserializer(serialized_value: str) -> float:
-            return json.loads(serialized_value)
 
+    # Create an instance of the abstract store
+    abstract_store = MyCustomStore()
 
-        # Create an instance of the abstract store
-        abstract_store = MyCustomStore()
-
-        # Create an instance of the encoder-backed store
-        store = EncoderBackedStore(
-            store=abstract_store,
-            key_encoder=key_encoder,
-            value_serializer=value_serializer,
-            value_deserializer=value_deserializer,
-        )
-
-        # Use the encoder-backed store methods
-        store.mset([(1, 3.14), (2, 2.718)])
-        values = store.mget([1, 2])  # Retrieves [3.14, 2.718]
-        store.mdelete([1, 2])  # Deletes the keys 1 and 2
+    # Create an instance of the encoder-backed store
+    store = EncoderBackedStore(
+        store=abstract_store,
+        key_encoder=key_encoder,
+        value_serializer=value_serializer,
+        value_deserializer=value_deserializer,
+    )
 
+    # Use the encoder-backed store methods
+    store.mset([(1, 3.14), (2, 2.718)])
+    values = store.mget([1, 2])  # Retrieves [3.14, 2.718]
+    store.mdelete([1, 2])  # Deletes the keys 1 and 2
+    ```
     """
 
     def __init__(