Strukturierte Ausgaben mit LLMs: JSON-Modus, Funktionsaufrufe und wann man was verwendet

Strukturierte Ausgaben mit LLMs: JSON-Modus, Funktionsaufrufe und wann man welche verwendet

Große Sprachmodelle (LLMs) sind für Entwickler unverzichtbare Werkzeuge geworden, aber die Extraktion zuverlässiger, strukturierter Daten aus ihren Freitextausgaben bleibt eine anhaltende Herausforderung. Ob Sie einen Chatbot, eine automatisierte Datenpipeline oder ein Entscheidungsunterstützungssystem entwickeln – Sie benötigen, dass Ihr LLM Daten in einem vorhersagbaren Format zurückgibt. Dieser Artikel untersucht zwei primäre Techniken zur Erzielung strukturierter Ausgaben: JSON-Modus und Funktionsaufrufe. Wir vergleichen ihre Funktionsweise, Anwendungsfälle und geben praktische Hinweise, wann welche Methode eingesetzt werden sollte.

Die Herausforderung verstehen

LLMs generieren Text Token für Token, was bedeutet, dass ihre Ausgabe von Natur aus unstrukturiert ist. Eine einfache Aufforderung wie "Liste die Hauptstädte Europas auf" könnte je nach Training und Zufälligkeit des Modells eine Aufzählungsliste, eine Tabelle oder einen Absatz ergeben. Für Produktionssysteme ist diese Variabilität inakzeptabel. Sie benötigen ein Schema – eine vordefinierte Struktur, an die sich das Modell halten muss. JSON-Modus und Funktionsaufrufe sind zwei Methoden, die solche Schemata erzwingen, aber sie funktionieren unterschiedlich und eignen sich für verschiedene Szenarien.

Voraussetzungen

Bevor Sie mit der Implementierung beginnen, stellen Sie sicher, dass Folgendes vorhanden ist:

• Python 3.8 oder höher auf Ihrem System installiert.
• Zugriff auf eine LLM-API, die strukturierte Ausgaben unterstützt. OpenAIs GPT-4 und GPT-4 Turbo sind am gebräuchlichsten, aber andere Anbieter (z. B. Anthropic, Google) bieten ähnliche Funktionen. Wir verwenden OpenAI als Referenzimplementierung.
• Ein API-Schlüssel von Ihrem LLM-Anbieter. Für OpenAI registrieren Sie sich unter platform.openai.com und erstellen einen Schlüssel.
• Grundlegende Vertrautheit mit Python und Befehlszeilenwerkzeugen.

Schritt-für-Schritt-Installation

Wir richten eine Python-Umgebung ein und installieren die erforderlichen Bibliotheken. Diese Schritte gehen davon aus, dass Sie ein Unix-ähnliches Terminal verwenden (Linux, macOS oder WSL unter Windows).

1. Virtuelle Umgebung erstellen

Die Isolierung von Abhängigkeiten verhindert Konflikte mit anderen Projekten. Führen Sie die folgenden Befehle aus:

python3 -m venv llm-structured
source llm-structured/bin/activate

Der erste Befehl erstellt eine virtuelle Umgebung namens `llm-structured`. Der zweite aktiviert sie, sodass alle von Ihnen installierten Python-Pakete in dieser Umgebung enthalten sind.

2. OpenAI Python-Bibliothek installieren

Die OpenAI-Bibliothek bietet eine saubere Schnittstelle für die Interaktion mit ihrer API. Installieren Sie sie mit pip:

pip install openai

Dies installiert die neueste Version des `openai`-Pakets, das Unterstützung für JSON-Modus und Funktionsaufrufe enthält.

3. API-Schlüssel festlegen

Sie müssen sich bei OpenAI authentifizieren. Setzen Sie Ihren API-Schlüssel aus Sicherheitsgründen als Umgebungsvariable:

export OPENAI_API_KEY="ihr-api-schluessel-hier"

Ersetzen Sie `ihr-api-schluessel-hier` durch Ihren tatsächlichen Schlüssel. Für dauerhafte Verwendung fügen Sie diese Zeile Ihrer `.bashrc`- oder `.zshrc`-Datei hinzu.

4. Installation überprüfen

Testen Sie, ob alles funktioniert, indem Sie ein einfaches Skript ausführen:

python3 -c "import openai; print('OpenAI-Bibliothek erfolgreich installiert')"

Wenn keine Fehler auftreten, können Sie fortfahren.

JSON-Modus: Strukturierte Ausgaben ohne Funktionen

Der JSON-Modus weist das LLM an, mit einem gültigen JSON-Objekt zu antworten, das einem von Ihnen bereitgestellten Schema entspricht. Er ist einfach, flexibel und funktioniert mit standardmäßigen Chat-Vervollständigungen.

Wie der JSON-Modus funktioniert

Wenn Sie den JSON-Modus aktivieren, wird das Modell gezwungen, eine Ausgabe zu generieren, die als JSON analysiert werden kann. Sie geben die erwartete Struktur in der Systemnachricht oder Benutzeraufforderung an, typischerweise mit einer Schemabeschreibung. Das Modell führt keinen Code aus; es formatiert lediglich seine Antwort als JSON.

Anwendungsbeispiel: Produktinformationen extrahieren

Angenommen, Sie möchten Produktdetails aus einer Benutzerbeschreibung extrahieren. Hier ist ein vollständiges Python-Skript:

import openai
import json

client = openai.OpenAI()

response = client.chat.completions.create(
    model="gpt-4-turbo",
    response_format={"type": "json_object"},
    messages=[
        {"role": "system", "content": "Extrahiere Produktinformationen in JSON mit den Schlüsseln: name, price, category, in_stock."},
        {"role": "user", "content": "Ich habe eine kabellose Premium-Maus für 49,99 € aus der Elektronikabteilung gekauft. Sie ist derzeit auf Lager."}
    ]
)

# JSON-Antwort parsen
product_data = json.loads(response.choices[0].message.content)
print(product_data)

**Erklärung:**

• Der Parameter `response_format={"type": "json_object"}` aktiviert den JSON-Modus.
• Die Systemnachricht teilt dem Modell die erwartete JSON-Struktur mit.
• Das Modell gibt einen String zurück, den Sie mit `json.loads` parsen können.

Wann der JSON-Modus verwendet werden sollte

Der JSON-Modus ist ideal, wenn:

• Sie eine einfache, flache Datenstruktur benötigen (z. B. ein einzelnes Objekt mit wenigen Feldern).
• Das Ausgabeschema statisch ist und nicht von Benutzereingaben abhängt.
• Sie minimalen Overhead wünschen – keine Notwendigkeit, Funktionen zu definieren oder Tool-Aufrufe zu verwalten.
• Die Antwort des Modells die endgültige Ausgabe ist, kein Zwischenschritt.

**Einschränkungen:** Der JSON-Modus kann keine komplexen Schemata wie verschachtelte Objekte oder Arrays mit bedingten Strukturen erzwingen. Das Modell kann gelegentlich fehlerhaftes JSON produzieren, was eine Fehlerbehandlung erfordert.

Funktionsaufrufe: Strukturierte Aktionen ausführen

Funktionsaufrufe (auch als Tool-Nutzung bekannt) ermöglichen es dem LLM, die Ausführung vordefinierter Funktionen anzufordern. Das Modell gibt ein strukturiertes JSON-Objekt zurück, das angibt, welche Funktion mit welchen Argumenten aufgerufen werden soll. Dies ist leistungsfähiger als der JSON-Modus, da das Modell basierend auf dem Gesprächskontext entscheiden kann, wann eine Funktion aufgerufen werden soll.

Wie Funktionsaufrufe funktionieren

Sie definieren Funktionen mit Parametern und Beschreibungen. Das Modell bewertet das Gespräch und gibt, falls angemessen, eine Funktionsaufrufanforderung zurück. Ihr Code führt dann die Funktion aus und übergibt das Ergebnis zur weiteren Verarbeitung an das Modell zurück.

Anwendungsbeispiel: Wetterdaten abrufen

Lassen Sie uns einen Wetterassistenten erstellen, der Funktionsaufrufe verwendet:

import openai
import json

client = openai.OpenAI()

# Eine Funktion für das Modell definieren
functions = [
    {
        "name": "get_weather",
        "description": "Aktuelles Wetter für eine Stadt abrufen",
        "parameters": {
            "type": "object",
            "properties": {
                "city": {
                    "type": "string",
                    "description": "Der Stadtname, z.B. Berlin"
                },
                "unit": {
                    "type": "string",
                    "enum": ["celsius", "fahrenheit"],
                    "description": "Temperatureinheit"
                }
            },
            "required": ["city"]
        }
    }
]

def get_weather(city, unit="celsius"):
    """Simuliert einen Wetter-API-Aufruf"""
    return f"Das Wetter in {city} beträgt 22° {unit}."

# Gespräch senden
response = client.chat.completions.create(
    model="gpt-4-turbo",
    messages=[
        {"role": "user", "content": "Wie ist das Wetter in Paris?"}
    ],
    functions=functions,
    function_call="auto"
)

message = response.choices[0].message

# Prüfen, ob das Modell eine Funktion aufrufen möchte
if message.function_call:
    function_name = message.function_call.name
    arguments = json.loads(message.function_call.arguments)
    
    # Funktion ausführen
    result = get_weather(arguments["city"], arguments.get("unit", "celsius"))
    
    # Funktionsergebnis an das Modell zurücksenden
    second_response = client.chat.completions.create(
        model="gpt-4-turbo",
        messages=[
            {"role": "user", "content": "Wie ist das Wetter in Paris?"},
            message,
            {
                "role": "function",
                "name": function_name,
                "content": result
            }
        ],
        functions=functions
    )
    
    print(second_response.choices[0].message.content)
else:
    print(message.content)

**Erklärung:**

• Die `functions`-Liste definiert eine Funktion mit ihren Parametern und Beschreibungen.
• `function_call="auto"` lässt das Modell entscheiden, wann die Funktion aufgerufen werden soll.
• Das Modell gibt ein `function_call`-Objekt mit dem Funktionsnamen und den Argumenten zurück.
• Sie führen die Funktion aus und geben das Ergebnis zur Erstellung einer menschenlesbaren Antwort an das Modell zurück.

Wann Funktionsaufrufe verwendet werden sollten

Funktionsaufrufe sind am besten geeignet, wenn:

• Sie benötigen, dass das Modell mit externen Systemen interagiert (z. B. APIs, Datenbanken).
• Das Ausgabeschema dynamisch ist oder vom Gesprächskontext abhängt.
• Sie möchten, dass das Modell mehrschrittige Überlegungen durchführt (z. B. eine Funktion aufrufen, dann das Ergebnis in einem Folgeaufruf verwenden).
• Die strukturierte Ausgabe ein Zwischenschritt in einem größeren Workflow ist.

**Einschränkungen:** Funktionsaufrufe erfordern mehr Code, um den Aufruf-Rückgabe-Zyklus zu verwalten. Sie erhöhen auch die Latenz, da mehrere API-Aufrufe getätigt werden.

Vergleich von JSON-Modus und Funktionsaufrufen

| Merkmal | JSON-Modus | Funktionsaufrufe | |------------------------|-------------------------------------|--------------------------------------| | Ausgabestruktur | Einzelnes JSON-Objekt | JSON-Objekt + Funktionsausführung | | Schema-Erzwingung | Über Prompt-Anweisungen | Über explizite Funktionsdefinitionen | | Komplexität | Niedrig | Mittel bis hoch | | Latenz | Ein API-Aufruf | Zwei oder mehr API-Aufrufe | | Dynamische Schemata | Eingeschränkt | Vollständig unterstützt | | Externe Interaktionen | Nein | Ja (über Funktionsausführung) | | Fehlerbehandlung | Manuell (JSON parsen) | Integriert (Funktionsaufrufvalidierung) |

Die richtige Wahl treffen

Die Entscheidung hängt von Ihrem Anwendungsfall ab:

• **Verwenden Sie den JSON-Modus** für einfache Datenextraktionsaufgaben, bei denen die Ausgabe das Endprodukt ist. Beispiele: Parsen von Benutzerabfragen, Generieren von Konfigurationsdateien oder Formatieren von Protokollen.
• **Verwenden Sie Funktionsaufrufe**, wenn das LLM reale Aktionen auslösen muss oder wenn das Ausgabeschema von Benutzereingaben abhängt. Beispiele: Erstellen eines Chatbots, der Termine bucht, Abfragen einer Datenbank oder Orchestrieren mehrschrittiger Workflows.

Hybrider Ansatz

Sie können beide Techniken kombinieren. Verwenden Sie beispielsweise Funktionsaufrufe, um Daten von einer API abzurufen, und bitten Sie dann das Modell, das Ergebnis mit dem JSON-Modus in eine bestimmte JSON-Struktur zu formatieren. Dies bietet das Beste aus beiden Welten: externe Interaktion plus konsistente Formatierung.

Best Practices

1. **Ausgabe immer validieren**: Selbst mit strukturierten Modi können Modelle Fehler machen. Verwenden Sie `try-except`-Blöcke beim Parsen von JSON und validieren Sie Felder gegen Ihr Schema. 2. **Klare Anweisungen geben**: Je spezifischer Sie bezüglich der erwarteten Struktur sind, desto zuverlässiger ist die Ausgabe. Fügen Sie Beispiele in die Systemnachricht ein. 3. **Randfälle behandeln**: Funktionsaufrufe können mehrere Funktionsaufrufe oder gar keine zurückgeben. Ihr Code sollte alle Szenarien ordnungsgemäß behandeln. 4. **Kosten überwachen**: Funktionsaufrufe erfordern mehrere API-Aufrufe, was die Token-Nutzung erhöht. Profilieren Sie Ihre Anwendung, um sicherzustellen, dass sie im Budget bleibt. 5. **Mit mehreren Modellen testen**: Verschiedene Modelle (z. B. GPT-3.5 vs. GPT-4) können unterschiedliche Zuverlässigkeit aufweisen. Testen Sie gründlich vor dem Produktionseinsatz.

Fazit

JSON-Modus und Funktionsaufrufe sind leistungsstarke Werkzeuge zur Extraktion strukturierter Ausgaben aus LLMs, aber sie dienen unterschiedlichen Zwecken. Der JSON-Modus bietet Einfachheit und Geschwindigkeit für statische Datenextraktion, während Funktionsaufrufe Flexibilität und externe Integration für dynamische Workflows bieten. Durch das Verständnis ihrer Stärken und Einschränkungen können Sie den richtigen Ansatz für Ihre Anwendung wählen – oder sie für maximale Wirkung kombinieren. Beginnen Sie mit dem JSON-Modus für einfache Aufgaben und steigen Sie auf Funktionsaufrufe um, wenn Ihr System Interaktion mit der Außenwelt erfordert. Der Schlüssel liegt darin, die Technik an die Komplexität Ihres Problems anzupassen, um zuverlässige, wartbare und effiziente KI-gestützte Anwendungen zu gewährleisten.