langchain-core 1.0.0a8__py3-none-any.whl → 1.0.0rc2__py3-none-any.whl

langchain_core/__init__.py

@@ -1,4 +1,4 @@
-"""``langchain-core`` defines the base abstractions for the LangChain ecosystem.
+"""`langchain-core` defines the base abstractions for the LangChain ecosystem.
 
 The interfaces for core components like chat models, LLMs, vector stores, retrievers,
 and more are defined here. The universal invocation protocol (Runnables) along with

langchain_core/_api/__init__.py

@@ -6,7 +6,6 @@ This module is only relevant for LangChain developers, not for users.
 
     This module and its submodules are for internal use only. Do not use them in your
     own code.  We may change the API at any time with no warning.
-
 """
 
 from typing import TYPE_CHECKING

langchain_core/_api/beta_decorator.py

@@ -40,40 +40,37 @@ def beta(
     """Decorator to mark a function, a class, or a property as beta.
 
     When marking a classmethod, a staticmethod, or a property, the
-    ``@beta`` decorator should go *under* ``@classmethod`` and
-    ``@staticmethod`` (i.e., `beta` should directly decorate the
-    underlying callable), but *over* ``@property``.
+    `@beta` decorator should go *under* `@classmethod` and
+    `@staticmethod` (i.e., `beta` should directly decorate the
+    underlying callable), but *over* `@property`.
 
-    When marking a class ``C`` intended to be used as a base class in a
-    multiple inheritance hierarchy, ``C`` *must* define an ``__init__`` method
-    (if ``C`` instead inherited its ``__init__`` from its own base class, then
-    ``@beta`` would mess up ``__init__`` inheritance when installing its
-    own (annotation-emitting) ``C.__init__``).
+    When marking a class `C` intended to be used as a base class in a
+    multiple inheritance hierarchy, `C` *must* define an `__init__` method
+    (if `C` instead inherited its `__init__` from its own base class, then
+    `@beta` would mess up `__init__` inheritance when installing its
+    own (annotation-emitting) `C.__init__`).
 
     Args:
-        message : str, optional
+        message:
             Override the default beta message. The %(since)s,
             %(name)s, %(alternative)s, %(obj_type)s, %(addendum)s,
             and %(removal)s format specifiers will be replaced by the
             values of the respective arguments passed to this function.
-        name : str, optional
+        name:
             The name of the beta object.
-        obj_type : str, optional
+        obj_type:
             The object type being beta.
-        addendum : str, optional
+        addendum:
             Additional text appended directly to the final message.
 
     Returns:
         A decorator which can be used to mark functions or classes as beta.
 
-    Examples:
-
-        .. code-block:: python
-
-            @beta
-            def the_function_to_annotate():
-                pass
-
+    ```python
+    @beta
+    def the_function_to_annotate():
+        pass
+    ```
     """
 
     def beta(

langchain_core/_api/deprecation.py

@@ -82,62 +82,59 @@ def deprecated(
     """Decorator to mark a function, a class, or a property as deprecated.
 
     When deprecating a classmethod, a staticmethod, or a property, the
-    ``@deprecated`` decorator should go *under* ``@classmethod`` and
-    ``@staticmethod`` (i.e., `deprecated` should directly decorate the
-    underlying callable), but *over* ``@property``.
+    `@deprecated` decorator should go *under* `@classmethod` and
+    `@staticmethod` (i.e., `deprecated` should directly decorate the
+    underlying callable), but *over* `@property`.
 
-    When deprecating a class ``C`` intended to be used as a base class in a
-    multiple inheritance hierarchy, ``C`` *must* define an ``__init__`` method
-    (if ``C`` instead inherited its ``__init__`` from its own base class, then
-    ``@deprecated`` would mess up ``__init__`` inheritance when installing its
-    own (deprecation-emitting) ``C.__init__``).
+    When deprecating a class `C` intended to be used as a base class in a
+    multiple inheritance hierarchy, `C` *must* define an `__init__` method
+    (if `C` instead inherited its `__init__` from its own base class, then
+    `@deprecated` would mess up `__init__` inheritance when installing its
+    own (deprecation-emitting) `C.__init__`).
 
     Parameters are the same as for `warn_deprecated`, except that *obj_type*
     defaults to 'class' if decorating a class, 'attribute' if decorating a
     property, and 'function' otherwise.
 
     Args:
-        since : str
+        since:
             The release at which this API became deprecated.
-        message : str, optional
+        message:
             Override the default deprecation message. The %(since)s,
             %(name)s, %(alternative)s, %(obj_type)s, %(addendum)s,
             and %(removal)s format specifiers will be replaced by the
             values of the respective arguments passed to this function.
-        name : str, optional
+        name:
             The name of the deprecated object.
-        alternative : str, optional
+        alternative:
             An alternative API that the user may use in place of the
             deprecated API. The deprecation warning will tell the user
             about this alternative if provided.
-        alternative_import: str, optional
+        alternative_import:
             An alternative import that the user may use instead.
-        pending : bool, optional
-            If True, uses a PendingDeprecationWarning instead of a
+        pending:
+            If `True`, uses a `PendingDeprecationWarning` instead of a
             DeprecationWarning. Cannot be used together with removal.
-        obj_type : str, optional
+        obj_type:
             The object type being deprecated.
-        addendum : str, optional
+        addendum:
             Additional text appended directly to the final message.
-        removal : str, optional
+        removal:
             The expected removal version. With the default (an empty
             string), a removal version is automatically computed from
             since. Set to other Falsy values to not schedule a removal
             date. Cannot be used together with pending.
-        package: str, optional
+        package:
             The package of the deprecated object.
 
     Returns:
         A decorator to mark a function or class as deprecated.
 
-    Examples:
-
-        .. code-block:: python
-
-            @deprecated("1.4.0")
-            def the_function_to_deprecate():
-                pass
-
+    ```python
+    @deprecated("1.4.0")
+    def the_function_to_deprecate():
+        pass
+    ```
     """
     _validate_deprecation_params(
         removal, alternative, alternative_import, pending=pending
@@ -372,7 +369,7 @@ def deprecated(
         components = [
             _message,
             f"Use {_alternative} instead." if _alternative else "",
-            f"Use ``{_alternative_import}`` instead." if _alternative_import else "",
+            f"Use `{_alternative_import}` instead." if _alternative_import else "",
             _addendum,
         ]
         details = " ".join([component.strip() for component in components if component])
@@ -440,7 +437,7 @@ def warn_deprecated(
         alternative_import:
             An alternative import that the user may use instead.
         pending:
-            If True, uses a PendingDeprecationWarning instead of a
+            If `True`, uses a `PendingDeprecationWarning` instead of a
             DeprecationWarning. Cannot be used together with removal.
         obj_type:
             The object type being deprecated.
@@ -550,12 +547,10 @@ def rename_parameter(
         A decorator indicating that a parameter was renamed.
 
     Example:
-
-        .. code-block:: python
-
-            @_api.rename_parameter("3.1", "bad_name", "good_name")
-            def func(good_name): ...
-
+        ```python
+        @_api.rename_parameter("3.1", "bad_name", "good_name")
+        def func(good_name): ...
+        ```
     """
 
     def decorator(f: Callable[_P, _R]) -> Callable[_P, _R]:

langchain_core/_import_utils.py

@@ -13,7 +13,7 @@ def import_attr(
 
     Args:
         attr_name: The name of the attribute to import.
-        module_name: The name of the module to import from. If None, the attribute
+        module_name: The name of the module to import from. If `None`, the attribute
             is imported from the package itself.
         package: The name of the package where the module is located.
 

langchain_core/agents.py

@@ -1,8 +1,9 @@
 """Schema definitions for representing agent actions, observations, and return values.
 
-**ATTENTION** The schema definitions are provided for backwards compatibility.
+!!! warning
+    The schema definitions are provided for backwards compatibility.
 
-!!! important
+!!! warning
     New agents should be built using the
     [langgraph library](https://github.com/langchain-ai/langgraph), which provides a
     simpler and more flexible way to define agents.
@@ -16,10 +17,10 @@ Agents use language models to choose a sequence of actions to take.
 A basic agent works in the following manner:
 
 1. Given a prompt an agent uses an LLM to request an action to take
-   (e.g., a tool to run).
+    (e.g., a tool to run).
 2. The agent executes the action (e.g., runs the tool), and receives an observation.
 3. The agent returns the observation to the LLM, which can then be used to generate
-   the next action.
+    the next action.
 4. When the agent reaches a stopping condition, it returns a final return value.
 
 The schemas for the agents themselves are defined in langchain.agents.agent.
@@ -83,10 +84,10 @@ class AgentAction(Serializable):
 
     @classmethod
     def get_lc_namespace(cls) -> list[str]:
-        """Get the namespace of the langchain object.
+        """Get the namespace of the LangChain object.
 
         Returns:
-            ``["langchain", "schema", "agent"]``
+            `["langchain", "schema", "agent"]`
         """
         return ["langchain", "schema", "agent"]
 
@@ -111,7 +112,7 @@ class AgentActionMessageLog(AgentAction):
     if (tool, tool_input) cannot be used to fully recreate the LLM
     prediction, and you need that LLM prediction (for future agent iteration).
     Compared to `log`, this is useful when the underlying LLM is a
-    ChatModel (and therefore returns messages rather than a string)."""
+    chat model (and therefore returns messages rather than a string)."""
     # Ignoring type because we're overriding the type from AgentAction.
     # And this is the correct thing to do in this case.
     # The type literal is used for serialization purposes.
@@ -160,10 +161,10 @@ class AgentFinish(Serializable):
 
     @classmethod
     def get_lc_namespace(cls) -> list[str]:
-        """Get the namespace of the langchain object.
+        """Get the namespace of the LangChain object.
 
         Returns:
-            ``["langchain", "schema", "agent"]``
+            `["langchain", "schema", "agent"]`
         """
         return ["langchain", "schema", "agent"]
 

langchain_core/caches.py

@@ -1,24 +1,15 @@
-"""Cache classes.
+"""`caches` provides an optional caching layer for language models.
 
 !!! warning
-  Beta Feature!
+    This is a beta feature! Please be wary of deploying experimental code to production
+    unless you've taken appropriate precautions.
 
-**Cache** provides an optional caching layer for LLMs.
+A cache is useful for two reasons:
 
-Cache is useful for two reasons:
-
-- It can save you money by reducing the number of API calls you make to the LLM
-  provider if you're often requesting the same completion multiple times.
-- It can speed up your application by reducing the number of API calls you make
-  to the LLM provider.
-
-Cache directly competes with Memory. See documentation for Pros and Cons.
-
-**Class hierarchy:**
-
-.. code-block::
-
-    BaseCache --> <name>Cache  # Examples: InMemoryCache, RedisCache, GPTCache
+1. It can save you money by reducing the number of API calls you make to the LLM
+    provider if you're often requesting the same completion multiple times.
+2. It can speed up your application by reducing the number of API calls you make to the
+    LLM provider.
 """
 
 from __future__ import annotations
@@ -40,8 +31,8 @@ class BaseCache(ABC):
 
     The cache interface consists of the following methods:
 
-    - lookup: Look up a value based on a prompt and llm_string.
-    - update: Update the cache based on a prompt and llm_string.
+    - lookup: Look up a value based on a prompt and `llm_string`.
+    - update: Update the cache based on a prompt and `llm_string`.
     - clear: Clear the cache.
 
     In addition, the cache interface provides an async version of each method.
@@ -53,14 +44,14 @@ class BaseCache(ABC):
 
     @abstractmethod
     def lookup(self, prompt: str, llm_string: str) -> RETURN_VAL_TYPE | None:
-        """Look up based on prompt and llm_string.
+        """Look up based on `prompt` and `llm_string`.
 
         A cache implementation is expected to generate a key from the 2-tuple
         of prompt and llm_string (e.g., by concatenating them with a delimiter).
 
         Args:
-            prompt: a string representation of the prompt.
-                In the case of a Chat model, the prompt is a non-trivial
+            prompt: A string representation of the prompt.
+                In the case of a chat model, the prompt is a non-trivial
                 serialization of the prompt into the language model.
             llm_string: A string representation of the LLM configuration.
                 This is used to capture the invocation parameters of the LLM
@@ -69,27 +60,27 @@ class BaseCache(ABC):
                 representation.
 
         Returns:
-            On a cache miss, return None. On a cache hit, return the cached value.
-            The cached value is a list of Generations (or subclasses).
+            On a cache miss, return `None`. On a cache hit, return the cached value.
+            The cached value is a list of `Generation` (or subclasses).
         """
 
     @abstractmethod
     def update(self, prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE) -> None:
-        """Update cache based on prompt and llm_string.
+        """Update cache based on `prompt` and `llm_string`.
 
         The prompt and llm_string are used to generate a key for the cache.
         The key should match that of the lookup method.
 
         Args:
-            prompt: a string representation of the prompt.
-                In the case of a Chat model, the prompt is a non-trivial
+            prompt: A string representation of the prompt.
+                In the case of a chat model, the prompt is a non-trivial
                 serialization of the prompt into the language model.
             llm_string: A string representation of the LLM configuration.
                 This is used to capture the invocation parameters of the LLM
                 (e.g., model name, temperature, stop tokens, max tokens, etc.).
                 These invocation parameters are serialized into a string
                 representation.
-            return_val: The value to be cached. The value is a list of Generations
+            return_val: The value to be cached. The value is a list of `Generation`
                 (or subclasses).
         """
 
@@ -98,14 +89,14 @@ class BaseCache(ABC):
         """Clear cache that can take additional keyword arguments."""
 
     async def alookup(self, prompt: str, llm_string: str) -> RETURN_VAL_TYPE | None:
-        """Async look up based on prompt and llm_string.
+        """Async look up based on `prompt` and `llm_string`.
 
         A cache implementation is expected to generate a key from the 2-tuple
         of prompt and llm_string (e.g., by concatenating them with a delimiter).
 
         Args:
-            prompt: a string representation of the prompt.
-                In the case of a Chat model, the prompt is a non-trivial
+            prompt: A string representation of the prompt.
+                In the case of a chat model, the prompt is a non-trivial
                 serialization of the prompt into the language model.
             llm_string: A string representation of the LLM configuration.
                 This is used to capture the invocation parameters of the LLM
@@ -114,29 +105,29 @@ class BaseCache(ABC):
                 representation.
 
         Returns:
-            On a cache miss, return None. On a cache hit, return the cached value.
-            The cached value is a list of Generations (or subclasses).
+            On a cache miss, return `None`. On a cache hit, return the cached value.
+            The cached value is a list of `Generation` (or subclasses).
         """
         return await run_in_executor(None, self.lookup, prompt, llm_string)
 
     async def aupdate(
         self, prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE
     ) -> None:
-        """Async update cache based on prompt and llm_string.
+        """Async update cache based on `prompt` and `llm_string`.
 
         The prompt and llm_string are used to generate a key for the cache.
         The key should match that of the look up method.
 
         Args:
-            prompt: a string representation of the prompt.
-                In the case of a Chat model, the prompt is a non-trivial
+            prompt: A string representation of the prompt.
+                In the case of a chat model, the prompt is a non-trivial
                 serialization of the prompt into the language model.
             llm_string: A string representation of the LLM configuration.
                 This is used to capture the invocation parameters of the LLM
                 (e.g., model name, temperature, stop tokens, max tokens, etc.).
                 These invocation parameters are serialized into a string
                 representation.
-            return_val: The value to be cached. The value is a list of Generations
+            return_val: The value to be cached. The value is a list of `Generation`
                 (or subclasses).
         """
         return await run_in_executor(None, self.update, prompt, llm_string, return_val)
@@ -154,12 +145,11 @@ class InMemoryCache(BaseCache):
 
         Args:
             maxsize: The maximum number of items to store in the cache.
-                If None, the cache has no maximum size.
+                If `None`, the cache has no maximum size.
                 If the cache exceeds the maximum size, the oldest items are removed.
-                Default is None.
 
         Raises:
-            ValueError: If maxsize is less than or equal to 0.
+            ValueError: If `maxsize` is less than or equal to `0`.
         """
         self._cache: dict[tuple[str, str], RETURN_VAL_TYPE] = {}
         if maxsize is not None and maxsize <= 0:
@@ -168,28 +158,28 @@ class InMemoryCache(BaseCache):
         self._maxsize = maxsize
 
     def lookup(self, prompt: str, llm_string: str) -> RETURN_VAL_TYPE | None:
-        """Look up based on prompt and llm_string.
+        """Look up based on `prompt` and `llm_string`.
 
         Args:
-            prompt: a string representation of the prompt.
-                In the case of a Chat model, the prompt is a non-trivial
+            prompt: A string representation of the prompt.
+                In the case of a chat model, the prompt is a non-trivial
                 serialization of the prompt into the language model.
             llm_string: A string representation of the LLM configuration.
 
         Returns:
-            On a cache miss, return None. On a cache hit, return the cached value.
+            On a cache miss, return `None`. On a cache hit, return the cached value.
         """
         return self._cache.get((prompt, llm_string), None)
 
     def update(self, prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE) -> None:
-        """Update cache based on prompt and llm_string.
+        """Update cache based on `prompt` and `llm_string`.
 
         Args:
-            prompt: a string representation of the prompt.
-                In the case of a Chat model, the prompt is a non-trivial
+            prompt: A string representation of the prompt.
+                In the case of a chat model, the prompt is a non-trivial
                 serialization of the prompt into the language model.
             llm_string: A string representation of the LLM configuration.
-            return_val: The value to be cached. The value is a list of Generations
+            return_val: The value to be cached. The value is a list of `Generation`
                 (or subclasses).
         """
         if self._maxsize is not None and len(self._cache) == self._maxsize:
@@ -202,30 +192,30 @@ class InMemoryCache(BaseCache):
         self._cache = {}
 
     async def alookup(self, prompt: str, llm_string: str) -> RETURN_VAL_TYPE | None:
-        """Async look up based on prompt and llm_string.
+        """Async look up based on `prompt` and `llm_string`.
 
         Args:
-            prompt: a string representation of the prompt.
-                In the case of a Chat model, the prompt is a non-trivial
+            prompt: A string representation of the prompt.
+                In the case of a chat model, the prompt is a non-trivial
                 serialization of the prompt into the language model.
             llm_string: A string representation of the LLM configuration.
 
         Returns:
-            On a cache miss, return None. On a cache hit, return the cached value.
+            On a cache miss, return `None`. On a cache hit, return the cached value.
         """
         return self.lookup(prompt, llm_string)
 
     async def aupdate(
         self, prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE
     ) -> None:
-        """Async update cache based on prompt and llm_string.
+        """Async update cache based on `prompt` and `llm_string`.
 
         Args:
-            prompt: a string representation of the prompt.
-                In the case of a Chat model, the prompt is a non-trivial
+            prompt: A string representation of the prompt.
+                In the case of a chat model, the prompt is a non-trivial
                 serialization of the prompt into the language model.
             llm_string: A string representation of the LLM configuration.
-            return_val: The value to be cached. The value is a list of Generations
+            return_val: The value to be cached. The value is a list of `Generation`
                 (or subclasses).
         """
         self.update(prompt, llm_string, return_val)

langchain_core/callbacks/__init__.py

@@ -1,11 +1,4 @@
-"""**Callback handlers** allow listening to events in LangChain.
-
-**Class hierarchy:**
-
-.. code-block::
-
-    BaseCallbackHandler --> <name>CallbackHandler  # Example: AimCallbackHandler
-"""
+"""**Callback handlers** allow listening to events in LangChain."""
 
 from typing import TYPE_CHECKING