langchain-core 1.0.0rc1__py3-none-any.whl → 1.0.0rc3__py3-none-any.whl

langchain_core/agents.py

@@ -84,7 +84,7 @@ 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"]`
@@ -112,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.
@@ -161,7 +161,7 @@ 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_core/caches.py

@@ -1,18 +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
+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.
-- 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.
+2. It can speed up your application by reducing the number of API calls you make to the
+    LLM provider.
 """
 
 from __future__ import annotations
@@ -34,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.
@@ -47,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
@@ -63,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).
         """
 
@@ -92,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
@@ -108,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)
@@ -150,10 +147,9 @@ class InMemoryCache(BaseCache):
             maxsize: The maximum number of items to store in the cache.
                 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:
@@ -162,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:
@@ -196,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/base.py

@@ -1001,7 +1001,7 @@ class BaseCallbackManager(CallbackManagerMixin):
 
         Args:
             handler: The handler to add.
-            inherit: Whether to inherit the handler. Default is True.
+            inherit: Whether to inherit the handler.
         """
         if handler not in self.handlers:
             self.handlers.append(handler)
@@ -1028,7 +1028,7 @@ class BaseCallbackManager(CallbackManagerMixin):
 
         Args:
             handlers: The handlers to set.
-            inherit: Whether to inherit the handlers. Default is True.
+            inherit: Whether to inherit the handlers.
         """
         self.handlers = []
         self.inheritable_handlers = []
@@ -1044,7 +1044,7 @@ class BaseCallbackManager(CallbackManagerMixin):
 
         Args:
             handler: The handler to set.
-            inherit: Whether to inherit the handler. Default is True.
+            inherit: Whether to inherit the handler.
         """
         self.set_handlers([handler], inherit=inherit)
 
@@ -1057,7 +1057,7 @@ class BaseCallbackManager(CallbackManagerMixin):
 
         Args:
             tags: The tags to add.
-            inherit: Whether to inherit the tags. Default is True.
+            inherit: Whether to inherit the tags.
         """
         for tag in tags:
             if tag in self.tags:
@@ -1087,7 +1087,7 @@ class BaseCallbackManager(CallbackManagerMixin):
 
         Args:
             metadata: The metadata to add.
-            inherit: Whether to inherit the metadata. Default is True.
+            inherit: Whether to inherit the metadata.
         """
         self.metadata.update(metadata)
         if inherit:

langchain_core/callbacks/file.py

@@ -132,7 +132,7 @@ class FileCallbackHandler(BaseCallbackHandler):
         Args:
             text: The text to write to the file.
             color: Optional color for the text. Defaults to `self.color`.
-            end: String appended after the text. Defaults to `""`.
+            end: String appended after the text.
             file: Optional file to write to. Defaults to `self.file`.
 
         Raises:
@@ -239,7 +239,7 @@ class FileCallbackHandler(BaseCallbackHandler):
             text: The text to write.
             color: Color override for this specific output. If `None`, uses
                 `self.color`.
-            end: String appended after the text. Defaults to `""`.
+            end: String appended after the text.
             **kwargs: Additional keyword arguments.
 
         """

langchain_core/callbacks/stdout.py

@@ -104,7 +104,7 @@ class StdOutCallbackHandler(BaseCallbackHandler):
         Args:
             text: The text to print.
             color: The color to use for the text.
-            end: The end character to use. Defaults to "".
+            end: The end character to use.
             **kwargs: Additional keyword arguments.
         """
         print_text(text, color=color or self.color, end=end)

langchain_core/chat_history.py

@@ -153,7 +153,7 @@ class BaseChatMessageHistory(ABC):
 
         Raises:
             NotImplementedError: If the sub-class has not implemented an efficient
-                add_messages method.
+                `add_messages` method.
         """
         if type(self).add_messages != BaseChatMessageHistory.add_messages:
             # This means that the sub-class has implemented an efficient add_messages

langchain_core/document_loaders/base.py

@@ -35,38 +35,38 @@ class BaseLoader(ABC):  # noqa: B024
     # Sub-classes should not implement this method directly. Instead, they
     # should implement the lazy load method.
     def load(self) -> list[Document]:
-        """Load data into Document objects.
+        """Load data into `Document` objects.
 
         Returns:
-            the documents.
+            The documents.
         """
         return list(self.lazy_load())
 
     async def aload(self) -> list[Document]:
-        """Load data into Document objects.
+        """Load data into `Document` objects.
 
         Returns:
-            the documents.
+            The documents.
         """
         return [document async for document in self.alazy_load()]
 
     def load_and_split(
         self, text_splitter: TextSplitter | None = None
     ) -> list[Document]:
-        """Load Documents and split into chunks. Chunks are returned as Documents.
+        """Load Documents and split into chunks. Chunks are returned as `Document`.
 
         Do not override this method. It should be considered to be deprecated!
 
         Args:
-            text_splitter: TextSplitter instance to use for splitting documents.
-                Defaults to RecursiveCharacterTextSplitter.
+            text_splitter: `TextSplitter` instance to use for splitting documents.
+                Defaults to `RecursiveCharacterTextSplitter`.
 
         Raises:
-            ImportError: If langchain-text-splitters is not installed
-                and no text_splitter is provided.
+            ImportError: If `langchain-text-splitters` is not installed
+                and no `text_splitter` is provided.
 
         Returns:
-            List of Documents.
+            List of `Document`.
         """
         if text_splitter is None:
             if not _HAS_TEXT_SPLITTERS:
@@ -86,10 +86,10 @@ class BaseLoader(ABC):  # noqa: B024
     # Attention: This method will be upgraded into an abstractmethod once it's
     #            implemented in all the existing subclasses.
     def lazy_load(self) -> Iterator[Document]:
-        """A lazy loader for Documents.
+        """A lazy loader for `Document`.
 
         Yields:
-            the documents.
+            The `Document` objects.
         """
         if type(self).load != BaseLoader.load:
             return iter(self.load())
@@ -97,10 +97,10 @@ class BaseLoader(ABC):  # noqa: B024
         raise NotImplementedError(msg)
 
     async def alazy_load(self) -> AsyncIterator[Document]:
-        """A lazy loader for Documents.
+        """A lazy loader for `Document`.
 
         Yields:
-            the documents.
+            The `Document` objects.
         """
         iterator = await run_in_executor(None, self.lazy_load)
         done = object()
@@ -115,7 +115,7 @@ class BaseBlobParser(ABC):
     """Abstract interface for blob parsers.
 
     A blob parser provides a way to parse raw data stored in a blob into one
-    or more documents.
+    or more `Document` objects.
 
     The parser can be composed with blob loaders, making it easy to reuse
     a parser independent of how the blob was originally loaded.
@@ -128,25 +128,25 @@ class BaseBlobParser(ABC):
         Subclasses are required to implement this method.
 
         Args:
-            blob: Blob instance
+            blob: `Blob` instance
 
         Returns:
-            Generator of documents
+            Generator of `Document` objects
         """
 
     def parse(self, blob: Blob) -> list[Document]:
-        """Eagerly parse the blob into a document or documents.
+        """Eagerly parse the blob into a `Document` or `Document` objects.
 
         This is a convenience method for interactive development environment.
 
-        Production applications should favor the lazy_parse method instead.
+        Production applications should favor the `lazy_parse` method instead.
 
         Subclasses should generally not over-ride this parse method.
 
         Args:
-            blob: Blob instance
+            blob: `Blob` instance
 
         Returns:
-            List of documents
+            List of `Document` objects
         """
         return list(self.lazy_parse(blob))

langchain_core/document_loaders/langsmith.py

@@ -76,8 +76,8 @@ class LangSmithLoader(BaseLoader):
             splits: A list of dataset splits, which are
                 divisions of your dataset such as 'train', 'test', or 'validation'.
                 Returns examples only from the specified splits.
-            inline_s3_urls: Whether to inline S3 URLs. Defaults to `True`.
-            offset: The offset to start from. Defaults to 0.
+            inline_s3_urls: Whether to inline S3 URLs.
+            offset: The offset to start from.
             limit: The maximum number of examples to return.
             metadata: Metadata to filter by.
             filter: A structured filter string to apply to the examples.

langchain_core/documents/base.py

@@ -57,51 +57,51 @@ class Blob(BaseMedia):
 
     Example: Initialize a blob from in-memory data
 
-        ```python
-        from langchain_core.documents import Blob
+    ```python
+    from langchain_core.documents import Blob
 
-        blob = Blob.from_data("Hello, world!")
+    blob = Blob.from_data("Hello, world!")
 
-        # Read the blob as a string
-        print(blob.as_string())
+    # Read the blob as a string
+    print(blob.as_string())
 
-        # Read the blob as bytes
-        print(blob.as_bytes())
+    # Read the blob as bytes
+    print(blob.as_bytes())
 
-        # Read the blob as a byte stream
-        with blob.as_bytes_io() as f:
-            print(f.read())
-        ```
+    # Read the blob as a byte stream
+    with blob.as_bytes_io() as f:
+        print(f.read())
+    ```
 
     Example: Load from memory and specify mime-type and metadata
 
-        ```python
-        from langchain_core.documents import Blob
+    ```python
+    from langchain_core.documents import Blob
 
-        blob = Blob.from_data(
-            data="Hello, world!",
-            mime_type="text/plain",
-            metadata={"source": "https://example.com"},
-        )
-        ```
+    blob = Blob.from_data(
+        data="Hello, world!",
+        mime_type="text/plain",
+        metadata={"source": "https://example.com"},
+    )
+    ```
 
     Example: Load the blob from a file
 
-        ```python
-        from langchain_core.documents import Blob
+    ```python
+    from langchain_core.documents import Blob
 
-        blob = Blob.from_path("path/to/file.txt")
+    blob = Blob.from_path("path/to/file.txt")
 
-        # Read the blob as a string
-        print(blob.as_string())
+    # Read the blob as a string
+    print(blob.as_string())
 
-        # Read the blob as bytes
-        print(blob.as_bytes())
+    # Read the blob as bytes
+    print(blob.as_bytes())
 
-        # Read the blob as a byte stream
-        with blob.as_bytes_io() as f:
-            print(f.read())
-        ```
+    # Read the blob as a byte stream
+    with blob.as_bytes_io() as f:
+        print(f.read())
+    ```
     """
 
     data: bytes | str | None = None
@@ -111,7 +111,7 @@ class Blob(BaseMedia):
     encoding: str = "utf-8"
     """Encoding to use if decoding the bytes into a string.
 
-    Use utf-8 as default encoding, if decoding to string.
+    Use `utf-8` as default encoding, if decoding to string.
     """
     path: PathLike | None = None
     """Location where the original content was found."""
@@ -127,7 +127,7 @@ class Blob(BaseMedia):
 
         If a path is associated with the blob, it will default to the path location.
 
-        Unless explicitly set via a metadata field called "source", in which
+        Unless explicitly set via a metadata field called `"source"`, in which
         case that value will be used instead.
         """
         if self.metadata and "source" in self.metadata:
@@ -211,11 +211,11 @@ class Blob(BaseMedia):
         """Load the blob from a path like object.
 
         Args:
-            path: path like object to file to be read
+            path: Path-like object to file to be read
             encoding: Encoding to use if decoding the bytes into a string
-            mime_type: if provided, will be set as the mime-type of the data
+            mime_type: If provided, will be set as the mime-type of the data
             guess_type: If `True`, the mimetype will be guessed from the file extension,
-                        if a mime-type was not provided
+                if a mime-type was not provided
             metadata: Metadata to associate with the blob
 
         Returns:
@@ -248,10 +248,10 @@ class Blob(BaseMedia):
         """Initialize the blob from in-memory data.
 
         Args:
-            data: the in-memory data associated with the blob
+            data: The in-memory data associated with the blob
             encoding: Encoding to use if decoding the bytes into a string
-            mime_type: if provided, will be set as the mime-type of the data
-            path: if provided, will be set as the source from which the data came
+            mime_type: If provided, will be set as the mime-type of the data
+            path: If provided, will be set as the source from which the data came
             metadata: Metadata to associate with the blob
 
         Returns:
@@ -303,7 +303,7 @@ class Document(BaseMedia):
 
     @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", "document"]

langchain_core/embeddings/fake.py

@@ -18,7 +18,8 @@ class FakeEmbeddings(Embeddings, BaseModel):
 
     This embedding model creates embeddings by sampling from a normal distribution.
 
-    Do not use this outside of testing, as it is not a real embedding model.
+    !!! warning
+        Do not use this outside of testing, as it is not a real embedding model.
 
     Instantiate:
         ```python
@@ -72,7 +73,8 @@ class DeterministicFakeEmbedding(Embeddings, BaseModel):
     This embedding model creates embeddings by sampling from a normal distribution
     with a seed based on the hash of the text.
 
-    Do not use this outside of testing, as it is not a real embedding model.
+    !!! warning
+        Do not use this outside of testing, as it is not a real embedding model.
 
     Instantiate:
         ```python