langchain 0.3.23__py3-none-any.whl → 0.3.24__py3-none-any.whl

langchain/callbacks/streaming_aiter.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
 import asyncio
-from typing import Any, AsyncIterator, Dict, List, Literal, Union, cast
+from collections.abc import AsyncIterator
+from typing import Any, Literal, Union, cast
 
 from langchain_core.callbacks import AsyncCallbackHandler
 from langchain_core.outputs import LLMResult
@@ -25,7 +26,7 @@ class AsyncIteratorCallbackHandler(AsyncCallbackHandler):
         self.done = asyncio.Event()
 
     async def on_llm_start(
-        self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
+        self, serialized: dict[str, Any], prompts: list[str], **kwargs: Any
     ) -> None:
         # If two calls are made in a row, this resets the state
         self.done.clear()

langchain/callbacks/streaming_aiter_final_only.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, Dict, List, Optional
+from typing import Any, Optional
 
 from langchain_core.outputs import LLMResult
 
@@ -30,7 +30,7 @@ class AsyncFinalIteratorCallbackHandler(AsyncIteratorCallbackHandler):
     def __init__(
         self,
         *,
-        answer_prefix_tokens: Optional[List[str]] = None,
+        answer_prefix_tokens: Optional[list[str]] = None,
         strip_tokens: bool = True,
         stream_prefix: bool = False,
     ) -> None:
@@ -62,7 +62,7 @@ class AsyncFinalIteratorCallbackHandler(AsyncIteratorCallbackHandler):
         self.answer_reached = False
 
     async def on_llm_start(
-        self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
+        self, serialized: dict[str, Any], prompts: list[str], **kwargs: Any
     ) -> None:
         # If two calls are made in a row, this resets the state
         self.done.clear()

langchain/callbacks/streaming_stdout_final_only.py

@@ -1,7 +1,7 @@
 """Callback Handler streams to stdout on new llm token."""
 
 import sys
-from typing import Any, Dict, List, Optional
+from typing import Any, Optional
 
 from langchain_core.callbacks import StreamingStdOutCallbackHandler
 
@@ -31,7 +31,7 @@ class FinalStreamingStdOutCallbackHandler(StreamingStdOutCallbackHandler):
     def __init__(
         self,
         *,
-        answer_prefix_tokens: Optional[List[str]] = None,
+        answer_prefix_tokens: Optional[list[str]] = None,
         strip_tokens: bool = True,
         stream_prefix: bool = False,
     ) -> None:
@@ -63,7 +63,7 @@ class FinalStreamingStdOutCallbackHandler(StreamingStdOutCallbackHandler):
         self.answer_reached = False
 
     def on_llm_start(
-        self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
+        self, serialized: dict[str, Any], prompts: list[str], **kwargs: Any
     ) -> None:
         """Run when LLM starts running."""
         self.answer_reached = False

langchain/chains/api/base.py

@@ -2,7 +2,8 @@
 
 from __future__ import annotations
 
-from typing import Any, Dict, List, Optional, Sequence, Tuple
+from collections.abc import Sequence
+from typing import Any, Optional
 from urllib.parse import urlparse
 
 from langchain_core._api import deprecated
@@ -20,7 +21,7 @@ from langchain.chains.base import Chain
 from langchain.chains.llm import LLMChain
 
 
-def _extract_scheme_and_domain(url: str) -> Tuple[str, str]:
+def _extract_scheme_and_domain(url: str) -> tuple[str, str]:
     """Extract the scheme + domain from a given URL.
 
     Args:
@@ -198,9 +199,7 @@ try:
         api_docs: str
         question_key: str = "question"  #: :meta private:
         output_key: str = "output"  #: :meta private:
-        limit_to_domains: Optional[Sequence[str]] = Field(
-            default_factory=list  # type: ignore
-        )
+        limit_to_domains: Optional[Sequence[str]] = Field(default_factory=list)  # type: ignore[arg-type]
         """Use to limit the domains that can be accessed by the API chain.
         
         * For example, to limit to just the domain `https://www.example.com`, set
@@ -215,7 +214,7 @@ try:
         """
 
         @property
-        def input_keys(self) -> List[str]:
+        def input_keys(self) -> list[str]:
             """Expect input key.
 
             :meta private:
@@ -223,7 +222,7 @@ try:
             return [self.question_key]
 
         @property
-        def output_keys(self) -> List[str]:
+        def output_keys(self) -> list[str]:
             """Expect output key.
 
             :meta private:
@@ -243,7 +242,7 @@ try:
 
         @model_validator(mode="before")
         @classmethod
-        def validate_limit_to_domains(cls, values: Dict) -> Any:
+        def validate_limit_to_domains(cls, values: dict) -> Any:
             """Check that allowed domains are valid."""
             # This check must be a pre=True check, so that a default of None
             # won't be set to limit_to_domains if it's not provided.
@@ -275,9 +274,9 @@ try:
 
         def _call(
             self,
-            inputs: Dict[str, Any],
+            inputs: dict[str, Any],
             run_manager: Optional[CallbackManagerForChainRun] = None,
-        ) -> Dict[str, str]:
+        ) -> dict[str, str]:
             _run_manager = run_manager or CallbackManagerForChainRun.get_noop_manager()
             question = inputs[self.question_key]
             api_url = self.api_request_chain.predict(
@@ -308,9 +307,9 @@ try:
 
         async def _acall(
             self,
-            inputs: Dict[str, Any],
+            inputs: dict[str, Any],
             run_manager: Optional[AsyncCallbackManagerForChainRun] = None,
-        ) -> Dict[str, str]:
+        ) -> dict[str, str]:
             _run_manager = (
                 run_manager or AsyncCallbackManagerForChainRun.get_noop_manager()
             )

langchain/chains/base.py

@@ -1,12 +1,13 @@
 """Base interface that all chains should implement."""
 
+import builtins
 import inspect
 import json
 import logging
 import warnings
 from abc import ABC, abstractmethod
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Type, Union, cast
+from typing import Any, Optional, Union, cast
 
 import yaml
 from langchain_core._api import deprecated
@@ -46,7 +47,7 @@ def _get_verbosity() -> bool:
     return get_verbose()
 
 
-class Chain(RunnableSerializable[Dict[str, Any], Dict[str, Any]], ABC):
+class Chain(RunnableSerializable[dict[str, Any], dict[str, Any]], ABC):
     """Abstract base class for creating structured sequences of calls to components.
 
     Chains should be used to encode a sequence of calls to components like
@@ -86,13 +87,13 @@ class Chain(RunnableSerializable[Dict[str, Any], Dict[str, Any]], ABC):
     """Whether or not run in verbose mode. In verbose mode, some intermediate logs
     will be printed to the console. Defaults to the global `verbose` value,
     accessible via `langchain.globals.get_verbose()`."""
-    tags: Optional[List[str]] = None
+    tags: Optional[list[str]] = None
     """Optional list of tags associated with the chain. Defaults to None.
     These tags will be associated with each call to this chain,
     and passed as arguments to the handlers defined in `callbacks`.
     You can use these to eg identify a specific instance of a chain with its use case.
     """
-    metadata: Optional[Dict[str, Any]] = None
+    metadata: Optional[dict[str, Any]] = None
     """Optional metadata associated with the chain. Defaults to None.
     This metadata will be associated with each call to this chain,
     and passed as arguments to the handlers defined in `callbacks`.
@@ -107,26 +108,22 @@ class Chain(RunnableSerializable[Dict[str, Any], Dict[str, Any]], ABC):
 
     def get_input_schema(
         self, config: Optional[RunnableConfig] = None
-    ) -> Type[BaseModel]:
+    ) -> type[BaseModel]:
         # This is correct, but pydantic typings/mypy don't think so.
-        return create_model(  # type: ignore[call-overload]
-            "ChainInput", **{k: (Any, None) for k in self.input_keys}
-        )
+        return create_model("ChainInput", **{k: (Any, None) for k in self.input_keys})
 
     def get_output_schema(
         self, config: Optional[RunnableConfig] = None
-    ) -> Type[BaseModel]:
+    ) -> type[BaseModel]:
         # This is correct, but pydantic typings/mypy don't think so.
-        return create_model(  # type: ignore[call-overload]
-            "ChainOutput", **{k: (Any, None) for k in self.output_keys}
-        )
+        return create_model("ChainOutput", **{k: (Any, None) for k in self.output_keys})
 
     def invoke(
         self,
-        input: Dict[str, Any],
+        input: dict[str, Any],
         config: Optional[RunnableConfig] = None,
         **kwargs: Any,
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         config = ensure_config(config)
         callbacks = config.get("callbacks")
         tags = config.get("tags")
@@ -162,7 +159,7 @@ class Chain(RunnableSerializable[Dict[str, Any], Dict[str, Any]], ABC):
                 else self._call(inputs)
             )
 
-            final_outputs: Dict[str, Any] = self.prep_outputs(
+            final_outputs: dict[str, Any] = self.prep_outputs(
                 inputs, outputs, return_only_outputs
             )
         except BaseException as e:
@@ -176,10 +173,10 @@ class Chain(RunnableSerializable[Dict[str, Any], Dict[str, Any]], ABC):
 
     async def ainvoke(
         self,
-        input: Dict[str, Any],
+        input: dict[str, Any],
         config: Optional[RunnableConfig] = None,
         **kwargs: Any,
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         config = ensure_config(config)
         callbacks = config.get("callbacks")
         tags = config.get("tags")
@@ -213,7 +210,7 @@ class Chain(RunnableSerializable[Dict[str, Any], Dict[str, Any]], ABC):
                 if new_arg_supported
                 else await self._acall(inputs)
             )
-            final_outputs: Dict[str, Any] = await self.aprep_outputs(
+            final_outputs: dict[str, Any] = await self.aprep_outputs(
                 inputs, outputs, return_only_outputs
             )
         except BaseException as e:
@@ -231,7 +228,7 @@ class Chain(RunnableSerializable[Dict[str, Any], Dict[str, Any]], ABC):
 
     @model_validator(mode="before")
     @classmethod
-    def raise_callback_manager_deprecation(cls, values: Dict) -> Any:
+    def raise_callback_manager_deprecation(cls, values: dict) -> Any:
         """Raise deprecation warning if callback_manager is used."""
         if values.get("callback_manager") is not None:
             if values.get("callbacks") is not None:
@@ -261,15 +258,15 @@ class Chain(RunnableSerializable[Dict[str, Any], Dict[str, Any]], ABC):
 
     @property
     @abstractmethod
-    def input_keys(self) -> List[str]:
+    def input_keys(self) -> list[str]:
         """Keys expected to be in the chain input."""
 
     @property
     @abstractmethod
-    def output_keys(self) -> List[str]:
+    def output_keys(self) -> list[str]:
         """Keys expected to be in the chain output."""
 
-    def _validate_inputs(self, inputs: Dict[str, Any]) -> None:
+    def _validate_inputs(self, inputs: dict[str, Any]) -> None:
         """Check that all inputs are present."""
         if not isinstance(inputs, dict):
             _input_keys = set(self.input_keys)
@@ -289,7 +286,7 @@ class Chain(RunnableSerializable[Dict[str, Any], Dict[str, Any]], ABC):
         if missing_keys:
             raise ValueError(f"Missing some input keys: {missing_keys}")
 
-    def _validate_outputs(self, outputs: Dict[str, Any]) -> None:
+    def _validate_outputs(self, outputs: dict[str, Any]) -> None:
         missing_keys = set(self.output_keys).difference(outputs)
         if missing_keys:
             raise ValueError(f"Missing some output keys: {missing_keys}")
@@ -297,9 +294,9 @@ class Chain(RunnableSerializable[Dict[str, Any], Dict[str, Any]], ABC):
     @abstractmethod
     def _call(
         self,
-        inputs: Dict[str, Any],
+        inputs: dict[str, Any],
         run_manager: Optional[CallbackManagerForChainRun] = None,
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         """Execute the chain.
 
         This is a private method that is not user-facing. It is only called within
@@ -319,9 +316,9 @@ class Chain(RunnableSerializable[Dict[str, Any], Dict[str, Any]], ABC):
 
     async def _acall(
         self,
-        inputs: Dict[str, Any],
+        inputs: dict[str, Any],
         run_manager: Optional[AsyncCallbackManagerForChainRun] = None,
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         """Asynchronously execute the chain.
 
         This is a private method that is not user-facing. It is only called within
@@ -345,15 +342,15 @@ class Chain(RunnableSerializable[Dict[str, Any], Dict[str, Any]], ABC):
     @deprecated("0.1.0", alternative="invoke", removal="1.0")
     def __call__(
         self,
-        inputs: Union[Dict[str, Any], Any],
+        inputs: Union[dict[str, Any], Any],
         return_only_outputs: bool = False,
         callbacks: Callbacks = None,
         *,
-        tags: Optional[List[str]] = None,
-        metadata: Optional[Dict[str, Any]] = None,
+        tags: Optional[list[str]] = None,
+        metadata: Optional[dict[str, Any]] = None,
         run_name: Optional[str] = None,
         include_run_info: bool = False,
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         """Execute the chain.
 
         Args:
@@ -396,15 +393,15 @@ class Chain(RunnableSerializable[Dict[str, Any], Dict[str, Any]], ABC):
     @deprecated("0.1.0", alternative="ainvoke", removal="1.0")
     async def acall(
         self,
-        inputs: Union[Dict[str, Any], Any],
+        inputs: Union[dict[str, Any], Any],
         return_only_outputs: bool = False,
         callbacks: Callbacks = None,
         *,
-        tags: Optional[List[str]] = None,
-        metadata: Optional[Dict[str, Any]] = None,
+        tags: Optional[list[str]] = None,
+        metadata: Optional[dict[str, Any]] = None,
         run_name: Optional[str] = None,
         include_run_info: bool = False,
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         """Asynchronously execute the chain.
 
         Args:
@@ -445,10 +442,10 @@ class Chain(RunnableSerializable[Dict[str, Any], Dict[str, Any]], ABC):
 
     def prep_outputs(
         self,
-        inputs: Dict[str, str],
-        outputs: Dict[str, str],
+        inputs: dict[str, str],
+        outputs: dict[str, str],
         return_only_outputs: bool = False,
-    ) -> Dict[str, str]:
+    ) -> dict[str, str]:
         """Validate and prepare chain outputs, and save info about this run to memory.
 
         Args:
@@ -471,10 +468,10 @@ class Chain(RunnableSerializable[Dict[str, Any], Dict[str, Any]], ABC):
 
     async def aprep_outputs(
         self,
-        inputs: Dict[str, str],
-        outputs: Dict[str, str],
+        inputs: dict[str, str],
+        outputs: dict[str, str],
         return_only_outputs: bool = False,
-    ) -> Dict[str, str]:
+    ) -> dict[str, str]:
         """Validate and prepare chain outputs, and save info about this run to memory.
 
         Args:
@@ -495,7 +492,7 @@ class Chain(RunnableSerializable[Dict[str, Any], Dict[str, Any]], ABC):
         else:
             return {**inputs, **outputs}
 
-    def prep_inputs(self, inputs: Union[Dict[str, Any], Any]) -> Dict[str, str]:
+    def prep_inputs(self, inputs: Union[dict[str, Any], Any]) -> dict[str, str]:
         """Prepare chain inputs, including adding inputs from memory.
 
         Args:
@@ -519,7 +516,7 @@ class Chain(RunnableSerializable[Dict[str, Any], Dict[str, Any]], ABC):
             inputs = dict(inputs, **external_context)
         return inputs
 
-    async def aprep_inputs(self, inputs: Union[Dict[str, Any], Any]) -> Dict[str, str]:
+    async def aprep_inputs(self, inputs: Union[dict[str, Any], Any]) -> dict[str, str]:
         """Prepare chain inputs, including adding inputs from memory.
 
         Args:
@@ -557,8 +554,8 @@ class Chain(RunnableSerializable[Dict[str, Any], Dict[str, Any]], ABC):
         self,
         *args: Any,
         callbacks: Callbacks = None,
-        tags: Optional[List[str]] = None,
-        metadata: Optional[Dict[str, Any]] = None,
+        tags: Optional[list[str]] = None,
+        metadata: Optional[dict[str, Any]] = None,
         **kwargs: Any,
     ) -> Any:
         """Convenience method for executing chain.
@@ -628,8 +625,8 @@ class Chain(RunnableSerializable[Dict[str, Any], Dict[str, Any]], ABC):
         self,
         *args: Any,
         callbacks: Callbacks = None,
-        tags: Optional[List[str]] = None,
-        metadata: Optional[Dict[str, Any]] = None,
+        tags: Optional[list[str]] = None,
+        metadata: Optional[dict[str, Any]] = None,
         **kwargs: Any,
     ) -> Any:
         """Convenience method for executing chain.
@@ -695,7 +692,7 @@ class Chain(RunnableSerializable[Dict[str, Any], Dict[str, Any]], ABC):
             f" but not both. Got args: {args} and kwargs: {kwargs}."
         )
 
-    def dict(self, **kwargs: Any) -> Dict:
+    def dict(self, **kwargs: Any) -> dict:
         """Dictionary representation of chain.
 
         Expects `Chain._chain_type` property to be implemented and for memory to be
@@ -763,7 +760,7 @@ class Chain(RunnableSerializable[Dict[str, Any], Dict[str, Any]], ABC):
 
     @deprecated("0.1.0", alternative="batch", removal="1.0")
     def apply(
-        self, input_list: List[Dict[str, Any]], callbacks: Callbacks = None
-    ) -> List[Dict[str, str]]:
+        self, input_list: list[builtins.dict[str, Any]], callbacks: Callbacks = None
+    ) -> list[builtins.dict[str, str]]:
         """Call the chain on all inputs in the list."""
         return [self(inputs, callbacks=callbacks) for inputs in input_list]

langchain/chains/combine_documents/base.py

@@ -1,7 +1,7 @@
 """Base interface for chains combining documents."""
 
 from abc import ABC, abstractmethod
-from typing import Any, Dict, List, Optional, Tuple, Type
+from typing import Any, Optional
 
 from langchain_core._api import deprecated
 from langchain_core.callbacks import (
@@ -47,22 +47,22 @@ class BaseCombineDocumentsChain(Chain, ABC):
 
     def get_input_schema(
         self, config: Optional[RunnableConfig] = None
-    ) -> Type[BaseModel]:
+    ) -> type[BaseModel]:
         return create_model(
             "CombineDocumentsInput",
-            **{self.input_key: (List[Document], None)},  # type: ignore[call-overload]
+            **{self.input_key: (list[Document], None)},
         )
 
     def get_output_schema(
         self, config: Optional[RunnableConfig] = None
-    ) -> Type[BaseModel]:
+    ) -> type[BaseModel]:
         return create_model(
             "CombineDocumentsOutput",
-            **{self.output_key: (str, None)},  # type: ignore[call-overload]
+            **{self.output_key: (str, None)},
         )
 
     @property
-    def input_keys(self) -> List[str]:
+    def input_keys(self) -> list[str]:
         """Expect input key.
 
         :meta private:
@@ -70,14 +70,14 @@ class BaseCombineDocumentsChain(Chain, ABC):
         return [self.input_key]
 
     @property
-    def output_keys(self) -> List[str]:
+    def output_keys(self) -> list[str]:
         """Return output key.
 
         :meta private:
         """
         return [self.output_key]
 
-    def prompt_length(self, docs: List[Document], **kwargs: Any) -> Optional[int]:
+    def prompt_length(self, docs: list[Document], **kwargs: Any) -> Optional[int]:
         """Return the prompt length given the documents passed in.
 
         This can be used by a caller to determine whether passing in a list
@@ -96,7 +96,7 @@ class BaseCombineDocumentsChain(Chain, ABC):
         return None
 
     @abstractmethod
-    def combine_docs(self, docs: List[Document], **kwargs: Any) -> Tuple[str, dict]:
+    def combine_docs(self, docs: list[Document], **kwargs: Any) -> tuple[str, dict]:
         """Combine documents into a single string.
 
         Args:
@@ -111,8 +111,8 @@ class BaseCombineDocumentsChain(Chain, ABC):
 
     @abstractmethod
     async def acombine_docs(
-        self, docs: List[Document], **kwargs: Any
-    ) -> Tuple[str, dict]:
+        self, docs: list[Document], **kwargs: Any
+    ) -> tuple[str, dict]:
         """Combine documents into a single string.
 
         Args:
@@ -127,9 +127,9 @@ class BaseCombineDocumentsChain(Chain, ABC):
 
     def _call(
         self,
-        inputs: Dict[str, List[Document]],
+        inputs: dict[str, list[Document]],
         run_manager: Optional[CallbackManagerForChainRun] = None,
-    ) -> Dict[str, str]:
+    ) -> dict[str, str]:
         """Prepare inputs, call combine docs, prepare outputs."""
         _run_manager = run_manager or CallbackManagerForChainRun.get_noop_manager()
         docs = inputs[self.input_key]
@@ -143,9 +143,9 @@ class BaseCombineDocumentsChain(Chain, ABC):
 
     async def _acall(
         self,
-        inputs: Dict[str, List[Document]],
+        inputs: dict[str, list[Document]],
         run_manager: Optional[AsyncCallbackManagerForChainRun] = None,
-    ) -> Dict[str, str]:
+    ) -> dict[str, str]:
         """Prepare inputs, call combine docs, prepare outputs."""
         _run_manager = run_manager or AsyncCallbackManagerForChainRun.get_noop_manager()
         docs = inputs[self.input_key]
@@ -229,7 +229,7 @@ class AnalyzeDocumentChain(Chain):
     combine_docs_chain: BaseCombineDocumentsChain
 
     @property
-    def input_keys(self) -> List[str]:
+    def input_keys(self) -> list[str]:
         """Expect input key.
 
         :meta private:
@@ -237,7 +237,7 @@ class AnalyzeDocumentChain(Chain):
         return [self.input_key]
 
     @property
-    def output_keys(self) -> List[str]:
+    def output_keys(self) -> list[str]:
         """Return output key.
 
         :meta private:
@@ -246,28 +246,28 @@ class AnalyzeDocumentChain(Chain):
 
     def get_input_schema(
         self, config: Optional[RunnableConfig] = None
-    ) -> Type[BaseModel]:
+    ) -> type[BaseModel]:
         return create_model(
             "AnalyzeDocumentChain",
-            **{self.input_key: (str, None)},  # type: ignore[call-overload]
+            **{self.input_key: (str, None)},
         )
 
     def get_output_schema(
         self, config: Optional[RunnableConfig] = None
-    ) -> Type[BaseModel]:
+    ) -> type[BaseModel]:
         return self.combine_docs_chain.get_output_schema(config)
 
     def _call(
         self,
-        inputs: Dict[str, str],
+        inputs: dict[str, str],
         run_manager: Optional[CallbackManagerForChainRun] = None,
-    ) -> Dict[str, str]:
+    ) -> dict[str, str]:
         """Split document into chunks and pass to CombineDocumentsChain."""
         _run_manager = run_manager or CallbackManagerForChainRun.get_noop_manager()
         document = inputs[self.input_key]
         docs = self.text_splitter.create_documents([document])
         # Other keys are assumed to be needed for LLM prediction
-        other_keys: Dict = {k: v for k, v in inputs.items() if k != self.input_key}
+        other_keys: dict = {k: v for k, v in inputs.items() if k != self.input_key}
         other_keys[self.combine_docs_chain.input_key] = docs
         return self.combine_docs_chain(
             other_keys, return_only_outputs=True, callbacks=_run_manager.get_child()

langchain/chains/combine_documents/map_reduce.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import Any, Dict, List, Optional, Tuple, Type
+from typing import Any, Optional
 
 from langchain_core._api import deprecated
 from langchain_core.callbacks import Callbacks
@@ -113,20 +113,20 @@ class MapReduceDocumentsChain(BaseCombineDocumentsChain):
 
     def get_output_schema(
         self, config: Optional[RunnableConfig] = None
-    ) -> Type[BaseModel]:
+    ) -> type[BaseModel]:
         if self.return_intermediate_steps:
             return create_model(
                 "MapReduceDocumentsOutput",
                 **{
                     self.output_key: (str, None),
-                    "intermediate_steps": (List[str], None),
-                },  # type: ignore[call-overload]
+                    "intermediate_steps": (list[str], None),
+                },
             )
 
         return super().get_output_schema(config)
 
     @property
-    def output_keys(self) -> List[str]:
+    def output_keys(self) -> list[str]:
         """Expect input key.
 
         :meta private:
@@ -143,7 +143,7 @@ class MapReduceDocumentsChain(BaseCombineDocumentsChain):
 
     @model_validator(mode="before")
     @classmethod
-    def get_reduce_chain(cls, values: Dict) -> Any:
+    def get_reduce_chain(cls, values: dict) -> Any:
         """For backwards compatibility."""
         if "combine_document_chain" in values:
             if "reduce_documents_chain" in values:
@@ -167,7 +167,7 @@ class MapReduceDocumentsChain(BaseCombineDocumentsChain):
 
     @model_validator(mode="before")
     @classmethod
-    def get_return_intermediate_steps(cls, values: Dict) -> Any:
+    def get_return_intermediate_steps(cls, values: dict) -> Any:
         """For backwards compatibility."""
         if "return_map_steps" in values:
             values["return_intermediate_steps"] = values["return_map_steps"]
@@ -176,7 +176,7 @@ class MapReduceDocumentsChain(BaseCombineDocumentsChain):
 
     @model_validator(mode="before")
     @classmethod
-    def get_default_document_variable_name(cls, values: Dict) -> Any:
+    def get_default_document_variable_name(cls, values: dict) -> Any:
         """Get default document variable name, if not provided."""
         if "llm_chain" not in values:
             raise ValueError("llm_chain must be provided")
@@ -227,11 +227,11 @@ class MapReduceDocumentsChain(BaseCombineDocumentsChain):
 
     def combine_docs(
         self,
-        docs: List[Document],
+        docs: list[Document],
         token_max: Optional[int] = None,
         callbacks: Callbacks = None,
         **kwargs: Any,
-    ) -> Tuple[str, dict]:
+    ) -> tuple[str, dict]:
         """Combine documents in a map reduce manner.
 
         Combine by mapping first chain over all documents, then reducing the results.
@@ -258,11 +258,11 @@ class MapReduceDocumentsChain(BaseCombineDocumentsChain):
 
     async def acombine_docs(
         self,
-        docs: List[Document],
+        docs: list[Document],
         token_max: Optional[int] = None,
         callbacks: Callbacks = None,
         **kwargs: Any,
-    ) -> Tuple[str, dict]:
+    ) -> tuple[str, dict]:
         """Combine documents in a map reduce manner.
 
         Combine by mapping first chain over all documents, then reducing the results.