+160 XP

Arbeiten mit langen Dokumenten und großen Inputs

# Arbeiten mit langen Dokumenten und großen Inputs

Sie laden einen 60-seitigen Vertrag in ChatGPT und fragen „extrahiere jede Klausel", und Sie bekommen eine selbstsichere, flüssige Antwort, die ein Drittel des Dokuments stillschweigend überspringt. Das Modell hat nicht gelogen. Es ist nur gegen eine Wand gelaufen, die Sie nicht sehen konnten. In dieser Lektion geht es darum, diese Wand zu sehen und dann drumherum zu konstruieren.

Die zwei Grenzen, gegen die Sie tatsächlich ankämpfen

Es gibt zwei separate Beschränkungen, und sie werden ständig vermischt.

Die erste ist das Context Window: wie viel Text das Modell gleichzeitig im Arbeitsgedächtnis halten kann. Moderne ChatGPT-Modelle haben große Windows, aber „groß" ist nicht „unendlich", und das Window enthält Ihre Datei *plus* Ihre Anweisungen *plus* die gesamte vorherige Konversation *plus* den Output des Modells selbst. Ein 60-seitiger Vertrag kann davon allein leicht einen großen Teil auffressen.

Die zweite ist das Attention Budget: Selbst wenn der Text technisch hineinpasst, verteilt das Modell seine Aufmerksamkeit über einen langen Input ungleichmäßig. Inhalte in der Mitte eines riesigen Blocks werden schwächer behandelt als Inhalte am Anfang oder Ende. Deshalb liefert ein Vertrag, der „hineinpasst", trotzdem eine Zusammenfassung, in der Klausel 34 auf Seite 41 fehlt.

Der Fehlermodus ist also selten ein harter Fehler. Es ist stilles Auslassen. Ihre Aufgabe ist es, Prompts und Pipelines so zu bauen, dass Auslassungen *sichtbar* und *billig zu finden* werden.

Wie ChatGPT eine Datei einliest (und warum das zählt)

Wenn Sie ein PDF in ChatGPT hochladen, passiert je nach eingesetztem Tool eines von zwei Dingen.

Ist Advanced Data Analysis (die Code-Interpreter-Sandbox) aktiv, kann ChatGPT Python ausführen, um die Datei zu öffnen, zu parsen und den Text Seite für Seite zu extrahieren. Es „liest" nicht das Ganze auf einmal in das Modell hinein. Es schreibt Code, der das Dokument programmatisch verarbeitet, und argumentiert dann über die Ergebnisse.

Sind Sie in einem einfachen Chat ohne Sandbox, wird die Datei direkter in den Kontext geladen, und Sie sind beiden oben genannten Grenzen viel stärker ausgesetzt.

Dieser Unterschied ist der wichtigste Hebel, den Sie haben. Bei einem langen, strukturierten Dokument soll das Modell Code über die Datei schreiben, nicht die Datei in seinen Kopf stopfen. Zum aktuellen Verhalten siehe OpenAIs Überblick zu File Handling und Tools.

Strategie 1: Erzwingen Sie eine strukturierte Extraktion, keine Zusammenfassung

„Fasse diesen Vertrag zusammen" ist die falsche Aufforderung. Zusammenfassungen komprimieren, und in der Komprimierung sterben Klauseln.

Definieren Sie stattdessen ein Schema: die exakten Felder, die Sie für jedes Element wollen, mechanisch wiederholt. Das verwandelt eine unscharfe Leseaufgabe in eine Lückenfüllaufgabe, und die erledigen Modelle deutlich zuverlässiger.

Hier das Prompt-Muster für den Vertrag:

> Gehe den beigefügten Vertrag Abschnitt für Abschnitt durch. Gib für jede nummerierte Klausel und Unterklausel eine Zeile aus mit: clause_id, heading, verbatim_text (erste 200 Zeichen), plain_english, obligations_on_us, obligations_on_them, risk_flag (low/med/high). Fasse nicht über Klauseln hinweg zusammen. Hat eine Klausel Unterteile, listen Sie jeden Unterteil als eigene Zeile. Schließe mit der Gesamtzahl der gefundenen Klauseln ab.

Zwei Dinge machen das wirksam. Das Schema pro Klausel verhindert, dass das Modell Details kollabiert, und die abschließende Zählung gibt Ihnen einen billigen Integritätscheck. Wenn die Nummerierung auf Seite 1 bei 9.4 endet, das Modell aber 22 Klauseln meldet, haben Sie eine Diskrepanz, der Sie nachgehen können.

Strategie 2: Chunking mit Absicht, nicht aus Versehen

Bei einem 60-seitigen Vertrag fügen Sie nicht alles ein und hoffen. Zerlegen Sie ihn in logische Einheiten (nach Artikel, nach Abschnitt) und verarbeiten Sie jeden Chunk mit dem *gleichen* Schema. Chunking heißt hier, den Input in Stücke zu teilen, die klein genug sind, dass das Modell jedem Stück vollständig Aufmerksamkeit widmet.

Die zentrale Regel: Chunken Sie an semantischen Grenzen, nicht nach willkürlichen Zeichenzahlen. Ein Schnitt mitten in einer Klausel erzeugt verwaisten Text, der die Extraktion verwirrt. Trennen Sie bei „Artikel 5", „Artikel 6" und so weiter.

In ChatGPT können Sie das im Gespräch innerhalb eines Projects machen (so bleiben Schema und Anweisungen erhalten):

1. „Hier ist der Vertrag. Liste zuerst jede Artikelüberschrift und deren Seitenbereich auf. Extrahiere noch nicht."

2. Prüfen Sie diese Liste selbst gegen das Inhaltsverzeichnis.

3. „Extrahiere jetzt nur die Klauseln für Artikel 1 bis 3, nach dem Schema."

4. Wiederholen pro Artikel-Batch, dann eine zusammengeführte Tabelle anfordern.

Dass Sie es in einem Project tun, zählt: Ihr Schema, Ihre Custom Instructions und die hochgeladene Datei bleiben auf diesen Workspace begrenzt, sodass jeder Batch die gleichen Regeln erbt, ohne dass Sie sie neu einfügen.

Strategie 3: Lassen Sie Code Interpreter die schwere Arbeit machen

Bei einem 60-seitigen Dokument ist der zuverlässigste Weg innerhalb von ChatGPT, Advanced Data Analysis die Datei deterministisch aufteilen zu lassen und dann pro Chunk zu extrahieren. Sie können buchstäblich fragen:

> Öffne das PDF mit Python, teile den Text anhand der Regex für Klauselnummern (z. B. Zeilen, die mit \d+\. oder \d+\.\d+ beginnen) und zeige mir, wie viele Klauseln du erkannt hast und deren IDs. Extrahiere noch keine Inhalte.

Jetzt hat der *Code* die Klauseln gefunden, nicht die Aufmerksamkeit des Modells. Sie erhalten eine deterministische Zahl, an der alles andere verankert wird. Dann extrahieren Sie den Klauseltext in Batches, wieder über Code, sodass nichts stillschweigend verschwindet.

Long Document Extraction with ChatGPT Advanced Data Analysis

Watch on YouTube

Wenn ChatGPT nicht reicht: die API und Structured Outputs

Die Chat-UI ist gut für einen einzelnen Vertrag. Für Dutzende Verträge, oder für Output, dem Sie ohne Prüfung jeder einzelnen Zeile vertrauen können, wechseln Sie zur OpenAI API, wo Sie das Schema programmatisch erzwingen können.

Das relevante Feature sind Structured Outputs: Sie übergeben dem Modell ein JSON Schema, und die Antwort entspricht *garantiert* dieser Form. Keine Überraschungen der Art „das Modell hat ein Feld vergessen". Kombinieren Sie das mit Chunking, und Sie haben eine echte Extraktionspipeline.

Hier ein kompaktes Beispiel mit der Responses API. Sie iterieren über vorab geteilte Chunks und zwingen jedes Ergebnis in Ihr Klauselschema:

python
from openai import OpenAI

client = OpenAI()

clause_schema = {
    "type": "object",
    "properties": {
        "clauses": {
            "type": "array",
            "items": {
                "type": "object",
                "properties": {
                    "clause_id": {"type": "string"},
                    "heading": {"type": "string"},
                    "plain_english": {"type": "string"},
                    "risk_flag": {"type": "string", "enum": ["low", "med", "high"]},
                },
                "required": ["clause_id", "heading", "plain_english", "risk_flag"],
                "additionalProperties": False,
            },
        }
    },
    "required": ["clauses"],
    "additionalProperties": False,
}

def extract(chunk_text: str) -> dict:
    resp = client.responses.create(
        model="gpt-4.1",
        input=[
            {"role": "system", "content": "Extract every clause. Do not summarize across clauses."},
            {"role": "user", "content": chunk_text},
        ],
        text={"format": {"type": "json_schema", "name": "clauses", "schema": clause_schema, "strict": True}},
    )
    return resp.output_text

for i, chunk in enumerate(article_chunks):
    print(f"Article {i + 1}:", extract(chunk))

Weil strict auf True steht, liefert jeder Chunk gültiges JSON in genau Ihrer Form. Sie führen die Arrays zusammen, deduplizieren nach clause_id, und Sie haben eine vollständige, maschinell prüfbare Extraktion. Die offizielle Referenz ist Structured Outputs in der OpenAI-Dokumentation.

Beachten Sie, was wir *nicht* getan haben: Wir haben nicht 60 Seiten in einem Call geschickt. Wir haben semantische Chunks geschickt, jeder gut innerhalb einer komfortablen Aufmerksamkeitsspanne, und das Schema garantierte Vollständigkeit pro Chunk.

Wissenscheck

1. Was ist laut Lektion der häufigste Fehlermodus, wenn Sie ChatGPT bitten, Informationen aus einem sehr langen Dokument zu extrahieren?

2. Was ist der zentrale Unterschied zwischen „Context Window" und „Attention Budget"?

3. Warum bevorzugt die Lektion, ChatGPT Code über eine lange Datei schreiben zu lassen (per Advanced Data Analysis), statt sie direkt in einen einfachen Chat einzulesen?

MEHRFACHAUSWAHL

4. Wählen Sie ALLE Aussagen, die laut Lektion über das Context Window zutreffen.

Wählen Sie alle richtigen Antworten aus.

MEHRFACHAUSWAHL

5. Wählen Sie ALLE Gründe, die die Lektion für ein strukturiertes Extraktionsschema anstelle einer Zusammenfassung angibt.

Wählen Sie alle richtigen Antworten aus.

Verifikation: der Schritt, den jeder überspringt

Eine Pipeline für lange Dokumente ist nur so gut wie ihre Checks. Drei billige fangen die meisten Fehler ab.

Abgleich der Zählung. Code Interpreter (oder Ihre Regex) hat N Klausel-IDs gefunden. Ihre extrahierte Tabelle hat M Zeilen. Wenn N nicht gleich M ist, listen Sie die fehlenden IDs auf. Allein das fängt den häufigsten Bug des stillen Auslassens ab.

Wortwörtliche Stichprobe. Fragen Sie: „Füge für die Klauseln 12.3, 31.1 und 48.2 den exakten Quelltext neben deine Klartextversion." Wenn der wortwörtliche Text im Dokument nicht existiert, hat das Modell ihn erfunden, und Sie haben eine Halluzination abgefangen, bevor sie in Ihre Zusammenfassung gelangt ist.

Adversariales Nachlesen. „Durchsuche das Dokument erneut nach Formulierungen zu Freistellung, Kündigung oder automatischer Verlängerung, die NICHT bereits in der Tabelle stehen." Gezielte Nachlesedurchgänge finden, was ein einzelner Durchgang übersehen hat, weil Sie die Aufmerksamkeit jetzt auf bestimmte Risikokategorien lenken.

Den Ansatz wählen

Ein kurzer Entscheidungsleitfaden für lange Inputs:

  • Ein Dokument, exploratorisch: ChatGPT-Chat mit Advanced Data Analysis, plus den Prompt für strukturierte Extraktion. Schnell, dialogisch, gut genug.
  • Ein Dokument, hoher Einsatz: dasselbe, aber mit allen drei Verifikationsschritten und wortwörtlichen Zitaten für jede Hochrisikoklausel.
  • Viele Dokumente, wiederholbar: API mit Chunking und Structured Outputs. Sie bekommen auditierbares JSON und können Verträge gegeneinander diffen.
  • Ein laufender Eingang (z. B. jeder neue Vertrag, der in einem Ordner landet): Kapseln Sie die API-Pipeline und triggern Sie sie. Connectors und das breitere Agent-Tooling können Dokumente hereinleiten, aber der Extraktionskern bleibt derselbe: chunken, Schema, verifizieren.

Die Versuchung bei größeren Context Windows ist, das ganze Dokument hineinzuwerfen und dem Modell zu vertrauen. Widerstehen Sie ihr. Ein 60-seitiger Vertrag ist kein Context-Window-Problem, das Sie durch den Kauf von mehr Window lösen. Es ist ein Aufmerksamkeits- und Verifikationsproblem, das Sie mit Struktur lösen.

Key Takeaways

  • Schema schlägt Zusammenfassung. Definieren Sie exakte Felder pro Klausel und fordern Sie eine abschließende Zählung. Damit wird Auslassung von unsichtbar zu messbar.
  • Chunken Sie an semantischen Grenzen (Artikel, Abschnitte), niemals nach willkürlichen Zeichenzahlen, und verarbeiten Sie jeden Chunk mit dem identischen Schema.
  • Lassen Sie erst den Code die Struktur finden. Lassen Sie Advanced Data Analysis das PDF aufteilen und die Klauseln deterministisch zählen, bevor irgendetwas extrahiert wird, damit Sie eine Ground-Truth-Zahl zum Abgleich haben.
  • Für Skalierung und Vertrauen gehen Sie zur API mit Structured Outputs (strict: true), damit jeder Chunk garantiert gültiges JSON liefert, das Sie zusammenführen und auditieren können.
  • Führen Sie immer den Abgleich der Zählung und eine wortwörtliche Stichprobe durch. Eine Pipeline für lange Dokumente ohne Verifikation ist nur eine selbstsichere Vermutung.

Was Sie aus dieser Lektion umsetzen

Diese Maßnahmen sind im Playbook der Rolle zusammengefasst.

  • Lange Dokumente per Schema extrahieren, mit abschließender Zählung und Abgleich
  • Dokumente an semantischen Grenzen chunken, niemals nach beliebiger Zeichenzahl
Vollständiges Action Playbook ansehen

Verwandte Artikel

Aktuelle Blogartikel, die auf dieser Lektion aufbauen.