langchain-core 1.0.0a6__py3-none-any.whl → 1.0.3__py3-none-any.whl

langchain_core/retrievers.py

@@ -3,34 +3,17 @@
 It is more general than a vector store. A retriever does not need to be able to
 store documents, only to return (or retrieve) it. Vector stores can be used as
 the backbone of a retriever, but there are other types of retrievers as well.
-
-**Class hierarchy:**
-
-.. code-block::
-
-    BaseRetriever --> <name>Retriever  # Examples: ArxivRetriever, MergerRetriever
-
-**Main helpers:**
-
-.. code-block::
-
-    RetrieverInput, RetrieverOutput, RetrieverLike, RetrieverOutputLike,
-    Document, Serializable, Callbacks,
-    CallbackManagerForRetrieverRun, AsyncCallbackManagerForRetrieverRun
 """
 
 from __future__ import annotations
 
-import warnings
 from abc import ABC, abstractmethod
 from inspect import signature
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any
 
 from pydantic import ConfigDict
 from typing_extensions import Self, TypedDict, override
 
-from langchain_core._api import deprecated
-from langchain_core.callbacks import Callbacks
 from langchain_core.callbacks.manager import AsyncCallbackManager, CallbackManager
 from langchain_core.documents import Document
 from langchain_core.runnables import (
@@ -58,77 +41,74 @@ class LangSmithRetrieverParams(TypedDict, total=False):
 
     ls_retriever_name: str
     """Retriever name."""
-    ls_vector_store_provider: Optional[str]
+    ls_vector_store_provider: str | None
     """Vector store provider."""
-    ls_embedding_provider: Optional[str]
+    ls_embedding_provider: str | None
     """Embedding provider."""
-    ls_embedding_model: Optional[str]
+    ls_embedding_model: str | None
     """Embedding model."""
 
 
 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"
 
-        .. code-block:: python
+        ```python
+        from langchain_core.documents import Document
+        from langchain_core.retrievers import BaseRetriever
 
-            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 "Simple retriever based on a scikit-learn vectorizer"
 
-    Example: A simple retriever based on a scikit-learn vectorizer
+        ```python
+        from sklearn.metrics.pairwise import cosine_similarity
 
-        .. code-block:: python
 
-            from sklearn.metrics.pairwise import cosine_similarity
+        class TFIDFRetriever(BaseRetriever, BaseModel):
+            vectorizer: Any
+            docs: list[Document]
+            tfidf_array: Any
+            k: int = 4
 
+            class Config:
+                arbitrary_types_allowed = True
 
-            class TFIDFRetriever(BaseRetriever, BaseModel):
-                vectorizer: Any
-                docs: list[Document]
-                tfidf_array: Any
-                k: int = 4
-
-                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(
@@ -137,17 +117,21 @@ class BaseRetriever(RunnableSerializable[RetrieverInput, RetrieverOutput], ABC):
 
     _new_arg_supported: bool = False
     _expects_other_args: bool = False
-    tags: Optional[list[str]] = None
-    """Optional list of tags associated with the retriever. Defaults to None.
+    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: Optional[dict[str, Any]] = None
-    """Optional metadata associated with the retriever. Defaults to None.
+    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.
     """
@@ -155,35 +139,6 @@ class BaseRetriever(RunnableSerializable[RetrieverInput, RetrieverOutput], ABC):
     @override
     def __init_subclass__(cls, **kwargs: Any) -> None:
         super().__init_subclass__(**kwargs)
-        # Version upgrade for old retrievers that implemented the public
-        # methods directly.
-        if cls.get_relevant_documents != BaseRetriever.get_relevant_documents:
-            warnings.warn(
-                "Retrievers must implement abstract `_get_relevant_documents` method"
-                " instead of `get_relevant_documents`",
-                DeprecationWarning,
-                stacklevel=4,
-            )
-            swap = cls.get_relevant_documents
-            cls.get_relevant_documents = (  # type: ignore[method-assign]
-                BaseRetriever.get_relevant_documents
-            )
-            cls._get_relevant_documents = swap  # type: ignore[method-assign]
-        if (
-            hasattr(cls, "aget_relevant_documents")
-            and cls.aget_relevant_documents != BaseRetriever.aget_relevant_documents
-        ):
-            warnings.warn(
-                "Retrievers must implement abstract `_aget_relevant_documents` method"
-                " instead of `aget_relevant_documents`",
-                DeprecationWarning,
-                stacklevel=4,
-            )
-            aswap = cls.aget_relevant_documents
-            cls.aget_relevant_documents = (  # type: ignore[method-assign]
-                BaseRetriever.aget_relevant_documents
-            )
-            cls._aget_relevant_documents = aswap  # type: ignore[method-assign]
         parameters = signature(cls._get_relevant_documents).parameters
         cls._new_arg_supported = parameters.get("run_manager") is not None
         if (
@@ -216,7 +171,7 @@ class BaseRetriever(RunnableSerializable[RetrieverInput, RetrieverOutput], ABC):
 
     @override
     def invoke(
-        self, input: str, config: Optional[RunnableConfig] = None, **kwargs: Any
+        self, input: str, config: RunnableConfig | None = None, **kwargs: Any
     ) -> list[Document]:
         """Invoke the retriever to get relevant documents.
 
@@ -224,18 +179,16 @@ class BaseRetriever(RunnableSerializable[RetrieverInput, RetrieverOutput], ABC):
 
         Args:
             input: The query string.
-            config: Configuration for the retriever. Defaults to None.
-            kwargs: Additional arguments to pass to the retriever.
+            config: Configuration for the retriever.
+            **kwargs: Additional arguments to pass to the retriever.
 
         Returns:
             List of relevant documents.
 
         Examples:
-
-        .. code-block:: python
-
-            retriever.invoke("query")
-
+        ```python
+        retriever.invoke("query")
+        ```
         """
         config = ensure_config(config)
         inheritable_metadata = {
@@ -278,7 +231,7 @@ class BaseRetriever(RunnableSerializable[RetrieverInput, RetrieverOutput], ABC):
     async def ainvoke(
         self,
         input: str,
-        config: Optional[RunnableConfig] = None,
+        config: RunnableConfig | None = None,
         **kwargs: Any,
     ) -> list[Document]:
         """Asynchronously invoke the retriever to get relevant documents.
@@ -287,18 +240,16 @@ class BaseRetriever(RunnableSerializable[RetrieverInput, RetrieverOutput], ABC):
 
         Args:
             input: The query string.
-            config: Configuration for the retriever. Defaults to None.
-            kwargs: Additional arguments to pass to the retriever.
+            config: Configuration for the retriever.
+            **kwargs: Additional arguments to pass to the retriever.
 
         Returns:
             List of relevant documents.
 
         Examples:
-
-        .. code-block:: python
-
-            await retriever.ainvoke("query")
-
+        ```python
+        await retriever.ainvoke("query")
+        ```
         """
         config = ensure_config(config)
         inheritable_metadata = {
@@ -369,91 +320,3 @@ class BaseRetriever(RunnableSerializable[RetrieverInput, RetrieverOutput], ABC):
             query,
             run_manager=run_manager.get_sync(),
         )
-
-    @deprecated(since="0.1.46", alternative="invoke", removal="1.0")
-    def get_relevant_documents(
-        self,
-        query: str,
-        *,
-        callbacks: Callbacks = None,
-        tags: Optional[list[str]] = None,
-        metadata: Optional[dict[str, Any]] = None,
-        run_name: Optional[str] = None,
-        **kwargs: Any,
-    ) -> list[Document]:
-        """Retrieve documents relevant to a query.
-
-        Users should favor using `.invoke` or `.batch` rather than
-        `get_relevant_documents directly`.
-
-        Args:
-            query: string to find relevant documents for.
-            callbacks: Callback manager or list of callbacks. Defaults to None.
-            tags: 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`.
-                Defaults to None.
-            metadata: 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`.
-                Defaults to None.
-            run_name: Optional name for the run. Defaults to None.
-            kwargs: Additional arguments to pass to the retriever.
-
-        Returns:
-            List of relevant documents.
-        """
-        config: RunnableConfig = {}
-        if callbacks:
-            config["callbacks"] = callbacks
-        if tags:
-            config["tags"] = tags
-        if metadata:
-            config["metadata"] = metadata
-        if run_name:
-            config["run_name"] = run_name
-        return self.invoke(query, config, **kwargs)
-
-    @deprecated(since="0.1.46", alternative="ainvoke", removal="1.0")
-    async def aget_relevant_documents(
-        self,
-        query: str,
-        *,
-        callbacks: Callbacks = None,
-        tags: Optional[list[str]] = None,
-        metadata: Optional[dict[str, Any]] = None,
-        run_name: Optional[str] = None,
-        **kwargs: Any,
-    ) -> list[Document]:
-        """Asynchronously get documents relevant to a query.
-
-        Users should favor using `.ainvoke` or `.abatch` rather than
-        `aget_relevant_documents directly`.
-
-        Args:
-            query: string to find relevant documents for.
-            callbacks: Callback manager or list of callbacks.
-            tags: 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`.
-                Defaults to None.
-            metadata: 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`.
-                Defaults to None.
-            run_name: Optional name for the run. Defaults to None.
-            kwargs: Additional arguments to pass to the retriever.
-
-        Returns:
-            List of relevant documents.
-        """
-        config: RunnableConfig = {}
-        if callbacks:
-            config["callbacks"] = callbacks
-        if tags:
-            config["tags"] = tags
-        if metadata:
-            config["metadata"] = metadata
-        if run_name:
-            config["run_name"] = run_name
-        return await self.ainvoke(query, config, **kwargs)