Document Intelligence mit LLMs: Struktur aus unstrukturierten Daten extrahieren [2026]

Unternehmen ertrinken in Dokumenten. Finanzberichte kommen als PDFs. Verträge existieren als gescannte Bilder. Rechnungen, Formulare und Reports sammeln sich in Formaten an, die sich der Automatisierung widersetzen. Laut IDC machen unstrukturierte Daten 80-90% aller Unternehmensdaten aus, doch der Grossteil bleibt für analytische Systeme und Geschäftsprozesse gesperrt.

Traditionelle Dokumentenverarbeitung stützte sich auf starre Templates und regelbasierte OCR. Diese Ansätze brechen zusammen, sobald ein Lieferant sein Rechnungsformat ändert oder ein neuer Vertragstyp eintrifft. Large Language Models mit Vision-Fähigkeiten haben fundamental verändert, was möglich ist: Systeme, die Dokumentstruktur verstehen, Bedeutung aus dem Kontext extrahieren und sich ohne Neuprogrammierung an neue Formate anpassen.

Die Document-Intelligence-Herausforderung

Dokumentenverarbeitung ist kein neues Problem. Was sich geändert hat, ist die Ausgereiftheit der verfügbaren Tools und die Erwartungen an Genauigkeit und Flexibilität.

Warum traditionelle OCR nicht ausreicht

Optical Character Recognition (OCR) konvertiert Bilder in Text, aber Text allein erfasst keine Dokumentbedeutung. Ein Kontoauszug ist mehr als Zeichen auf einer Seite: Er hat Konten, Transaktionen, Daten und Salden in einer spezifischen logischen Struktur angeordnet.

Traditionelle Ansätze scheitern aus mehreren Gründen:

• Layout-Blindheit — OCR produziert einen Textstrom ohne Verständnis für Spalten, Tabellen oder Abschnitte
• Template-Abhängigkeit — Regelbasierte Extraktoren brechen zusammen, wenn sich Dokumentformate ändern
• Kontext-Ignoranz — Systeme können keine Bedeutung aus umgebendem Inhalt ableiten
• Kein semantisches Verständnis — "Summe" neben einer Zahl verknüpft diese nicht automatisch

Was LLMs zur Dokumentenverarbeitung beitragen

Vision-fähige LLMs (GPT-4 Vision, Claude, Gemini) können ein Dokumentbild betrachten und es ähnlich wie ein Mensch verstehen. Sie erkennen:

• Dokumentstruktur — Überschriften, Abschnitte, Absätze, Listen, Tabellen
• Semantische Beziehungen — Welche Werte zu welchen Labels gehören
• Kontext aus Inhalt — Dokumenttyp und -zweck aus dem Text selbst ableiten
• Flexibilität über Formate — Dasselbe Modell verarbeitet Rechnungen, Verträge und Formulare

Das bedeutet nicht, dass traditionelle Techniken obsolet sind. Die besten Pipelines kombinieren spezialisierte Extraktionstools mit LLM-Verständnis. Für einen Überblick, wie LLMs mit externen Datenquellen arbeiten, siehe unseren RAG-Leitfaden.

Architekturansätze

Es gibt keine einzelne korrekte Architektur für Document Intelligence. Die richtige Wahl hängt von Ihren Dokumenttypen, Genauigkeitsanforderungen und Infrastrukturbeschränkungen ab.

Vision-First-Ansatz

Die einfachste Architektur sendet Dokumentbilder direkt an ein Vision-fähiges LLM mit Anweisungen, was extrahiert werden soll. Dies funktioniert bemerkenswert gut für viele Anwendungsfälle und erfordert minimale Vorverarbeitung.

Vorteile:

• Verarbeitet jedes Dokumentlayout ohne Konfiguration
• Versteht visuellen Kontext (Stempel, Unterschriften, Logos)
• Schnell zu implementieren und zu iterieren

Nachteile:

• Kosten skalieren mit Seitenzahl
• Grosse Dokumente können Token-Limits überschreiten
• Weniger präzise für dichte Tabellendaten

Textextraktion + LLM

Zuerst Text mittels OCR oder PDF-Textextraktion extrahieren, dann ein LLM verwenden, um den Inhalt zu strukturieren und zu interpretieren. Niedrigere Kosten pro Dokument, aber verliert räumliche Beziehungen.

Hybrid-Pipeline

Produktionssysteme kombinieren oft Ansätze: spezialisierte Tabellenextraktion für Finanzdaten, Layout-Analyse für Dokumentsegmentierung und LLMs für semantisches Verständnis und Validierung. Dies bietet die beste Genauigkeit, erfordert aber mehr Engineering-Investition.

Aufbau einer Extraktions-Pipeline

Eine produktive Document-Intelligence-Pipeline umfasst typischerweise diese Phasen: Ingestion, Layout-Analyse, Inhaltsextraktion, LLM-Strukturierung und Validierung. Gehen wir jede Phase mit Code-Beispielen durch.

Dokument-Ingestion

Der erste Schritt ist das Laden von Dokumenten und deren Konvertierung in ein verarbeitbares Format. Bei PDFs kann das Textextraktion, Seiten als Bilder rendern oder beides bedeuten.

import fitz  # PyMuPDF
from pathlib import Path
from dataclasses import dataclass

@dataclass
class DocumentPage:
    page_number: int
    text: str
    image_path: Path | None = None

def load_pdf(pdf_path: str, render_images: bool = True) -> list[DocumentPage]:
    """PDF laden und Text extrahieren, optional Seitenbilder rendern."""
    doc = fitz.open(pdf_path)
    pages = []

    for page_num, page in enumerate(doc):
        # Text mit Layout-Erhaltung extrahieren
        text = page.get_text("text")

        image_path = None
        if render_images:
            # Seite als Bild für Vision-Modelle rendern
            pix = page.get_pixmap(matrix=fitz.Matrix(2, 2))  # 2x Zoom für Qualität
            image_path = Path(f"/tmp/page_{page_num}.png")
            pix.save(str(image_path))

        pages.append(DocumentPage(
            page_number=page_num + 1,
            text=text,
            image_path=image_path
        ))

    doc.close()
    return pages

Layout-Analyse

Das Verständnis der Dokumentstruktur vor der Extraktion verbessert die Genauigkeit. Layout-Analyse identifiziert Überschriften, Absätze, Tabellen und andere strukturelle Elemente.

Für komplexe Dokumente erwägen Sie spezialisierte Layout-Modelle wie LayoutLM oder Document-AI-Services, die Bounding Boxes und Element-Klassifizierungen zurückgeben. Für einfachere Fälle reichen oft Heuristiken basierend auf Textpositionierung.

Tabellenextraktion

Tabellen sind notorisch schwierig für allgemeine Extraktion. Zweckgebaute Tools übertreffen sowohl OCR als auch Vision-LLMs für dichte Tabellendaten erheblich.

import pdfplumber
from typing import Any

def extract_tables(pdf_path: str) -> list[dict[str, Any]]:
    """Tabellen aus PDF mittels pdfplumber extrahieren."""
    tables = []

    with pdfplumber.open(pdf_path) as pdf:
        for page_num, page in enumerate(pdf.pages):
            page_tables = page.extract_tables()

            for table_idx, table in enumerate(page_tables):
                if not table or len(table) < 2:
                    continue

                # Erste Zeile als Header, Rest als Daten
                headers = [str(h).strip() if h else f"col_{i}"
                          for i, h in enumerate(table[0])]
                rows = []

                for row in table[1:]:
                    row_dict = {}
                    for i, cell in enumerate(row):
                        header = headers[i] if i < len(headers) else f"col_{i}"
                        row_dict[header] = str(cell).strip() if cell else ""
                    rows.append(row_dict)

                tables.append({
                    "page": page_num + 1,
                    "table_index": table_idx,
                    "headers": headers,
                    "rows": rows
                })

    return tables

LLM-gestützte Strukturierung

Die Rolle des LLM ist es, extrahierten Inhalt zu interpretieren und strukturierte Ausgabe zu produzieren. Die Verwendung von strukturierten Ausgabemodi (JSON-Modus oder Function Calling) stellt konsistente, parsbare Ergebnisse sicher.

import anthropic
import base64
from pathlib import Path

def extract_with_vision(
    image_path: Path,
    extraction_prompt: str,
    schema_description: str
) -> dict:
    """Strukturierte Daten aus Dokumentbild mittels Claude extrahieren."""
    client = anthropic.Anthropic()

    # Bild laden und encodieren
    with open(image_path, "rb") as f:
        image_data = base64.standard_b64encode(f.read()).decode("utf-8")

    # Medientyp bestimmen
    suffix = image_path.suffix.lower()
    media_type = {
        ".png": "image/png",
        ".jpg": "image/jpeg",
        ".jpeg": "image/jpeg"
    }.get(suffix, "image/png")

    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=4096,
        messages=[
            {
                "role": "user",
                "content": [
                    {
                        "type": "image",
                        "source": {
                            "type": "base64",
                            "media_type": media_type,
                            "data": image_data
                        }
                    },
                    {
                        "type": "text",
                        "text": f"""{extraction_prompt}

Gib die extrahierten Daten als JSON zurück, das diesem Schema entspricht:
{schema_description}

Antworte nur mit gültigem JSON, ohne zusätzlichen Text."""
                    }
                ]
            }
        ]
    )

    import json
    return json.loads(response.content[0].text)

Validierung mit Pydantic

Validierung ist kritisch. LLMs können Felder halluzinieren, Daten falsch formatieren oder unerwartete Strukturen zurückgeben. Pydantic-Schemas erzwingen Datenverträge und liefern klare Fehlermeldungen, wenn die Extraktion fehlschlägt.

from pydantic import BaseModel, Field, field_validator
from datetime import date
from decimal import Decimal
from typing import Optional

class Transaction(BaseModel):
    date: date
    description: str
    amount: Decimal
    transaction_type: str = Field(pattern="^(credit|debit)$")

    @field_validator("amount", mode="before")
    @classmethod
    def parse_amount(cls, v):
        """Verschiedene Betragsformate verarbeiten."""
        if isinstance(v, str):
            # Währungssymbole und Kommas entfernen
            cleaned = v.replace("€", "").replace("$", "").replace(",", "").replace(" ", "")
            return Decimal(cleaned)
        return v

class BankStatement(BaseModel):
    account_number: str
    statement_period_start: date
    statement_period_end: date
    opening_balance: Decimal
    closing_balance: Decimal
    transactions: list[Transaction]

    @field_validator("account_number")
    @classmethod
    def validate_account(cls, v):
        """Kontonummerformat sicherstellen."""
        cleaned = v.replace(" ", "").replace("-", "")
        if not cleaned.isdigit() or len(cleaned) < 8:
            raise ValueError("Ungültiges Kontonummerformat")
        return cleaned

def validate_extraction(raw_data: dict, schema: type[BaseModel]) -> BaseModel:
    """Extrahierte Daten gegen Pydantic-Schema validieren."""
    try:
        return schema.model_validate(raw_data)
    except Exception as e:
        # Validierungsfehler für Review loggen
        print(f"Validierung fehlgeschlagen: {e}")
        raise

Vollständiges Pipeline-Beispiel

So fügen sich diese Komponenten in einer vollständigen Extraktions-Pipeline zusammen:

from pathlib import Path
from dataclasses import dataclass
from typing import TypeVar, Generic
from pydantic import BaseModel

T = TypeVar("T", bound=BaseModel)

@dataclass
class ExtractionResult(Generic[T]):
    success: bool
    data: T | None
    errors: list[str]
    confidence: float
    raw_response: dict

class DocumentExtractor:
    def __init__(self, model: str = "claude-sonnet-4-20250514"):
        self.model = model

    def extract(
        self,
        pdf_path: str,
        schema: type[T],
        extraction_prompt: str
    ) -> ExtractionResult[T]:
        """Vollständige Extraktions-Pipeline mit Validierung."""
        errors = []

        # 1. Dokument laden
        pages = load_pdf(pdf_path, render_images=True)

        # 2. Tabellen extrahieren (für Dokumente mit Tabellendaten)
        tables = extract_tables(pdf_path)

        # 3. Kontext für LLM aufbauen
        context = self._build_context(pages, tables)

        # 4. Mit Vision extrahieren (erstes Seitenbild verwenden)
        if pages and pages[0].image_path:
            try:
                raw_data = extract_with_vision(
                    pages[0].image_path,
                    extraction_prompt,
                    schema.model_json_schema()
                )
            except Exception as e:
                errors.append(f"Extraktion fehlgeschlagen: {e}")
                return ExtractionResult(
                    success=False,
                    data=None,
                    errors=errors,
                    confidence=0.0,
                    raw_response={}
                )

        # 5. Gegen Schema validieren
        try:
            validated = schema.model_validate(raw_data)
            return ExtractionResult(
                success=True,
                data=validated,
                errors=[],
                confidence=0.95,
                raw_response=raw_data
            )
        except Exception as e:
            errors.append(f"Validierung fehlgeschlagen: {e}")
            return ExtractionResult(
                success=False,
                data=None,
                errors=errors,
                confidence=0.0,
                raw_response=raw_data
            )

    def _build_context(self, pages, tables) -> str:
        """Seitentext und Tabellendaten zu Kontext kombinieren."""
        context_parts = []

        for page in pages:
            context_parts.append(f"--- Seite {page.page_number} ---\n{page.text}")

        if tables:
            context_parts.append("\n--- Extrahierte Tabellen ---")
            for table in tables:
                context_parts.append(f"Tabelle auf Seite {table['page']}:")
                context_parts.append(str(table['rows'][:5]))  # Erste 5 Zeilen

        return "\n\n".join(context_parts)

Umgang mit komplexen Dokumenttypen

Verschiedene Dokumentkategorien erfordern unterschiedliche Extraktionsstrategien. Hier ist eine Anleitung für gängige Unternehmens-Dokumenttypen.

Finanzberichte

Kontoauszüge, Rechnungen und Finanzberichte teilen gemeinsame Herausforderungen: dichte Tabellen, präzise numerische Anforderungen und strenge Validierungsbedürfnisse.

• Spezialisierte Tabellenextraktion verwenden — pdfplumber oder Camelot für Transaktionstabellen
• Summen validieren — Extrahierte Transaktionen summieren und mit angegebenen Summen vergleichen
• Mehrseitige Tabellen behandeln — Header über Seitenumbrüche hinweg verfolgen
• Währungs-Parsing — Formate normalisieren (1.234,56 vs 1,234.56)

Verträge und Rechtsdokumente

Rechtsdokumente priorisieren Textextraktionsgenauigkeit und Abschnittserkennung über Tabellendaten.

• Abschnittserkennung — Klauseln, Parteien, Daten und Schlüsselbegriffe identifizieren
• Querverweisbehandlung — "Wie in Abschnitt 3.2 definiert"
• Unterschriftserkennung — Unterschriebene vs. nicht unterschriebene Dokumente identifizieren
• Nachtragsverfolgung — Nachträge mit Originalvereinbarungen verknüpfen

Formulare und Anträge

Strukturierte Formulare mit Feldern und Checkboxen profitieren von Layout-Verständnis.

• Feld-Wert-Paarung — Labels mit ihren ausgefüllten Werten abgleichen
• Checkbox-Erkennung — Angekreuzte vs. nicht angekreuzte Optionen identifizieren
• Handschrifterkennung — Vision-Modelle verarbeiten handschriftliche Einträge
• Pflichtfeld-Validierung — Sicherstellen, dass obligatorische Felder ausgefüllt sind

Produktionsüberlegungen

Der Übergang von Document Intelligence vom Prototyp zur Produktion erfordert Aufmerksamkeit für Genauigkeitsmessung, Kostenmanagement und Datensicherheit.

Genauigkeitsmessung

Was man nicht misst, kann man nicht verbessern. Bauen Sie Evaluation von Tag eins in Ihre Pipeline ein.

• Ground-Truth-Datensätze — Manuell eine repräsentative Stichprobe von Dokumenten labeln
• Feldebenen-Genauigkeit — Genauigkeit pro Feld verfolgen, nicht nur pro Dokument
• Konfidenz-Scoring — Extraktionen mit niedriger Konfidenz für menschliche Überprüfung markieren
• Fehlerkategorisierung — OCR-Fehler, Schema-Mismatches und Halluzinationen unterscheiden

Die Zielgenauigkeit hängt von der nachgelagerten Verwendung ab. Automatisierte Verarbeitung könnte 99%+ Genauigkeit erfordern, während Human-in-the-Loop-Workflows niedrigere Schwellenwerte mit Review-Queues tolerieren können.

Kostenoptimierung

Dokumentenverarbeitungskosten können im Massstab schnell eskalieren. Optimieren Sie durch:

• Gestaffelte Verarbeitung — Günstigere Modelle für einfache Dokumente, teure Modelle für komplexe
• Caching — Extraktionen für bereits gesehene Dokumente cachen
• Batching — Mehrere Seiten in einzelnen API-Aufrufen verarbeiten, wo möglich
• Auflösungs-Tuning — Niedrigere Bildauflösung für textlastige Dokumente

Typische Kosten liegen zwischen 0,01-0,10€ pro Seite, abhängig von Komplexität und Modellwahl.

Sicherheit und Compliance

Dokumente enthalten oft sensible Informationen. Adressieren Sie Sicherheit frühzeitig:

• Datenresidenz — Sicherstellen, dass Verarbeitung in angemessenen Jurisdiktionen stattfindet
• PII-Erkennung — Personenbezogene Informationen angemessen identifizieren und behandeln
• Audit-Logging — Verfolgen, was aus welchen Dokumenten extrahiert wurde
• Aufbewahrungsrichtlinien — Definieren, wie lange extrahierte Daten gespeichert werden

Für DSGVO und ähnliche Vorschriften erwägen Sie On-Premises-Verarbeitung oder Anbieter mit entsprechenden Zertifizierungen.

Tools und Services-Landschaft

Der Document-Intelligence-Markt umfasst Cloud-Services, Open-Source-Tools und spezialisierte Plattformen.

Cloud-Service-Vergleich

Für Anwendungen, die semantische Suche über extrahierte Inhalte erfordern, erwägen Sie die Integration mit einer Vektordatenbank, um Retrieval über Ihren Dokumentenkorpus zu ermöglichen.

Fazit

Document Intelligence hat einen praktischen Wendepunkt erreicht. Vision-fähige LLMs können jetzt Dokumentlayouts verstehen, semantische Bedeutung extrahieren und Formatvariationen verarbeiten, die vor wenigen Jahren noch Monate regelbasierter Programmierung erfordert hätten. Die Lücke zwischen dem, was technisch möglich ist, und dem, was in Produktion eingesetzt wird, schliesst sich rapide.

Erfolg kommt aus der Kombination der richtigen Tools: spezialisierte Extraktion für Tabellen und strukturierte Daten, Vision-Modelle für semantisches Verständnis und Flexibilität, und rigorose Validierung, um Fehler abzufangen, bevor sie sich ausbreiten. Pydantic-Schemas sind nicht nur nice-to-have; sie sind essenziell für den Aufbau von Systemen, denen Sie mit echten Geschäftsdaten vertrauen können.

Beginnen Sie mit einem fokussierten Anwendungsfall und messbaren Genauigkeitszielen. Bauen Sie Evaluation von Tag eins in Ihre Pipeline ein. Und denken Sie daran, dass das Ziel nicht perfekte Extraktion aus jedem möglichen Dokument ist — es ist zuverlässige Extraktion aus Ihren spezifischen Dokumenten, die sich sauber in Ihre bestehenden Systeme und Workflows integriert.