Sentence Chunking

What Is Sentence Chunking?

Sentence chunking divides a document into chunks using sentence boundaries instead of cutting text at an arbitrary character position.

The basic idea is simple: detect complete sentences first, then group one or more sentences into a chunk. This helps a chunk preserve a complete thought when the source document has normal prose.

Why Sentence Boundaries Matter

Imagine a policy sentence says that a refund is available within 30 days if the product is returned unused. Splitting in the middle of that sentence can separate the condition from the rule.

This does not mean every sentence should become its own chunk. Very short chunks may lose useful context, so sentence chunking usually means grouping several sentences into a practical window.

Sentence Chunking vs Fixed-size Chunking

Step 1: Split Text into Sentences

For a learning example, a small regular expression can split ordinary English prose on sentence-ending punctuation. This is useful for understanding the algorithm, but real production text can contain abbreviations, decimals, quotations, headings, and other edge cases.

import re

text = "RAG retrieves external knowledge. The retrieved text is added to the prompt. The model then generates an answer."

sentences = re.split(r'(?<=[.!?])\s+', text.strip())

for number, sentence in enumerate(sentences, start=1):
    print(f"Sentence {number}: {sentence}")

Step 2: Group Sentences into Chunks

After splitting the document into sentences, we can keep adding sentences until a target word count is reached. The boundary is checked between sentences, not in the middle of one.

sentences = [
    "RAG retrieves external knowledge.",
    "The retrieved text is added to the prompt.",
    "The model then generates an answer.",
    "Good chunking can improve retrieval quality."
]

max_words = 12
chunks = []
current = []
current_words = 0

for sentence in sentences:
    words = len(sentence.split())

    if current and current_words + words > max_words:
        chunks.append(" ".join(current))
        current = []
        current_words = 0

    current.append(sentence)
    current_words += words

if current:
    chunks.append(" ".join(current))

for number, chunk in enumerate(chunks, start=1):
    print(f"Chunk {number}: {chunk}")

The result is a set of chunks made from complete sentences. The target is a guide, not a guarantee that every chunk has exactly the same number of words.

Sentence Chunk Size

There are two different decisions: where a sentence ends and how many sentences should be grouped together. A useful starting point is to choose a maximum word or token budget and add complete sentences until the next sentence would exceed it.

Sentence Chunking and Overlap

Overlap means repeating some sentences at the beginning of the next chunk. This can preserve context when an important idea spans a chunk boundary.

Python: Sentence Overlap

A simple sentence-window approach can move forward by fewer sentences than the chunk contains.

sentences = [
    "Sentence one explains the problem.",
    "Sentence two adds important context.",
    "Sentence three gives the rule.",
    "Sentence four explains the exception.",
    "Sentence five gives an example."
]

chunk_size = 3
overlap = 1
step = chunk_size - overlap

chunks = [
    " ".join(sentences[i:i + chunk_size])
    for i in range(0, len(sentences), step)
]

for number, chunk in enumerate(chunks, start=1):
    print(f"Chunk {number}: {chunk}")

Here, the last sentence of one window is repeated in the next window. Production systems should also prevent unnecessary tiny final chunks.

Sentence Chunking Is Not Semantic Chunking

Sentence boundaries are linguistic boundaries, not semantic boundaries. Two adjacent sentences can discuss different topics, while a single topic can continue across several paragraphs.

Sentence chunking is therefore a useful middle step between arbitrary fixed windows and more advanced semantic strategies.

Sentence Chunking in RAG

The retrieved chunks are then passed to the LLM as context. Better chunk boundaries can help the retrieved context contain complete, relevant information instead of fragments.

Keep Metadata With Each Chunk

Chunk text is not the only useful information. Store metadata such as the source document, section, page, chunk position, and document ID so the application can filter and trace retrieved results.

Where Sentence Chunking Works Well

Where It Can Struggle

Improve Sentence Chunking With Structure

A practical pipeline does not have to choose between “only sentences” and “only fixed size.” You can combine rules.

This approach can preserve a section heading while still using sentences as the basic boundary. If a chunk becomes too large, the size rule can split it between sentences rather than through a sentence.

How to Evaluate Sentence Chunking

Do not judge chunking only by whether the chunks look nice. Test whether the right information is retrieved for real questions.

Common Mistakes