LangChain / RAG / Vector DBs · 강의

LLM을 활용한 컨텍스트 압축

검색된 문서를 동적으로 필터링하고 압축해 관련 정보에 집중하도록 LLM에 전달할 컨텍스트를 최적화합니다.

레슨 2/412개 단계

LLM을 활용한 컨텍스트 압축은(는) CoddyKit의 무료 LangChain / RAG / Vector DBs 강의입니다. 이것은 4개 중 2번째 강의입니다. 아래에서 전체 강의를 무료로 읽을 수 있으며, 내장 코드 에디터와 24/7 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.

무료로 시작

AI 튜터와 함께 LangChain / RAG / Vector DBs을(를) 배우세요 — 무료

브라우저에서 실제 코드를 작성하고 실행하며, 24/7 AI 튜터로부터 즉각적인 도움을 받고, 웹이나 앱에서 중단한 부분부터 계속 학습하세요.

코스: 12
레슨: 48

무료로 학습 시작 전체 코스 보기

자주 묻는 질문

“LLM을 활용한 컨텍스트 압축” 강의는 무료인가요?

네 — “LLM을 활용한 컨텍스트 압축” 전체 내용을 이 웹사이트에서 무료로 읽을 수 있습니다. 인터랙티브하게 실습하려면(내장 코드 에디터와 24/7 AI 튜터), CoddyKit PRO로 업그레이드하면 LangChain / RAG / Vector DBs 강의 전체를 잠금 해제할 수 있습니다. LangChain / RAG / Vector DBs 강의에는 총 4개의 강의가 포함되어 있습니다.

“LLM을 활용한 컨텍스트 압축”에서 뭘 배우나요?

검색된 문서를 동적으로 필터링하고 압축해 관련 정보에 집중하도록 LLM에 전달할 컨텍스트를 최적화합니다. 브라우저에서 직접 실행하는 실습 코드로 LangChain / RAG / Vector DBs을(를) 배우며, 24/7 AI 튜터가 강의를 진행하면서 질문에 답변해줍니다.

LangChain / RAG / Vector DBs을(를) 시작하는 데 경험이 필요한가요?

사전 경험은 필요하지 않습니다. CoddyKit의 LangChain / RAG / Vector DBs은(는) 초급자부터 고급 학습자까지를 위해 구성되어 있으므로, 여기서 시작하거나 처음부터 시작할 수 있으며 자신의 속도대로 진행할 수 있습니다. 이것은 4개 중 2번째 강의입니다.

“LLM을 활용한 컨텍스트 압축” 강의는 얼마나 걸리나요?

대부분의 CoddyKit 강의는 약 5~10분이 소요됩니다. 각 강의는 간결하고 인터랙티브하여 꾸준한 진행이 가능하며, 웹과 앱에서 중단한 부분부터 바로 시작할 수 있습니다.

이 LangChain / RAG / Vector DBs 강의에서 코드를 작성하고 실행할 수 있나요?

네. 모든 LangChain / RAG / Vector DBs 강의에는 내장 코드 에디터가 포함되어 있으므로, 브라우저에서 바로 실제 코드를 작성하고 실행한 후 즉시 AI 피드백을 받을 수 있습니다 — 로컬 설정이 필요 없습니다.

이 강의의 모든 강의

← LangChain / RAG / Vector DBs(으)로 돌아가기