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

langchain/chains/chat_vector_db/prompts.py

@@ -1,19 +0,0 @@
-from langchain_core.prompts.prompt import PromptTemplate
-
-_template = """Given the following conversation and a follow up question, rephrase the follow up question to be a standalone question.
-
-Chat History:
-{chat_history}
-Follow Up Input: {question}
-Standalone question:"""  # noqa: E501
-CONDENSE_QUESTION_PROMPT = PromptTemplate.from_template(_template)
-
-prompt_template = """Use the following pieces of context to answer the question at the end. If you don't know the answer, just say that you don't know, don't try to make up an answer.
-
-{context}
-
-Question: {question}
-Helpful Answer:"""  # noqa: E501
-QA_PROMPT = PromptTemplate(
-    template=prompt_template, input_variables=["context", "question"]
-)

langchain/chains/combine_documents/__init__.py

@@ -1,15 +0,0 @@
-"""Different ways to combine documents."""
-
-from langchain.chains.combine_documents.reduce import (
-    acollapse_docs,
-    collapse_docs,
-    split_list_of_docs,
-)
-from langchain.chains.combine_documents.stuff import create_stuff_documents_chain
-
-__all__ = [
-    "acollapse_docs",
-    "collapse_docs",
-    "create_stuff_documents_chain",
-    "split_list_of_docs",
-]

langchain/chains/combine_documents/base.py

@@ -1,287 +0,0 @@
-"""Base interface for chains combining documents."""
-
-from abc import ABC, abstractmethod
-from typing import Any, Optional
-
-from langchain_core._api import deprecated
-from langchain_core.callbacks import (
-    AsyncCallbackManagerForChainRun,
-    CallbackManagerForChainRun,
-)
-from langchain_core.documents import Document
-from langchain_core.prompts import BasePromptTemplate, PromptTemplate
-from langchain_core.runnables.config import RunnableConfig
-from langchain_core.utils.pydantic import create_model
-from langchain_text_splitters import RecursiveCharacterTextSplitter, TextSplitter
-from pydantic import BaseModel, Field
-
-from langchain.chains.base import Chain
-
-DEFAULT_DOCUMENT_SEPARATOR = "\n\n"
-DOCUMENTS_KEY = "context"
-DEFAULT_DOCUMENT_PROMPT = PromptTemplate.from_template("{page_content}")
-
-
-def _validate_prompt(prompt: BasePromptTemplate, document_variable_name: str) -> None:
-    if document_variable_name not in prompt.input_variables:
-        msg = (
-            f"Prompt must accept {document_variable_name} as an input variable. "
-            f"Received prompt with input variables: {prompt.input_variables}"
-        )
-        raise ValueError(msg)
-
-
-class BaseCombineDocumentsChain(Chain, ABC):
-    """Base interface for chains combining documents.
-
-    Subclasses of this chain deal with combining documents in a variety of
-    ways. This base class exists to add some uniformity in the interface these types
-    of chains should expose. Namely, they expect an input key related to the documents
-    to use (default `input_documents`), and then also expose a method to calculate
-    the length of a prompt from documents (useful for outside callers to use to
-    determine whether it's safe to pass a list of documents into this chain or whether
-    that will be longer than the context length).
-    """
-
-    input_key: str = "input_documents"  #: :meta private:
-    output_key: str = "output_text"  #: :meta private:
-
-    def get_input_schema(
-        self,
-        config: Optional[RunnableConfig] = None,
-    ) -> type[BaseModel]:
-        return create_model(
-            "CombineDocumentsInput",
-            **{self.input_key: (list[Document], None)},
-        )
-
-    def get_output_schema(
-        self,
-        config: Optional[RunnableConfig] = None,
-    ) -> type[BaseModel]:
-        return create_model(
-            "CombineDocumentsOutput",
-            **{self.output_key: (str, None)},
-        )
-
-    @property
-    def input_keys(self) -> list[str]:
-        """Expect input key.
-
-        :meta private:
-        """
-        return [self.input_key]
-
-    @property
-    def output_keys(self) -> list[str]:
-        """Return output key.
-
-        :meta private:
-        """
-        return [self.output_key]
-
-    def prompt_length(self, docs: list[Document], **kwargs: Any) -> Optional[int]:
-        """Return the prompt length given the documents passed in.
-
-        This can be used by a caller to determine whether passing in a list
-        of documents would exceed a certain prompt length. This useful when
-        trying to ensure that the size of a prompt remains below a certain
-        context limit.
-
-        Args:
-            docs: List[Document], a list of documents to use to calculate the
-                total prompt length.
-
-        Returns:
-            Returns None if the method does not depend on the prompt length,
-            otherwise the length of the prompt in tokens.
-        """
-        return None
-
-    @abstractmethod
-    def combine_docs(self, docs: list[Document], **kwargs: Any) -> tuple[str, dict]:
-        """Combine documents into a single string.
-
-        Args:
-            docs: List[Document], the documents to combine
-            **kwargs: Other parameters to use in combining documents, often
-                other inputs to the prompt.
-
-        Returns:
-            The first element returned is the single string output. The second
-            element returned is a dictionary of other keys to return.
-        """
-
-    @abstractmethod
-    async def acombine_docs(
-        self,
-        docs: list[Document],
-        **kwargs: Any,
-    ) -> tuple[str, dict]:
-        """Combine documents into a single string.
-
-        Args:
-            docs: List[Document], the documents to combine
-            **kwargs: Other parameters to use in combining documents, often
-                other inputs to the prompt.
-
-        Returns:
-            The first element returned is the single string output. The second
-            element returned is a dictionary of other keys to return.
-        """
-
-    def _call(
-        self,
-        inputs: dict[str, list[Document]],
-        run_manager: Optional[CallbackManagerForChainRun] = None,
-    ) -> dict[str, str]:
-        """Prepare inputs, call combine docs, prepare outputs."""
-        _run_manager = run_manager or CallbackManagerForChainRun.get_noop_manager()
-        docs = inputs[self.input_key]
-        # Other keys are assumed to be needed for LLM prediction
-        other_keys = {k: v for k, v in inputs.items() if k != self.input_key}
-        output, extra_return_dict = self.combine_docs(
-            docs,
-            callbacks=_run_manager.get_child(),
-            **other_keys,
-        )
-        extra_return_dict[self.output_key] = output
-        return extra_return_dict
-
-    async def _acall(
-        self,
-        inputs: dict[str, list[Document]],
-        run_manager: Optional[AsyncCallbackManagerForChainRun] = None,
-    ) -> dict[str, str]:
-        """Prepare inputs, call combine docs, prepare outputs."""
-        _run_manager = run_manager or AsyncCallbackManagerForChainRun.get_noop_manager()
-        docs = inputs[self.input_key]
-        # Other keys are assumed to be needed for LLM prediction
-        other_keys = {k: v for k, v in inputs.items() if k != self.input_key}
-        output, extra_return_dict = await self.acombine_docs(
-            docs,
-            callbacks=_run_manager.get_child(),
-            **other_keys,
-        )
-        extra_return_dict[self.output_key] = output
-        return extra_return_dict
-
-
-@deprecated(
-    since="0.2.7",
-    alternative=(
-        "example in API reference with more detail: "
-        "https://api.python.langchain.com/en/latest/chains/langchain.chains.combine_documents.base.AnalyzeDocumentChain.html"
-    ),
-    removal="1.0",
-)
-class AnalyzeDocumentChain(Chain):
-    """Chain that splits documents, then analyzes it in pieces.
-
-    This chain is parameterized by a TextSplitter and a CombineDocumentsChain.
-    This chain takes a single document as input, and then splits it up into chunks
-    and then passes those chucks to the CombineDocumentsChain.
-
-    This class is deprecated. See below for alternative implementations which
-    supports async and streaming modes of operation.
-
-    If the underlying combine documents chain takes one ``input_documents`` argument
-    (e.g., chains generated by ``load_summarize_chain``):
-
-        .. code-block:: python
-
-            split_text = lambda x: text_splitter.create_documents([x])
-
-            summarize_document_chain = split_text | chain
-
-    If the underlying chain takes additional arguments (e.g., ``load_qa_chain``, which
-    takes an additional ``question`` argument), we can use the following:
-
-        .. code-block:: python
-
-            from operator import itemgetter
-            from langchain_core.runnables import RunnableLambda, RunnableParallel
-
-            split_text = RunnableLambda(
-                lambda x: text_splitter.create_documents([x])
-            )
-            summarize_document_chain = RunnableParallel(
-                question=itemgetter("question"),
-                input_documents=itemgetter("input_document") | split_text,
-            ) | chain.pick("output_text")
-
-    To additionally return the input parameters, as ``AnalyzeDocumentChain`` does,
-    we can wrap this construction with ``RunnablePassthrough``:
-
-        .. code-block:: python
-
-            from operator import itemgetter
-            from langchain_core.runnables import (
-                RunnableLambda,
-                RunnableParallel,
-                RunnablePassthrough,
-            )
-
-            split_text = RunnableLambda(
-                lambda x: text_splitter.create_documents([x])
-            )
-            summarize_document_chain = RunnablePassthrough.assign(
-                output_text=RunnableParallel(
-                    question=itemgetter("question"),
-                    input_documents=itemgetter("input_document") | split_text,
-                ) | chain.pick("output_text")
-            )
-    """
-
-    input_key: str = "input_document"  #: :meta private:
-    text_splitter: TextSplitter = Field(default_factory=RecursiveCharacterTextSplitter)
-    combine_docs_chain: BaseCombineDocumentsChain
-
-    @property
-    def input_keys(self) -> list[str]:
-        """Expect input key.
-
-        :meta private:
-        """
-        return [self.input_key]
-
-    @property
-    def output_keys(self) -> list[str]:
-        """Return output key.
-
-        :meta private:
-        """
-        return self.combine_docs_chain.output_keys
-
-    def get_input_schema(
-        self,
-        config: Optional[RunnableConfig] = None,
-    ) -> type[BaseModel]:
-        return create_model(
-            "AnalyzeDocumentChain",
-            **{self.input_key: (str, None)},
-        )
-
-    def get_output_schema(
-        self,
-        config: Optional[RunnableConfig] = None,
-    ) -> type[BaseModel]:
-        return self.combine_docs_chain.get_output_schema(config)
-
-    def _call(
-        self,
-        inputs: dict[str, str],
-        run_manager: Optional[CallbackManagerForChainRun] = None,
-    ) -> dict[str, str]:
-        """Split document into chunks and pass to CombineDocumentsChain."""
-        _run_manager = run_manager or CallbackManagerForChainRun.get_noop_manager()
-        document = inputs[self.input_key]
-        docs = self.text_splitter.create_documents([document])
-        # Other keys are assumed to be needed for LLM prediction
-        other_keys: dict = {k: v for k, v in inputs.items() if k != self.input_key}
-        other_keys[self.combine_docs_chain.input_key] = docs
-        return self.combine_docs_chain(
-            other_keys,
-            return_only_outputs=True,
-            callbacks=_run_manager.get_child(),
-        )

langchain/chains/combine_documents/map_reduce.py

@@ -1,300 +0,0 @@
-"""Combining documents by mapping a chain over them first, then combining results."""
-
-from __future__ import annotations
-
-from typing import Any, Optional
-
-from langchain_core._api import deprecated
-from langchain_core.callbacks import Callbacks
-from langchain_core.documents import Document
-from langchain_core.runnables.config import RunnableConfig
-from langchain_core.utils.pydantic import create_model
-from pydantic import BaseModel, ConfigDict, model_validator
-
-from langchain.chains.combine_documents.base import BaseCombineDocumentsChain
-from langchain.chains.combine_documents.reduce import ReduceDocumentsChain
-from langchain.chains.llm import LLMChain
-
-
-@deprecated(
-    since="0.3.1",
-    removal="1.0",
-    message=(
-        "This class is deprecated. Please see the migration guide here for "
-        "a recommended replacement: "
-        "https://python.langchain.com/docs/versions/migrating_chains/map_reduce_chain/"
-    ),
-)
-class MapReduceDocumentsChain(BaseCombineDocumentsChain):
-    """Combining documents by mapping a chain over them, then combining results.
-
-    We first call `llm_chain` on each document individually, passing in the
-    `page_content` and any other kwargs. This is the `map` step.
-
-    We then process the results of that `map` step in a `reduce` step. This should
-    likely be a ReduceDocumentsChain.
-
-    Example:
-        .. code-block:: python
-
-            from langchain.chains import (
-                StuffDocumentsChain,
-                LLMChain,
-                ReduceDocumentsChain,
-                MapReduceDocumentsChain,
-            )
-            from langchain_core.prompts import PromptTemplate
-            from langchain_community.llms import OpenAI
-
-            # This controls how each document will be formatted. Specifically,
-            # it will be passed to `format_document` - see that function for more
-            # details.
-            document_prompt = PromptTemplate(
-                input_variables=["page_content"],
-                 template="{page_content}"
-            )
-            document_variable_name = "context"
-            llm = OpenAI()
-            # The prompt here should take as an input variable the
-            # `document_variable_name`
-            prompt = PromptTemplate.from_template(
-                "Summarize this content: {context}"
-            )
-            llm_chain = LLMChain(llm=llm, prompt=prompt)
-            # We now define how to combine these summaries
-            reduce_prompt = PromptTemplate.from_template(
-                "Combine these summaries: {context}"
-            )
-            reduce_llm_chain = LLMChain(llm=llm, prompt=reduce_prompt)
-            combine_documents_chain = StuffDocumentsChain(
-                llm_chain=reduce_llm_chain,
-                document_prompt=document_prompt,
-                document_variable_name=document_variable_name
-            )
-            reduce_documents_chain = ReduceDocumentsChain(
-                combine_documents_chain=combine_documents_chain,
-            )
-            chain = MapReduceDocumentsChain(
-                llm_chain=llm_chain,
-                reduce_documents_chain=reduce_documents_chain,
-            )
-            # If we wanted to, we could also pass in collapse_documents_chain
-            # which is specifically aimed at collapsing documents BEFORE
-            # the final call.
-            prompt = PromptTemplate.from_template(
-                "Collapse this content: {context}"
-            )
-            llm_chain = LLMChain(llm=llm, prompt=prompt)
-            collapse_documents_chain = StuffDocumentsChain(
-                llm_chain=llm_chain,
-                document_prompt=document_prompt,
-                document_variable_name=document_variable_name
-            )
-            reduce_documents_chain = ReduceDocumentsChain(
-                combine_documents_chain=combine_documents_chain,
-                collapse_documents_chain=collapse_documents_chain,
-            )
-            chain = MapReduceDocumentsChain(
-                llm_chain=llm_chain,
-                reduce_documents_chain=reduce_documents_chain,
-            )
-    """
-
-    llm_chain: LLMChain
-    """Chain to apply to each document individually."""
-    reduce_documents_chain: BaseCombineDocumentsChain
-    """Chain to use to reduce the results of applying `llm_chain` to each doc.
-    This typically either a ReduceDocumentChain or StuffDocumentChain."""
-    document_variable_name: str
-    """The variable name in the llm_chain to put the documents in.
-    If only one variable in the llm_chain, this need not be provided."""
-    return_intermediate_steps: bool = False
-    """Return the results of the map steps in the output."""
-
-    def get_output_schema(
-        self,
-        config: Optional[RunnableConfig] = None,
-    ) -> type[BaseModel]:
-        if self.return_intermediate_steps:
-            return create_model(
-                "MapReduceDocumentsOutput",
-                **{
-                    self.output_key: (str, None),
-                    "intermediate_steps": (list[str], None),
-                },
-            )
-
-        return super().get_output_schema(config)
-
-    @property
-    def output_keys(self) -> list[str]:
-        """Expect input key.
-
-        :meta private:
-        """
-        _output_keys = super().output_keys
-        if self.return_intermediate_steps:
-            _output_keys = [*_output_keys, "intermediate_steps"]
-        return _output_keys
-
-    model_config = ConfigDict(
-        arbitrary_types_allowed=True,
-        extra="forbid",
-    )
-
-    @model_validator(mode="before")
-    @classmethod
-    def get_reduce_chain(cls, values: dict) -> Any:
-        """For backwards compatibility."""
-        if "combine_document_chain" in values:
-            if "reduce_documents_chain" in values:
-                msg = (
-                    "Both `reduce_documents_chain` and `combine_document_chain` "
-                    "cannot be provided at the same time. `combine_document_chain` "
-                    "is deprecated, please only provide `reduce_documents_chain`"
-                )
-                raise ValueError(msg)
-            combine_chain = values["combine_document_chain"]
-            collapse_chain = values.get("collapse_document_chain")
-            reduce_chain = ReduceDocumentsChain(
-                combine_documents_chain=combine_chain,
-                collapse_documents_chain=collapse_chain,
-            )
-            values["reduce_documents_chain"] = reduce_chain
-            del values["combine_document_chain"]
-            values.pop("collapse_document_chain", None)
-
-        return values
-
-    @model_validator(mode="before")
-    @classmethod
-    def get_return_intermediate_steps(cls, values: dict) -> Any:
-        """For backwards compatibility."""
-        if "return_map_steps" in values:
-            values["return_intermediate_steps"] = values["return_map_steps"]
-            del values["return_map_steps"]
-        return values
-
-    @model_validator(mode="before")
-    @classmethod
-    def get_default_document_variable_name(cls, values: dict) -> Any:
-        """Get default document variable name, if not provided."""
-        if "llm_chain" not in values:
-            msg = "llm_chain must be provided"
-            raise ValueError(msg)
-
-        llm_chain_variables = values["llm_chain"].prompt.input_variables
-        if "document_variable_name" not in values:
-            if len(llm_chain_variables) == 1:
-                values["document_variable_name"] = llm_chain_variables[0]
-            else:
-                msg = (
-                    "document_variable_name must be provided if there are "
-                    "multiple llm_chain input_variables"
-                )
-                raise ValueError(msg)
-        elif values["document_variable_name"] not in llm_chain_variables:
-            msg = (
-                f"document_variable_name {values['document_variable_name']} was "
-                f"not found in llm_chain input_variables: {llm_chain_variables}"
-            )
-            raise ValueError(msg)
-        return values
-
-    @property
-    def collapse_document_chain(self) -> BaseCombineDocumentsChain:
-        """Kept for backward compatibility."""
-        if isinstance(self.reduce_documents_chain, ReduceDocumentsChain):
-            if self.reduce_documents_chain.collapse_documents_chain:
-                return self.reduce_documents_chain.collapse_documents_chain
-            return self.reduce_documents_chain.combine_documents_chain
-        msg = (
-            f"`reduce_documents_chain` is of type "
-            f"{type(self.reduce_documents_chain)} so it does not have "
-            f"this attribute."
-        )
-        raise ValueError(msg)
-
-    @property
-    def combine_document_chain(self) -> BaseCombineDocumentsChain:
-        """Kept for backward compatibility."""
-        if isinstance(self.reduce_documents_chain, ReduceDocumentsChain):
-            return self.reduce_documents_chain.combine_documents_chain
-        msg = (
-            f"`reduce_documents_chain` is of type "
-            f"{type(self.reduce_documents_chain)} so it does not have "
-            f"this attribute."
-        )
-        raise ValueError(msg)
-
-    def combine_docs(
-        self,
-        docs: list[Document],
-        token_max: Optional[int] = None,
-        callbacks: Callbacks = None,
-        **kwargs: Any,
-    ) -> tuple[str, dict]:
-        """Combine documents in a map reduce manner.
-
-        Combine by mapping first chain over all documents, then reducing the results.
-        This reducing can be done recursively if needed (if there are many documents).
-        """
-        map_results = self.llm_chain.apply(
-            # FYI - this is parallelized and so it is fast.
-            [{self.document_variable_name: d.page_content, **kwargs} for d in docs],
-            callbacks=callbacks,
-        )
-        question_result_key = self.llm_chain.output_key
-        result_docs = [
-            Document(page_content=r[question_result_key], metadata=docs[i].metadata)
-            # This uses metadata from the docs, and the textual results from `results`
-            for i, r in enumerate(map_results)
-        ]
-        result, extra_return_dict = self.reduce_documents_chain.combine_docs(
-            result_docs,
-            token_max=token_max,
-            callbacks=callbacks,
-            **kwargs,
-        )
-        if self.return_intermediate_steps:
-            intermediate_steps = [r[question_result_key] for r in map_results]
-            extra_return_dict["intermediate_steps"] = intermediate_steps
-        return result, extra_return_dict
-
-    async def acombine_docs(
-        self,
-        docs: list[Document],
-        token_max: Optional[int] = None,
-        callbacks: Callbacks = None,
-        **kwargs: Any,
-    ) -> tuple[str, dict]:
-        """Combine documents in a map reduce manner.
-
-        Combine by mapping first chain over all documents, then reducing the results.
-        This reducing can be done recursively if needed (if there are many documents).
-        """
-        map_results = await self.llm_chain.aapply(
-            # FYI - this is parallelized and so it is fast.
-            [{self.document_variable_name: d.page_content, **kwargs} for d in docs],
-            callbacks=callbacks,
-        )
-        question_result_key = self.llm_chain.output_key
-        result_docs = [
-            Document(page_content=r[question_result_key], metadata=docs[i].metadata)
-            # This uses metadata from the docs, and the textual results from `results`
-            for i, r in enumerate(map_results)
-        ]
-        result, extra_return_dict = await self.reduce_documents_chain.acombine_docs(
-            result_docs,
-            token_max=token_max,
-            callbacks=callbacks,
-            **kwargs,
-        )
-        if self.return_intermediate_steps:
-            intermediate_steps = [r[question_result_key] for r in map_results]
-            extra_return_dict["intermediate_steps"] = intermediate_steps
-        return result, extra_return_dict
-
-    @property
-    def _chain_type(self) -> str:
-        return "map_reduce_documents_chain"