Strukturierte Ausgaben

Strukturierte Ausgaben sind essentiell für die Integration von KI in Workflows und Systeme. Lerne, wie du KI-Modelle dazu bringst, konsistent formatierte Daten zu produzieren - von einfachen Listen bis zu komplexen JSON-Strukturen und Datenbankschemata.

Warum strukturierte Ausgaben?

Unstrukturierte Textausgaben sind für Menschen lesbar, aber schwer für Systeme zu verarbeiten. Strukturierte Ausgaben ermöglichen:

• Automatisierte Verarbeitung: Direkte Integration in Workflows
• Konsistenz: Vorhersagbare Formate für zuverlässige Systeme
• Skalierbarkeit: Massenverarbeitung ohne manuelle Nachbearbeitung
• Interoperabilität: Nahtlose Datenübertragung zwischen Systemen
• Validierung: Automatische Qualitätsprüfung der Ausgaben

Gängige Ausgabeformate

JSON-Format

JSON ist das vielseitigste und am weitesten verbreitete Format für strukturierte Daten. Es ermöglicht hierarchische Datenstrukturen und ist von praktisch allen Programmiersprachen unterstützt.

Konkrete API-Beispiele

Moderne KI-APIs bieten native Unterstützung für strukturierte Ausgaben. Hier sind konkrete Code-Beispiele für die wichtigsten Anbieter:

Gemini API (Google)

Die Gemini API unterstützt strukturierte Ausgaben über das responseSchemaKonfigurationsfeld. Dies ist die empfohlene Methode, da sie das Modell zwingt, valides JSON zu generieren.

# Python-Beispiel mit Pydantic
from google import genai
from pydantic import BaseModel
from typing import List

# Schema definieren
class ProductReview(BaseModel):
    product_name: str
    rating: int
    pros: List[str]
    cons: List[str]
    summary: str

# Client initialisieren
client = genai.Client(api_key="YOUR_API_KEY")

# Strukturierte Ausgabe anfordern
response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents="Analysiere diese Produktbewertung und extrahiere die wichtigsten Informationen: 'Das iPhone 15 Pro ist ein tolles Gerät mit excellenter Kamera und starker Performance. Die Akkulaufzeit könnte besser sein und der Preis ist sehr hoch.'",
    config={
        "response_mime_type": "application/json",
        "response_schema": ProductReview,
    }
)

# Ergebnis als strukturiertes Objekt nutzen
review = response.parsed
print(f"Produkt: {review.product_name}")
print(f"Bewertung: {review.rating}/5")

Claude API (Anthropic)

Claude unterstützt strukturierte Ausgaben durch präzise Prompt-Instruktionen und Tool-Use für garantierte Strukturen.

# Python-Beispiel mit Tool Use
import anthropic

client = anthropic.Anthropic(api_key="YOUR_API_KEY")

# Tool (Schema) definieren
analyze_tool = {
    "name": "analyze_review",
    "description": "Extrahiert strukturierte Informationen aus einer Produktbewertung",
    "input_schema": {
        "type": "object",
        "properties": {
            "product_name": {"type": "string"},
            "rating": {"type": "integer", "minimum": 1, "maximum": 5},
            "pros": {"type": "array", "items": {"type": "string"}},
            "cons": {"type": "array", "items": {"type": "string"}},
            "summary": {"type": "string"}
        },
        "required": ["product_name", "rating", "pros", "cons", "summary"]
    }
}

# Anfrage mit Tool Use
response = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=1024,
    tools=[analyze_tool],
    tool_choice={"type": "tool", "name": "analyze_review"},
    messages=[{
        "role": "user",
        "content": "Analysiere diese Produktbewertung: 'Das iPhone 15 Pro ist ein tolles Gerät mit excellenter Kamera und starker Performance. Die Akkulaufzeit könnte besser sein und der Preis ist sehr hoch.'"
    }]
)

# Strukturierte Ausgabe extrahieren
if response.content[0].type == "tool_use":
    review_data = response.content[0].input
    print(f"Produkt: {review_data['product_name']}")
    print(f"Bewertung: {review_data['rating']}/5")

OpenAI API

OpenAI bietet strukturierte Ausgaben über response_formatmit JSON Schema Unterstützung.

# Python-Beispiel mit strukturierter Ausgabe
from openai import OpenAI
from pydantic import BaseModel
from typing import List

client = OpenAI(api_key="YOUR_API_KEY")

# Schema definieren
class ProductReview(BaseModel):
    product_name: str
    rating: int
    pros: List[str]
    cons: List[str]
    summary: str

# Strukturierte Ausgabe anfordern
completion = client.beta.chat.completions.parse(
    model="gpt-4o-2024-08-06",
    messages=[
        {"role": "system", "content": "Du bist ein Experte für Produktanalyse."},
        {"role": "user", "content": "Analysiere diese Bewertung: 'Das iPhone 15 Pro ist ein tolles Gerät mit excellenter Kamera und starker Performance. Die Akkulaufzeit könnte besser sein und der Preis ist sehr hoch.'"}
    ],
    response_format=ProductReview,
)

# Ergebnis als strukturiertes Objekt
review = completion.choices[0].message.parsed
print(f"Produkt: {review.product_name}")
print(f"Bewertung: {review.rating}/5")

# Alternative: JSON Mode ohne Pydantic
response = client.chat.completions.create(
    model="gpt-4o-2024-08-06",
    messages=[
        {"role": "system", "content": "Gib deine Antwort als JSON zurück mit den Feldern: product_name, rating, pros, cons, summary"},
        {"role": "user", "content": "Analysiere die iPhone 15 Pro Bewertung..."}
    ],
    response_format={"type": "json_object"}
)

Vergleich der Ansätze

Praktische Tipps für alle APIs

• Schema-Design: Halte Schemas so einfach wie möglich, aber so komplex wie nötig
• Fehlende Daten: Mache Felder optional, wenn Informationen fehlen könnten
• Enums verwenden: Für kategorische Daten sind Enums ideal
• Arrays begrenzen: Setze sinnvolle Limits für Array-Längen
• Property Ordering: Bei Gemini die Reihenfolge der Properties beachten

Tabellen-Format

Strukturierte Tabellen eignen sich hervorragend für Vergleiche, Listen und übersichtliche Datenaufbereitung.

Best Practices

Design-Prinzipien

• Start Simple: Beginne mit einfachen Strukturen und erweitere schrittweise
• Clear Schemas: Definiere exakte Datentypen und Constraints
• Error Handling: Plane für unvollständige oder fehlerhafte Eingaben
• Validation: Implementiere sowohl Prompt- als auch Code-basierte Validierung
• Documentation: Dokumentiere Schemas und erwartete Formate ausführlich

Fazit

Strukturierte Ausgaben sind der Schlüssel zur erfolgreichen Integration von KI in automatisierte Workflows und Systeme. Durch präzise Schema-Definition, robuste Validierung und durchdachte Error-Handling-Strategien verwandelst du unstrukturierte KI-Ausgaben in zuverlässige, verarbeitbare Daten.

Die wichtigsten Erfolgsfaktoren:

• Definiere klare, validierbare Schemas vor der Implementierung
• Nutze niedrige Temperature-Werte für konsistente Strukturierung
• Implementiere mehrschichtige Validierung (Prompt + Code)
• Plane für Edge Cases und unvollständige Daten
• Teste systematisch mit verschiedenen Input-Typen und -Qualitäten

Mit strukturierten Ausgaben machst du KI zu einem verlässlichen Partner für Datenverarbeitung und Workflow-Automatisierung, der nicht nur verständliche Antworten liefert, sondern direkt in deine Systeme und Prozesse integrierbar ist.