LLMListwiseRerank Class — langchain Architecture

Source Code

libs/langchain/langchain_classic/retrievers/document_compressors/listwise_rerank.py lines 40–146

class LLMListwiseRerank(BaseDocumentCompressor):
    """Document compressor that uses `Zero-Shot Listwise Document Reranking`.

    Adapted from: https://arxiv.org/pdf/2305.02156.pdf

    `LLMListwiseRerank` uses a language model to rerank a list of documents based on
    their relevance to a query.

    !!! note
        Requires that underlying model implement `with_structured_output`.

    Example usage:
        ```python
        from langchain_classic.retrievers.document_compressors.listwise_rerank import (
            LLMListwiseRerank,
        )
        from langchain_core.documents import Document
        from langchain_openai import ChatOpenAI

        documents = [
            Document("Sally is my friend from school"),
            Document("Steve is my friend from home"),
            Document("I didn't always like yogurt"),
            Document("I wonder why it's called football"),
            Document("Where's waldo"),
        ]

        reranker = LLMListwiseRerank.from_llm(
            llm=ChatOpenAI(model="gpt-3.5-turbo"), top_n=3
        )
        compressed_docs = reranker.compress_documents(documents, "Who is steve")
        assert len(compressed_docs) == 3
        assert "Steve" in compressed_docs[0].page_content
        ```
    """

    reranker: Runnable[dict, list[Document]]
    """LLM-based reranker to use for filtering documents. Expected to take in a dict
        with 'documents: Sequence[Document]' and 'query: str' keys and output a
        List[Document]."""

    top_n: int = 3
    """Number of documents to return."""

    model_config = ConfigDict(
        arbitrary_types_allowed=True,
    )

    def compress_documents(
        self,
        documents: Sequence[Document],
        query: str,
        callbacks: Callbacks | None = None,
    ) -> Sequence[Document]:
        """Filter down documents based on their relevance to the query."""
        results = self.reranker.invoke(
            {"documents": documents, "query": query},
            config={"callbacks": callbacks},
        )
        return results[: self.top_n]

    @classmethod
    def from_llm(
        cls,
        llm: BaseLanguageModel,
        *,
        prompt: BasePromptTemplate | None = None,
        **kwargs: Any,
    ) -> "LLMListwiseRerank":
        """Create a LLMListwiseRerank document compressor from a language model.

        Args:
            llm: The language model to use for filtering. **Must implement
                BaseLanguageModel.with_structured_output().**
            prompt: The prompt to use for the filter.
            kwargs: Additional arguments to pass to the constructor.

        Returns:
            A LLMListwiseRerank document compressor that uses the given language model.
        """
        if type(llm).with_structured_output == BaseLanguageModel.with_structured_output: