Extraktion und Validierung mit Werkzeugen

Aufbau zuverlässiger Extraktionspipelines

Durch die Kombination von strukturierten Ausgaben mit Werkzeugen (Web-Suche, Code-Ausführung) können Sie robuste Extraktions- und Validierungspipelines erstellen. Diese Lektion zeigt, wie Sie diese Pipelines für den produktiven Einsatz architektonisch gestalten.

Muster: angereicherte Extraktion

Das häufigste Muster besteht darin, die Datenerfassung durch eine Web-Suche zu erweitern. Sie beginnen mit rohem Text, und das Modell extrahiert Entitäten, die dann mit online gefundenen Informationen angereichert werden.

from pydantic import BaseModel

class EntrepriseEnrichie(BaseModel):
    nom: str
    secteur: str
    pays_siege: str
    site_web: str | None
    description_courte: str
    nombre_employes_estime: str | None
    technologies_utilisees: list[str]

class ExtractionEnrichie(BaseModel):
    entreprises: list[EntrepriseEnrichie]
    relations: list[str]
    contexte: str

response, parsed = client.chat.parse(
    model="grok-4.20-0309-reasoning",
    messages=[{
        "role": "user",
        "content": """Extrahieren und erweitern Sie die in diesem Text genannten Unternehmen:

        'Mistral AI hat eine Partnerschaft mit Scaleway angekündigt,
        um seine Modelle in Frankreich zu hosten. Gleichzeitig
        arbeitet Hugging Face weiterhin mit OVHcloud an
        Open-Source-Infrastruktur zusammen.'"""
    }],
    response_format=ExtractionEnrichie,
    tools=[{"type": "web_search"}]
)

Muster: Kreuzvalidierung

Die Kreuzvalidierung nutzt die Web-Suche, um geprüfte Informationen, die aus einem Dokument extrahiert wurden, zu verifizieren:

class FactCheck(BaseModel):
    affirmation: str
    verifie: bool
    source: str | None
    correction: str | None
    confiance: float

class RapportValidation(BaseModel):
    document_original: str
    verifications: list[FactCheck]
    fiabilite_globale: float
    resume: str

response, parsed = client.chat.parse(
    model="grok-4.20-0309-reasoning",
    messages=[{
        "role": "user",
        "content": """Prüfen Sie die Fakten in diesem Text:
        'Frankreich hat 68 Millionen Einwohner. Paris ist die
        größte Stadt in Europa. Das BIP Frankreichs ist das
        7. größte weltweit.'"""
    }],
    response_format=RapportValidation,
    tools=[{"type": "web_search"}]
)

for v in parsed.verifications:
    status = "Verifiziert" if v.verifie else "Nicht verifiziert"
    print(f"[{status}] {v.affirmation}")
    if v.correction:
        print(f"  → Korrektur: {v.correction}")

Muster: Berechnung und Strukturierung

Kombinieren Sie Code-Ausführung für Berechnungen und strukturierte Ausgaben für das Formatieren:

class LigneFacture(BaseModel):
    description: str
    quantite: int
    prix_unitaire_ht: float
    montant_ht: float
    tva: float
    montant_ttc: float

class Facture(BaseModel):
    lignes: list[LigneFacture]
    total_ht: float
    total_tva: float
    total_ttc: float

response, parsed = client.chat.parse(
    model="grok-4.20-0309-reasoning",
    messages=[{
        "role": "user",
        "content": """Berechnen Sie die Rechnung:
        - 3x Pro-Lizenz à 299 EUR zzgl. MwSt. (MwSt. 20%)
        - 1x Schulung à 1500 EUR zzgl. MwSt. (MwSt. 20%)
        - 12x Monatlicher Support à 49 EUR zzgl. MwSt. (MwSt. 20%)"""
    }],
    response_format=Facture,
    tools=[{"type": "code_interpreter"}]
)

print(f"Total zzgl. MwSt.: {parsed.total_ht} EUR")
print(f"Total inkl. MwSt.: {parsed.total_ttc} EUR")

Architektur einer robusten Pipeline

Für den produktiven Einsatz strukturieren Sie Ihre Pipeline in Schritte:

# Schritt 1: Rohextraktion
class ExtractionBrute(BaseModel):
    entites: list[str]
    dates: list[str]
    montants: list[str]

# Schritt 2: Anreicherung
class EntiteEnrichie(BaseModel):
    nom: str
    type: str
    details: str

# Schritt 3: Validierung
class ResultatValide(BaseModel):
    entites: list[EntiteEnrichie]
    score_qualite: float
    alertes: list[str]

Jeder Schritt verwendet einen separaten Aufruf mit einem maßgeschneiderten Schema. Dieser modulare Ansatz vereinfacht das Debugging und die Überwachung.

Fehlerbehandlung in der Produktion

try:
    response, parsed = client.chat.parse(
        model="grok-4.20-0309-reasoning",
        messages=messages,
        response_format=MonSchema,
        tools=[{"type": "web_search"}]
    )
except Exception as e:
    # Fallback ohne Web-Suche
    response, parsed = client.chat.parse(
        model="grok-4.20-0309-reasoning",
        messages=messages,
        response_format=MonSchema
    )

Kernaussagen

• Angereicherte Extraktion kombiniert Web-Suche und strukturierte Ausgaben für vollständige Daten.
• Kreuzvalidierung verifiziert Fakten mit der Web-Suche.
• Code-Ausführung gewährleistet exakte Berechnungen in finanziellen Pipelines.
• Strukturieren Sie in separate Schritte für Robustheit und Debugging.
• Planen Sie immer einen Fallback ein, falls Werkzeuge ausfallen.