Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Strukturierte Entitätsextraktion

Lektion 13 von 16 Aktualisiert am 3. November 2026 Entwickler
Auf dieser Seite
  1. Strukturierte Entitätsextraktion
  2. Grundlegende Extraktionspipeline
  3. Beispiel 1: Lebenslauf-Extraktion
  4. Beispiel 2: Extraktion aus geschäftlichen E-Mails
  5. Batch-Extraktion
  6. Bewertung der Extraktionsqualität
  7. Erstellen Sie Ihre Referenz, bevor Sie optimieren
  8. Kernaussagen

Lektion aktualisiert am 3. November 2026 basierend auf der OpenAI-Dokumentation: temperature und top_p werden nur mit einem Reasoning-Effort von none akzeptiert, während GPT-5.6-Modelle standardmäßig mit medium reasonieren. Aufrufe, die diese Parameter setzen, müssen daher reasoning={"effort": "none"} (Responses API) oder reasoning_effort="none" (Chat Completions) angeben. Quellen: Using GPT-6 · GPT-5.6 Terra.

Strukturierte Entitätsextraktion

Die strukturierte Entitätsextraktion ist einer der am häufigsten angefragten Anwendungsfälle in der Produktion: die Umwandlung von freiem Text (E-Mails, Dokumente, Webseiten) in Daten, die Ihre Anwendung tatsächlich nutzen kann. Durch die Kombination von strukturierten Ausgaben mit spezialisierten Prompts können Sie zuverlässige Extraktionspipelines erstellen, ohne ein dediziertes NER-Modell zu trainieren.

Grundlegende Extraktionspipeline

Die gesamte Spezifität der Extraktion liegt im Systemprompt der nachfolgenden Funktion und verdient eine sorgfältige Aufmerksamkeit. Drei Anweisungen überschneiden sich hier: Extrahieren Sie nur das, was vorhanden ist, verwenden Sie null für fehlende Daten und leiten Sie niemals Informationen ab, die nicht explizit erwähnt werden.

Letzter Satz ist in der Praxis der wichtigste. Wenn ein Modell auf sich allein gestellt ist, füllt es gerne eine plausible SIRET-Nummer aus oder errät eine Stadt aus einem Vorwahlbereich, und zwar mit den besten Absichten. Für eine Extraktion, die für ein Geschäftssystem bestimmt ist, ist diese Hilfsbereitschaft ein schwerwiegender Fehler: Sobald die Daten in der Datenbank sind, gibt es keinen Weg, zu unterscheiden, was gelesen wurde und was angenommen wurde. Das Setzen von temperature auf 0,0 dient demselben Zweck: Über zwei Durchläufe desselben Dokuments möchten Sie dieselbe Ausgabe, nur um einen Vorfall reproduzieren zu können.

import json
from openai import OpenAI

client = OpenAI()

def extract_entities(text: str, schema: dict,
                     instructions: str = "") -> dict:
    """Extrahiert strukturierte Entitäten aus freiem Text."""
    system = (
        "Sie sind ein spezialisierter Entitätsextraktor. "
        "Extrahieren SIE NUR Informationen, die im Text vorhanden sind. "
        "Wenn Informationen fehlen, verwenden Sie null. "
        "LEITEN SIE NIEMALS Informationen ab, die nicht explizit erwähnt werden."
    )
    if instructions:
        system += f"\n\nZusätzliche Anweisungen: {instructions}"

    response = client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # temperature erfordert effort none
        instructions=system,
        input=f"Text zur Analyse:\n\n{text}",
        text={
            "format": {
                "type": "json_schema",
                "name": "extraction",
                "schema": schema,
                "strict": True
            }
        },
        temperature=0.0
    )
    return json.loads(response.output_text)

Beispiel 1: Lebenslauf-Extraktion

Ein Lebenslauf ist ein hervorragender Testbereich, da er stabile Abschnitte mit einem völlig freien Layout kombiniert. Das untenstehende Schema gruppiert Kontaktdaten in ein identity-Objekt, bei dem fast jedes Feld nullable ist – ein Kandidat könnte keine Telefonnummer angeben, und die Anforderung dieses Feldes würde im Wesentlichen das Modell dazu einladen, eine zu erfinden.

Fähigkeiten sind keine einfachen Strings, sondern Objekte mit drei Attributen, was es Ihnen ermöglicht, das angegebene Niveau zu bewahren und jede Fähigkeit zu kategorisieren. Ohne diese Enums würden “Scrum” und “Python” in derselben flachen Liste nebeneinander landen, was für einen Filter, der versucht, Sprachen zu isolieren, nutzlos wäre. Beachten Sie auch das Feld end_date in den Erfahrungen, das nullable ist, während start_date es nicht ist: So kodieren Sie eine aktuelle Position, ohne eine hausgemachte Konvention wie “present” oder “9999” zu erfinden. Auf dem Test-Lebenslauf spielt diese Feinheit sich auf der TechCorp-Linie aus.

resume_schema = {
    "type": "object",
    "properties": {
        "identity": {
            "type": "object",
            "properties": {
                "full_name": {"type": "string"},
                "email": {"type": ["string", "null"]},
                "phone": {"type": ["string", "null"]},
                "location": {"type": ["string", "null"]},
                "linkedin": {"type": ["string", "null"]}
            },
            "required": ["full_name", "email", "phone",
                          "location", "linkedin"],
            "additionalProperties": False
        },
        "current_title": {"type": ["string", "null"]},
        "years_experience": {"type": ["integer", "null"]},
        "skills": {
            "type": "array",
            "items": {
                "type": "object",
                "properties": {
                    "name": {"type": "string"},
                    "level": {
                        "type": "string",
                        "enum": ["beginner", "intermediate",
                                 "advanced", "expert"]
                    },
                    "category": {
                        "type": "string",
                        "enum": ["language", "framework", "tool",
                                 "methodology", "soft_skill"]
                    }
                },
                "required": ["name", "level", "category"],
                "additionalProperties": False
            }
        },
        "experiences": {
            "type": "array",
            "items": {
                "type": "object",
                "properties": {
                    "company": {"type": "string"},
                    "title": {"type": "string"},
                    "start_date": {"type": "string"},
                    "end_date": {"type": ["string", "null"]},
                    "description": {"type": "string"}
                },
                "required": ["company", "title", "start_date",
                              "end_date", "description"],
                "additionalProperties": False
            }
        },
        "education": {
            "type": "array",
            "items": {
                "type": "object",
                "properties": {
                    "institution": {"type": "string"},
                    "degree": {"type": "string"},
                    "year": {"type": ["string", "null"]}
                },
                "required": ["institution", "degree", "year"],
                "additionalProperties": False
            }
        },
        "languages": {
            "type": "array",
            "items": {
                "type": "object",
                "properties": {
                    "language": {"type": "string"},
                    "level": {
                        "type": "string",
                        "enum": ["a1", "a2", "b1", "b2",
                                 "c1", "c2", "native"]
                    }
                },
                "required": ["language", "level"],
                "additionalProperties": False
            }
        }
    },
    "required": ["identity", "current_title", "years_experience",
                  "skills", "experiences", "education", "languages"],
    "additionalProperties": False
}

resume_text = """
Marie Dupont - Senior Full Stack Developer
Email: [email protected] | Tel: +33 6 12 34 56 78
Paris, France | linkedin.com/in/mariedupont

8 years of experience in web development.

Skills: Python (expert), TypeScript (advanced), React (advanced),
Django (expert), PostgreSQL (advanced), Docker (intermediate),
Scrum (advanced)

Experience:
- TechCorp (2022-present): Lead Full Stack Developer
  Principal architect of a B2B SaaS platform, team of 6 devs.
- StartupAI (2019-2022): Senior Developer
  Development of ML APIs in Python/FastAPI.

Education:
- EPITECH Paris, Master in Computer Science (2017)

Languages: French (native), English (C1), Spanish (B1)
"""

result = extract_entities(resume_text, resume_schema)

Beispiel 2: Extraktion aus geschäftlichen E-Mails

Das zweite Beispiel ändert die Natur: Wir kopieren nicht nur Informationen, sondern bitten das Modell um Interpretation. intent und urgency sind Urteile – kein Satz in der E-Mail sagt “dies ist eine Angebotsanfrage, hohe Priorität”. Genau das ist etwas, was eine klassische Extraktionspipeline, die auf Regeln oder regulären Ausdrücken basiert, nicht kann, und genau das rechtfertigt den Einsatz eines LLMs hier und nicht anderswo.

Der Rest des Schemas kehrt zu überprüfbaren Fakten zurück: erwähnte Produkte, Beträge mit ihrem Kontext, Daten und ihre Bedeutung, erforderliche Aktionen. Das Feld summary schließt das Objekt ab und dient dem Menschen, der die Warteschlange überprüft, nicht dem Code. Ein Punkt der Wachsamkeit bei diesem gemischten Schema: Ein Fehler bei der Klassifizierung von urgency ungültigt nicht die Beträge, aber das Gegenteil kann passieren, da ein Modell, das die Absicht missversteht, den Rest manchmal durch dieses Missverständnis liest. Wenn die Klassifizierung für Ihre Routing-Logik kritisch ist, trennen Sie sie in einen dedizierten Aufruf.

email_schema = {
    "type": "object",
    "properties": {
        "intent": {
            "type": "string",
            "enum": ["quote_request", "complaint", "information",
                     "order", "partnership", "other"]
        },
        "urgency": {
            "type": "string",
            "enum": ["critical", "high", "normal", "low"]
        },
        "sender": {
            "type": "object",
            "properties": {
                "name": {"type": ["string", "null"]},
                "company": {"type": ["string", "null"]},
                "email": {"type": ["string", "null"]}
            },
            "required": ["name", "company", "email"],
            "additionalProperties": False
        },
        "mentioned_products": {
            "type": "array",
            "items": {"type": "string"}
        },
        "mentioned_amounts": {
            "type": "array",
            "items": {
                "type": "object",
                "properties": {
                    "value": {"type": "number"},
                    "currency": {"type": "string"},
                    "context": {"type": "string"}
                },
                "required": ["value", "currency", "context"],
                "additionalProperties": False
            }
        },
        "key_dates": {
            "type": "array",
            "items": {
                "type": "object",
                "properties": {
                    "date": {"type": "string"},
                    "significance": {"type": "string"}
                },
                "required": ["date", "significance"],
                "additionalProperties": False
            }
        },
        "required_actions": {
            "type": "array",
            "items": {"type": "string"}
        },
        "summary": {"type": "string"}
    },
    "required": ["intent", "urgency", "sender",
                  "mentioned_products", "mentioned_amounts",
                  "key_dates", "required_actions", "summary"],
    "additionalProperties": False
}

Batch-Extraktion

Um große Volumina zu verarbeiten, parallelisieren Sie Ihre Extraktionen. Ein sequentieller Loop über tausend Dokumente verbringt die meiste Zeit mit dem Warten auf das Netzwerk; mit asyncio überlappen sich diese Wartezeiten und der Batch-Prozess läuft in einem Bruchteil der Zeit.

Das Semaphore ist kein dekoratives Detail. Ohne es wird das Starten von tausend Aufgaben gleichzeitig Ihre Quote sättigen und Fehlerschwellenfehler auslösen, die in Wiederholungen mehr kosten als sie in der Geschwindigkeit sparen. Setzen Sie den max_concurrent-Wert, indem Sie Ihre eigenen Grenzen beobachten, wobei zehn ein vorsichtiger Startpunkt ist. Beachten Sie auch return_exceptions=True: Es verhindert, dass ein einzelnes fehlerhaftes Dokument den gesamten Batch abstürzt und lässt Sie die Fehler später aufräumen.

import asyncio
from openai import AsyncOpenAI

async_client = AsyncOpenAI()

async def extract_batch(texts: list[str], schema: dict,
                          max_concurrent: int = 10) -> list[dict]:
    """Parallele Extraktion mit Konfliktkontrolle."""
    semaphore = asyncio.Semaphore(max_concurrent)

    async def extract_one(text: str) -> dict:
        async with semaphore:
            response = await async_client.responses.create(
                model="gpt-5.6-terra",
                reasoning={"effort": "none"},  # temperature erfordert effort none
                instructions="Extrahieren Sie Entitäten aus dem bereitgestellten Text. "
                             "Verwenden Sie null für fehlende Felder.",
                input=text,
                text={
                    "format": {
                        "type": "json_schema",
                        "name": "extraction",
                        "schema": schema,
                        "strict": True
                    }
                },
                temperature=0.0
            )
            return json.loads(response.output_text)

    tasks = [extract_one(t) for t in texts]
    return await asyncio.gather(*tasks, return_exceptions=True)

Bewertung der Extraktionsqualität

Eine Extraktionspipeline ohne einen annotierten Testsatz ist eine Pipeline, deren Zuverlässigkeit niemand kennt, und der Eindruck, der durch drei manuell gelesene Beispiele hinterlassen wird, ist fast immer zu optimistisch. Die nachfolgende Funktion vergleicht ein erhaltenes Extraktionsfeld für Feld mit einem manuell erstellten Referenzwert und gibt die gesamte Präzision zusammen mit einer Aufschlüsselung der Diskrepanzen zurück.

Diese Aufschlüsselung ist der nützliche Teil: Fehler sind fast nie gleichmäßig verteilt. Ein Feld konzentriert die Probleme – oft ein mehrdeutiges Datum, ein implizites Fähigkeitsniveau oder eine schlecht definierte Kategorie – und ein einziger Satz, der dem Systemprompt hinzugefügt wird, behebt ihn. Ohne diese Messung würden Sie den Prompt willkürlich anpassen und möglicherweise ein Feld verschlechtern, das bereits funktioniert.

def evaluate_extraction(expected: dict, obtained: dict,
                       fields: list[str]) -> dict:
    """Vergleicht die erhaltene Extraktion mit dem Referenzwert."""
    correct = 0
    total = len(fields)
    errors = []

    for field in fields:
        val_expected = expected.get(field)
        val_obtained = obtained.get(field)

        if val_expected == val_obtained:
            correct += 1
        else:
            errors.append({
                "field": field,
                "expected": val_expected,
                "obtained": val_obtained
            })

    return {
        "precision": correct / total if total > 0 else 0,
        "correct": correct,
        "total": total,
        "errors": errors
    }

Erstellen Sie Ihre Referenz, bevor Sie optimieren

Wählen Sie einen Dokumententyp aus Ihrem Bereich – Verträge, Rechnungen, Berichte – und definieren Sie ein Extraktionsschema mit mindestens zehn Feldern, wobei Sie bewusst einfache Felder mit solchen mischen, die Sie als mehrdeutig kennen. Montieren Sie fünf Beispiel-Dokumente mit ihren erwarteten Extraktionen, handschriftlich geschrieben: Dieser Schritt ist mühsam, dauert eine Stunde und ist es, was allen nachfolgenden Arbeiten ihren Wert gibt.

Führen Sie dann die Pipeline aus, messen Sie die Präzision und lesen Sie die Liste der Fehler Feld für Feld. Das fehlerhafteste Feld wird Ihnen sagen, was Sie im Prompt korrigieren müssen; eine zweite Messung wird Ihnen sagen, ob die Korrektur tatsächlich geholfen hat – oder ob sie ein anderes Feld im Prozess verschlechtert hat, was öfter passiert, als Sie vielleicht denken, sobald eine zusätzliche Anweisung die Aufmerksamkeit des Modells verschiebt.

Kernaussagen

  • Strukturierte Extraktion ersetzt dedizierte NER-Modelle für die meisten Anwendungsfälle
  • Verwenden Sie temperature=0.0, um die Konsistenz zu maximieren
  • Machen Sie optionale Felder nullable statt optional
  • Parallelisieren Sie mit asyncio für große Volumina
  • Bewerten Sie die Qualität systematisch mit einem annotierten Testsatz
  • Systemprompt-Anweisungen leiten den Inhalt, das Schema begrenzt die Struktur