---
title: "RAG-Chunk-Größe und Overlap: Retrieval und Token-Kosten"
description: "Wie Chunk-Größe und Overlap Recall, Indexgröße, Embedding-Kosten und die Tokens pro LLM-Anfrage verändern, mit veröffentlichten Ergebnissen und Rechenbeispielen."
url: https://broadrouter.com/de/blog/rag-chunk-size-overlap/
lang: de
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Mit KI-Unterstützung aus dem Englischen übersetzt. [Englisches Original lesen](https://broadrouter.com/blog/rag-chunk-size-overlap/) (aktualisiert am 2026-11-16).

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

Vom Team von BroadNet Inference · 7 Min. Lesezeit · Veröffentlicht 2026-11-15 · Aktualisiert 2026-11-16

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.

## Das Wichtigste in Kürze

-   Der Input pro Anfrage ist ungefähr top-k × Chunk-Größe + Prompt. Der Wechsel von 5 × 400 auf 8 × 1.024 Tokens sendet bei jeder Anfrage etwa das 3,4-Fache an Input.
-   Overlap bläht den Index um Größe ÷ (Größe − Overlap) auf: 15 % Overlap ergeben bis zu etwa 18 % mehr (17 % bei den hier gemessenen Dokumenten mit 10.000 Tokens), 50 % verdoppeln ihn.
-   In der Evaluation von Chroma aus 2024 erreichten oder übertrafen Chunks mit 200 bis 400 Tokens ohne Overlap solche mit 800 Tokens und 400 Overlap, dem Standard der Dateisuche von OpenAI.
-   Die Tests von NVIDIA aus 2025 fanden keine allgemein beste Größe: Faktenfragen profitierten von 256 bis 512 Tokens, analytische Fragen von 1.024 Tokens oder einer ganzen Seite.
-   Messen Sie die Chunk-Größe in Tokens Ihres Embedding-Modells. Manche Splitter zählen standardmäßig Zeichen.

**Auf dieser Seite**

1.  Was verändern Chunk-Größe und Overlap?
2.  Was sagen veröffentlichte Tests zur Chunk-Größe?
3.  Wie stark bläht Overlap den Index auf?
4.  Was macht die Chunk-Größe mit der LLM-Rechnung?
5.  Wie chunken Sie nach Tokens, ohne Wörter zu zerschneiden?
6.  Wie wählen Sie die Zahlen für Ihre Daten?
7.  Wo BroadNet Inference ins Bild passt

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](https://broadrouter.com/de/blog/long-context-vs-rag/). Für arabische Dokumente lesen Sie zusätzlich [RAG auf Arabisch](https://broadrouter.com/de/blog/arabic-rag-search/) und [Normalisierung arabischer Texte](https://broadrouter.com/de/blog/arabic-text-normalization-search/).

## 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](https://broadrouter.com/tools/embedding-cost-calculator/).

## 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](https://broadrouter.com/de/models/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](https://broadrouter.com/de/models/qwen3.8-27b/) ($0.175 Input) oder [GLM 5.3](https://broadrouter.com/de/models/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](https://broadrouter.com/de/blog/cached-input-tokens-explained/) 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](https://broadrouter.com/de/blog/long-context-vs-rag/) gewandert, und dieser Vergleich hat seine eigene Mathematik. Der [RAG-Chunking-Rechner](https://broadrouter.com/tools/rag-chunking-calculator/) 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](https://broadrouter.com/de/blog/tokens-per-word-arabic-english/). 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.

```python
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](https://broadrouter.com/de/blog/evaluate-llm-before-switching/) 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](https://broadrouter.com/de/blog/estimate-llm-api-cost-before-launch/).

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](https://broadrouter.com/de/blog/long-context-vs-rag/) das Chunking womöglich ganz.

Kostenlose Tools zum Thema (auf Englisch)

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[Kostenlose Tools (auf Englisch)](https://broadrouter.com/tools/)

## Begriffe in diesem Artikel

[Token](https://broadrouter.com/de/glossary/token/)

Ein Token ist die Texteinheit, die ein Sprachmodell liest und schreibt: ein Wort, ein Wortteil, ein Satzzeichen oder eine Bytefolge, die der Tokenizer des Modells erzeugt. LLM-APIs zählen, begrenzen und berechnen die Nutzung meist in Tokens.

[Chunking (RAG)](https://broadrouter.com/de/glossary/chunking/)

Chunking ist der Schritt in einer Retrieval-Pipeline, der Dokumente in kleinere Stücke, sogenannte Chunks, zerlegt, bevor sie eingebettet und indexiert werden. Die Chunk-Größe legt fest, wie viel Text jedes Stück enthält, und der Chunk-Overlap wiederholt etwas Text zwischen benachbarten Chunks, damit an einer Grenze zerschnittene Gedanken nicht verloren gehen.

[RAG (Retrieval-Augmented Generation)](https://broadrouter.com/de/glossary/rag/)

RAG (Retrieval-Augmented Generation) ist ein Muster, bei dem eine Anwendung zuerst zur Frage passende Abschnitte aus einem externen Speicher abruft, etwa einem Such- oder Vektorindex, und sie dann in den Prompt einfügt, damit ein Sprachmodell aus diesem Text antwortet statt nur aus seinem Gedächtnis.

[Tool Calling (Function Calling)](https://broadrouter.com/de/glossary/tool-calling/)

Tool Calling, auch Function Calling genannt, ist eine Funktion von LLM-APIs, bei der das Modell eine strukturierte Anfrage zurückgibt, eine vom Entwickler definierte Funktion mit JSON-Argumenten auszuführen. Die Anwendung führt die Funktion aus und sendet das Ergebnis zurück; das Modell selbst führt nie Code aus.

[System-Prompt](https://broadrouter.com/de/glossary/system-prompt/)

Ein System-Prompt ist der Anweisungstext, den eine Anwendung einem Sprachmodell vor dem Gespräch sendet, meist als Nachricht mit der Rolle system oder developer. Er legt Rolle, Regeln, Ton und Ausgabeformat des Modells fest, und das Modell soll ihm auch bei widersprechenden Nutzernachrichten folgen.

[Embeddings](https://broadrouter.com/de/glossary/embeddings/)

Embeddings sind Listen von Gleitkommazahlen (Vektoren), die ein Modell erzeugt, um einen Text, ein Bild oder einen anderen Input darzustellen. Inputs mit ähnlicher Bedeutung erhalten nah beieinanderliegende Vektoren; über den Abstand lassen sich Suchergebnisse ranken, Dokumente clustern oder verwandte Elemente finden.

[Kontextfenster (Context Window)](https://broadrouter.com/de/glossary/context-window/)

Das Kontextfenster ist die maximale Anzahl an Tokens, mit der ein Sprachmodell in einer einzelnen Anfrage arbeiten kann. Es umfasst Prompt, Gesprächsverlauf, Tool-Definitionen, Bilder und den erzeugten Output einschließlich Reasoning-Tokens. Was nicht hineinpasst, muss gekürzt, zusammengefasst oder auf mehrere Anfragen verteilt werden.

[Vektordatenbank (vector database)](https://broadrouter.com/de/glossary/vector-database/)

Eine Vektordatenbank ist ein Datenspeicher für Embedding-Vektoren, oft zusammen mit Quelltext und Metadaten, der Nearest-Neighbour-Abfragen beantwortet: Zu einem Anfragevektor liefert sie die ähnlichsten gespeicherten Vektoren, meist nach Kosinus-Distanz, euklidischer Distanz oder Skalarprodukt.

## 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.

## Weiterlesen

-   [Long Context vs. RAG: Wann 1M Tokens die Vektordatenbank ersetzen](https://broadrouter.com/de/blog/long-context-vs-rag/)
-   [RAG auf Arabisch: Normalisierung, Chunking und Retrieval, die wirken](https://broadrouter.com/de/blog/arabic-rag-search/)
-   [Arabische Textnormalisierung für Suche und RAG: was ändern, was nicht](https://broadrouter.com/de/blog/arabic-text-normalization-search/)
-   [LLM-API-Kosten vor dem Launch eines Features schätzen](https://broadrouter.com/de/blog/estimate-llm-api-cost-before-launch/)
-   [Gecachte Input-Tokens: So senken Sie die Rechnung Ihrer LLM-API](https://broadrouter.com/de/blog/cached-input-tokens-explained/)
-   [GPU-Hardware und Serving von BroadNet, wie BroadNet sie beschreibt](https://broadrouter.com/de/blog/broadnet-gpu-fleet-and-serving/)
-   [LLM-Antworten cachen, Kosten senken: ein Exact-Match-Cache in Python](https://broadrouter.com/de/blog/cache-llm-responses-cut-cost/)
-   [Anleitung: OpenAI Python SDK mit BroadNet Inference nutzen](https://broadrouter.com/de/guides/openai-python-sdk/)

Testen Sie es mit Ihrem echten Workload. Neue Konten starten mit USD 5 Guthaben für Gemma und Transkription. DeepSeek, GLM und Qwen3.8 erfordern eine Aufladung.

[Loslegen](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=de-blog-rag-chunk-size-overlap&utm_content=page-cta) ·

**Quellen**

-   [Smith und Troynikov, Evaluating Chunking Strategies for Retrieval, technischer Bericht von Chroma, Juli 2024 (geprüft am 2026-11-15)](https://research.trychroma.com/evaluating-chunking)
-   [NVIDIA Technical Blog, Finding the Best Chunking Strategy for Accurate AI Responses, Juni 2025 (geprüft am 2026-11-15)](https://developer.nvidia.com/blog/finding-the-best-chunking-strategy-for-accurate-ai-responses/)
-   [Retrieval-Leitfaden von OpenAI: standardmäßig Chunks mit 800 Tokens und 400 Tokens Overlap, Grenzen von chunking\_strategy (geprüft am 2026-11-15)](https://developers.openai.com/api/docs/guides/retrieval)
-   [LangChain-Dokumentation, RecursiveCharacterTextSplitter: Chunk-Größe gemessen per length\_function, standardmäßig in Zeichen (geprüft am 2026-11-15)](https://docs.langchain.com/oss/python/integrations/splitters/recursive_text_splitter)
-   [Preise und API-Referenz von BroadNet Inference: Modelle, Kontextlängen, gecachter Input (geprüft am 2026-11-15) (auf Englisch)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=de-blog-rag-chunk-size-overlap&utm_content=sources)
