langchain 0.3.27__py3-none-any.whl → 1.0.0a1__py3-none-any.whl

langchain/retrievers/cohere_rag_retriever.py

@@ -1,23 +0,0 @@
-from typing import TYPE_CHECKING, Any
-
-from langchain._api import create_importer
-
-if TYPE_CHECKING:
-    from langchain_community.retrievers import CohereRagRetriever
-
-# Create a way to dynamically look up deprecated imports.
-# Used to consolidate logic for raising deprecation warnings and
-# handling optional imports.
-DEPRECATED_LOOKUP = {"CohereRagRetriever": "langchain_community.retrievers"}
-
-_import_attribute = create_importer(__package__, deprecated_lookups=DEPRECATED_LOOKUP)
-
-
-def __getattr__(name: str) -> Any:
-    """Look up attributes dynamically."""
-    return _import_attribute(name)
-
-
-__all__ = [
-    "CohereRagRetriever",
-]

langchain/retrievers/contextual_compression.py

@@ -1,81 +0,0 @@
-from typing import Any
-
-from langchain_core.callbacks import (
-    AsyncCallbackManagerForRetrieverRun,
-    CallbackManagerForRetrieverRun,
-)
-from langchain_core.documents import BaseDocumentCompressor, Document
-from langchain_core.retrievers import BaseRetriever, RetrieverLike
-from pydantic import ConfigDict
-
-
-class ContextualCompressionRetriever(BaseRetriever):
-    """Retriever that wraps a base retriever and compresses the results."""
-
-    base_compressor: BaseDocumentCompressor
-    """Compressor for compressing retrieved documents."""
-
-    base_retriever: RetrieverLike
-    """Base Retriever to use for getting relevant documents."""
-
-    model_config = ConfigDict(
-        arbitrary_types_allowed=True,
-    )
-
-    def _get_relevant_documents(
-        self,
-        query: str,
-        *,
-        run_manager: CallbackManagerForRetrieverRun,
-        **kwargs: Any,
-    ) -> list[Document]:
-        """Get documents relevant for a query.
-
-        Args:
-            query: string to find relevant documents for
-
-        Returns:
-            Sequence of relevant documents
-        """
-        docs = self.base_retriever.invoke(
-            query,
-            config={"callbacks": run_manager.get_child()},
-            **kwargs,
-        )
-        if docs:
-            compressed_docs = self.base_compressor.compress_documents(
-                docs,
-                query,
-                callbacks=run_manager.get_child(),
-            )
-            return list(compressed_docs)
-        return []
-
-    async def _aget_relevant_documents(
-        self,
-        query: str,
-        *,
-        run_manager: AsyncCallbackManagerForRetrieverRun,
-        **kwargs: Any,
-    ) -> list[Document]:
-        """Get documents relevant for a query.
-
-        Args:
-            query: string to find relevant documents for
-
-        Returns:
-            List of relevant documents
-        """
-        docs = await self.base_retriever.ainvoke(
-            query,
-            config={"callbacks": run_manager.get_child()},
-            **kwargs,
-        )
-        if docs:
-            compressed_docs = await self.base_compressor.acompress_documents(
-                docs,
-                query,
-                callbacks=run_manager.get_child(),
-            )
-            return list(compressed_docs)
-        return []

langchain/retrievers/databerry.py

@@ -1,23 +0,0 @@
-from typing import TYPE_CHECKING, Any
-
-from langchain._api import create_importer
-
-if TYPE_CHECKING:
-    from langchain_community.retrievers.databerry import DataberryRetriever
-
-# Create a way to dynamically look up deprecated imports.
-# Used to consolidate logic for raising deprecation warnings and
-# handling optional imports.
-DEPRECATED_LOOKUP = {"DataberryRetriever": "langchain_community.retrievers.databerry"}
-
-_import_attribute = create_importer(__package__, deprecated_lookups=DEPRECATED_LOOKUP)
-
-
-def __getattr__(name: str) -> Any:
-    """Look up attributes dynamically."""
-    return _import_attribute(name)
-
-
-__all__ = [
-    "DataberryRetriever",
-]

langchain/retrievers/docarray.py

@@ -1,28 +0,0 @@
-from typing import TYPE_CHECKING, Any
-
-from langchain._api import create_importer
-
-if TYPE_CHECKING:
-    from langchain_community.retrievers import DocArrayRetriever
-    from langchain_community.retrievers.docarray import SearchType
-
-# Create a way to dynamically look up deprecated imports.
-# Used to consolidate logic for raising deprecation warnings and
-# handling optional imports.
-DEPRECATED_LOOKUP = {
-    "SearchType": "langchain_community.retrievers.docarray",
-    "DocArrayRetriever": "langchain_community.retrievers",
-}
-
-_import_attribute = create_importer(__package__, deprecated_lookups=DEPRECATED_LOOKUP)
-
-
-def __getattr__(name: str) -> Any:
-    """Look up attributes dynamically."""
-    return _import_attribute(name)
-
-
-__all__ = [
-    "DocArrayRetriever",
-    "SearchType",
-]

langchain/retrievers/document_compressors/__init__.py

@@ -1,44 +0,0 @@
-import importlib
-from typing import Any
-
-from langchain.retrievers.document_compressors.base import DocumentCompressorPipeline
-from langchain.retrievers.document_compressors.chain_extract import (
-    LLMChainExtractor,
-)
-from langchain.retrievers.document_compressors.chain_filter import (
-    LLMChainFilter,
-)
-from langchain.retrievers.document_compressors.cohere_rerank import CohereRerank
-from langchain.retrievers.document_compressors.cross_encoder_rerank import (
-    CrossEncoderReranker,
-)
-from langchain.retrievers.document_compressors.embeddings_filter import (
-    EmbeddingsFilter,
-)
-from langchain.retrievers.document_compressors.listwise_rerank import (
-    LLMListwiseRerank,
-)
-
-_module_lookup = {
-    "FlashrankRerank": "langchain_community.document_compressors.flashrank_rerank",
-}
-
-
-def __getattr__(name: str) -> Any:
-    if name in _module_lookup:
-        module = importlib.import_module(_module_lookup[name])
-        return getattr(module, name)
-    msg = f"module {__name__} has no attribute {name}"
-    raise AttributeError(msg)
-
-
-__all__ = [
-    "CohereRerank",
-    "CrossEncoderReranker",
-    "DocumentCompressorPipeline",
-    "EmbeddingsFilter",
-    "FlashrankRerank",
-    "LLMChainExtractor",
-    "LLMChainFilter",
-    "LLMListwiseRerank",
-]

langchain/retrievers/document_compressors/base.py

@@ -1,82 +0,0 @@
-from collections.abc import Sequence
-from inspect import signature
-from typing import Optional, Union
-
-from langchain_core.callbacks import Callbacks
-from langchain_core.documents import (
-    BaseDocumentCompressor,
-    BaseDocumentTransformer,
-    Document,
-)
-from pydantic import ConfigDict
-
-
-class DocumentCompressorPipeline(BaseDocumentCompressor):
-    """Document compressor that uses a pipeline of Transformers."""
-
-    transformers: list[Union[BaseDocumentTransformer, BaseDocumentCompressor]]
-    """List of document filters that are chained together and run in sequence."""
-
-    model_config = ConfigDict(
-        arbitrary_types_allowed=True,
-    )
-
-    def compress_documents(
-        self,
-        documents: Sequence[Document],
-        query: str,
-        callbacks: Optional[Callbacks] = None,
-    ) -> Sequence[Document]:
-        """Transform a list of documents."""
-        for _transformer in self.transformers:
-            if isinstance(_transformer, BaseDocumentCompressor):
-                accepts_callbacks = (
-                    signature(_transformer.compress_documents).parameters.get(
-                        "callbacks",
-                    )
-                    is not None
-                )
-                if accepts_callbacks:
-                    documents = _transformer.compress_documents(
-                        documents,
-                        query,
-                        callbacks=callbacks,
-                    )
-                else:
-                    documents = _transformer.compress_documents(documents, query)
-            elif isinstance(_transformer, BaseDocumentTransformer):
-                documents = _transformer.transform_documents(documents)
-            else:
-                msg = f"Got unexpected transformer type: {_transformer}"
-                raise ValueError(msg)  # noqa: TRY004
-        return documents
-
-    async def acompress_documents(
-        self,
-        documents: Sequence[Document],
-        query: str,
-        callbacks: Optional[Callbacks] = None,
-    ) -> Sequence[Document]:
-        """Compress retrieved documents given the query context."""
-        for _transformer in self.transformers:
-            if isinstance(_transformer, BaseDocumentCompressor):
-                accepts_callbacks = (
-                    signature(_transformer.acompress_documents).parameters.get(
-                        "callbacks",
-                    )
-                    is not None
-                )
-                if accepts_callbacks:
-                    documents = await _transformer.acompress_documents(
-                        documents,
-                        query,
-                        callbacks=callbacks,
-                    )
-                else:
-                    documents = await _transformer.acompress_documents(documents, query)
-            elif isinstance(_transformer, BaseDocumentTransformer):
-                documents = await _transformer.atransform_documents(documents)
-            else:
-                msg = f"Got unexpected transformer type: {_transformer}"
-                raise ValueError(msg)  # noqa: TRY004
-        return documents

langchain/retrievers/document_compressors/chain_extract.py

@@ -1,121 +0,0 @@
-"""DocumentFilter that uses an LLM chain to extract the relevant parts of documents."""
-
-from __future__ import annotations
-
-from collections.abc import Sequence
-from typing import Any, Callable, Optional, cast
-
-from langchain_core.callbacks import Callbacks
-from langchain_core.documents import BaseDocumentCompressor, Document
-from langchain_core.language_models import BaseLanguageModel
-from langchain_core.output_parsers import BaseOutputParser, StrOutputParser
-from langchain_core.prompts import PromptTemplate
-from langchain_core.runnables import Runnable
-from pydantic import ConfigDict
-
-from langchain.chains.llm import LLMChain
-from langchain.retrievers.document_compressors.chain_extract_prompt import (
-    prompt_template,
-)
-
-
-def default_get_input(query: str, doc: Document) -> dict[str, Any]:
-    """Return the compression chain input."""
-    return {"question": query, "context": doc.page_content}
-
-
-class NoOutputParser(BaseOutputParser[str]):
-    """Parse outputs that could return a null string of some sort."""
-
-    no_output_str: str = "NO_OUTPUT"
-
-    def parse(self, text: str) -> str:
-        cleaned_text = text.strip()
-        if cleaned_text == self.no_output_str:
-            return ""
-        return cleaned_text
-
-
-def _get_default_chain_prompt() -> PromptTemplate:
-    output_parser = NoOutputParser()
-    template = prompt_template.format(no_output_str=output_parser.no_output_str)
-    return PromptTemplate(
-        template=template,
-        input_variables=["question", "context"],
-        output_parser=output_parser,
-    )
-
-
-class LLMChainExtractor(BaseDocumentCompressor):
-    """Document compressor that uses an LLM chain to extract
-    the relevant parts of documents."""
-
-    llm_chain: Runnable
-    """LLM wrapper to use for compressing documents."""
-
-    get_input: Callable[[str, Document], dict] = default_get_input
-    """Callable for constructing the chain input from the query and a Document."""
-
-    model_config = ConfigDict(
-        arbitrary_types_allowed=True,
-    )
-
-    def compress_documents(
-        self,
-        documents: Sequence[Document],
-        query: str,
-        callbacks: Optional[Callbacks] = None,
-    ) -> Sequence[Document]:
-        """Compress page content of raw documents."""
-        compressed_docs = []
-        for doc in documents:
-            _input = self.get_input(query, doc)
-            output_ = self.llm_chain.invoke(_input, config={"callbacks": callbacks})
-            if isinstance(self.llm_chain, LLMChain):
-                output = output_[self.llm_chain.output_key]
-                if self.llm_chain.prompt.output_parser is not None:
-                    output = self.llm_chain.prompt.output_parser.parse(output)
-            else:
-                output = output_
-            if len(output) == 0:
-                continue
-            compressed_docs.append(
-                Document(page_content=cast(str, output), metadata=doc.metadata),
-            )
-        return compressed_docs
-
-    async def acompress_documents(
-        self,
-        documents: Sequence[Document],
-        query: str,
-        callbacks: Optional[Callbacks] = None,
-    ) -> Sequence[Document]:
-        """Compress page content of raw documents asynchronously."""
-        inputs = [self.get_input(query, doc) for doc in documents]
-        outputs = await self.llm_chain.abatch(inputs, {"callbacks": callbacks})
-        compressed_docs = []
-        for i, doc in enumerate(documents):
-            if len(outputs[i]) == 0:
-                continue
-            compressed_docs.append(
-                Document(page_content=outputs[i], metadata=doc.metadata),
-            )
-        return compressed_docs
-
-    @classmethod
-    def from_llm(
-        cls,
-        llm: BaseLanguageModel,
-        prompt: Optional[PromptTemplate] = None,
-        get_input: Optional[Callable[[str, Document], str]] = None,
-        llm_chain_kwargs: Optional[dict] = None,
-    ) -> LLMChainExtractor:
-        """Initialize from LLM."""
-        _prompt = prompt if prompt is not None else _get_default_chain_prompt()
-        _get_input = get_input if get_input is not None else default_get_input
-        if _prompt.output_parser is not None:
-            parser = _prompt.output_parser
-        else:
-            parser = StrOutputParser()
-        llm_chain = _prompt | llm | parser
-        return cls(llm_chain=llm_chain, get_input=_get_input)  # type: ignore[arg-type]

langchain/retrievers/document_compressors/chain_extract_prompt.py

@@ -1,10 +0,0 @@
-prompt_template = """Given the following question and context, extract any part of the context *AS IS* that is relevant to answer the question. If none of the context is relevant return {no_output_str}.
-
-Remember, *DO NOT* edit the extracted parts of the context.
-
-> Question: {{question}}
-> Context:
->>>
-{{context}}
->>>
-Extracted relevant parts:"""  # noqa: E501

langchain/retrievers/document_compressors/chain_filter.py

@@ -1,133 +0,0 @@
-"""Filter that uses an LLM to drop documents that aren't relevant to the query."""
-
-from collections.abc import Sequence
-from typing import Any, Callable, Optional
-
-from langchain_core.callbacks import Callbacks
-from langchain_core.documents import BaseDocumentCompressor, Document
-from langchain_core.language_models import BaseLanguageModel
-from langchain_core.output_parsers import StrOutputParser
-from langchain_core.prompts import BasePromptTemplate, PromptTemplate
-from langchain_core.runnables import Runnable
-from langchain_core.runnables.config import RunnableConfig
-from pydantic import ConfigDict
-
-from langchain.chains import LLMChain
-from langchain.output_parsers.boolean import BooleanOutputParser
-from langchain.retrievers.document_compressors.chain_filter_prompt import (
-    prompt_template,
-)
-
-
-def _get_default_chain_prompt() -> PromptTemplate:
-    return PromptTemplate(
-        template=prompt_template,
-        input_variables=["question", "context"],
-        output_parser=BooleanOutputParser(),
-    )
-
-
-def default_get_input(query: str, doc: Document) -> dict[str, Any]:
-    """Return the compression chain input."""
-    return {"question": query, "context": doc.page_content}
-
-
-class LLMChainFilter(BaseDocumentCompressor):
-    """Filter that drops documents that aren't relevant to the query."""
-
-    llm_chain: Runnable
-    """LLM wrapper to use for filtering documents.
-    The chain prompt is expected to have a BooleanOutputParser."""
-
-    get_input: Callable[[str, Document], dict] = default_get_input
-    """Callable for constructing the chain input from the query and a Document."""
-
-    model_config = ConfigDict(
-        arbitrary_types_allowed=True,
-    )
-
-    def compress_documents(
-        self,
-        documents: Sequence[Document],
-        query: str,
-        callbacks: Optional[Callbacks] = None,
-    ) -> Sequence[Document]:
-        """Filter down documents based on their relevance to the query."""
-        filtered_docs = []
-
-        config = RunnableConfig(callbacks=callbacks)
-        outputs = zip(
-            self.llm_chain.batch(
-                [self.get_input(query, doc) for doc in documents],
-                config=config,
-            ),
-            documents,
-        )
-
-        for output_, doc in outputs:
-            include_doc = None
-            if isinstance(self.llm_chain, LLMChain):
-                output = output_[self.llm_chain.output_key]
-                if self.llm_chain.prompt.output_parser is not None:
-                    include_doc = self.llm_chain.prompt.output_parser.parse(output)
-            elif isinstance(output_, bool):
-                include_doc = output_
-            if include_doc:
-                filtered_docs.append(doc)
-
-        return filtered_docs
-
-    async def acompress_documents(
-        self,
-        documents: Sequence[Document],
-        query: str,
-        callbacks: Optional[Callbacks] = None,
-    ) -> Sequence[Document]:
-        """Filter down documents based on their relevance to the query."""
-        filtered_docs = []
-
-        config = RunnableConfig(callbacks=callbacks)
-        outputs = zip(
-            await self.llm_chain.abatch(
-                [self.get_input(query, doc) for doc in documents],
-                config=config,
-            ),
-            documents,
-        )
-        for output_, doc in outputs:
-            include_doc = None
-            if isinstance(self.llm_chain, LLMChain):
-                output = output_[self.llm_chain.output_key]
-                if self.llm_chain.prompt.output_parser is not None:
-                    include_doc = self.llm_chain.prompt.output_parser.parse(output)
-            elif isinstance(output_, bool):
-                include_doc = output_
-            if include_doc:
-                filtered_docs.append(doc)
-
-        return filtered_docs
-
-    @classmethod
-    def from_llm(
-        cls,
-        llm: BaseLanguageModel,
-        prompt: Optional[BasePromptTemplate] = None,
-        **kwargs: Any,
-    ) -> "LLMChainFilter":
-        """Create a LLMChainFilter from a language model.
-
-        Args:
-            llm: The language model to use for filtering.
-            prompt: The prompt to use for the filter.
-            kwargs: Additional arguments to pass to the constructor.
-
-        Returns:
-            A LLMChainFilter that uses the given language model.
-        """
-        _prompt = prompt if prompt is not None else _get_default_chain_prompt()
-        if _prompt.output_parser is not None:
-            parser = _prompt.output_parser
-        else:
-            parser = StrOutputParser()
-        llm_chain = _prompt | llm | parser
-        return cls(llm_chain=llm_chain, **kwargs)

langchain/retrievers/document_compressors/chain_filter_prompt.py

@@ -1,8 +0,0 @@
-prompt_template = """Given the following question and context, return YES if the context is relevant to the question and NO if it isn't.
-
-> Question: {question}
-> Context:
->>>
-{context}
->>>
-> Relevant (YES / NO):"""  # noqa: E501

langchain/retrievers/document_compressors/cohere_rerank.py

@@ -1,124 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import Sequence
-from copy import deepcopy
-from typing import Any, Optional, Union
-
-from langchain_core._api.deprecation import deprecated
-from langchain_core.callbacks import Callbacks
-from langchain_core.documents import BaseDocumentCompressor, Document
-from langchain_core.utils import get_from_dict_or_env
-from pydantic import ConfigDict, model_validator
-
-
-@deprecated(
-    since="0.0.30",
-    removal="1.0",
-    alternative_import="langchain_cohere.CohereRerank",
-)
-class CohereRerank(BaseDocumentCompressor):
-    """Document compressor that uses `Cohere Rerank API`."""
-
-    client: Any = None
-    """Cohere client to use for compressing documents."""
-    top_n: Optional[int] = 3
-    """Number of documents to return."""
-    model: str = "rerank-english-v2.0"
-    """Model to use for reranking."""
-    cohere_api_key: Optional[str] = None
-    """Cohere API key. Must be specified directly or via environment variable
-        COHERE_API_KEY."""
-    user_agent: str = "langchain"
-    """Identifier for the application making the request."""
-
-    model_config = ConfigDict(
-        arbitrary_types_allowed=True,
-        extra="forbid",
-    )
-
-    @model_validator(mode="before")
-    @classmethod
-    def validate_environment(cls, values: dict) -> Any:
-        """Validate that api key and python package exists in environment."""
-        if not values.get("client"):
-            try:
-                import cohere
-            except ImportError as e:
-                msg = (
-                    "Could not import cohere python package. "
-                    "Please install it with `pip install cohere`."
-                )
-                raise ImportError(msg) from e
-            cohere_api_key = get_from_dict_or_env(
-                values,
-                "cohere_api_key",
-                "COHERE_API_KEY",
-            )
-            client_name = values.get("user_agent", "langchain")
-            values["client"] = cohere.Client(cohere_api_key, client_name=client_name)
-        return values
-
-    def rerank(
-        self,
-        documents: Sequence[Union[str, Document, dict]],
-        query: str,
-        *,
-        model: Optional[str] = None,
-        top_n: Optional[int] = -1,
-        max_chunks_per_doc: Optional[int] = None,
-    ) -> list[dict[str, Any]]:
-        """Returns an ordered list of documents ordered by their relevance to the provided query.
-
-        Args:
-            query: The query to use for reranking.
-            documents: A sequence of documents to rerank.
-            model: The model to use for re-ranking. Default to self.model.
-            top_n : The number of results to return. If None returns all results.
-                Defaults to self.top_n.
-            max_chunks_per_doc : The maximum number of chunks derived from a document.
-        """  # noqa: E501
-        if len(documents) == 0:  # to avoid empty api call
-            return []
-        docs = [
-            doc.page_content if isinstance(doc, Document) else doc for doc in documents
-        ]
-        model = model or self.model
-        top_n = top_n if (top_n is None or top_n > 0) else self.top_n
-        results = self.client.rerank(
-            query=query,
-            documents=docs,
-            model=model,
-            top_n=top_n,
-            max_chunks_per_doc=max_chunks_per_doc,
-        )
-        if hasattr(results, "results"):
-            results = results.results
-        return [
-            {"index": res.index, "relevance_score": res.relevance_score}
-            for res in results
-        ]
-
-    def compress_documents(
-        self,
-        documents: Sequence[Document],
-        query: str,
-        callbacks: Optional[Callbacks] = None,
-    ) -> Sequence[Document]:
-        """
-        Compress documents using Cohere's rerank API.
-
-        Args:
-            documents: A sequence of documents to compress.
-            query: The query to use for compressing the documents.
-            callbacks: Callbacks to run during the compression process.
-
-        Returns:
-            A sequence of compressed documents.
-        """
-        compressed = []
-        for res in self.rerank(documents, query):
-            doc = documents[res["index"]]
-            doc_copy = Document(doc.page_content, metadata=deepcopy(doc.metadata))
-            doc_copy.metadata["relevance_score"] = res["relevance_score"]
-            compressed.append(doc_copy)
-        return compressed