Contextual compression in LangChain - Step-by-Step Execution

Concept Flow - Contextual compression

Input: Long Text

↓

Split Text into Chunks

↓

Compress Each Chunk Using Context

↓

Combine Compressed Chunks

↓

Output: Compressed Text

The process breaks a long text into smaller parts, compresses each part using context, then combines them into a shorter version.

Execution Sample

LangChain

from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.text_compression import ContextualCompression

text = "This is a long text that needs compression."
splitter = RecursiveCharacterTextSplitter(chunk_size=20)
chunks = splitter.split_text(text)
compressor = ContextualCompression()
compressed = [compressor.compress(chunk) for chunk in chunks]

This code splits a long text into chunks and compresses each chunk contextually.

Execution Table

Step	Action	Input	Output	Notes
1	Split text	"This is a long text that needs compression."	["This is a long text ", "that needs compression."]	Text split into two chunks of max 20 chars
2	Compress chunk 1	"This is a long text "	"This is long text"	Compression removes redundant words using context
3	Compress chunk 2	"that needs compression."	"needs compression"	Compression keeps key meaning
4	Combine compressed chunks	["This is long text", "needs compression"]	"This is long text needs compression"	Chunks joined into compressed text

💡 All chunks compressed and combined into final compressed text

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4
text	"This is a long text that needs compression."	"This is a long text that needs compression."	"This is a long text that needs compression."	"This is a long text that needs compression."	"This is a long text that needs compression."
chunks	[]	["This is a long text ", "that needs compression."]	["This is a long text ", "that needs compression."]	["This is a long text ", "that needs compression."]	["This is a long text ", "that needs compression."]
compressed	[]	[]	["This is long text"]	["This is long text", "needs compression"]	["This is long text", "needs compression"]
final_text	""	""	""	""	"This is long text needs compression"

Key Moments - 3 Insights

Why do we split the text before compressing?

Splitting breaks the long text into smaller parts that are easier to compress effectively, as shown in execution_table step 1.

Does compression remove all words?

No, compression removes only redundant or less important words while keeping the main meaning, as seen in steps 2 and 3.

How do compressed chunks become the final text?

Compressed chunks are combined in order to form a shorter but meaningful text, as shown in step 4.

Visual Quiz - 3 Questions

Look at the execution_table, what is the output after compressing the first chunk?

A "needs compression"

B "This is a long text "

C "This is long text"

D "This is a long text that needs compression."

💡 Hint

Check execution_table row 2 under Output column

At which step are the chunks combined into the final compressed text?

A Step 2

B Step 4

C Step 3

D Step 1

💡 Hint

Look at execution_table rows and find where 'Combine compressed chunks' happens

If the chunk size was larger, how would the number of chunks change?

A Fewer chunks

B More chunks

C Same number of chunks

D Chunks would be empty

💡 Hint

Refer to variable_tracker 'chunks' after Step 1 and think about chunk size effect

Concept Snapshot

Contextual compression breaks long text into smaller chunks.
Each chunk is compressed by removing redundant words using context.
Compressed chunks are combined to form a shorter meaningful text.
Use text splitters and compressors from Langchain.
This helps reduce text size while keeping key information.

Full Transcript

Contextual compression in Langchain works by first splitting a long text into smaller chunks. Each chunk is then compressed by removing unnecessary words while keeping the main meaning. Finally, the compressed chunks are combined to produce a shorter version of the original text. This process helps manage large texts efficiently by reducing their size but preserving important content. The example code shows splitting a text into two parts and compressing each before joining them back. The execution table traces each step, showing inputs and outputs. Variables like 'chunks' and 'compressed' track the state changes. Key moments clarify why splitting is needed and how compression keeps meaning. The quiz tests understanding of outputs at each step and effects of chunk size. Overall, contextual compression is a useful technique to shorten text smartly using Langchain tools.

Practice

1. What is the main purpose of Contextual compression in langchain?

easy

A. To check grammar and spelling errors

B. To translate text into multiple languages

C. To generate random text from a prompt

D. To reduce text size while keeping its important meaning

Solution

1. Step 1: Understand the goal of contextual compression

   Contextual compression aims to shrink text but keep its main meaning intact.

2. Step 2: Compare options with this goal

   Only To reduce text size while keeping its important meaning matches this goal; others describe different tasks.

3. Final Answer:

   To reduce text size while keeping its important meaning -> Option D

4. Quick Check:

   Contextual compression = reduce text size + keep meaning [OK]

Hint: Focus on meaning retention while reducing text size [OK]

Common Mistakes:

• Confusing compression with translation
• Thinking it generates new text
• Assuming it checks grammar

2. Which of the following is the correct way to create a ContextualCompressionRetriever in langchain?

easy

A. ContextualCompressionRetriever(base_retriever, llm)

B. ContextualCompressionRetriever(llm, base_retriever)

C. ContextualCompressionRetriever()

D. ContextualCompressionRetriever(llm)

Solution

1. Step 1: Recall the constructor parameters order

   The correct order is base_retriever first, then llm.

2. Step 2: Match options with correct order

   Only ContextualCompressionRetriever(base_retriever, llm) matches this order; others have wrong order or missing arguments.

3. Final Answer:

   ContextualCompressionRetriever(base_retriever, llm) -> Option A

4. Quick Check:

   Constructor order = base_retriever, llm [OK]

Hint: Remember: retriever first, then language model [OK]

Common Mistakes:

• Swapping the order of parameters
• Omitting required arguments
• Using empty constructor

3. Given this code snippet, what will be the output type of compressed_docs?

from langchain.retrievers import ContextualCompressionRetriever
compressed_retriever = ContextualCompressionRetriever(base_retriever, llm)
compressed_docs = compressed_retriever.get_relevant_documents(query)

medium

A. A list of compressed Document objects

B. A single compressed string

C. A dictionary with original and compressed texts

D. An error because get_relevant_documents is undefined

Solution

1. Step 1: Understand what get_relevant_documents returns

   It returns a list of Document objects relevant to the query.

2. Step 2: Consider compression effect

   ContextualCompressionRetriever compresses content inside Document objects but still returns a list of Documents.

3. Final Answer:

   A list of compressed Document objects -> Option A

4. Quick Check:

   get_relevant_documents returns list of Documents [OK]

Hint: Retriever methods return lists of Documents, not strings [OK]

Common Mistakes:

• Expecting a single string instead of list
• Thinking it returns a dictionary
• Assuming method does not exist

4. You wrote this code but get an error: TypeError: ContextualCompressionRetriever() missing 1 required positional argument. What is the likely cause?

compressed_retriever = ContextualCompressionRetriever(llm)

medium

A. You passed arguments in the wrong order

B. You forgot to pass the base retriever argument

C. You need to import ContextualCompressionRetriever differently

D. The llm argument is invalid

Solution

1. Step 1: Check constructor requirements

   ContextualCompressionRetriever requires both base_retriever and llm arguments.

2. Step 2: Analyze the error message and code

   The code passes only llm, missing base_retriever, causing the error.

3. Final Answer:

   You forgot to pass the base retriever argument -> Option B

4. Quick Check:

   Missing base retriever causes TypeError [OK]

Hint: Always pass base retriever first, then llm [OK]

Common Mistakes:

• Passing only one argument
• Swapping argument order
• Ignoring error message details

5. You want to speed up document retrieval by compressing context but keep key info. Which approach best applies ContextualCompressionRetriever correctly in a langchain app?

hard

A. Replace your retriever with only an LLM that compresses text manually

B. Use ContextualCompressionRetriever without a base retriever to compress all documents at once

C. Wrap your existing retriever with ContextualCompressionRetriever passing your LLM, then query it

D. Compress documents before adding them to the retriever, then use a normal retriever

Solution

1. Step 1: Understand how ContextualCompressionRetriever works

   It wraps an existing retriever and uses an LLM to compress retrieved documents on the fly.

2. Step 2: Evaluate options for correct usage

   Wrap your existing retriever with ContextualCompressionRetriever passing your LLM, then query it correctly wraps the retriever with compression; others either omit retriever or do manual steps outside the pattern.

3. Final Answer:

   Wrap your existing retriever with ContextualCompressionRetriever passing your LLM, then query it -> Option C

4. Quick Check:

   Wrap retriever + LLM = ContextualCompressionRetriever usage [OK]

Hint: Wrap retriever with compression, don't replace or skip it [OK]

Common Mistakes:

• Skipping base retriever wrapping
• Trying to compress all docs at once without retriever
• Replacing retriever with only LLM