0Pricing
AI Prompt Engineering · Lektion

Kontext über Chunks hinweg bewahren

Überlappungen, fortlaufenden Kontext und das Einfügen von Metadaten für Kontinuität nutzen

Kontext über Chunks hinweg bewahren ist eine kostenlose AI Prompt Engineering-Lektion auf CoddyKit. Dies ist Lektion 4 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.

Das Problem des Kontexts zwischen Chunks

Wenn ein Dokument in Chunks aufgeteilt wird, werden möglicherweise Informationen aus Chunk N benötigt, um Chunk N+1 korrekt zu interpretieren. Ein Beispiel: Ein in Chunk 3 definierter Begriff wird in Chunk 7 verwendet. Ohne eine Kontextüberbrückung kennt das Modell, das Chunk 7 verarbeitet, diese Definition nicht.

Vier Strategien helfen dabei: Überlappung, Einfügen einer fortlaufenden Zusammenfassung, Metadaten-Tags und Seitenzahlverweise.

Strategie 1: Token-Überlappung

Bei einer Überlappung werden die letzten N Tokens von Chunk N am Anfang von Chunk N+1 wiederholt. Dadurch wird sichergestellt, dass ein Satz oder Argument, das über eine Grenze hinweggeht, in mindestens einem Chunk vollständig enthalten ist.

Typische Überlappung: 100–200 Tokens (etwa 75–150 Wörter). Eine zu große Überlappung erhöht Redundanz und Kosten; eine zu kleine führt zu Lücken an den Grenzen.

import tiktoken

enc = tiktoken.get_encoding('cl100k_base')

def chunk_with_overlap(text, max_tokens=1000, overlap=200):
    tokens = enc.encode(text)
    chunks = []
    step = max_tokens - overlap
    i = 0
    while i < len(tokens):
        chunk = tokens[i:i + max_tokens]
        chunks.append(enc.decode(chunk))
        i += step
    return chunks

chunks = chunk_with_overlap(document, max_tokens=1000, overlap=200)
print(f'{len(chunks)} chunks with 200-token overlap')

Überlappung bei Retrieval und Zusammenfassungen

Überlappung wirkt sich bei verschiedenen Aufgaben unterschiedlich aus:

  • Retrieval: Überlappung hilft — eine Abfrage passt in beiden benachbarten Chunks zum überlappenden Bereich, wodurch der Recall verbessert wird. Verwenden Sie eine Überlappung von 10–20 % der Chunk-Größe.
  • Zusammenfassungen: Überlappung kann Wiederholungen verursachen — derselbe Satz wird zweimal zusammengefasst. Verwenden Sie eine kleinere Überlappung (5–10 %) oder entfernen Sie die Überlappung vor dem Zusammenfassen.
def strip_overlap(chunks, overlap_tokens=200):
    '''Remove the leading overlap from each chunk (except the first).'''
    cleaned = [chunks[0]]
    for chunk in chunks[1:]:
        tokens = enc.encode(chunk)
        trimmed = enc.decode(tokens[overlap_tokens:])
        cleaned.append(trimmed)
    return cleaned

Strategie 2: Einfügen einer fortlaufenden Zusammenfassung

Eine fortlaufende Zusammenfassung ist eine laufend aktualisierte Kurzfassung aller bisher verarbeiteten Chunks. Vor der Verarbeitung von Chunk N fügen Sie die fortlaufende Zusammenfassung als Kontext in den Prompt ein. So erhält das Modell Kenntnisse über vorherige Inhalte, ohne das Kontextfenster zu überschreiten.

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

def process_with_rolling_summary(chunks):
    rolling_summary = ''
    results = []

    for i, chunk in enumerate(chunks):
        context = ''
        if rolling_summary:
            context = f'Summary of previous sections:\n{rolling_summary}\n\n'

        prompt = context + f'Current section:\n{chunk}'
        resp = client.chat.completions.create(
            model='gpt-4o',
            messages=[
                {'role': 'system', 'content': 'Answer questions or summarize, using prior context.'},
                {'role': 'user', 'content': prompt}
            ]
        )
        result = resp.choices[0].message.content
        results.append(result)

        # Update rolling summary
        rolling_summary = update_rolling_summary(rolling_summary, chunk)

    return results

Aktualisieren der fortlaufenden Zusammenfassung

Die fortlaufende Zusammenfassung sollte schrittweise wachsen. Bitten Sie das LLM nach der Verarbeitung jedes Chunks, die Zusammenfassung zu aktualisieren, indem es die neuen Informationen aus diesem Chunk aufnimmt. Halten Sie die fortlaufende Zusammenfassung kurz — 200–400 Token — damit genügend Platz für den aktuellen Chunk bleibt.

def update_rolling_summary(current_summary, new_chunk, max_words=150):
    if not current_summary:
        prompt = f'Summarize the following in under {max_words} words:\n\n{new_chunk}'
    else:
        prompt = (
            f'Current running summary (under {max_words} words):\n{current_summary}\n\n'
            f'New section to incorporate:\n{new_chunk}\n\n'
            f'Update the summary to include the new section. Stay under {max_words} words.'
        )
    resp = client.chat.completions.create(
        model='gpt-4o-mini',
        messages=[{'role': 'user', 'content': prompt}]
    )
    return resp.choices[0].message.content

Strategie 3: Metadaten-Tags

Metadaten-Tags fügen jedem Chunk strukturierte Informationen hinzu, damit das LLM weiß, was es verarbeitet, und den logischen Zusammenhang aufrechterhalten kann.

Häufig verwendete Tags: document_title, chapter, section, page, chunk_index, total_chunks. Fügen Sie diese als Kopfzeile in den Prompt ein, nicht in den Chunk-Text, um Inhalt und Metadaten voneinander zu trennen.

def build_prompt_with_metadata(chunk, metadata):
    header = (
        f'Document: {metadata["title"]}\n'
        f'Chapter: {metadata["chapter"]}\n'
        f'Section: {metadata["section"]}\n'
        f'Page: {metadata["page"]}\n'
        f'Chunk: {metadata["chunk_index"] + 1} of {metadata["total_chunks"]}\n'
        '---\n'
    )
    return header + chunk

prompt = build_prompt_with_metadata(
    chunk=chunks[5],
    metadata={
        'title': 'Annual Report 2024',
        'chapter': '3. Financial Results',
        'section': '3.2 Revenue Breakdown',
        'page': 42,
        'chunk_index': 5,
        'total_chunks': 120
    }
)

Strategie 4: Verweise auf Seitenzahlen

Wenn ein Chunk auf etwas von einer vorherigen Seite verweist, kann das Modell es zitieren, sofern Seitenzahlen eingebettet sind. Fügen Sie Seitenumbrüche vor dem Chunking als Markierungen in den Text ein, damit sie in den Chunks erhalten bleiben:

def inject_page_markers(pages):
    '''pages: list of strings, one per page.'''
    marked = []
    for i, page_text in enumerate(pages):
        marked.append(f'[PAGE {i+1}]\n{page_text}')
    return '\n\n'.join(marked)

# When the model sees [PAGE 12] in context, it can say
# 'As defined on page 12...' in its output, enabling traceability.
document_with_markers = inject_page_markers(pdf_pages)
chunks = chunk_with_overlap(document_with_markers)

Strategien kombinieren

Kombinieren Sie in Produktionsumgebungen alle vier Strategien, um die Kontexttreue zu maximieren:

  1. Fügen Sie vor dem Chunking Seitenmarkierungen hinzu
  2. Erstellen Sie Chunks mit einer Überlappung von 200 Token
  3. Fügen Sie dem Prompt für jeden Chunk eine Metadaten-Kopfzeile hinzu
  4. Fügen Sie vor jedem Chunk die fortlaufende Zusammenfassung ein

Der kombinierte Ansatz stellt sicher, dass das Modell stets weiß, an welcher Stelle des Dokuments es sich befindet, was zuvor kam und in welcher Beziehung der aktuelle Chunk zum gesamten Dokument steht.

def process_document(pages, doc_metadata):
    # Step 1: inject page markers
    full_text = inject_page_markers(pages)
    # Step 2: chunk with overlap
    chunks = chunk_with_overlap(full_text, max_tokens=900, overlap=150)
    total = len(chunks)
    rolling_summary = ''
    results = []

    for i, chunk in enumerate(chunks):
        meta = {**doc_metadata, 'chunk_index': i, 'total_chunks': total}
        prompt = build_prompt_with_metadata(chunk, meta)
        if rolling_summary:
            prompt = 'Prior context:\n' + rolling_summary + '\n\n' + prompt
        result = call_llm(prompt)
        results.append(result)
        rolling_summary = update_rolling_summary(rolling_summary, chunk)

    return results

Kontexterhalt bewerten

Um zu überprüfen, ob Ihre Kontextstrategie funktioniert, erstellen Sie Testfragen, die Informationen aus mehreren Chunks erfordern:

  • Einen in Chunk 2 eingeführten Begriff definieren, der in Chunk 8 abgefragt wird
  • Eine Summe berechnen, die sich über mehrere Seiten erstreckt
  • Einen Widerspruch zwischen Kapitel 1 und Kapitel 5 erkennen

Führen Sie die Pipeline aus und prüfen Sie, ob die Antworten korrekt auf vorherige Inhalte verweisen. Wenn dies nicht gelingt, erhöhen Sie die Überlappung oder die Größe der fortlaufenden Zusammenfassung.

test_questions = [
    {
        'question': 'What is the definition of "net recurring revenue" used in this report?',
        'defined_in_chunk': 2,
        'asked_in_chunk': 9,
        'expected_keywords': ['net recurring revenue', 'subscription', 'exclude']
    }
]

def evaluate_context_retention(pipeline_results, test_questions):
    for test in test_questions:
        answer = pipeline_results[test['asked_in_chunk']]
        for kw in test['expected_keywords']:
            if kw.lower() not in answer.lower():
                print(f'FAIL: missing "{kw}" in answer to chunk {test["asked_in_chunk"]}')

Zusammenfassung der Abwägungen

Jede Strategie hat Vor- und Nachteile:

  • Überlappung: einfach, erhöht die Tokenanzahl um den Überlappungsanteil und kann zu Wiederholungen in der Zusammenfassung führen
  • Fortlaufende Zusammenfassung: leistungsfähig, fügt pro Chunk einen LLM-Aufruf hinzu; die Zusammenfassung kann sich allmählich vom Inhalt entfernen oder Details verlieren
  • Metadaten-Tags: kostenlos hinzuzufügen, erleichtern dem Modell die Orientierung, ersetzen jedoch nicht den Inhalt
  • Seitenmarkierungen: ermöglichen die Nachvollziehbarkeit, fügen dem Text Zeichen hinzu, verursachen aber nur einen minimalen zusätzlichen Tokenaufwand

Beginnen Sie mit Überlappung und Metadaten. Fügen Sie die fortlaufende Zusammenfassung erst hinzu, wenn beim Testen Fehler beim Kontext über Chunk-Grenzen hinweg beobachtet werden.

Praxisleitfaden zur Größenbestimmung

Praktische Größen für ein 100-seitiges Dokument (durchschnittlich 500 Token pro Seite = insgesamt 50.000 Token):

  • Chunk-Größe: 800 Token, Überlappung 150 Token → ca. 73 Chunks
  • Fortlaufende Zusammenfassung: maximal 200 Token (nach jedem Chunk aktualisiert)
  • Metadaten-Kopfzeile: ca. 30 Token pro Chunk
  • Effektive Eingabe pro API-Aufruf: 800 + 200 + 30 = 1030 Token
  • Map-Kosten (gpt-4o-mini bei 0,15 $/1 Mio. Token): 73 × 1030 × 0,15 $/1 Mio. Token ≈ 0,011 $

Kontextstrategien verursachen nur minimale Kosten, verbessern jedoch die Kohärenz erheblich.

Wissenscheck

Welchen Zweck erfüllt eine fortlaufende Zusammenfassung bei der Verarbeitung eines Dokuments Chunk für Chunk?

Rückblick: Kontext über Chunk-Grenzen hinweg

Vier Strategien, um den Kontext über Chunk-Grenzen hinweg zu erhalten:

  • Überlappung: Die letzten N Token von Chunk N am Anfang von Chunk N+1 wiederholen
  • Fortlaufende Zusammenfassung: Vor jedem Chunk eine kurze, fortlaufend aktualisierte Kurzfassung einfügen
  • Metadaten-Tags: Kopfzeile mit Informationen zu Dokument, Kapitel, Abschnitt und Seite
  • Seitenmarkierungen: Seitenzahlen vor dem Chunking in den Text einbetten

Kombinieren Sie alle vier Strategien für Produktionspipelines. Testen Sie den Kontexterhalt über Chunk-Grenzen hinweg mit Fragen, die mehrere Chunks erfordern. Damit ist Kurs 16 zu Strategien für die Verarbeitung langer Dokumente abgeschlossen.

Häufig gestellte Fragen

Ist die Lektion „Kontext über Chunks hinweg bewahren“ kostenlos?

Ja — der vollständige Text von „Kontext über Chunks hinweg bewahren“ 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 „Kontext über Chunks hinweg bewahren“?

Überlappungen, fortlaufenden Kontext und das Einfügen von Metadaten für Kontinuität nutzen 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 4 von 4.

Wie lange dauert die Lektion „Kontext über Chunks hinweg bewahren“?

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

  1. Chunking-Strategien für lange Texte
  2. Map-Reduce-Muster zur Zusammenfassung
  3. Hierarchische Zusammenfassung
  4. Kontext über Chunks hinweg bewahren
← Zurück zu AI Prompt Engineering