langchain-core 0.3.79__py3-none-any.whl → 1.0.0__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,11 +41,11 @@ 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."""
 
 
@@ -87,48 +70,45 @@ class BaseRetriever(RunnableSerializable[RetrieverInput, RetrieverOutput], ABC):
 
     Example: A 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: A simple retriever based on a scikit-learn vectorizer
 
-        .. code-block:: 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 Config:
-                    arbitrary_types_allowed = True
+    class TFIDFRetriever(BaseRetriever, BaseModel):
+        vectorizer: Any
+        docs: list[Document]
+        tfidf_array: Any
+        k: int = 4
 
-                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]]
+        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]]
+    ```
     """
 
     model_config = ConfigDict(
@@ -137,15 +117,15 @@ 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
@@ -155,35 +135,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 +167,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 +175,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 +227,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 +236,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 +316,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)