MapRerankDocumentsChain Class — langchain Architecture

Source Code

libs/langchain/langchain_classic/chains/combine_documents/map_rerank.py lines 30–245

class MapRerankDocumentsChain(BaseCombineDocumentsChain):
    r"""Combining documents by mapping a chain over them, then reranking results.

    This algorithm calls an LLMChain on each input document. The LLMChain is expected
    to have an OutputParser that parses the result into both an answer (`answer_key`)
    and a score (`rank_key`). The answer with the highest score is then returned.

    Example:
        ```python
        from langchain_classic.chains import MapRerankDocumentsChain, LLMChain
        from langchain_core.prompts import PromptTemplate
        from langchain_openai import OpenAI
        from langchain_classic.output_parsers.regex import RegexParser

        document_variable_name = "context"
        model = OpenAI()
        # The prompt here should take as an input variable the
        # `document_variable_name`
        # The actual prompt will need to be a lot more complex, this is just
        # an example.
        prompt_template = (
            "Use the following context to tell me the chemical formula "
            "for water. Output both your answer and a score of how confident "
            "you are. Context: {context}"
        )
        output_parser = RegexParser(
            regex=r"(.*?)\nScore: (.*)",
            output_keys=["answer", "score"],
        )
        prompt = PromptTemplate(
            template=prompt_template,
            input_variables=["context"],
            output_parser=output_parser,
        )
        llm_chain = LLMChain(llm=model, prompt=prompt)
        chain = MapRerankDocumentsChain(
            llm_chain=llm_chain,
            document_variable_name=document_variable_name,
            rank_key="score",
            answer_key="answer",
        )
        ```
    """

    llm_chain: LLMChain
    """Chain to apply to each document individually."""
    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."""
    rank_key: str
    """Key in output of llm_chain to rank on."""
    answer_key: str
    """Key in output of llm_chain to return as answer."""
    metadata_keys: list[str] | None = None
    """Additional metadata from the chosen document to return."""
    return_intermediate_steps: bool = False
    """Return intermediate steps.
    Intermediate steps include the results of calling llm_chain on each document."""

    model_config = ConfigDict(
        arbitrary_types_allowed=True,
        extra="forbid",
    )

    @override
    def get_output_schema(
        self,
        config: RunnableConfig | None = None,
    ) -> type[BaseModel]:
        schema: dict[str, Any] = {
            self.output_key: (str, None),
        }
        if self.return_intermediate_steps:
            schema["intermediate_steps"] = (list[str], None)
        if self.metadata_keys:
            schema.update(dict.fromkeys(self.metadata_keys, (Any, None)))

        return create_model("MapRerankOutput", **schema)

    @property
    def output_keys(self) -> list[str]: