LangChain / RAG / Vector DBs · 课时

使用 LLM 进行上下文压缩

动态筛选并压缩检索到的文档，聚焦相关内容，从而优化传递给 LLM 的上下文

使用 LLM 进行上下文压缩 是 CoddyKit 上的免费 LangChain / RAG / Vector DBs 课时。这是第 2 节课，共 4 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 LangChain / RAG / Vector DBs 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 LangChain / RAG / Vector DBs 课程共包含 4 节课。

本课时的部分内容尚未翻译，以英文显示。

Why Compress Context?

When building RAG (Retrieval Augmented Generation) systems, Large Language Models (LLMs) have a limited context window. Feeding them too much irrelevant information can lead to several problems:

Performance issues: LLMs might get confused by noise.
Higher costs: More tokens mean higher API bills.
Slower responses: More text takes longer to process.

This is where contextual compression comes in!

What is Contextual Compression?

Contextual compression is a technique used to refine the documents retrieved by your RAG system before they are passed to the LLM. It acts as a smart filter and extractor.

Filter: Remove entire documents that are less relevant.
Extract: From the remaining documents, identify and keep only the most pertinent sentences or paragraphs related to the user's query.

Think of it like highlighting the most important parts of a long article.

The Base Retriever's Role

Contextual compression doesn't replace your initial retrieval mechanism. Instead, it works on top of it.

You still need a base retriever (e.g., a vector store retriever) to fetch an initial set of potentially relevant documents.
The compressor then takes these documents and applies its logic to narrow down or condense their content.

It's a refinement step, not a substitute for finding the initial information.

Introducing LangChain's Tools

LangChain provides excellent tools for implementing contextual compression:

The ContextualCompressionRetriever is the main component. It wraps your base retriever and a document compressor.
A document compressor (e.g., an LLM-based one) is the actual logic that filters or extracts information from the documents.

Let's see how to set up a dummy base retriever first.

Setting Up a Base Retriever

Here's a simple dummy retriever. In a real application, this would typically connect to a vector database like Pinecone or Chroma.

from langchain_core.documents import Document

class SimpleBaseRetriever:
    def get_relevant_documents(self, query: str):
        if "programming" in query.lower() or "python" in query.lower():
            return [
                Document(page_content="Python is a versatile programming language. Used in AI & web dev."),
                Document(page_content="Java is popular for enterprise apps."),
                Document(page_content="Data science uses Python for analysis & ML."),
                Document(page_content="History of programming languages dates back centuries.")
            ]
        return [
            Document(page_content="The quick brown fox jumps over the lazy dog."),
            Document(page_content="Cats enjoy napping in sunny spots, especially in the sun."),
            Document(page_content="A computer processes data very quickly and efficiently.")
        ]

base_retriever = SimpleBaseRetriever()
print("Base retriever initialized.")
# Example usage:
# docs = base_retriever.get_relevant_documents("python")
# for doc in docs: print(doc.page_content)

LLMs as Document Compressors

One of the most powerful ways to compress context is by using another LLM! An LLM can intelligently understand the query and the retrieved documents, then extract only the most relevant sentences.

This goes beyond simple keyword matching.
It leverages the LLM's understanding of semantics.

LangChain provides specific compressors that use LLMs for this task.

Using LLMChainExtractor (Code)

The LLMChainExtractor uses an LLM to extract relevant sections from documents. Here's how to set it up along with the ContextualCompressionRetriever.

from langchain_core.documents import Document
from langchain.retrievers.document_compressors import LLMChainExtractor
from langchain.retrievers import ContextualCompressionRetriever
from langchain_openai import OpenAI # pip install langchain-openai

# --- Dummy Base Retriever (for standalone runnable) ---
class SimpleBaseRetriever:
    def get_relevant_documents(self, query: str):
        if "programming" in query.lower() or "python" in query.lower():
            return [
                Document(page_content="Python is a versatile programming language. Used in AI & web dev."),
                Document(page_content="Java is popular for enterprise apps."),
                Document(page_content="Data science uses Python for analysis & ML."),
                Document(page_content="History of programming languages dates back centuries.")
            ]
        return [
            Document(page_content="The quick brown fox jumps over the lazy dog."),
            Document(page_content="Cats enjoy napping in sunny spots, especially in the sun."),
            Document(page_content="A computer processes data very quickly and efficiently.")
        ]
base_retriever = SimpleBaseRetriever()

# --- LLM for Compression ---
# NOTE: You need to set your OpenAI API key as an environment variable
# e.g., import os; os.environ["OPENAI_API_KEY"] = "YOUR_API_KEY"
# Ensure 'langchain-openai' is installed (pip install langchain-openai).
llm = OpenAI(temperature=0.1) # Low temp for focused extraction

# --- Create the Extractor and Compression Retriever ---
compressor = LLMChainExtractor.from_llm(llm)
compression_retriever = ContextualCompressionRetriever(
    base_compressor=compressor,
    base_retriever=base_retriever
)
print("LLMChainExtractor and ContextualCompressionRetriever initialized!")

Running Compressed Retrieval (Code)

Now, let's run a query and observe how the ContextualCompressionRetriever (using LLMChainExtractor) processes the documents. Pay attention to the length of the document content!

from langchain_core.documents import Document
from langchain.retrievers.document_compressors import LLMChainExtractor
from langchain.retrievers import ContextualCompressionRetriever
from langchain_openai import OpenAI # pip install langchain-openai

# --- Dummy Base Retriever (re-defined for standalone runnable) ---
class SimpleBaseRetriever:
    def get_relevant_documents(self, query: str):
        if "programming" in query.lower() or "python" in query.lower():
            return [
                Document(page_content="Python is a versatile programming language. Used in AI & web dev."),
                Document(page_content="Java is popular for enterprise apps."),
                Document(page_content="Data science uses Python for analysis & ML."),
                Document(page_content="History of programming languages dates back centuries.")
            ]
        return [
            Document(page_content="The quick brown fox jumps over the lazy dog."),
            Document(page_content="Cats enjoy napping in sunny spots, especially in the sun."),
            Document(page_content="A computer processes data very quickly and efficiently.")
        ]
base_retriever = SimpleBaseRetriever()

# --- LLM for Compression (re-defined for standalone runnable) ---
# NOTE: You need to set your OpenAI API key as an environment variable
# Ensure 'langchain-openai' is installed.
llm = OpenAI(temperature=0.1)
compressor = LLMChainExtractor.from_llm(llm)
compression_retriever = ContextualCompressionRetriever(
    base_compressor=compressor,
    base_retriever=base_retriever
)

# --- Run a Query ---
query = "What is Python used for?"
print(f"Query: '{query}'\n")

print("--- Original (simulated) documents ---")
original_docs = base_retriever.get_relevant_documents(query)
for i, doc in enumerate(original_docs):
    print(f"Doc {i+1} (Chars: {len(doc.page_content)}): {doc.page_content}")
print(f"Total original documents: {len(original_docs)}\n")

print("--- Content after compression ---")
compressed_docs = compression_retriever.get_relevant_documents(query)
for i, doc in enumerate(compressed_docs):
    # The LLMChainExtractor modifies the page_content of existing docs
    print(f"Compressed Doc {i+1} (Chars: {len(doc.page_content)}): {doc.page_content}")
print(f"Total compressed documents: {len(compressed_docs)}")

Other Compression Options

LangChain offers more than just LLMChainExtractor:

LLMChainFilter: Uses an LLM to decide if an entire document is relevant enough to keep, rather than extracting parts.
EmbeddingsFilter: Filters documents based on the semantic similarity of their embeddings to the query. This is often faster but less nuanced than LLM-based filtering.
DocumentCompressorPipeline: Allows you to chain multiple compressors together for complex logic!

Why Compression Matters

Contextual compression is a powerful technique for optimizing RAG systems:

Improved Relevance: LLMs receive more focused, pertinent information.
Reduced Cost: Fewer tokens are sent to the LLM API.
Faster Responses: LLMs process less text, leading to quicker answers.
Better Accuracy: Less irrelevant noise reduces the chance of LLM hallucinations.

It helps you get more out of your LLMs while saving resources!

Compression Check

Test your understanding of contextual compression!

Contextual Compression Recap

We've explored how contextual compression refines retrieved documents for LLMs:

It's a post-retrieval step that filters and extracts key information.
LangChain's ContextualCompressionRetriever wraps a base retriever and a document compressor.
LLMChainExtractor uses an LLM to intelligently extract relevant snippets.
Benefits include improved relevance, reduced costs, faster responses, and better accuracy.

This technique is vital for optimizing RAG systems, especially with large knowledge bases.

常见问题解答

「使用 LLM 进行上下文压缩」课时是免费的吗？

是的 — 「使用 LLM 进行上下文压缩」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 LangChain / RAG / Vector DBs 课程的其余内容，请升级到 CoddyKit PRO。 LangChain / RAG / Vector DBs 课程共包含 4 节课。

「使用 LLM 进行上下文压缩」这节课中我会学到什么？

动态筛选并压缩检索到的文档，聚焦相关内容，从而优化传递给 LLM 的上下文你通过在浏览器中直接运行的动手代码来练习 LangChain / RAG / Vector DBs，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 LangChain / RAG / Vector DBs 需要有经验吗？

无需任何先前经验。CoddyKit 上的 LangChain / RAG / Vector DBs 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 2 节课，共 4 节。

「使用 LLM 进行上下文压缩」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 LangChain / RAG / Vector DBs 课中编写并运行代码吗？

能。每节 LangChain / RAG / Vector DBs 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

← 返回 LangChain / RAG / Vector DBs