Semantic chunking strategies in LangChain - Step-by-Step Execution

Concept Flow - Semantic chunking strategies

Input Text Document

↓

Split Text into Chunks

↓

Apply Semantic Embeddings

↓

Compare Chunk Similarities

↓

Merge or Adjust Chunks Based on Similarity Threshold

↓

Output Optimized Semantic Chunks

The process starts with input text, splits it into chunks, applies semantic embeddings to understand meaning, compares chunks for similarity, merges or adjusts them, and outputs optimized chunks.

Execution Sample

LangChain

from langchain.text_splitter import RecursiveCharacterTextSplitter
splitter = RecursiveCharacterTextSplitter(chunk_size=100, chunk_overlap=20)
chunks = splitter.split_text(text)
# Then embed and merge semantically similar chunks

This code splits text into overlapping chunks, preparing for semantic embedding and merging.

Execution Table

Step	Action	Input/State	Output/State	Notes
1	Receive input text	Full document text	Text ready for splitting	Start with raw text
2	Split text into chunks	Full text	List of text chunks (each ~100 chars, 20 overlap)	Chunks created with overlap
3	Generate embeddings	Text chunks	Vector embeddings for each chunk	Semantic meaning captured numerically
4	Calculate similarity	Embeddings	Similarity scores between chunks	Measure semantic closeness
5	Merge similar chunks	Chunks + similarity scores	Optimized chunk list	Combine highly similar chunks
6	Output chunks	Optimized chunks	Final semantic chunks	Ready for downstream tasks
7	End	N/A	Process complete	All chunks semantically optimized

💡 All chunks processed and merged based on semantic similarity threshold

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 5	Final
text	Full document text	Same text	Same text	Same text	Same text
chunks	N/A	List of text chunks	Same list	Merged chunk list	Final chunk list
embeddings	N/A	N/A	List of vectors	Same list	Same list
similarity_scores	N/A	N/A	N/A	Matrix of scores	Used for merging

Key Moments - 3 Insights

Why do we split text into overlapping chunks instead of non-overlapping?

Overlapping chunks ensure context is preserved across chunk boundaries, as shown in execution_table step 2 where chunks overlap by 20 characters.

How do embeddings help in merging chunks?

Embeddings convert text chunks into vectors capturing meaning, allowing similarity calculation (step 4) to merge semantically close chunks (step 5).

What happens if similarity threshold is too low or too high?

If too low, unrelated chunks merge losing detail; if too high, chunks remain fragmented. The merging step (5) balances this for optimal chunk size.

Visual Quiz - 3 Questions

Look at the execution_table, what is the output after step 2?

A List of overlapping text chunks

B Vector embeddings of text

C Similarity scores matrix

D Final merged chunks

💡 Hint

Refer to execution_table row with Step 2 describing chunk splitting output

At which step are semantic embeddings generated?

A Step 5

B Step 2

C Step 3

D Step 6

💡 Hint

Check execution_table row for Step 3 about generating embeddings

If chunk overlap was removed, which variable in variable_tracker would change after Step 2?

A text

B chunks

C embeddings

D similarity_scores

💡 Hint

Look at variable_tracker for 'chunks' after Step 2 and consider overlap effect

Concept Snapshot

Semantic chunking splits text into overlapping pieces,
then converts chunks into vectors (embeddings) to capture meaning.
Chunks with high semantic similarity are merged to optimize size.
This helps keep context and improves downstream processing.
Overlap preserves context; embeddings guide merging.
Final chunks balance detail and size for best results.

Full Transcript

Semantic chunking strategies in Langchain start by taking a full text document and splitting it into smaller overlapping chunks to preserve context. Each chunk is then converted into a vector embedding that captures its semantic meaning. These embeddings are compared to find similarity scores between chunks. Based on these scores, chunks that are very similar are merged to create optimized semantic chunks. This process ensures that the chunks maintain meaningful context and are sized well for further tasks like search or summarization. Overlapping chunks help keep context across boundaries, and embeddings allow us to measure meaning beyond just text. The final output is a list of semantically optimized chunks ready for use.

Practice

1. What is the main purpose of semantic chunking in langchain?

easy

A. To compress text into shorter summaries

B. To split text into meaningful parts for better understanding by language models

C. To randomly divide text into equal parts without context

D. To translate text into different languages automatically

Solution

1. Step 1: Understand semantic chunking

   Semantic chunking means dividing text into parts that keep meaning intact for better processing.

2. Step 2: Identify the purpose in langchain

   Langchain uses semantic chunking to help language models understand text better by keeping related content together.

3. Final Answer:

   To split text into meaningful parts for better understanding by language models -> Option B

4. Quick Check:

   Semantic chunking = meaningful text parts [OK]

Hint: Semantic chunking means meaningful text parts, not random splits [OK]

Common Mistakes:

• Thinking chunking is random splitting
• Confusing chunking with summarization
• Assuming chunking translates text

2. Which of the following is the correct way to set chunk size and overlap in langchain's semantic chunking?

easy

A. chunk_size=500, chunk_overlap=50

B. chunk_size='large', chunk_overlap='small'

C. chunk_size=0, chunk_overlap=1000

D. chunk_size=-100, chunk_overlap=-10

Solution

1. Step 1: Check valid chunk size and overlap values

   Chunk size and overlap should be positive integers representing text length in characters or tokens.

2. Step 2: Evaluate each option

   chunk_size=500, chunk_overlap=50 uses positive integers (500 and 50), which is valid. Options B uses strings, C and D use zero or negative numbers which are invalid.

3. Final Answer:

   chunk_size=500, chunk_overlap=50 -> Option A

4. Quick Check:

   Valid chunk size and overlap are positive numbers [OK]

Hint: Use positive integers for chunk size and overlap [OK]

Common Mistakes:

• Using strings instead of numbers
• Setting zero or negative values
• Confusing chunk size with overlap

3. Given this code snippet using langchain's semantic chunking:

text = "Hello world. This is a test. Langchain helps chunk text."
chunks = chunk_text(text, chunk_size=12, chunk_overlap=4)
print(chunks)

What is the expected output?

medium

A. SyntaxError due to invalid chunking parameters

B. ["Hello world. This", "This is a test.", "Langchain helps chunk text."]

C. ["Hello", "world.", "This", "is", "a", "test."]

D. ["Hello world.", "world. This is", "This is a test.", "a test. Langchain", "Langchain helps", "helps chunk text."]

Solution

1. Step 1: Understand chunk size and overlap effect

   Chunk size 12 means each chunk has up to 12 characters; overlap 4 means next chunk starts 4 characters before previous chunk ends.

2. Step 2: Trace chunk creation on text

   Chunks will overlap by 4 characters, producing overlapping meaningful parts like "Hello world.", "world. This is", etc.

3. Final Answer:

   ["Hello world.", "world. This is", "This is a test.", "a test. Langchain", "Langchain helps", "helps chunk text."] -> Option D

4. Quick Check:

   Chunk size 12 + overlap 4 = overlapping meaningful chunks [OK]

Hint: Overlap means next chunk starts before previous ends [OK]

Common Mistakes:

• Ignoring overlap and making chunks non-overlapping
• Splitting by words instead of characters
• Assuming syntax error without checking parameters

4. You wrote this code for semantic chunking but get an error:

chunks = chunk_text(text, chunk_size=100, chunk_overlap=150)

What is the likely cause of the error?

medium

A. chunk_overlap is larger than chunk_size, causing invalid overlap

B. chunk_size is too large for the text length

C. Missing import statement for chunk_text function

D. chunk_size and chunk_overlap must be strings, not integers

Solution

1. Step 1: Check relationship between chunk_size and chunk_overlap

   Overlap cannot be larger than chunk size because overlap defines how much chunks share content.

2. Step 2: Identify error cause

   chunk_overlap=150 is greater than chunk_size=100, which is invalid and causes error.

3. Final Answer:

   chunk_overlap is larger than chunk_size, causing invalid overlap -> Option A

4. Quick Check:

   Overlap must be ≤ chunk size [OK]

Hint: Overlap cannot exceed chunk size [OK]

Common Mistakes:

• Setting overlap larger than chunk size
• Assuming large chunk size causes error
• Confusing data types for parameters

5. You want to chunk a long document so that each chunk ends at a sentence boundary and overlaps by one sentence to keep context. Which semantic chunking strategy in langchain best fits this need?

hard

A. Use chunking with chunk_size smaller than sentence length

B. Use fixed-size chunking with chunk_size=1000 and chunk_overlap=0

C. Use a separator-based chunking with '\n\n' as separator and chunk_overlap set to one sentence

D. Use random chunking ignoring sentence boundaries

Solution

1. Step 1: Understand requirement for sentence boundary chunking

   To keep chunks ending at sentence boundaries, use a separator that matches sentence breaks like double newlines.

2. Step 2: Choose chunking strategy with overlap

   Separator-based chunking with overlap of one sentence keeps context by repeating last sentence in next chunk.

3. Final Answer:

   Use a separator-based chunking with '\n\n' as separator and chunk_overlap set to one sentence -> Option C

4. Quick Check:

   Separator chunking + overlap = sentence boundary chunks [OK]

Hint: Use separators matching sentences plus overlap for context [OK]

Common Mistakes:

• Using fixed-size chunking ignoring sentence ends
• Setting zero overlap losing context
• Choosing chunk size smaller than sentence length