Chunking: uw documenten intelligent opsplitsen
Op deze pagina
Doelstellingen
- Begrijpen waarom chunking cruciaal is voor de kwaliteit van RAG
- Verschillende splitsstrategieën beheersen
- De juiste chunk-grootte en overlap kiezen
Waarom documenten splitsen?
Embedding-modellen hebben een tokenlimiet: 8.191 voor OpenAI. Deze limiet is de eerste reden om documenten te splitsen, maar niet de belangrijkste. Zelfs een document dat ruim onder deze grens blijft, levert slechte resultaten op wanneer het als één blok wordt gecodeerd, omdat de resulterende vector alle inhoud middelt en details verliest. Neem een HR-handboek van 40 pagina’s dat verlofbeleid, thuiswerken, onkostenvergoedingen en zorgverzekeringen behandelt: de enkele embedding daarvan lijkt niet echt op een van deze vier onderwerpen, en een zoekopdracht naar “hoeveel verlofdagen” zal het lager ranken dan een veel korter, maar veel gerichter document.
Chunking lost dit probleem op door het document in coherente stukken te breken, die elk een specifiek idee of alinea vastleggen. Dit is de stap waarbij een RAG-pipeline de meeste kwaliteit wint of verliest, nog voordat u een embedding-model kiest.
Strategie 1: Chunking met vaste grootte
De eenvoudigste methode telt woorden en snijdt op regelmatige intervallen. Deze methode negeert de tekststructuur volledig, wat rigoureus is, maar het kost slechts drie regels code en dient als een essentiële basislijn: elke meer geavanceerde strategie moet bewijzen dat deze beter presteert dan deze.
def chunker_fixed_size(
text: str,
size: int = 500,
overlap: int = 100
) -> list[str]:
"""Splits text into fixed-size chunks with overlap."""
words = text.split()
chunks = []
for i in range(0, len(words), size - overlap):
chunk = " ".join(words[i:i + size])
if chunk.strip():
chunks.append(chunk)
return chunks
long_text = "A very long document... " * 500
chunks = chunker_fixed_size(long_text, size=300, overlap=50)
print(f"{len(chunks)} chunks generated")
De parameter overlap verdient aandacht. Zonder overlap zal een snee uiteindelijk midden in een uitleg belanden: de zin “de opzegtermijn bedraagt drie maanden” belandt in de ene chunk en “behalve tijdens de proeftijd” in de volgende. Geen van beide beantwoordt de vraag correct, en de tweede is zelfs misleidend. Door chunks met 10–20% van hun grootte te laten overlappen, garandeert u dat elk idee minstens één keer intact ergens in de index bestaat. Dit is een goed uitgangspunt; pas dit later aan op basis van uw documentdichtheid.
Strategie 2: Chunking op basis van scheidingstekens
In plaats van woord voor woord te snijden, kunt u de natuurlijke grenzen van de tekst respecteren. Het idee is om eerst het sterkste scheidingsteken te proberen — de dubbele regeleinde die twee alinea’s scheidt — en vervolgens af te dalen naar progressively zwakkere scheidingstekens zolang het resulterende stuk de maximale grootte overschrijdt. Een blogpost wordt zo alinea per alinea gesplitst, en alleen een monstrueuze alinea wordt gefragmenteerd op zinsniveau.
import re
def chunker_separators(
text: str,
separators: list[str] = ["\n\n", "\n", ". ", " "],
max_size: int = 1000
) -> list[str]:
"""Splits text while respecting natural separators."""
chunks = []
current_chunk = ""
# Split by the strongest separator first
segments = [text]
for sep in separators:
new_segments = []
for segment in segments:
parts = segment.split(sep)
for part in parts:
if len(part.split()) > max_size:
new_segments.append(part)
else:
if (current_chunk and
len((current_chunk + sep + part).split()) > max_size):
chunks.append(current_chunk.strip())
current_chunk = part
else:
current_chunk = (
current_chunk + sep + part
if current_chunk else part
)
segments = new_segments
if current_chunk.strip():
chunks.append(current_chunk.strip())
return chunks
Strategie 3: Chunking van Markdown-secties
Wanneer uw corpus uit gestructureerde documentatie bestaat, doen koppen het werk al voor u: de auteur heeft de betekeniseenheden al afgebakend. Splitsen op #- en ##-kopniveaus produceert chunks die exact overeenkomen met secties, en de onderstaande functie houdt de kop samen met de tekst, wat we direct daarna gebruiken voor verrijking.
def chunker_markdown(text: str, max_level: int = 2) -> list[dict]:
"""Splits a Markdown document by sections."""
chunks = []
current_section = {"title": "", "content": "", "level": 0}
for line in text.split("\n"):
# Detect headings
match = re.match(r"^(#{1,6})\s+(.+)$", line)
if match:
level = len(match.group(1))
title = match.group(2)
if level <= max_level and current_section["content"].strip():
chunks.append({
"title": current_section["title"],
"text": current_section["content"].strip(),
"level": current_section["level"]
})
if level <= max_level:
current_section = {
"title": title,
"content": "",
"level": level
}
else:
current_section["content"] += line + "\n"
else:
current_section["content"] += line + "\n"
if current_section["content"].strip():
chunks.append({
"title": current_section["title"],
"text": current_section["content"].strip(),
"level": current_section["level"]
})
return chunks
Strategie 4: Semantische chunking
Voor tekst zonder expliciete structuur — een vergaderverslag, een transcriptie van een telefoongesprek — weten noch grootte noch scheidingstekens waar het onderwerp verandert. Embeddings wel. U codeert elke zin, vergelijkt elke zin met de vorige en snijdt waar de similariteit instort: dat is precies waar de spreker overschakelde van budget naar werving. Merk op dat text-embedding-3-small hier voldoende is, aangezien u niet op absolute precisie zoekt, maar op een relatief breekpunt.
from openai import OpenAI
import numpy as np
client = OpenAI()
def chunker_semantic(
text: str,
similarity_threshold: float = 0.75,
min_sentence_length: int = 20
) -> list[str]:
"""Groups sentences by semantic similarity."""
# Split into sentences
sentences = re.split(r"(?<=[.!?])\s+", text)
sentences = [s for s in sentences if len(s) > min_sentence_length]
if len(sentences) <= 1:
return [text]
# Embeddings for each sentence
resp = client.embeddings.create(
input=sentences,
model="text-embedding-3-small" # small is sufficient here
)
embs = np.array([d.embedding for d in sorted(resp.data, key=lambda x: x.index)])
# Find break points
chunks = []
chunk_sentences = [sentences[0]]
for i in range(1, len(sentences)):
sim = float(np.dot(embs[i], embs[i - 1]))
if sim < similarity_threshold:
# Semantic break detected
chunks.append(" ".join(chunk_sentences))
chunk_sentences = [sentences[i]]
else:
chunk_sentences.append(sentences[i])
if chunk_sentences:
chunks.append(" ".join(chunk_sentences))
return chunks
Chunks verrijken met context
Een geïsoleerde chunk verliest vaak de informatie die het interpreteerbaar maakte. “De duur is drie jaar” betekent niets als de lezer — of het embedding-model — niet weet dat dit uit het hoofdstuk over fabrieksgarantie komt. Door elke chunk te voorzien van de documenttitel en sectietitel, herstelt u deze context direct in de vector zelf, en een zoekopdracht naar “garantieduur” zal de passage dan vinden.
def enrich_chunk(chunk: str, doc_title: str, section: str = "") -> str:
"""Adds context to the chunk for better embedding."""
prefix = f"Document: {doc_title}"
if section:
prefix += f" | Section: {section}"
return f"{prefix}\n\n{chunk}"
Welke chunk-grootte kiest u?
De keuze houdt een afweging in tussen precisie en context: een korte chunk richt zich fijn, maar is verminkt, terwijl een lange chunk alles begrijpt maar het signaal verdunt.
| Grootte (tokens) | Voordelen | Nadelen |
|---|---|---|
| 100–200 | Zeer precies, goede granulariteit | Verliest context |
| 300–500 | Goed compromis | Standaard |
| 500–1000 | Rijke context | Minder precies, duurder |
| 1000+ | Maximale context | Verdunt informatie |
Er is geen universele waarde: de ideale grootte hangt af van uw documenten en query’s. De enige betrouwbare methode is om hetzelfde corpus te indexeren met twee of drie groottes en vervolgens te meten met behulp van de metrieken uit les 10 op een set echte vragen. Een kennisbank voor support met korte antwoorden tolereert 200 tokens; een juridisch corpus vereist 800.
Belangrijkste punten
- Chunking is de meest impactvolle stap in de RAG-pipeline
- Gebruik vaste grootte als basislijn, scheidingstekens om structuur te respecteren
- Semantische chunking detecteert automatisch onderwijswijzigingen
- Overlap en contextuele verrijking verbeteren de kwaliteit
- Test verschillende groottes en meet met zoekmetrieken