Chunking: Opdel dine dokumenter intelligent
På denne side
Mål
- Forstå hvorfor chunking er afgørende for RAG-kvalitet
- Beherske forskellige opdelingsstrategier
- Vælge den rette chunk-størrelse og overlapning
Hvorfor opdele dokumenter?
Embedding-modeller har en token-grænse: 8.191 for OpenAI. Denne grænse er den første grund til at opdele dokumenter, men det er ikke den vigtigste. Selv et dokument, der ligger langt under loftet, giver dårlige resultater, når det kodés som én enkelt blok, fordi den resulterende vektor udgør et gennemsnit af alt indholdet og mister detaljer. Tag fx en HR-håndbog på 40 sider, der dækker ferieregler, hjemmearbejde, udgiftsrapporter og sundhedsforsikring: dens enkelte embedding ligner ikke rigtig nogen af disse fire emner, og en søgning på „hvor mange feriedage” vil rangere den lavere end et meget kortere, men langt mere målrettet dokument.
Chunking løser dette problem ved at bryde dokumentet op i sammenhængende bidder, hvor hver bid fanger en specifik idé eller et afsnit. Dette er det trin, hvor en RAG-pipeline vinder eller taber mest kvalitet – endda før du vælger en embedding-model.
Strategi 1: Chunking med fast størrelse
Den enkleste metode tæller ord og skærer med jævne mellemrum. Den ignorerer fuldstændigt tekstens struktur, hvilket gør den brutal, men den kræver kun tre linjer kode og fungerer som et essentielt baseline: enhver mere sofistikeret strategi skal bevise, at den performer bedre end denne.
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")
Parameteren overlap fortjener opmærksomhed. Uden overlapning vil et snit før eller siden lande midt i en forklaring: sætningen „opsigelsesvarslet er tre måneder” havner i én chunk, og „undtagen i prøvetiden” i den næste. Ingen af dem svarer korrekt på spørgsmålet, og den anden er ligefrem vildledende. Ved at overlappe chunks med 10–20 % af deres størrelse garanterer du, at hver idé eksisterer intakt mindst én gang et sted i indekset. Dette er et godt udgangspunkt; justér det senere baseret på din dokumenttæthed.
Strategi 2: Separator-baseret chunking
I stedet for at skære ord for ord kan du respektere tekstens naturlige grænser. Ideen er at prøve den stærkeste separator først – det dobbelte linjeskift, der adskiller to afsnit – og derefter gå ned til progressively svagere separatorer, så længe det resulterende stykke overstiger maksimalstørrelsen. Et blogindlæg vil dermed blive opdelt afsnit for afsnit, og kun et monstrøst afsnit vil blive fragmenteret efter sætninger.
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
Strategi 3: Chunking efter Markdown-sektioner
Når dit korpus består af struktureret dokumentation, har overskrifterne allerede gjort arbejdet for dig: forfatteren har allerede afgrænset meningsenhederne. Opdeling ved overskriftsniveauerne # og ## producerer chunks, der svarer nøjagtigt til sektionerne, og funktionen nedenfor beholder overskriften sammen med teksten, hvilket vi straks efter vil bruge til berigelse.
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
Strategi 4: Semantisk chunking
For tekst uden eksplicit struktur – et referat af et møde, en transskription af et opkald – ved hverken størrelse eller separatorer, hvor emnet skifter. Det gør embeddings til gengæld. Du encoder hver sætning, sammenligner hver sætning med den foregående og skærer, hvor ligheden kollapser: det er præcis dér, hvor taleren skiftede fra budget til rekruttering. Bemærk, at text-embedding-3-small er tilstrækkelig her, da du ikke leder efter absolut præcision, men et relativt brud.
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
Berigelse af chunks med kontekst
En isoleret chunk mister ofte den information, der gjorde den fortolkelig. „Varigheden er tre år” betyder ingenting, hvis læseren – eller embedding-modellen – ikke ved, at det stammer fra kapitlet om fabriksgaranti. Ved at sætte dokumenttitlen og sektionstitlen foran hver chunk gendannes denne kontekst direkte i selve vektoren, og en søgning på „garantivarighed” vil derefter finde passagen.
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}"
Hvilken chunk-størrelse skal du vælge?
Valget indebærer en afvejning mellem præcision og kontekst: en kort chunk målretter fint, men er amputeret, mens en lang chunk forstår alt, men udvander signalet.
| Størrelse (tokens) | Fordele | Ulemper |
|---|---|---|
| 100–200 | Meget præcis, god granularitet | Mister kontekst |
| 300–500 | Godt kompromis | Standard |
| 500–1000 | Rig kontekst | Mindre præcis, dyr |
| 1000+ | Maksimal kontekst | Udvander information |
Der findes ingen universel værdi: den ideelle størrelse afhænger af dine dokumenter og forespørgsler. Den eneste pålidelige metode er at indeksere det samme korpus med to eller tre størrelser og derefter måle ved hjælp af metrikkerne fra lektion 10 på et sæt af rigtige spørgsmål. En vidensbase til support bestående af korte svar tolererer 200 tokens; et juridisk korpus vil kræve 800.
Vigtige pointer
- Chunking er det mest impactful trin i RAG-pipelinen
- Brug fast størrelse som baseline, separatorer for at respektere struktur
- Semantisk chunking registrerer automatisk emneskift
- Overlapning og kontekstuel berigelse forbedrer kvaliteten
- Test forskellige størrelser og mål med søgemetrics