Retrieved document (600 tokens):
"XYZ Corp was founded in 1985 and has grown to 50,000 employees worldwide.
The company operates in 30 countries and serves over 10 million customers.
Our customer service team is available 24/7 and we pride ourselves on
customer satisfaction scores in the top quartile for our industry.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Our return policy allows customers to return items within 30 days of purchase
for a full refund, provided the item is in original condition. Items purchased
during sale events may have a 15-day return window. For defective items,
we offer a 90-day return period regardless of sale status.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
We are committed to sustainability and have reduced carbon emissions by 30%..."

Query: "What is the return policy?"

Relevant portion (80 tokens):
"Our return policy allows customers to return items within 30 days of purchase
for a full refund, provided the item is in original condition. Items purchased
during sale events may have a 15-day return window. For defective items,
we offer a 90-day return period regardless of sale status."

87% token reduction, 100% of the answer preserved.

from langchain.retrievers import ContextualCompressionRetriever
from langchain.retrievers.document_compressors import LLMChainExtractor
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)

# LLM-based extractor: asks LLM to extract relevant portions
compressor = LLMChainExtractor.from_llm(llm)

compression_retriever = ContextualCompressionRetriever(
    base_compressor=compressor,
    base_retriever=base_retriever,  # any retriever
)

# Returns only the relevant portions of each document
compressed_docs = compression_retriever.invoke(
    "What is the return policy for defective items?"
)

for doc in compressed_docs:
    print(doc.page_content)  # only the relevant extract

from langchain.retrievers.document_compressors import EmbeddingsFilter
from langchain_openai import OpenAIEmbeddings

embeddings_filter = EmbeddingsFilter(
    embeddings=OpenAIEmbeddings(),
    similarity_threshold=0.76,  # keep sentences with >0.76 cosine sim to query
)

compression_retriever = ContextualCompressionRetriever(
    base_compressor=embeddings_filter,
    base_retriever=base_retriever,
)

Original prompt (800 tokens):
"Please answer the following question based on the provided context.
The context is from our product documentation.
[Full 600-token document with all sentences]
Question: What is the return policy?"

LLMLingua compressed (200 tokens):
"Answer based on context.
[return policy allow customer return items 30 days full refund original condition
sale events 15-day return defective items 90-day]
Question: return policy?"

75% compression with ~95% answer accuracy preservation

from llmlingua import PromptCompressor

llm_lingua = PromptCompressor(
    model_name="microsoft/llmlingua-2-bert-base-multilingual-cased-meetingbank",
    use_llmlingua2=True,
)

context = "\n\n".join([doc.page_content for doc in retrieved_docs])

compressed_prompt = llm_lingua.compress_prompt(
    context,
    question="What is the return policy?",
    target_token=200,  # compress to 200 tokens
    rank_method="longllmlingua",
    context_budget="+100",
)

final_prompt = f"{compressed_prompt}\n\nQuestion: What is the return policy?"

from langchain_core.runnables import RunnablePassthrough
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate

prompt = ChatPromptTemplate.from_messages([
    ("system", "Answer the question using only the provided context."),
    ("human", "Context:\n{context}\n\nQuestion: {question}"),
])

def format_compressed_docs(docs):
    return "\n\n---\n\n".join([doc.page_content for doc in docs])

# Full compressed RAG chain
rag_chain = (
    {
        "context": compression_retriever | format_compressed_docs,
        "question": RunnablePassthrough(),
    }
    | prompt
    | ChatOpenAI(model="gpt-4o")
    | StrOutputParser()
)

answer = rag_chain.invoke("What is the return policy for defective items?")

def evaluate_compression(
    original_docs: list[str],
    compressed_docs: list[str],
    answers_with_original: list[str],
    answers_with_compressed: list[str],
    ground_truth: list[str],
) -> dict:
    token_reduction = 1 - (
        sum(len(c.split()) for c in compressed_docs) /
        sum(len(d.split()) for d in original_docs)
    )

    # Use ROUGE-L to compare answer quality
    from rouge_score import rouge_scorer
    scorer = rouge_scorer.RougeScorer(['rougeL'], use_stemmer=True)

    original_quality = sum(
        scorer.score(gt, ans)['rougeL'].fmeasure
        for gt, ans in zip(ground_truth, answers_with_original)
    ) / len(ground_truth)

    compressed_quality = sum(
        scorer.score(gt, ans)['rougeL'].fmeasure
        for gt, ans in zip(ground_truth, answers_with_compressed)
    ) / len(ground_truth)

    return {
        "token_reduction": token_reduction,
        "quality_original": original_quality,
        "quality_compressed": compressed_quality,
        "quality_preservation": compressed_quality / original_quality,
    }