ChatGPT · Arbeiten mit langen Dokumenten und großen Inputs

Werfen Sie einen 60-seitigen Vertrag in ChatGPT und fragen Sie „extrahiere jede Klausel“, dann bekommen Sie eine selbstsichere, flüssige Antwort, die stillschweigend ein Drittel des Dokuments ü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 sie dann technisch zu umgehen.

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

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

Die erste ist das Context WindowContext WindowDas Context Window ist die maximale Textmenge (gemessen in Tokens), die ein Sprachmodell auf einmal verarbeiten kann, einschließlich Input-Prompt und generiertem Output.Vollständige Definition ansehen →: wie viel Text das Modell gleichzeitig im Arbeitsspeicher halten kann. Moderne ChatGPT-Modelle haben große Windows, aber „groß“ ist nicht „unbegrenzt“, und das Window enthält Ihre Datei *plus* Ihre Instruktionen *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 ein Text technisch hineinpasst, verteilt ein 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 erkennen* werden**.

Wie ChatGPT eine Datei aufnimmt (und warum das wichtig ist)

Wenn Sie ein PDF in ChatGPT hochladen, passiert eines von zwei Dingen, je nachdem, welches Tool im Spiel ist.

Ist Advanced Data Analysis (die Code-Interpreter-Sandbox) aktiv, kann ChatGPT Python ausführen, um die Datei zu öffnen, zu parsen und Text seitenweise zu extrahieren. Es „liest“ nicht das Ganze auf einmal ins Modell. Es schreibt Code, der das Dokument programmatisch verarbeitet, und denkt dann über die Ergebnisse nach.

Sind Sie in einem einfachen Chat ohne Sandbox, wird die Datei direkter in den Kontext eingelesen, 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 wollen Sie, dass das Modell Code über die Datei schreibt, und nicht, dass es sich die Datei in den Kopf stopft. Aktuelles 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 Aufgabe. Zusammenfassungen komprimieren, und in der Kompression sterben Klauseln.

Definieren Sie stattdessen ein SchemaSchemaEin Schema ist der formale Bauplan, der festlegt, wie Daten in einer Datenbank, einer Datei oder einer Nachricht strukturiert, benannt, typisiert und miteinander verknüpft sind.Vollständige Definition ansehen →: die genauen 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 Unterpunkte, liste jeden Unterpunkt als eigene Zeile. Beende mit einer Zählung der insgesamt gefundenen Klauseln.

Zwei Dinge lassen das funktionieren. Das Schema pro Klausel verhindert, dass das Modell Details kollabiert, und die abschließende Zählung gibt Ihnen eine billige Integritätsprüfung. Endet die Nummerierung auf Seite 1 bei 9.4, das Modell meldet aber 22 Klauseln, haben Sie eine Diskrepanz zum Nachverfolgen.

Strategie 2: Chunken mit Absicht, nicht aus Versehen

Bei einem 60-seitigen Vertrag fügen Sie nicht das Ganze ein und hoffen. Teilen 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 aufteilen, die klein genug sind, dass das Modell jedem Stück vollständig Aufmerksamkeit widmet.

Die zentrale Regel: Chunken 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 kkDie durchschnittliche Zahl neuer Nutzer, die jeder bestehende Nutzer über Empfehlungen generiert. Über 1,0 verstärkt sich das Wachstum selbst und wird exponentiell.Vollständige Definition ansehen →önnen Sie das im Gespräch innerhalb eines Projects tun (so bleiben Schema und Instruktionen erhalten):

1. „Hier ist der Vertrag. Liste zuerst jede Artikelüberschrift und ihren 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, mit dem Schema.“
4. Pro Artikel-Batch wiederholen, dann eine zusammengeführte Tabelle anfordern.

Es in einem Project zu machen, ist relevant: Ihr Schema, Ihre Custom Instructions und die hochgeladene Datei bleiben auf diesen Workspace beschränkt, sodass jeder Batch die gleichen Regeln erbt, ohne erneutes Einfügen.

Strategie 3: Lassen Sie den Code Interpreter die Schwerarbeit 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 wörtlich 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 den Inhalt noch nicht.

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

Wenn ChatGPT nicht reicht: die APIAPIApplication Programming Interface: eine standardisierte Schnittstelle, über die Anwendungen kommunizieren und Daten austauschen, ohne die interne Funktionsweise der jeweils anderen zu kennen.Vollständige Definition ansehen → und Structured Outputs

Die Chat-UI ist super für einzelne Verträge. Für Dutzende Verträge oder für Output, dem Sie vertrauen können, ohne jede Zeile zu prüfen, wechseln Sie zur OpenAI API, wo Sie das Schema programmatisch erzwingen können.

Das relevante Feature sind Structured Outputs: Sie geben dem Modell ein JSON Schema, und die Antwort entspricht *garantiert* dieser Form. Keine Überraschungen à la „das Modell hat ein Feld vergessen“. Kombinieren Sie das mit Chunking, und Sie haben eine echte Extraktions-PipelinePipelineAlle aktiven Verkaufschancen über die Phasen des Vertriebsprozesses hinweg, zusammen mit ihrem gesamten potenziellen Wert und ihrer Abschlusswahrscheinlichkeit.Vollständige Definition ansehen →.

Hier ein kompaktes Beispiel mit der Responses API. Sie loopen über vorab aufgeteilte Chunks und zwingen jedes Ergebnis in Ihr Klausel-Schema:

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 valides 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 den OpenAI-Docs.

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

Verifikation: der Schritt, den alle überspringen

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

Abgleich der Zählung. Der Code Interpreter (oder Ihre Regex) hat N Klausel-IDs gefunden. Ihre extrahierte Tabelle hat M Zeilen. Ist N ungleich M, lassen Sie die fehlenden IDs auflisten. Allein das fängt den häufigsten Bug des stillen Auslassens ab.

Wörtliche Stichprobe. Fragen Sie: „Füge für die Klauseln 12.3, 31.1 und 48.2 den exakten Quelltext neben deine Fassung in einfachem Englisch.“ Existiert der wörtliche Text nicht im Dokument, hat das Modell ihn erfunden, und Sie haben eine Halluzination erwischt, bevor sie in Ihre Zusammenfassung gelangt ist.

Adversariales Wiederlesen. „Scanne das Dokument erneut nach jeglicher Formulierung zu Freistellung, Kündigung oder automatischer Verlängerung, die NICHT bereits in der Tabelle steht.“ Gezielte Wiederlesungen finden, was ein einzelner Durchgang verpasst hat, weil Sie die Aufmerksamkeit jetzt auf bestimmte Risikokategorien lenken.

Die Wahl Ihres Vorgehens

Ein kurzer Entscheidungsleitfaden für lange Inputs:

• Ein Dokument, exploratives Arbeiten: ChatGPT-Chat mit Advanced Data Analysis plus dem Prompt für strukturierte Extraktion. Schnell, dialogisch, gut genug.
• Ein Dokument, hohe Einsätze: Genauso, aber mit allen drei Verifikationsschritten und wörtlichen Zitaten für jede Hochrisikoklausel.
• Viele Dokumente, wiederholbar: API mit Chunking und Structured Outputs. Sie erhalten auditierbares JSON und können Verträge gegeneinander diffen.
• Ein laufender Eingang (z. B. jeder neue Vertrag, der in einem Ordner landet): Die API-Pipeline verpacken und triggern. Connectors und das breitere Agent-Tooling können Dokumente hineinrouten, aber der Extraktionskern bleibt gleich: chunken, Schema, verifizieren.

Die Versuchung bei größeren Context Windows ist, das ganze Dokument hineinzuwerfen und dem Modell zu vertrauen. Widerstehen Sie. 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.

Wichtigste Erkenntnisse

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