Wie erhalte ich JSON-Ausgaben von einem offenen Modell?

Übergeben Sie in einer Chat-Completions-Anfrage `response_format` mit `type: "json_schema"`, einem `name`, Ihrem JSON Schema und `strict: true`. Die Antwort in `message.content` ist dann JSON, das dem Schema entspricht. Für eine lockerere Garantie nutzen Sie `type: "json_object"` und beschreiben die Felder im Prompt.

Ist das mit den Structured Outputs von OpenAI kompatibel?

Ja. `response_format` mit `json_schema` und `json_object` folgt der OpenAI Chat Completions API, `text.format` der Responses API. SDK-Helfer, die das Schema aus einem Pydantic- oder Zod-Modell erzeugen, etwa `client.chat.completions.parse` in Python, funktionieren mit inference.eu.

Was unterscheidet den JSON-Modus von Structured Outputs?

Der JSON-Modus garantiert gültiges JSON, aber nicht, welche Schlüssel es enthält. Structured Outputs mit `json_schema` garantieren, dass die Ausgabe Ihrem Schema folgt: Pflichtfelder vorhanden, Typen korrekt, keine zusätzlichen Eigenschaften. Nutzen Sie Structured Outputs, wann immer Sie die benötigte Form kennen.

Welche Funktionen von JSON Schema werden unterstützt?

Objekte, Arrays, Strings, Zahlen, Ganzzahlen, Booleans, `null`, `enum`, `required`, verschachtelte Objekte, `additionalProperties: false` und Beschreibungen funktionieren. Sehr komplexe Konstrukte können mit einem 400-Fehler samt Problembeschreibung abgelehnt werden. Flache, eindeutige Schemas liefern die zuverlässigsten Ergebnisse.

Kann ich Pydantic-Modelle verwenden?

Ja. Definieren Sie in Python ein Pydantic-Modell und übergeben Sie es als `response_format` an `client.chat.completions.parse`. Das SDK wandelt es in ein JSON Schema um, sendet es und liefert ein geparstes Objekt in `message.parsed`. Mit Zod funktioniert das in TypeScript über den Helfer des SDK genauso.

Warum ist mein JSON abgeschnitten?

Das Modell hat `max_tokens` erreicht, bevor es fertig war, und `finish_reason` lautet `length`. Erhöhen Sie `max_tokens`, kürzen Sie lange Textfelder im Schema oder extrahieren Sie weniger Einträge pro Anfrage. Reasoning-Modelle brauchen zusätzlichen Platz, weil ihr Nachdenken ebenfalls zum Limit zählt.

Lassen sich Structured Outputs mit Tool Calling kombinieren?

Ja. Werkzeuge können in ihrer Funktionsdefinition `strict: true` nutzen, damit die Argumente dem Parameterschema folgen, und die endgültige Antwort kann `response_format` verwenden. Häufig ruft das Modell zuerst Nachschlagewerkzeuge auf und liefert dann eine strukturierte Zusammenfassung.

Ist die Antwort durch Structured Outputs automatisch richtig?

Nein. Garantiert ist die Form, nicht die Richtigkeit jedes Werts. Ein Modell kann ein Dokument falsch lesen oder einen Wert raten. Erlauben Sie `null` für fehlende Daten, prüfen Sie wichtige Felder im Code und kontrollieren Sie eine Stichprobe der Ergebnisse von Hand.

Structured Outputs mit JSON Schema · OpenAI-kompatibel, EU

extract_invoice.py

import json, os
from openai import OpenAI

client = OpenAI(base_url="https://api.inference.eu/v1", api_key=os.environ["INFERENCE_EU_API_KEY"])

schema = {
    "type": "object",
    "properties": {
        "supplier": {"type": "string"},
        "invoice_number": {"type": "string"},
        "issue_date": {"type": "string", "description": "ISO 8601 date"},
        "currency": {"type": "string", "enum": ["EUR", "GBP", "CHF", "PLN", "SEK"]},
        "total": {"type": "number"},
        "vat_id": {"type": ["string", "null"]},
    },
    "required": ["supplier", "invoice_number", "issue_date", "currency", "total", "vat_id"],
    "additionalProperties": False,
}

reply = client.chat.completions.create(
    model="gpt-oss-120b",
    messages=[
        {"role": "system", "content": "Extract invoice fields. Use null when a field is missing."},
        {"role": "user", "content": open("invoice.md").read()},
    ],
    response_format={
        "type": "json_schema",
        "json_schema": {"name": "invoice", "schema": schema, "strict": True},
    },
)
invoice = json.loads(reply.choices[0].message.content)

So funktionieren Structured Outputs

Ergänzen Sie response_format mit type: "json_schema" und einem Objekt json_schema, das einen name, Ihr schema als JSON Schema und strict: true enthält. Während das Modell generiert, lässt die API nur Tokens zu, die die Ausgabe gültig gegenüber dem Schema halten. Das Ergebnis in message.content ist ein JSON-String, den Sie direkt parsen können.

Das ist zuverlässiger, als im Prompt um JSON zu bitten. Das Modell kann keinen Satz vor die öffnende Klammer setzen, kein Pflichtfeld weglassen und keine undefinierte Eigenschaft erfinden. Die Aufgabe beschreiben Sie weiterhin im Prompt: Das Schema bestimmt die Form, der Prompt den Inhalt.

JSON-Modus und Schemagestaltung

response_format: {"type": "json_object"} ist die lockerere Variante, der JSON-Modus. Die Ausgabe ist garantiert gültiges JSON, folgt aber keiner bestimmten Struktur; nennen Sie die erwarteten Felder daher im Prompt. Bevorzugen Sie json_schema, wann immer Sie die Form kennen.

Halten Sie Schemas einfach und eindeutig. Führen Sie jede Eigenschaft in required auf und setzen Sie additionalProperties auf false, wie es der strikte Modus erwartet. Optionale Werte bilden Sie als Typ ab, der null erlaubt, wie vat_id im Beispiel. So kann das Modell „nicht gefunden“ sagen, statt zu raten. Nutzen Sie enum für feste Kategorien und description für Felder, deren Bedeutung sich nicht aus dem Namen ergibt.

Eine bewährte Extraktions-Pipeline

Ein verbreitetes Muster macht aus Dokumenten Daten. Wandeln Sie jedes PDF mit dem Werkzeug zur Dokumentkonvertierung in Markdown um, senden Sie den Text mit kurzem Systemprompt und Ihrem Schema und parsen Sie das Ergebnis. Prüfen Sie das Objekt im Code mit demselben Schema und anschließend Geschäftsregeln, die das Schema nicht abbildet, etwa ob Summen stimmen.

Für Tausende Dokumente bündeln Sie dieselben Anfragen in einem Batch-Job. Ein Feld für die Sicherheit des Modells oder ein kurzer notes-String hilft Prüfern zu verstehen, warum ein Wert gewählt wurde. In der Responses API gehört dasselbe Schema in text.format statt in response_format.

Fehler und Sonderfälle

Sehr große oder tief verschachtelte Schemas sowie ungewöhnliche Schlüsselwörter wie komplexe pattern-Ausdrücke oder oneOf mit überlappenden Zweigen können mit einem 400-Fehler abgelehnt werden, der den nicht unterstützten Teil nennt. Teilen oder vereinfachen Sie solche Schemas.

Das Schema garantiert das Format, nicht die Fakten. Ein Modell kann ein falsches Datum in ein gültiges Datumsfeld schreiben, prüfen Sie wichtige Werte also. Endet die Generierung bei max_tokens, ist das JSON abgeschnitten und nicht parsebar; prüfen Sie finish_reason und erhöhen Sie das Limit. Reasoning-Modelle denken vor dem JSON nach und brauchen Platz für beides. Ablehnungen kommen als Text, nicht als Schema-Ausgabe.

Structured Outputs: JSON, das Ihrem Schema entspricht

So funktionieren Structured Outputs

JSON-Modus und Schemagestaltung

Eine bewährte Extraktions-Pipeline

Fehler und Sonderfälle

Structured outputs: häufige Fragen

Verwandte Seiten

Verlagern Sie Ihre KI-Workloads auf europäische Infrastruktur