BroadRouter

RAG-Chunk-Größe und Overlap: Wirkung auf Retrieval und Kosten

Vom Team von BroadNet Inference · 7 Min. Lesezeit · Veröffentlicht · Aktualisiert

Beginnen Sie mit Chunks von etwa 256 bis 512 Tokens, 0 bis 15 % Overlap und einem top-k, das Sie mit Ihren eigenen Anfragen abstimmen. Größere Chunks erhöhen die Tokens, die jede Anfrage an das LLM sendet. Overlap vervielfacht die eingebetteten und gespeicherten Tokens um Größe ÷ (Größe − Overlap), 50 % Overlap verdoppeln also den Index. Veröffentlichte Tests fanden, dass kleine Chunks ohne Overlap oft gleich gut oder besser abschneiden.

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:

  1. 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.
  2. 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?

  1. Bauen Sie ein Evaluationsset. 50 bis 200 echte Fragen, jede mit der Passage, die sie beantwortet. Der Leitfaden zur LLM-Evaluation behandelt die Bewertung.
  2. Legen Sie das Kontextbudget fest. Halten Sie k × Größe nahe an einem Wert, etwa 2.000 Tokens, während Sie Größen vergleichen.
  3. 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.
  4. 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.
  5. 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.

Häufige Fragen

Welche Chunk-Größe ist gut für RAG?

Beginnen Sie bei etwa 256 bis 512 Tokens und testen Sie. Die Evaluation von Chroma fand, dass 200 bis 400 Tokens ohne Overlap gut abschnitten. NVIDIA fand 256 bis 512 Tokens passend für Faktenfragen, während analytische Fragen mit Chunks von 1.024 Tokens oder auf Seitenebene besser abschnitten.

Wie viel Chunk-Overlap sollte ich verwenden?

Weniger als die meisten Standardwerte. NVIDIA fand von den getesteten 10 %, 15 % und 20 % auf einem Datensatz 15 % am besten. Chroma fand, dass Einstellungen ohne Overlap oft gleich gut oder besser abschnitten. Jeder Prozentpunkt Overlap fügt Tokens hinzu, die eingebettet, gespeichert und gesendet werden.

Kostet eine größere Chunk-Größe mehr?

Beim Embedding nicht, sofern kein Overlap im Spiel ist: Der Korpus hat dieselbe Zahl an Tokens. Pro Anfrage kostet es mehr, weil jeder gefundene Chunk länger ist und top-k × Chunk-Größe wächst. Senken Sie k, wenn Sie die Größe erhöhen.

Wird die Chunk-Größe in Tokens oder Zeichen gemessen?

Das hängt vom Splitter ab. Der RecursiveCharacterTextSplitter von LangChain misst mit seiner length_function, standardmäßig die Zeichenlänge. Embedding-Limits und LLM-Rechnungen rechnen in Tokens, übergeben Sie also einen Token-Zähler.

Muss ich neu einbetten, wenn ich die Chunk-Größe ändere?

Ja. Neue Grenzen ergeben neue Chunks, und jeder braucht einen neuen Vektor. Neu einbetten kostet noch einmal den ganzen Index. Legen Sie das Chunking also an einer Stichprobe fest, bevor Sie den vollständigen Korpus einbetten.

Als Markdown lesenChatGPT fragenClaude fragenPerplexity fragen