Chunk-Größe und Overlap sind die beiden Zahlen, die jede RAG-Pipeline früh festlegt und selten wieder anfasst. Sie entscheiden, wie viele Vektoren Sie speichern, wie viele Tokens Sie einbetten, wie viele Tokens jede Frage an das LLM sendet und ob die richtige Passage überhaupt gefunden wird. Dieser Beitrag zeigt, was veröffentlichte Tests ergeben haben, und rechnet dann die Token-Mathematik durch, damit Sie die Kosten jeder Einstellung sehen, bevor Sie irgendetwas einbetten.
Wenn Sie noch entscheiden, ob Sie RAG überhaupt nutzen, beginnen Sie mit Long Context vs. RAG. Für arabische Dokumente lesen Sie zusätzlich RAG auf Arabisch und Normalisierung arabischer Texte.
Was verändern Chunk-Größe und Overlap?
- Chunk-Größe ist die Zahl der Tokens in jedem Stück, das Sie einbetten und abrufen.
- Overlap ist die Zahl der Tokens, die aufeinanderfolgende Chunks gemeinsam haben, damit ein an einer Grenze geteilter Satz in mindestens einem Chunk vollständig vorkommt.
- Top-k ist die Zahl der Chunks, die Sie pro Frage abrufen.
Zusammen bestimmen sie vier Größen:
| Größe | Formel (lange Dokumente) |
|---|---|
| Gespeicherte Chunks | Korpus-Tokens ÷ (Größe − Overlap) |
| Eingebettete Tokens | Korpus-Tokens × Größe ÷ (Größe − Overlap) |
| Kontext pro Anfrage | top-k × Größe |
| LLM-Input pro Anfrage | top-k × Größe + System-Prompt + Frage |
Die ersten beiden zahlen Sie einmal pro Indexierungslauf und erneut bei jedem Neu-Chunking. Die letzte zahlen Sie bei jeder Frage, für immer.
Was sagen veröffentlichte Tests zur Chunk-Größe?
Zwei öffentliche Evaluationen sollten Sie kennen, weil sie Unterschiedliches gemessen haben.
Chroma (Smith und Troynikov, Juli 2024) maß das Retrieval auf Token-Ebene: wie viel des relevanten Texts abgerufen wurde (Recall) und wie viel des Abgerufenen relevant war. Verwendet wurden fünf abgerufene Chunks und text-embedding-3-large von OpenAI. Ausgewählte Zeilen:
| Splitter | Größe (Tokens) | Overlap | Recall | IoU |
|---|---|---|---|---|
| Recursive | 800 | 400 | 85,4 % | 1,5 % |
| Token | 800 | 400 | 87,9 % | 1,4 % |
| Recursive | 400 | 200 | 88,1 % | 3,3 % |
| Recursive | 400 | 0 | 89,5 % | 3,6 % |
| Recursive | 200 | 0 | 88,1 % | 6,9 % |
IoU (Intersection over Union) misst, wie viel des abgerufenen Texts relevant war, und taugt damit auch als Maß für verschwendete Tokens. Die Zeilen mit 800/400 entsprechen dem Standard der Dateisuche von OpenAI; unter der Annahme eines Token-Splitters fand Chroma, dass diese Einstellung einen leicht unterdurchschnittlichen Recall und die niedrigsten Werte bei den anderen Metriken lieferte. Kleinere Chunks ohne Overlap erreichten den gleichen oder einen höheren Recall und enthielten weit weniger irrelevanten Text.
NVIDIA (Juni 2025) maß die Antwortgenauigkeit Ende zu Ende auf fünf Datensätzen, mit Token-Chunks von 128 bis 2.048 bei 15 % Overlap sowie Chunking auf Seiten- und Abschnittsebene. Chunking auf Seitenebene hatte die höchste durchschnittliche Genauigkeit (0,648) und die geringste Streuung. Die beste Token-Größe hing von den Fragen ab: Faktenfragen profitierten von 256 bis 512 Tokens, analytische Fragen von 1.024 Tokens oder ganzen Seiten. Beide Extreme, 128 und 2.048, schnitten meist schlechter ab.
In einem Punkt stimmen beide überein: Es gibt keine universell beste Größe, und sehr große Chunks mit starkem Overlap sind selten der richtige Standard.
Wie stark bläht Overlap den Index auf?
Jeder Chunk rückt um Größe − Overlap Tokens vor, der Index enthält also Größe ÷ (Größe − Overlap) Kopien des Korpus. Für einen Korpus von 2.000.000 Tokens aus Dokumenten mit je 10.000 Tokens:
| Größe | Overlap | Chunks | Eingebettete Tokens | Aufblähung |
|---|---|---|---|---|
| 200 | 0 | 10.000 | 2.000.000 | 1,00× |
| 400 | 0 | 5.000 | 2.000.000 | 1,00× |
| 512 | 77 (15 %) | 4.600 | 2.338.800 | 1,17× |
| 1.024 | 154 (15 %) | 2.400 | 2.338.800 | 1,17× |
| 800 | 400 (50 %) | 4.800 | 3.840.000 | 1,92× |
| 400 | 200 (50 %) | 9.800 | 3.920.000 | 1,96× |
Kurze Dokumente blähen etwas weniger auf, weil der letzte Chunk jedes Dokuments unvollständig ist. Die Formel gibt den Grenzwert an: 15 % Overlap kosten etwa 18 % mehr, 50 % etwa 100 % mehr, bei Embedding-Tokens, Vektorspeicher und Zeit für die Neuindexierung.
Overlap kostet auch zur Abfragezeit. Bei 50 % Overlap wiederholen zwei benachbarte Chunks, die für dieselbe Frage abgerufen werden, die Hälfte ihres Texts. Sie zahlen für diese doppelten Tokens, und sie verdrängen andere relevante Passagen aus dem top-k.
BroadNet verkauft keine Embeddings, dieser Teil der Rechnung geht also an Ihren Embedding-Anbieter. Beziffern Sie ihn mit dem Embedding-Kostenrechner.
Was macht die Chunk-Größe mit der LLM-Rechnung?
Jede Frage sendet top-k Chunks plus den Prompt. Nehmen Sie 100.000 Fragen pro Monat, 600 Tokens für System-Prompt und Frage und jedes Mal dieselbe Antwort mit 300 Tokens:
| Größe × top-k | Kontext pro Anfrage | Input pro Anfrage | Input pro Monat |
|---|---|---|---|
| 200 × 10 | 2.000 | 2.600 | 260 Millionen |
| 400 × 5 | 2.000 | 2.600 | 260 Millionen |
| 512 × 5 | 2.560 | 3.160 | 316 Millionen |
| 800 × 5 | 4.000 | 4.600 | 460 Millionen |
| 1.024 × 5 | 5.120 | 5.720 | 572 Millionen |
| 1.024 × 8 | 8.192 | 8.792 | 879 Millionen |
Die Ausgabe beträgt in jeder Zeile 30 Millionen Tokens pro Monat, es ändert sich also nur der Input. Bei einem Preis pro 1M Tokens sind die monatlichen Input-Kosten die Millionen in der letzten Spalte mal diesem Preis. Bei Gemma 4 VL 26B mit $0.10 pro 1M Input-Tokens kostet das Setup 1.024 × 8 monatlich 879 × $0.10 an Input, gegenüber 260 × $0.10 für 400 × 5. Das ist das 3,4-Fache, für eine Einstellung, bei der die veröffentlichten Tests keinen besseren Recall zeigen. Bei Qwen3.8 27B ($0.175 Input) oder GLM 5.3 ($0.78 Input) bleibt das Verhältnis gleich, und die Summen sind höher.
Zwei Hebel bewegen das stärker als der Modellpreis:
- Senken Sie k, wenn Sie die Größe erhöhen. 200 × 10 und 400 × 5 senden denselben Kontext. Halten Sie den Kontext pro Anfrage beim Testen der Größen ungefähr konstant, damit Sie die Retrieval-Qualität vergleichen und nicht das Kontextbudget.
- Cachen Sie den festen Teil. Stellen Sie den System-Prompt an den Anfang und halten Sie ihn byte-identisch, damit er bei Modellen mit einem Cache-Preis für Input zu diesem Preis abgerechnet werden kann. Abgerufene Chunks ändern sich mit jeder Frage und werden selten gecacht.
Auch Kontextlimits spielen eine Rolle. Gemma 4 VL 26B akzeptiert 32.768 Tokens pro Anfrage, reichlich für jede Zeile oben. Treiben Sie k × Größe in Richtung Zehntausender Tokens, sind Sie von RAG in Richtung Long Context gewandert, und dieser Vergleich hat seine eigene Mathematik. Der RAG-Chunking-Rechner wendet diese Formeln auf Ihren eigenen Korpus, Ihre Chunk-Größe, Ihren Overlap und Ihr top-k an.
Wie chunken Sie nach Tokens, ohne Wörter zu zerschneiden?
Zählen Sie in Tokens, aber schneiden Sie an Strukturgrenzen. Der RecursiveCharacterTextSplitter von LangChain misst die Größe mit seiner length_function, standardmäßig der Zeichenlänge. Eine „Größe“ von 512 sind dann 512 Zeichen, auf Englisch grob 100 bis 150 Tokens, und auf Arabisch wieder eine andere Zahl; siehe Tokens pro Wort auf Arabisch. Embedding-Limits und LLM-Rechnungen rechnen in Tokens.
Dieser Chunker packt ganze Absätze bis zu einem Token-Budget und trägt die letzten Absätze als Overlap weiter. Das Schneiden an Absatzgrenzen vermeidet, dass Wörter oder Multibyte-Zeichen im Arabischen zerteilt werden, was rohe Token-Fenster tun können.
import tiktoken
enc = tiktoken.get_encoding("o200k_base") # an estimate: count with your embedder's tokenizer
count = lambda s: len(enc.encode(s))
def chunk(text, size=512, overlap=64):
"""Pack whole paragraphs up to `size` tokens; repeat trailing paragraphs up to `overlap` tokens."""
chunks, cur, cur_len = [], [], 0
for para in (p.strip() for p in text.split("\n\n")):
if not para:
continue
n = count(para)
if cur and cur_len + n > size:
chunks.append("\n\n".join(cur))
tail, t = [], 0
for q in reversed(cur): # carry the end of this chunk forward
if t + count(q) > overlap:
break
tail.insert(0, q); t += count(q)
cur, cur_len = tail, t
cur.append(para); cur_len += n # a paragraph over `size` stays whole
if cur:
chunks.append("\n\n".join(cur))
return chunks
def plan(corpus_tokens, size, overlap, k, queries_per_month, prompt_tokens=600):
index_tokens = corpus_tokens * size / (size - overlap) # long-document limit
per_query = k * size + prompt_tokens
return {"chunks": round(index_tokens / size), "tokens_to_embed": round(index_tokens),
"input_per_query": per_query, "input_per_month": per_query * queries_per_month}
print(plan(2_000_000, 512, 64, 5, 100_000))
# {'chunks': 4464, 'tokens_to_embed': 2285714, 'input_per_query': 3160, 'input_per_month': 316000000}
Overlap bedeutet hier „bis zu“: Ein Absatz, der länger ist als das Overlap-Budget, wird nicht wiederholt. Ein einzelner Absatz, der länger ist als size, bleibt ganz; teilen Sie solche Absätze zuerst an Satzgrenzen, wenn Ihre Dokumente welche haben. Stellen Sie jedem Chunk den Dokumenttitel und die Abschnittsüberschrift voran, damit ein abgerufener Chunk weiterhin sagt, worum es geht. Das kostet pro Chunk ein paar Tokens und hilft oft mehr als Overlap.
Wie wählen Sie die Zahlen für Ihre Daten?
- Bauen Sie ein Evaluationsset. 50 bis 200 echte Fragen, jede mit der Passage, die sie beantwortet. Der Leitfaden zur LLM-Evaluation behandelt die Bewertung.
- Legen Sie das Kontextbudget fest. Halten Sie k × Größe nahe an einem Wert, etwa 2.000 Tokens, während Sie Größen vergleichen.
- Probieren Sie drei Größen und zwei Overlaps. Zum Beispiel 256, 512 und 1.024 Tokens, jeweils mit 0 und 15 % Overlap. Messen Sie den Recall der richtigen Passage bei k.
- Probieren Sie Struktur. Haben Ihre Dokumente Seiten oder nummerierte Abschnitte, testen Sie Chunks auf Seiten- oder Abschnittsebene gegen die Token-Größen. NVIDIA fand die Seitenebene am beständigsten.
- Wählen Sie die günstigste Einstellung, die höchstens ein bis zwei Punkte unter dem besten Recall liegt, und beziffern Sie sie dann bei Ihrem Anfragevolumen mit der Methode für Monatskosten.
Machen Sie das an einer Stichprobe, bevor Sie den vollständigen Korpus einbetten. Ein späterer Wechsel des Chunkings bedeutet, alles neu einzubetten.
Wo BroadNet Inference ins Bild passt
BroadNet Inference bedient den Antwortschritt von RAG, nicht das Retrieval. BroadNet verkauft weder Embeddings noch Vektorspeicher; kombinieren Sie es also mit einem Embedding-Anbieter und einer Vektordatenbank Ihrer Wahl. Für die Antwort ist Gemma 4 VL 26B die günstige Option und läuft mit dem Startguthaben von $5. Qwen3.8 27B (Kontext mit 262.144 Tokens) und GLM 5.3 (1.048.576) eignen sich nach einer Aufladung für größere top-k-Werte oder lange Dokumente. Prompts und abgerufene Passagen werden nach der Anfrage nicht gespeichert. Ist Ihr Korpus klein und stabil genug, um ins Kontextfenster zu passen, schlägt Long Context das Chunking womöglich ganz.
