langchain 1.0.0a4__py3-none-any.whl → 1.0.0a6__py3-none-any.whl

langchain/agents/tool_node.py

@@ -23,10 +23,12 @@ Typical Usage:
     from langchain_core.tools import tool
     from langchain.agents import ToolNode
 
+
     @tool
     def my_tool(x: int) -> str:
         return f"Result: {x}"
 
+
     tool_node = ToolNode([my_tool])
     ```
 """
@@ -38,6 +40,7 @@ import inspect
 import json
 from copy import copy, deepcopy
 from dataclasses import replace
+from types import UnionType
 from typing import (
     TYPE_CHECKING,
     Annotated,
@@ -85,11 +88,19 @@ INVALID_TOOL_NAME_ERROR_TEMPLATE = (
     "Error: {requested_tool} is not a valid tool, try one of [{available_tools}]."
 )
 TOOL_CALL_ERROR_TEMPLATE = "Error: {error}\n Please fix your mistakes."
-TOOL_EXECUTION_ERROR_TEMPLATE = "Error executing tool '{tool_name}' with kwargs {tool_kwargs} with error:\n {error}\n Please fix the error and try again."
-TOOL_INVOCATION_ERROR_TEMPLATE = "Error invoking tool '{tool_name}' with kwargs {tool_kwargs} with error:\n {error}\n Please fix the error and try again."
+TOOL_EXECUTION_ERROR_TEMPLATE = (
+    "Error executing tool '{tool_name}' with kwargs {tool_kwargs} with error:\n"
+    " {error}\n"
+    " Please fix the error and try again."
+)
+TOOL_INVOCATION_ERROR_TEMPLATE = (
+    "Error invoking tool '{tool_name}' with kwargs {tool_kwargs} with error:\n"
+    " {error}\n"
+    " Please fix the error and try again."
+)
 
 
-def msg_content_output(output: Any) -> Union[str, list[dict]]:
+def msg_content_output(output: Any) -> str | list[dict]:
     """Convert tool output to valid message content format.
 
     LangChain ToolMessages accept either string content or a list of content blocks.
@@ -159,13 +170,7 @@ def _default_handle_tool_errors(e: Exception) -> str:
 def _handle_tool_error(
     e: Exception,
     *,
-    flag: Union[
-        bool,
-        str,
-        Callable[..., str],
-        type[Exception],
-        tuple[type[Exception], ...],
-    ],
+    flag: bool | str | Callable[..., str] | type[Exception] | tuple[type[Exception], ...],
 ) -> str:
     """Generate error message content based on exception handling configuration.
 
@@ -242,7 +247,7 @@ def _infer_handled_types(handler: Callable[..., str]) -> tuple[type[Exception],
         type_hints = get_type_hints(handler)
         if first_param.name in type_hints:
             origin = get_origin(first_param.annotation)
-            if origin is Union:
+            if origin in [Union, UnionType]:
                 args = get_args(first_param.annotation)
                 if all(issubclass(arg, Exception) for arg in args):
                     return tuple(args)
@@ -317,7 +322,8 @@ class ToolNode(RunnableCallable):
               error template containing the exception details.
             - **str**: Catch all errors and return a ToolMessage with this custom
               error message string.
-            - **type[Exception]**: Only catch exceptions with the specified type and return the default error message for it.
+            - **type[Exception]**: Only catch exceptions with the specified type and
+              return the default error message for it.
             - **tuple[type[Exception], ...]**: Only catch exceptions with the specified
               types and return default error messages for them.
             - **Callable[..., str]**: Catch exceptions matching the callable's signature
@@ -369,21 +375,24 @@ class ToolNode(RunnableCallable):
         def handle_errors(e: ValueError) -> str:
             return "Invalid input provided"
 
+
         tool_node = ToolNode([my_tool], handle_tool_errors=handle_errors)
         ```
-    """
+    """  # noqa: E501
 
     name: str = "tools"
 
     def __init__(
         self,
-        tools: Sequence[Union[BaseTool, Callable]],
+        tools: Sequence[BaseTool | Callable],
         *,
         name: str = "tools",
         tags: list[str] | None = None,
-        handle_tool_errors: Union[
-            bool, str, Callable[..., str], type[Exception], tuple[type[Exception], ...]
-        ] = _default_handle_tool_errors,
+        handle_tool_errors: bool
+        | str
+        | Callable[..., str]
+        | type[Exception]
+        | tuple[type[Exception], ...] = _default_handle_tool_errors,
         messages_key: str = "messages",
     ) -> None:
         """Initialize the ToolNode with the provided tools and configuration.
@@ -417,11 +426,7 @@ class ToolNode(RunnableCallable):
 
     def _func(
         self,
-        input: Union[
-            list[AnyMessage],
-            dict[str, Any],
-            BaseModel,
-        ],
+        input: list[AnyMessage] | dict[str, Any] | BaseModel,
         config: RunnableConfig,
         *,
         store: Optional[BaseStore],  # noqa: UP045
@@ -436,11 +441,7 @@ class ToolNode(RunnableCallable):
 
     async def _afunc(
         self,
-        input: Union[
-            list[AnyMessage],
-            dict[str, Any],
-            BaseModel,
-        ],
+        input: list[AnyMessage] | dict[str, Any] | BaseModel,
         config: RunnableConfig,
         *,
         store: Optional[BaseStore],  # noqa: UP045
@@ -454,9 +455,9 @@ class ToolNode(RunnableCallable):
 
     def _combine_tool_outputs(
         self,
-        outputs: list[Union[ToolMessage, Command]],
+        outputs: list[ToolMessage | Command],
         input_type: Literal["list", "dict", "tool_calls"],
-    ) -> list[Union[Command, list[ToolMessage], dict[str, list[ToolMessage]]]]:
+    ) -> list[Command | list[ToolMessage] | dict[str, list[ToolMessage]]]:
         # preserve existing behavior for non-command tool outputs for backwards
         # compatibility
         if not any(isinstance(output, Command) for output in outputs):
@@ -499,7 +500,7 @@ class ToolNode(RunnableCallable):
         call: ToolCall,
         input_type: Literal["list", "dict", "tool_calls"],
         config: RunnableConfig,
-    ) -> Union[ToolMessage, Command]:
+    ) -> ToolMessage | Command:
         """Run a single tool call synchronously."""
         if invalid_tool_message := self._validate_tool_call(call):
             return invalid_tool_message
@@ -515,10 +516,12 @@ class ToolNode(RunnableCallable):
 
         # GraphInterrupt is a special exception that will always be raised.
         # It can be triggered in the following scenarios,
-        # Where GraphInterrupt(GraphBubbleUp) is raised from an `interrupt` invocation most commonly:
+        # Where GraphInterrupt(GraphBubbleUp) is raised from an `interrupt` invocation
+        # most commonly:
         # (1) a GraphInterrupt is raised inside a tool
         # (2) a GraphInterrupt is raised inside a graph node for a graph called as a tool
-        # (3) a GraphInterrupt is raised when a subgraph is interrupted inside a graph called as a tool
+        # (3) a GraphInterrupt is raised when a subgraph is interrupted inside a graph
+        #     called as a tool
         # (2 and 3 can happen in a "supervisor w/ tools" multi-agent architecture)
         except GraphBubbleUp:
             raise
@@ -553,7 +556,7 @@ class ToolNode(RunnableCallable):
         if isinstance(response, Command):
             return self._validate_tool_command(response, call, input_type)
         if isinstance(response, ToolMessage):
-            response.content = cast("Union[str, list]", msg_content_output(response.content))
+            response.content = cast("str | list", msg_content_output(response.content))
             return response
         msg = f"Tool {call['name']} returned unexpected type: {type(response)}"
         raise TypeError(msg)
@@ -563,7 +566,7 @@ class ToolNode(RunnableCallable):
         call: ToolCall,
         input_type: Literal["list", "dict", "tool_calls"],
         config: RunnableConfig,
-    ) -> Union[ToolMessage, Command]:
+    ) -> ToolMessage | Command:
         """Run a single tool call asynchronously."""
         if invalid_tool_message := self._validate_tool_call(call):
             return invalid_tool_message
@@ -579,10 +582,12 @@ class ToolNode(RunnableCallable):
 
         # GraphInterrupt is a special exception that will always be raised.
         # It can be triggered in the following scenarios,
-        # Where GraphInterrupt(GraphBubbleUp) is raised from an `interrupt` invocation most commonly:
+        # Where GraphInterrupt(GraphBubbleUp) is raised from an `interrupt` invocation
+        # most commonly:
         # (1) a GraphInterrupt is raised inside a tool
         # (2) a GraphInterrupt is raised inside a graph node for a graph called as a tool
-        # (3) a GraphInterrupt is raised when a subgraph is interrupted inside a graph called as a tool
+        # (3) a GraphInterrupt is raised when a subgraph is interrupted inside a graph
+        #     called as a tool
         # (2 and 3 can happen in a "supervisor w/ tools" multi-agent architecture)
         except GraphBubbleUp:
             raise
@@ -618,18 +623,14 @@ class ToolNode(RunnableCallable):
         if isinstance(response, Command):
             return self._validate_tool_command(response, call, input_type)
         if isinstance(response, ToolMessage):
-            response.content = cast("Union[str, list]", msg_content_output(response.content))
+            response.content = cast("str | list", msg_content_output(response.content))
             return response
         msg = f"Tool {call['name']} returned unexpected type: {type(response)}"
         raise TypeError(msg)
 
     def _parse_input(
         self,
-        input: Union[
-            list[AnyMessage],
-            dict[str, Any],
-            BaseModel,
-        ],
+        input: list[AnyMessage] | dict[str, Any] | BaseModel,
         store: BaseStore | None,
     ) -> tuple[list[ToolCall], Literal["list", "dict", "tool_calls"]]:
         input_type: Literal["list", "dict", "tool_calls"]
@@ -676,11 +677,7 @@ class ToolNode(RunnableCallable):
     def _inject_state(
         self,
         tool_call: ToolCall,
-        input: Union[
-            list[AnyMessage],
-            dict[str, Any],
-            BaseModel,
-        ],
+        input: list[AnyMessage] | dict[str, Any] | BaseModel,
     ) -> ToolCall:
         state_args = self._tool_to_state_args[tool_call["name"]]
         if state_args and isinstance(input, list):
@@ -737,11 +734,7 @@ class ToolNode(RunnableCallable):
     def inject_tool_args(
         self,
         tool_call: ToolCall,
-        input: Union[
-            list[AnyMessage],
-            dict[str, Any],
-            BaseModel,
-        ],
+        input: list[AnyMessage] | dict[str, Any] | BaseModel,
         store: BaseStore | None,
     ) -> ToolCall:
         """Inject graph state and store into tool call arguments.
@@ -791,10 +784,12 @@ class ToolNode(RunnableCallable):
         input_type: Literal["list", "dict", "tool_calls"],
     ) -> Command:
         if isinstance(command.update, dict):
-            # input type is dict when ToolNode is invoked with a dict input (e.g. {"messages": [AIMessage(..., tool_calls=[...])]})
+            # input type is dict when ToolNode is invoked with a dict input
+            # (e.g. {"messages": [AIMessage(..., tool_calls=[...])]})
             if input_type not in ("dict", "tool_calls"):
                 msg = (
-                    f"Tools can provide a dict in Command.update only when using dict with '{self._messages_key}' key as ToolNode input, "
+                    "Tools can provide a dict in Command.update only when using dict "
+                    f"with '{self._messages_key}' key as ToolNode input, "
                     f"got: {command.update} for tool '{call['name']}'"
                 )
                 raise ValueError(msg)
@@ -803,10 +798,12 @@ class ToolNode(RunnableCallable):
             state_update = cast("dict[str, Any]", updated_command.update) or {}
             messages_update = state_update.get(self._messages_key, [])
         elif isinstance(command.update, list):
-            # Input type is list when ToolNode is invoked with a list input (e.g. [AIMessage(..., tool_calls=[...])])
+            # Input type is list when ToolNode is invoked with a list input
+            # (e.g. [AIMessage(..., tool_calls=[...])])
             if input_type != "list":
                 msg = (
-                    f"Tools can provide a list of messages in Command.update only when using list of messages as ToolNode input, "
+                    "Tools can provide a list of messages in Command.update "
+                    "only when using list of messages as ToolNode input, "
                     f"got: {command.update} for tool '{call['name']}'"
                 )
                 raise ValueError(msg)
@@ -836,13 +833,17 @@ class ToolNode(RunnableCallable):
         # Command.update if command is sent to the CURRENT graph
         if updated_command.graph is None and not has_matching_tool_message:
             example_update = (
-                '`Command(update={"messages": [ToolMessage("Success", tool_call_id=tool_call_id), ...]}, ...)`'
+                '`Command(update={"messages": '
+                '[ToolMessage("Success", tool_call_id=tool_call_id), ...]}, ...)`'
                 if input_type == "dict"
-                else '`Command(update=[ToolMessage("Success", tool_call_id=tool_call_id), ...], ...)`'
+                else "`Command(update="
+                '[ToolMessage("Success", tool_call_id=tool_call_id), ...], ...)`'
             )
             msg = (
-                f"Expected to have a matching ToolMessage in Command.update for tool '{call['name']}', got: {messages_update}. "
-                "Every tool call (LLM requesting to call a tool) in the message history MUST have a corresponding ToolMessage. "
+                "Expected to have a matching ToolMessage in Command.update "
+                f"for tool '{call['name']}', got: {messages_update}. "
+                "Every tool call (LLM requesting to call a tool) "
+                "in the message history MUST have a corresponding ToolMessage. "
                 f"You can fix it by modifying the tool to return {example_update}."
             )
             raise ValueError(msg)
@@ -850,7 +851,7 @@ class ToolNode(RunnableCallable):
 
 
 def tools_condition(
-    state: Union[list[AnyMessage], dict[str, Any], BaseModel],
+    state: list[AnyMessage] | dict[str, Any] | BaseModel,
     messages_key: str = "messages",
 ) -> Literal["tools", "__end__"]:
     """Conditional routing function for tool-calling workflows.
@@ -887,16 +888,18 @@ def tools_condition(
         from langgraph.agents.tool_node import ToolNode, tools_condition
         from typing_extensions import TypedDict
 
+
         class State(TypedDict):
             messages: list
 
+
         graph = StateGraph(State)
         graph.add_node("llm", call_model)
         graph.add_node("tools", ToolNode([my_tool]))
         graph.add_conditional_edges(
             "llm",
             tools_condition,  # Routes to "tools" or "__end__"
-            {"tools": "tools", "__end__": "__end__"}
+            {"tools": "tools", "__end__": "__end__"},
         )
         ```
 
@@ -956,6 +959,7 @@ class InjectedState(InjectedToolArg):
             messages: List[BaseMessage]
             foo: str
 
+
         @tool
         def state_tool(x: int, state: Annotated[dict, InjectedState]) -> str:
             '''Do something with state.'''
@@ -964,11 +968,13 @@ class InjectedState(InjectedToolArg):
             else:
                 return "not enough messages"
 
+
         @tool
         def foo_tool(x: int, foo: Annotated[str, InjectedState("foo")]) -> str:
             '''Do something else with state.'''
             return foo + str(x + 1)
 
+
         node = ToolNode([state_tool, foo_tool])
 
         tool_call1 = {"name": "state_tool", "args": {"x": 1}, "id": "1", "type": "tool_call"}
@@ -982,8 +988,8 @@ class InjectedState(InjectedToolArg):
 
         ```pycon
         [
-            ToolMessage(content='not enough messages', name='state_tool', tool_call_id='1'),
-            ToolMessage(content='bar2', name='foo_tool', tool_call_id='2')
+            ToolMessage(content="not enough messages", name="state_tool", tool_call_id="1"),
+            ToolMessage(content="bar2", name="foo_tool", tool_call_id="2"),
         ]
         ```
 
@@ -1078,7 +1084,7 @@ class InjectedStore(InjectedToolArg):
     """
 
 
-def _is_injection(type_arg: Any, injection_type: type[Union[InjectedState, InjectedStore]]) -> bool:
+def _is_injection(type_arg: Any, injection_type: type[InjectedState | InjectedStore]) -> bool:
     """Check if a type argument represents an injection annotation.
 
     This utility function determines whether a type annotation indicates that

langchain/chat_models/base.py

@@ -9,7 +9,6 @@ from typing import (
     Any,
     Literal,
     TypeAlias,
-    Union,
     cast,
     overload,
 )
@@ -55,7 +54,7 @@ def init_chat_model(
     model: str | None = None,
     *,
     model_provider: str | None = None,
-    configurable_fields: Union[Literal["any"], list[str], tuple[str, ...]] = ...,
+    configurable_fields: Literal["any"] | list[str] | tuple[str, ...] = ...,
     config_prefix: str | None = None,
     **kwargs: Any,
 ) -> _ConfigurableModel: ...
@@ -68,10 +67,10 @@ def init_chat_model(
     model: str | None = None,
     *,
     model_provider: str | None = None,
-    configurable_fields: Union[Literal["any"], list[str], tuple[str, ...]] | None = None,
+    configurable_fields: Literal["any"] | list[str] | tuple[str, ...] | None = None,
     config_prefix: str | None = None,
     **kwargs: Any,
-) -> Union[BaseChatModel, _ConfigurableModel]:
+) -> BaseChatModel | _ConfigurableModel:
     """Initialize a ChatModel from the model name and provider.
 
     **Note:** Must have the integration package corresponding to the model provider
@@ -191,14 +190,12 @@ def init_chat_model(
             configurable_model = init_chat_model(temperature=0)
 
             configurable_model.invoke(
-                "what's your name",
-                config={"configurable": {"model": "gpt-4o"}}
+                "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"}}
+                "what's your name", config={"configurable": {"model": "claude-3-5-sonnet-latest"}}
             )
             # claude-3.5 sonnet response
 
@@ -213,7 +210,7 @@ def 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
+                temperature=0,
             )
 
             configurable_model_with_default.invoke("what's your name")
@@ -224,9 +221,9 @@ def init_chat_model(
                 config={
                     "configurable": {
                         "foo_model": "anthropic:claude-3-5-sonnet-latest",
-                        "foo_temperature": 0.6
+                        "foo_temperature": 0.6,
                     }
-                }
+                },
             )
             # Claude-3.5 sonnet response with temperature 0.6
 
@@ -241,23 +238,26 @@ def init_chat_model(
             from langchain.chat_models import init_chat_model
             from pydantic import BaseModel, Field
 
+
             class GetWeather(BaseModel):
                 '''Get the current weather in a given location'''
 
                 location: str = Field(..., description="The city and state, e.g. San Francisco, CA")
 
+
             class GetPopulation(BaseModel):
                 '''Get the current population in a given location'''
 
                 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
+                "gpt-4o", configurable_fields=("model", "model_provider"), temperature=0
             )
 
-            configurable_model_with_tools = configurable_model.bind_tools([GetWeather, GetPopulation])
+            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?"
             )
@@ -265,7 +265,7 @@ def init_chat_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"}}
+                config={"configurable": {"model": "claude-3-5-sonnet-latest"}},
             )
             # Claude-3.5 sonnet response with tools
 
@@ -530,12 +530,12 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
         self,
         *,
         default_config: dict | None = None,
-        configurable_fields: Union[Literal["any"], list[str], tuple[str, ...]] = "any",
+        configurable_fields: Literal["any"] | list[str] | tuple[str, ...] = "any",
         config_prefix: str = "",
         queued_declarative_operations: Sequence[tuple[str, tuple, dict]] = (),
     ) -> None:
         self._default_config: dict = default_config or {}
-        self._configurable_fields: Union[Literal["any"], list[str]] = (
+        self._configurable_fields: Literal["any"] | list[str] = (
             configurable_fields if configurable_fields == "any" else list(configurable_fields)
         )
         self._config_prefix = (
@@ -638,11 +638,7 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
         # 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.
-        return Union[
-            str,
-            Union[StringPromptValue, ChatPromptValueConcrete],
-            list[AnyMessage],
-        ]
+        return str | StringPromptValue | ChatPromptValueConcrete | list[AnyMessage]
 
     @override
     def invoke(
@@ -684,7 +680,7 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
     def batch(
         self,
         inputs: list[LanguageModelInput],
-        config: Union[RunnableConfig, list[RunnableConfig]] | None = None,
+        config: RunnableConfig | list[RunnableConfig] | None = None,
         *,
         return_exceptions: bool = False,
         **kwargs: Any | None,
@@ -712,7 +708,7 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
     async def abatch(
         self,
         inputs: list[LanguageModelInput],
-        config: Union[RunnableConfig, list[RunnableConfig]] | None = None,
+        config: RunnableConfig | list[RunnableConfig] | None = None,
         *,
         return_exceptions: bool = False,
         **kwargs: Any | None,
@@ -740,11 +736,11 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
     def batch_as_completed(
         self,
         inputs: Sequence[LanguageModelInput],
-        config: Union[RunnableConfig, Sequence[RunnableConfig]] | None = None,
+        config: RunnableConfig | Sequence[RunnableConfig] | None = None,
         *,
         return_exceptions: bool = False,
         **kwargs: Any,
-    ) -> Iterator[tuple[int, Union[Any, Exception]]]:
+    ) -> Iterator[tuple[int, Any | Exception]]:
         config = config or None
         # If <= 1 config use the underlying models batch implementation.
         if config is None or isinstance(config, dict) or len(config) <= 1:
@@ -769,7 +765,7 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
     async def abatch_as_completed(
         self,
         inputs: Sequence[LanguageModelInput],
-        config: Union[RunnableConfig, Sequence[RunnableConfig]] | None = None,
+        config: RunnableConfig | Sequence[RunnableConfig] | None = None,
         *,
         return_exceptions: bool = False,
         **kwargs: Any,
@@ -867,7 +863,7 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
         exclude_types: Sequence[str] | None = None,
         exclude_tags: Sequence[str] | None = None,
         **kwargs: Any,
-    ) -> Union[AsyncIterator[RunLogPatch], AsyncIterator[RunLog]]:
+    ) -> AsyncIterator[RunLogPatch] | AsyncIterator[RunLog]:
         async for x in self._model(config).astream_log(  # type: ignore[call-overload, misc]
             input,
             config=config,
@@ -915,7 +911,7 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
     # Explicitly added to satisfy downstream linters.
     def bind_tools(
         self,
-        tools: Sequence[Union[dict[str, Any], type[BaseModel], Callable, BaseTool]],
+        tools: Sequence[dict[str, Any] | type[BaseModel] | Callable | BaseTool],
         **kwargs: Any,
     ) -> Runnable[LanguageModelInput, AIMessage]:
         return self.__getattr__("bind_tools")(tools, **kwargs)
@@ -923,7 +919,7 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
     # Explicitly added to satisfy downstream linters.
     def with_structured_output(
         self,
-        schema: Union[dict, type[BaseModel]],
+        schema: dict | type[BaseModel],
         **kwargs: Any,
-    ) -> Runnable[LanguageModelInput, Union[dict, BaseModel]]:
+    ) -> Runnable[LanguageModelInput, dict | BaseModel]:
         return self.__getattr__("with_structured_output")(schema, **kwargs)

langchain/embeddings/base.py

@@ -2,7 +2,7 @@
 
 import functools
 from importlib import util
-from typing import Any, Union
+from typing import Any
 
 from langchain_core.embeddings import Embeddings
 from langchain_core.runnables import Runnable
@@ -126,7 +126,7 @@ def init_embeddings(
     *,
     provider: str | None = None,
     **kwargs: Any,
-) -> Union[Embeddings, Runnable[Any, list[float]]]:
+) -> Embeddings | Runnable[Any, list[float]]:
     """Initialize an embeddings model from a model name and optional provider.
 
     **Note:** Must have the integration package corresponding to the model provider
@@ -162,17 +162,11 @@ def init_embeddings(
             model.embed_query("Hello, world!")
 
             # Using explicit provider
-            model = init_embeddings(
-                model="text-embedding-3-small",
-                provider="openai"
-            )
+            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-..."
-            )
+            model = init_embeddings("openai:text-embedding-3-small", api_key="sk-...")
 
     .. versionadded:: 0.3.9
 

langchain/embeddings/cache.py

@@ -13,7 +13,7 @@ import hashlib
 import json
 import uuid
 import warnings
-from typing import TYPE_CHECKING, Literal, Union, cast
+from typing import TYPE_CHECKING, Literal, cast
 
 from langchain_core.embeddings import Embeddings
 from langchain_core.utils.iter import batch_iterate
@@ -178,7 +178,7 @@ class CacheBackedEmbeddings(Embeddings):
         Returns:
             A list of embeddings for the given texts.
         """
-        vectors: list[Union[list[float], None]] = self.document_embedding_store.mget(
+        vectors: list[list[float] | None] = self.document_embedding_store.mget(
             texts,
         )
         all_missing_indices: list[int] = [i for i, vector in enumerate(vectors) if vector is None]
@@ -210,7 +210,7 @@ class CacheBackedEmbeddings(Embeddings):
         Returns:
             A list of embeddings for the given texts.
         """
-        vectors: list[Union[list[float], None]] = await self.document_embedding_store.amget(texts)
+        vectors: list[list[float] | None] = await self.document_embedding_store.amget(texts)
         all_missing_indices: list[int] = [i for i, vector in enumerate(vectors) if vector is None]
 
         # batch_iterate supports None batch_size which returns all elements at once
@@ -285,11 +285,8 @@ class CacheBackedEmbeddings(Embeddings):
         *,
         namespace: str = "",
         batch_size: int | None = None,
-        query_embedding_cache: Union[bool, ByteStore] = False,
-        key_encoder: Union[
-            Callable[[str], str],
-            Literal["sha1", "blake2b", "sha256", "sha512"],
-        ] = "sha1",
+        query_embedding_cache: bool | ByteStore = False,
+        key_encoder: Callable[[str], str] | Literal["sha1", "blake2b", "sha256", "sha512"] = "sha1",
     ) -> CacheBackedEmbeddings:
         """On-ramp that adds the necessary serialization and encoding to the store.