langchain-core 1.0.0rc3__py3-none-any.whl → 1.0.2__py3-none-any.whl

langchain_core/prompts/structured.py

@@ -104,19 +104,23 @@ class StructuredPrompt(ChatPromptTemplate):
             )
             ```
         Args:
-            messages: sequence of message representations.
+            messages: Sequence of message representations.
+
                 A message can be represented using the following formats:
-                (1) BaseMessagePromptTemplate, (2) BaseMessage, (3) 2-tuple of
-                (message type, template); e.g., ("human", "{user_input}"),
-                (4) 2-tuple of (message class, template), (5) a string which is
-                shorthand for ("human", template); e.g., "{user_input}"
-            schema: a dictionary representation of function call, or a Pydantic model.
+
+                1. `BaseMessagePromptTemplate`
+                2. `BaseMessage`
+                3. 2-tuple of `(message type, template)`; e.g.,
+                    `("human", "{user_input}")`
+                4. 2-tuple of `(message class, template)`
+                5. A string which is shorthand for `("human", template)`; e.g.,
+                    `"{user_input}"`
+            schema: A dictionary representation of function call, or a Pydantic model.
             **kwargs: Any additional kwargs to pass through to
                 `ChatModel.with_structured_output(schema, **kwargs)`.
 
         Returns:
-            a structured prompt template
-
+            A structured prompt template
         """
         return cls(messages, schema, **kwargs)
 

langchain_core/rate_limiters.py

@@ -105,9 +105,7 @@ class InMemoryRateLimiter(BaseRateLimiter):
 
         from langchain_anthropic import ChatAnthropic
 
-        model = ChatAnthropic(
-            model_name="claude-sonnet-4-5-20250929", rate_limiter=rate_limiter
-        )
+        model = ChatAnthropic(model_name="claude-sonnet-4-5", rate_limiter=rate_limiter)
 
         for _ in range(5):
             tic = time.time()

langchain_core/retrievers.py

@@ -50,65 +50,65 @@ class LangSmithRetrieverParams(TypedDict, total=False):
 
 
 class BaseRetriever(RunnableSerializable[RetrieverInput, RetrieverOutput], ABC):
-    """Abstract base class for a Document retrieval system.
+    """Abstract base class for a document retrieval system.
 
     A retrieval system is defined as something that can take string queries and return
-    the most 'relevant' Documents from some source.
+    the most 'relevant' documents from some source.
 
     Usage:
 
-    A retriever follows the standard Runnable interface, and should be used
-    via the standard Runnable methods of `invoke`, `ainvoke`, `batch`, `abatch`.
+    A retriever follows the standard `Runnable` interface, and should be used via the
+    standard `Runnable` methods of `invoke`, `ainvoke`, `batch`, `abatch`.
 
     Implementation:
 
-    When implementing a custom retriever, the class should implement
-    the `_get_relevant_documents` method to define the logic for retrieving documents.
+    When implementing a custom retriever, the class should implement the
+    `_get_relevant_documents` method to define the logic for retrieving documents.
 
     Optionally, an async native implementations can be provided by overriding the
     `_aget_relevant_documents` method.
 
-    Example: A retriever that returns the first 5 documents from a list of documents
+    !!! example "Retriever that returns the first 5 documents from a list of documents"
 
-    ```python
-    from langchain_core.documents import Document
-    from langchain_core.retrievers import BaseRetriever
+        ```python
+        from langchain_core.documents import Document
+        from langchain_core.retrievers import BaseRetriever
 
-    class SimpleRetriever(BaseRetriever):
-        docs: list[Document]
-        k: int = 5
+        class SimpleRetriever(BaseRetriever):
+            docs: list[Document]
+            k: int = 5
 
-        def _get_relevant_documents(self, query: str) -> list[Document]:
-            \"\"\"Return the first k documents from the list of documents\"\"\"
-            return self.docs[:self.k]
+            def _get_relevant_documents(self, query: str) -> list[Document]:
+                \"\"\"Return the first k documents from the list of documents\"\"\"
+                return self.docs[:self.k]
 
-        async def _aget_relevant_documents(self, query: str) -> list[Document]:
-            \"\"\"(Optional) async native implementation.\"\"\"
-            return self.docs[:self.k]
-    ```
+            async def _aget_relevant_documents(self, query: str) -> list[Document]:
+                \"\"\"(Optional) async native implementation.\"\"\"
+                return self.docs[:self.k]
+        ```
 
-    Example: A simple retriever based on a scikit-learn vectorizer
+    !!! example "Simple retriever based on a scikit-learn vectorizer"
 
-    ```python
-    from sklearn.metrics.pairwise import cosine_similarity
+        ```python
+        from sklearn.metrics.pairwise import cosine_similarity
 
 
-    class TFIDFRetriever(BaseRetriever, BaseModel):
-        vectorizer: Any
-        docs: list[Document]
-        tfidf_array: Any
-        k: int = 4
+        class TFIDFRetriever(BaseRetriever, BaseModel):
+            vectorizer: Any
+            docs: list[Document]
+            tfidf_array: Any
+            k: int = 4
 
-        class Config:
-            arbitrary_types_allowed = True
+            class Config:
+                arbitrary_types_allowed = True
 
-        def _get_relevant_documents(self, query: str) -> list[Document]:
-            # Ip -- (n_docs,x), Op -- (n_docs,n_Feats)
-            query_vec = self.vectorizer.transform([query])
-            # Op -- (n_docs,1) -- Cosine Sim with each doc
-            results = cosine_similarity(self.tfidf_array, query_vec).reshape((-1,))
-            return [self.docs[i] for i in results.argsort()[-self.k :][::-1]]
-    ```
+            def _get_relevant_documents(self, query: str) -> list[Document]:
+                # Ip -- (n_docs,x), Op -- (n_docs,n_Feats)
+                query_vec = self.vectorizer.transform([query])
+                # Op -- (n_docs,1) -- Cosine Sim with each doc
+                results = cosine_similarity(self.tfidf_array, query_vec).reshape((-1,))
+                return [self.docs[i] for i in results.argsort()[-self.k :][::-1]]
+        ```
     """
 
     model_config = ConfigDict(
@@ -119,15 +119,19 @@ class BaseRetriever(RunnableSerializable[RetrieverInput, RetrieverOutput], ABC):
     _expects_other_args: bool = False
     tags: list[str] | None = None
     """Optional list of tags associated with the retriever.
+
     These tags will be associated with each call to this retriever,
     and passed as arguments to the handlers defined in `callbacks`.
+
     You can use these to eg identify a specific instance of a retriever with its
     use case.
     """
     metadata: dict[str, Any] | None = None
     """Optional metadata associated with the retriever.
+
     This metadata will be associated with each call to this retriever,
     and passed as arguments to the handlers defined in `callbacks`.
+
     You can use these to eg identify a specific instance of a retriever with its
     use case.
     """

langchain_core/runnables/base.py

@@ -147,11 +147,11 @@ class Runnable(ABC, Generic[Input, Output]):
     the `input_schema` property, the `output_schema` property and `config_schema`
     method.
 
-    LCEL and Composition
-    ====================
+    Composition
+    ===========
+
+    Runnable objects can be composed together to create chains in a declarative way.
 
-    The LangChain Expression Language (LCEL) is a declarative way to compose
-    `Runnable` objectsinto chains.
     Any chain constructed this way will automatically have sync, async, batch, and
     streaming support.
 
@@ -235,21 +235,21 @@ class Runnable(ABC, Generic[Input, Output]):
 
     You can set the global debug flag to True to enable debug output for all chains:
 
-        ```python
-        from langchain_core.globals import set_debug
+    ```python
+    from langchain_core.globals import set_debug
 
-        set_debug(True)
-        ```
+    set_debug(True)
+    ```
 
     Alternatively, you can pass existing or custom callbacks to any given chain:
 
-        ```python
-        from langchain_core.tracers import ConsoleCallbackHandler
+    ```python
+    from langchain_core.tracers import ConsoleCallbackHandler
 
-        chain.invoke(..., config={"callbacks": [ConsoleCallbackHandler()]})
-        ```
+    chain.invoke(..., config={"callbacks": [ConsoleCallbackHandler()]})
+    ```
 
-    For a UI (and much more) checkout [LangSmith](https://docs.smith.langchain.com/).
+    For a UI (and much more) checkout [LangSmith](https://docs.langchain.com/langsmith/home).
 
     """
 
@@ -1367,8 +1367,8 @@ class Runnable(ABC, Generic[Input, Output]):
 
         events = [event async for event in chain.astream_events("hello", version="v2")]
 
-        # will produce the following events (run_id, and parent_ids
-        # has been omitted for brevity):
+        # Will produce the following events
+        # (run_id, and parent_ids has been omitted for brevity):
         [
             {
                 "data": {"input": "hello"},
@@ -1423,7 +1423,7 @@ class Runnable(ABC, Generic[Input, Output]):
 
         async for event in slow_thing.astream_events("some_input", version="v2"):
             print(event)
-        ``
+        ```
 
         Args:
             input: The input to the `Runnable`.
@@ -1813,7 +1813,7 @@ class Runnable(ABC, Generic[Input, Output]):
             output_type: The output type to bind to the `Runnable`.
 
         Returns:
-            A new Runnable with the types bound.
+            A new `Runnable` with the types bound.
         """
         return RunnableBinding(
             bound=self,
@@ -1840,7 +1840,7 @@ class Runnable(ABC, Generic[Input, Output]):
                 giving up.
             exponential_jitter_params: Parameters for
                 `tenacity.wait_exponential_jitter`. Namely: `initial`, `max`,
-                `exp_base`, and `jitter` (all float values).
+                `exp_base`, and `jitter` (all `float` values).
 
         Returns:
             A new Runnable that retries the original Runnable on exceptions.
@@ -1925,15 +1925,15 @@ class Runnable(ABC, Generic[Input, Output]):
             fallbacks: A sequence of runnables to try if the original `Runnable`
                 fails.
             exceptions_to_handle: A tuple of exception types to handle.
-            exception_key: If string is specified then handled exceptions will be passed
-                to fallbacks as part of the input under the specified key.
+            exception_key: If `string` is specified then handled exceptions will be
+                passed to fallbacks as part of the input under the specified key.
                 If `None`, exceptions will not be passed to fallbacks.
                 If used, the base `Runnable` and its fallbacks must accept a
                 dictionary as input.
 
         Returns:
             A new `Runnable` that will try the original `Runnable`, and then each
-            Fallback in order, upon failures.
+                Fallback in order, upon failures.
 
         Example:
             ```python
@@ -1961,16 +1961,15 @@ class Runnable(ABC, Generic[Input, Output]):
             fallbacks: A sequence of runnables to try if the original `Runnable`
                 fails.
             exceptions_to_handle: A tuple of exception types to handle.
-            exception_key: If string is specified then handled exceptions will be passed
-                to fallbacks as part of the input under the specified key.
+            exception_key: If `string` is specified then handled exceptions will be
+                passed to fallbacks as part of the input under the specified key.
                 If `None`, exceptions will not be passed to fallbacks.
                 If used, the base `Runnable` and its fallbacks must accept a
                 dictionary as input.
 
         Returns:
             A new `Runnable` that will try the original `Runnable`, and then each
-            Fallback in order, upon failures.
-
+                Fallback in order, upon failures.
         """
         # Import locally to prevent circular import
         from langchain_core.runnables.fallbacks import (  # noqa: PLC0415
@@ -2520,9 +2519,6 @@ class Runnable(ABC, Generic[Input, Output]):
         as_tool = runnable.as_tool()
         as_tool.invoke("b")
         ```
-
-        !!! version-added "Added in version 0.2.14"
-
         """
         # Avoid circular import
         from langchain_core.tools import convert_runnable_to_tool  # noqa: PLC0415
@@ -3504,7 +3500,7 @@ class RunnableParallel(RunnableSerializable[Input, dict[str, Any]]):
 
     Returns a mapping of their outputs.
 
-    `RunnableParallel` is one of the two main composition primitives for the LCEL,
+    `RunnableParallel` is one of the two main composition primitives,
     alongside `RunnableSequence`. It invokes `Runnable`s concurrently, providing the
     same input to each.
 

langchain_core/runnables/branch.py

@@ -40,13 +40,13 @@ from langchain_core.runnables.utils import (
 class RunnableBranch(RunnableSerializable[Input, Output]):
     """Runnable that selects which branch to run based on a condition.
 
-    The Runnable is initialized with a list of (condition, Runnable) pairs and
+    The Runnable is initialized with a list of `(condition, Runnable)` pairs and
     a default branch.
 
     When operating on an input, the first condition that evaluates to True is
-    selected, and the corresponding Runnable is run on the input.
+    selected, and the corresponding `Runnable` is run on the input.
 
-    If no condition evaluates to True, the default branch is run on the input.
+    If no condition evaluates to `True`, the default branch is run on the input.
 
     Examples:
         ```python
@@ -65,9 +65,9 @@ class RunnableBranch(RunnableSerializable[Input, Output]):
     """
 
     branches: Sequence[tuple[Runnable[Input, bool], Runnable[Input, Output]]]
-    """A list of (condition, Runnable) pairs."""
+    """A list of `(condition, Runnable)` pairs."""
     default: Runnable[Input, Output]
-    """A Runnable to run if no condition is met."""
+    """A `Runnable` to run if no condition is met."""
 
     def __init__(
         self,
@@ -79,15 +79,15 @@ class RunnableBranch(RunnableSerializable[Input, Output]):
         ]
         | RunnableLike,
     ) -> None:
-        """A Runnable that runs one of two branches based on a condition.
+        """A `Runnable` that runs one of two branches based on a condition.
 
         Args:
-            *branches: A list of (condition, Runnable) pairs.
-                Defaults a Runnable to run if no condition is met.
+            *branches: A list of `(condition, Runnable)` pairs.
+                Defaults a `Runnable` to run if no condition is met.
 
         Raises:
             ValueError: If the number of branches is less than 2.
-            TypeError: If the default branch is not Runnable, Callable or Mapping.
+            TypeError: If the default branch is not `Runnable`, `Callable` or `Mapping`.
             TypeError: If a branch is not a tuple or list.
             ValueError: If a branch is not of length 2.
         """

langchain_core/runnables/config.py

@@ -527,8 +527,7 @@ class ContextThreadPoolExecutor(ThreadPoolExecutor):
         self,
         fn: Callable[..., T],
         *iterables: Iterable[Any],
-        timeout: float | None = None,
-        chunksize: int = 1,
+        **kwargs: Any,
     ) -> Iterator[T]:
         """Map a function to multiple iterables.
 
@@ -549,8 +548,7 @@ class ContextThreadPoolExecutor(ThreadPoolExecutor):
         return super().map(
             _wrapped_fn,
             *iterables,
-            timeout=timeout,
-            chunksize=chunksize,
+            **kwargs,
         )
 
 

langchain_core/runnables/configurable.py

@@ -475,11 +475,11 @@ _enums_for_spec_lock = threading.Lock()
 class RunnableConfigurableAlternatives(DynamicRunnable[Input, Output]):
     """Runnable that can be dynamically configured.
 
-    A RunnableConfigurableAlternatives should be initiated using the
+    A `RunnableConfigurableAlternatives` should be initiated using the
     `configurable_alternatives` method of a Runnable or can be
     initiated directly as well.
 
-    Here is an example of using a RunnableConfigurableAlternatives that uses
+    Here is an example of using a `RunnableConfigurableAlternatives` that uses
     alternative prompts to illustrate its functionality:
 
         ```python
@@ -506,7 +506,7 @@ class RunnableConfigurableAlternatives(DynamicRunnable[Input, Output]):
         chain.with_config(configurable={"prompt": "poem"}).invoke({"topic": "bears"})
         ```
 
-    Equivalently, you can initialize RunnableConfigurableAlternatives directly
+    Equivalently, you can initialize `RunnableConfigurableAlternatives` directly
     and use in LCEL in the same way:
 
         ```python

langchain_core/runnables/fallbacks.py

@@ -96,7 +96,7 @@ class RunnableWithFallbacks(RunnableSerializable[Input, Output]):
     Any exception that is not a subclass of these exceptions will be raised immediately.
     """
     exception_key: str | None = None
-    """If string is specified then handled exceptions will be passed to fallbacks as
+    """If `string` is specified then handled exceptions will be passed to fallbacks as
         part of the input under the specified key. If `None`, exceptions
         will not be passed to fallbacks. If used, the base Runnable and its fallbacks
         must accept a dictionary as input."""

langchain_core/runnables/graph.py

@@ -132,7 +132,7 @@ class Branch(NamedTuple):
     condition: Callable[..., str]
     """A callable that returns a string representation of the condition."""
     ends: dict[str, str] | None
-    """Optional dictionary of end node ids for the branches. """
+    """Optional dictionary of end node IDs for the branches. """
 
 
 class CurveStyle(Enum):
@@ -706,8 +706,10 @@ class Graph:
 def _first_node(graph: Graph, exclude: Sequence[str] = ()) -> Node | None:
     """Find the single node that is not a target of any edge.
 
-    Exclude nodes/sources with ids in the exclude list.
+    Exclude nodes/sources with IDs in the exclude list.
+
     If there is no such node, or there are multiple, return `None`.
+
     When drawing the graph, this node would be the origin.
     """
     targets = {edge.target for edge in graph.edges if edge.source not in exclude}
@@ -722,8 +724,10 @@ def _first_node(graph: Graph, exclude: Sequence[str] = ()) -> Node | None:
 def _last_node(graph: Graph, exclude: Sequence[str] = ()) -> Node | None:
     """Find the single node that is not a source of any edge.
 
-    Exclude nodes/targets with ids in the exclude list.
+    Exclude nodes/targets with IDs in the exclude list.
+
     If there is no such node, or there are multiple, return `None`.
+
     When drawing the graph, this node would be the destination.
     """
     sources = {edge.source for edge in graph.edges if edge.target not in exclude}

langchain_core/runnables/retry.py

@@ -126,7 +126,7 @@ class RunnableRetry(RunnableBindingBase[Input, Output]):  # type: ignore[no-rede
 
     exponential_jitter_params: ExponentialJitterParams | None = None
     """Parameters for `tenacity.wait_exponential_jitter`. Namely: `initial`,
-    `max`, `exp_base`, and `jitter` (all float values).
+    `max`, `exp_base`, and `jitter` (all `float` values).
     """
 
     max_attempt_number: int = 3

langchain_core/runnables/schema.py

@@ -65,7 +65,7 @@ class BaseStreamEvent(TypedDict):
 
         events = [event async for event in chain.astream_events("hello")]
 
-        # will produce the following events
+        # Will produce the following events
         # (where some fields have been omitted for brevity):
         [
             {
@@ -168,10 +168,7 @@ class StandardStreamEvent(BaseStreamEvent):
 
 
 class CustomStreamEvent(BaseStreamEvent):
-    """Custom stream event created by the user.
-
-    !!! version-added "Added in version 0.2.15"
-    """
+    """Custom stream event created by the user."""
 
     # Overwrite the event field to be more specific.
     event: Literal["on_custom_event"]  # type: ignore[misc]

langchain_core/runnables/utils.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import ast
 import asyncio
 import inspect
+import sys
 import textwrap
 from collections.abc import Callable, Mapping, Sequence
 from contextvars import Context
@@ -118,14 +119,13 @@ def accepts_context(callable: Callable[..., Any]) -> bool:  # noqa: A002
         return False
 
 
-@lru_cache(maxsize=1)
 def asyncio_accepts_context() -> bool:
-    """Cache the result of checking if asyncio.create_task accepts a `context` arg.
+    """Check if asyncio.create_task accepts a `context` arg.
 
     Returns:
         True if `asyncio.create_task` accepts a context argument, `False` otherwise.
     """
-    return accepts_context(asyncio.create_task)
+    return sys.version_info >= (3, 11)
 
 
 def coro_with_context(

langchain_core/stores.py

@@ -86,7 +86,7 @@ class BaseStore(ABC, Generic[K, V]):
 
         Returns:
             A sequence of optional values associated with the keys.
-            If a key is not found, the corresponding value will be None.
+            If a key is not found, the corresponding value will be `None`.
         """
 
     async def amget(self, keys: Sequence[K]) -> list[V | None]:
@@ -97,7 +97,7 @@ class BaseStore(ABC, Generic[K, V]):
 
         Returns:
             A sequence of optional values associated with the keys.
-            If a key is not found, the corresponding value will be None.
+            If a key is not found, the corresponding value will be `None`.
         """
         return await run_in_executor(None, self.mget, keys)
 
@@ -243,8 +243,7 @@ class InMemoryStore(InMemoryBaseStore[Any]):
     """In-memory store for any type of data.
 
     Attributes:
-        store (dict[str, Any]): The underlying dictionary that stores
-            the key-value pairs.
+        store: The underlying dictionary that stores the key-value pairs.
 
     Examples:
         ```python
@@ -267,8 +266,7 @@ class InMemoryByteStore(InMemoryBaseStore[bytes]):
     """In-memory store for bytes.
 
     Attributes:
-        store (dict[str, bytes]): The underlying dictionary that stores
-            the key-value pairs.
+        store: The underlying dictionary that stores the key-value pairs.
 
     Examples:
         ```python