AI Prompt Engineering · Lektion

Chunking-Strategien für lange Texte

Ansätze für Chunking mit fester Größe, an Satzgrenzen und nach semantischen Kriterien

Chunking-Strategien für lange Texte ist eine kostenlose AI Prompt Engineering-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des AI Prompt Engineering-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der AI Prompt Engineering-Kurs umfasst insgesamt 4 Lektionen.

Warum lange Dokumente eine Herausforderung darstellen

LLMs verfügen über ein Kontextfenster – eine maximale Anzahl von Tokens, die sie gleichzeitig verarbeiten können. GPT-4 unterstützt 128k Tokens, Claude 200k, doch viele Dokumente überschreiten selbst diese Grenzen. Noch wichtiger ist, dass die Forschung zeigt, dass die Genauigkeit von Modellen bei sehr langen Kontexten häufig abnimmt. Chunking bezeichnet das Aufteilen von Dokumenten in kleinere Teile vor der Verarbeitung.

Chunking mit fester Größe

Chunking mit fester Größe teilt Text unabhängig von Inhaltsgrenzen alle N Tokens (oder Zeichen) auf. Es ist die einfachste Strategie und erfordert kein semantisches Verständnis.

Typische Chunk-Größe: 500–1000 Tokens. Chunks lassen sich leicht indizieren und abrufen, können aber Sätze mitten im Satz teilen, wodurch an den Grenzen Bedeutung verloren geht.

import tiktoken

def fixed_chunk(text, max_tokens=1000):
    enc = tiktoken.get_encoding('cl100k_base')
    tokens = enc.encode(text)
    chunks = []
    for i in range(0, len(tokens), max_tokens):
        chunk_tokens = tokens[i:i + max_tokens]
        chunks.append(enc.decode(chunk_tokens))
    return chunks

chunks = fixed_chunk(long_document)
print(f'Total chunks: {len(chunks)}')

Vor- und Nachteile von Chunking mit fester Größe

Vorteile:

Einfach zu implementieren – kein NLP erforderlich
Vorhersehbare Chunk-Größen – API-Kosten lassen sich leichter verwalten
Schnelle Verarbeitung

Nachteile:

Schneidet Satz- und Absatzgrenzen durch
Ein auf mehrere Chunks verteilter Satz verliert beim Abruf seinen Kontext
Ungeeignet für Zusammenfassungen – ein Chunk kann mitten in einem Argument enden

Chunking an Satzgrenzen

Chunking an Satzgrenzen teilt Text an natürlichen Satz- oder Absatzgrenzen auf. Jeder Chunk endet nach einem vollständigen Satz, sodass kein Satz halbiert wird. Dadurch entstehen besser lesbare und in sich schlüssige Chunks.

Verwenden Sie einen Satz-Tokenizer (spaCy oder NLTK), um Grenzen zu erkennen, und gruppieren Sie anschließend Sätze, bis der Chunk die Zielgröße erreicht.

import spacy

nlp = spacy.load('en_core_web_sm')

def sentence_chunk(text, max_tokens=1000):
    doc = nlp(text)
    sentences = [sent.text.strip() for sent in doc.sents]
    chunks, current, count = [], [], 0
    for sent in sentences:
        word_count = len(sent.split())
        if count + word_count > max_tokens and current:
            chunks.append(' '.join(current))
            current, count = [], 0
        current.append(sent)
        count += word_count
    if current:
        chunks.append(' '.join(current))
    return chunks

Semantisches Chunking

Semantisches Chunking geht noch weiter – es teilt Text auf, wenn sich das Thema verschiebt. Indem benachbarte Sätze eingebettet und ihre Kosinusähnlichkeit gemessen werden, lässt sich erkennen, wann die Diskussion zu einem neuen Thema übergeht.

Wenn die Ähnlichkeit unter einen Schwellenwert fällt, fügen Sie eine Chunk-Grenze ein. Dadurch entstehen thematisch kohärente Chunks, die sich ideal für Retrieval-Augmented Generation (RAG) eignen.

from sentence_transformers import SentenceTransformer
from sklearn.metrics.pairwise import cosine_similarity
import numpy as np

model = SentenceTransformer('all-MiniLM-L6-v2')

def semantic_chunk(sentences, threshold=0.75):
    embeddings = model.encode(sentences)
    chunks, current = [], [sentences[0]]
    for i in range(1, len(sentences)):
        sim = cosine_similarity(
            [embeddings[i-1]], [embeddings[i]]
        )[0][0]
        if sim < threshold:
            chunks.append(' '.join(current))
            current = []
        current.append(sentences[i])
    if current:
        chunks.append(' '.join(current))
    return chunks

Vergleich der drei Strategien

Hier ist ein direkter Vergleich, der Ihnen bei der Auswahl hilft:

Feste Größe: schnellste Strategie, ungenaueste Grenzen – für einfache Pipelines
Satzgrenzen: erhält die Integrität von Sätzen – wenn Kohärenz wichtig ist
Semantisch: beste thematische Kohärenz – für RAG, wenn präziser Abruf entscheidend ist

In der Praxis verursacht semantisches Chunking durch die Berechnung von Embeddings zusätzliche Latenz. Treffen Sie Ihre Wahl anhand der Anforderungen an die Abrufgenauigkeit.

Chunking für Abrufaufgaben

Bei Retrieval-Augmented Generation (RAG) werden Chunks zur Sucheinheit. Eine Benutzeranfrage wird eingebettet, und die ähnlichsten Chunks werden abgerufen und in den Prompt eingefügt.

Kleinere Chunks (200–400 Tokens) verbessern die Abrufpräzision – jeder Chunk enthält eine einzelne, klar abgegrenzte Idee. Größere Chunks (800–1000 Tokens) liefern mehr Kontext, können aber neben der relevanten Passage auch irrelevante Inhalte enthalten.

import openai
import numpy as np

client = openai.OpenAI(api_key='sk-...')

def embed(text):
    resp = client.embeddings.create(
        model='text-embedding-3-small',
        input=text
    )
    return np.array(resp.data[0].embedding)

def retrieve(query, chunks, top_k=3):
    q_emb = embed(query)
    scores = [(i, np.dot(q_emb, embed(c))) for i, c in enumerate(chunks)]
    scores.sort(key=lambda x: x[1], reverse=True)
    return [chunks[i] for i, _ in scores[:top_k]]

Chunking für Zusammenfassungsaufgaben

Für Zusammenfassungen sollten Chunks groß genug sein, um ein vollständiges Argument oder einen ganzen Abschnitt zu enthalten. Chunks an Satzgrenzen mit 600–800 Tokens funktionieren gut.

Jeder Chunk wird unabhängig zusammengefasst (der map-Schritt), anschließend werden die Zusammenfassungen zu einer abschließenden Zusammenfassung kombiniert (der reduce-Schritt). Dies ist das klassische Map-Reduce-Muster, das in der nächsten Lektion behandelt wird.

Overlap: Chunk-Grenzen überbrücken

Eine praktische Technik zur Verringerung von Fehlern an Grenzen besteht darin, zwischen Chunks einen Overlap hinzuzufügen. Die letzten 100–200 Tokens von Chunk N werden am Anfang von Chunk N+1 wiederholt.

Durch den Overlap erscheint ein Satz, der sich über eine Grenze erstreckt, in mindestens einem Chunk vollständig. Das ist besonders für den Abruf wichtig – eine Anfrage zu einem Thema, das eine Grenze überschreitet, findet dadurch den überlappenden Chunk.

def fixed_chunk_with_overlap(text, max_tokens=1000, overlap=200):
    enc = tiktoken.get_encoding('cl100k_base')
    tokens = enc.encode(text)
    chunks = []
    step = max_tokens - overlap
    for i in range(0, len(tokens), step):
        chunk_tokens = tokens[i:i + max_tokens]
        chunks.append(enc.decode(chunk_tokens))
        if i + max_tokens >= len(tokens):
            break
    return chunks

Metadatenanreicherung pro Chunk

Jeder Chunk sollte Metadaten enthalten, damit nachgelagerte Schritte auf seine Herkunft verweisen können:

source: Dateiname oder URL
page: Seitenzahl
chunk_index: Position im Dokument
section: Kapitel oder Überschrift

Diese Metadaten werden zusammen mit dem Embedding in einer Vektordatenbank (Pinecone, Chroma, Weaviate) gespeichert und mit den abgerufenen Chunks zurückgegeben, damit das LLM Quellen zitieren kann.

def chunk_with_metadata(text, source='doc.pdf', page=1):
    chunks = fixed_chunk_with_overlap(text)
    return [
        {
            'text': chunk,
            'metadata': {
                'source': source,
                'page': page,
                'chunk_index': i
            }
        }
        for i, chunk in enumerate(chunks)
    ]

Die richtige Strategie auswählen

Ein kurzer Leitfaden zur Entscheidung:

Geschwindigkeit hat Priorität, der Inhalt ist Fließtext: Chunking an Satzgrenzen
Abrufgenauigkeit ist entscheidend: semantisches Chunking mit kleinen Chunks (300 Tokens)
Zusammenfassung eines Buchs oder Berichts: Satzgrenzen, größere Chunks (800 Tokens), Map-Reduce
Rechtliche oder technische Dokumente: semantisches Chunking, damit zusammengehörige Klauseln zusammenbleiben

Messen Sie immer den Retrieval-Recall anhand eines repräsentativen Abfragesatzes, bevor Sie sich auf eine Strategie festlegen.

Wissenscheck

Welche Chunking-Strategie teilt Text, wenn die Kosinusähnlichkeit zwischen benachbarten Satz-Embeddings unter einen Schwellenwert fällt?

Rückblick: Chunking-Strategien

Sie haben drei zentrale Chunking-Strategien kennengelernt:

Feste Größe: Aufteilung alle N Tokens — schnell, einfach, ohne Berücksichtigung von Grenzen
Satzgrenzen: Aufteilung an natürlichen Satzgrenzen — kohärent, mittlere Komplexität
Semantisch: Aufteilung bei Themenwechseln anhand der Embedding-Ähnlichkeit — am genauesten, höchste Kosten

Fügen Sie zwischen Chunks eine Überlappung hinzu, um Fehler an Grenzen zu reduzieren, und fügen Sie immer Metadaten (Quelle, Seite, Index) hinzu, damit Zitate und Nachvollziehbarkeit möglich sind. In der nächsten Lektion geht es um das Map-Reduce-Muster für Zusammenfassungen.

Häufig gestellte Fragen

Ist die Lektion „Chunking-Strategien für lange Texte“ kostenlos?

Ja — der vollständige Text von „Chunking-Strategien für lange Texte“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des AI Prompt Engineering-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der AI Prompt Engineering-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Chunking-Strategien für lange Texte“?

Ansätze für Chunking mit fester Größe, an Satzgrenzen und nach semantischen Kriterien Du übst AI Prompt Engineering mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um AI Prompt Engineering zu starten?

Keine Vorkenntnisse erforderlich. AI Prompt Engineering auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Chunking-Strategien für lange Texte“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser AI Prompt Engineering-Lektion Code schreiben und ausführen?

Ja. Jede AI Prompt Engineering-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu AI Prompt Engineering