Blog • KI / JSON Schema

Warum braucht KI JSON Schema? Structured Output, Function Calling und JSON Schema erklärt

Wenn Sie ChatGPT, Gemini oder DeepSeek anbinden, stehen in den Docs gleichzeitigFunction Calling, Structured Output undJSON Schema. Das wirkt wie drei Features. Es sind drei Nutzungen einer Vertragssprache.

JSON Schema beschreibt, wie ein JSON-Dokument aussehen muss. Der aktuelle Mainstream ist2020-12. Function Calling nutzt es für Werkzeugargumente, Structured Output für die Endantwort. KI braucht es nicht, weil JSON modern ist, sondern weil Downstream-Code natürliche Sprache nicht zuverlässig verarbeiten kann.

Dieser Artikel erklärt:

• Was jeder der drei Begriffe bindet
• Warum reine natürliche Sprache nicht reicht
• Wie Function Calling Schema für Argumente nutzt
• Wie Structured Output Schema für die Endantwort nutzt
• Wie Sie ein Schema zweifach verwenden, dann wählen und prüfen

Drei Begriffe in einer Tabelle

Legen Sie die drei Wörter zuerst in eine Tabelle. Sie teilen JSON Schema als Sprache, binden aber unterschiedliche Objekte.

Die drei Wörter vermischen sich, weil Docs Feature-Namen und Vertragssprache bündeln. Schichten merken: JSON Schema ist die Sprache; Function Calling und Structured Output sind zwei Nutzungen.

Warum KI nicht nur mit natürlicher Sprache auskommt

Steht im Prompt nur „bitte JSON zurückgeben“, treten diese Fehler auf.

Demos verstecken das mit Retries oder einem zweiten Parse. In Produktionsagenten, Pipelines und Automatisierung stürzt Downstream ab. JSON Schema ist der Formatvertrag: Felder, Typen und Pflichtkeys vor der Generierung deklarieren.

JSON Schema ist ein Vertrag, kein Kommentar

JSON Schema ist der Standard zur Beschreibung von JSON-Struktur. In KI-Integrationen ist es kein Menschenkommentar — es ist ein maschinenausführbarer Vertrag:

1. 1
   Feldnamen und Typen deklarieren

   Jeder Key in properties ist ein Ausgabefeld; type setzt string / integer / array usw.

2. 2
   Pflichtkeys und Enums begrenzen

   required listet Mussfelder; enum blockiert kreative Werte.

3. 3
   Zusatzfelder sperren

   additionalProperties: false verbietet undeclared Keys. Strict Schema verlangt das meist.

{
  "type": "object",
  "properties": {
    "ticket_id": {
      "type": "string",
      "description": "Support ticket ID, e.g. TCK-1042"
    },
    "priority": {
      "type": "string",
      "enum": ["low", "medium", "high"]
    },
    "summary": {
      "type": "string",
      "description": "One-sentence problem summary"
    }
  },
  "required": ["ticket_id", "priority", "summary"],
  "additionalProperties": false
}

Dieses Schema kümmert sich nicht, ob es in tools oder response_format liegt. Es beantwortet nur: Ist dieses JSON legal? Die nächsten zwei Abschnitte hängen es an Function Calling und Structured Output.

Function Calling: Schema für Werkzeugargumente

Function Calling lässt das Modell eine strukturierte Werkzeugaufruf statt einer Schätzung zurückgeben. Jedes Werkzeug-tools[].parameters ist JSON Schema:

{
  "model": "gpt-4o",
  "messages": [
    { "role": "user", "content": "Create a high-priority ticket for checkout timeout." }
  ],
  "tools": [
    {
      "type": "function",
      "function": {
        "name": "create_ticket",
        "description": "Create a support ticket from the user request.",
        "parameters": {
          "type": "object",
          "properties": {
            "ticket_id": { "type": "string" },
            "priority": { "type": "string", "enum": ["low", "medium", "high"] },
            "summary": { "type": "string" }
          },
          "required": ["ticket_id", "priority", "summary"],
          "additionalProperties": false
        }
      }
    }
  ]
}

Das Modell lieferttool_calls[0].function.arguments als JSON-String. Es versucht, parameters zu treffen, ist aber nicht jedes Mal gültig — fehlende Felder, falsche Typen, kaputte Syntax kommen vor. Parsen und Prüfen sind Sache der Fachschicht.

Zum Agent-Loop, MCP-inputSchema und ausführlicherem Werkzeugschreiben sieheWarum AI-Agenten JSON Schema brauchen.

Structured Output: Schema für die Endantwort

Structured Output bindet die Endantwort, nicht die Werkzeugargumente. OpenAI nutztresponse_format; Gemini nutztresponseSchema. Darunter ist beides JSON Schema:

{
  "model": "gpt-4o-2024-08-06",
  "messages": [
    { "role": "user", "content": "Extract a support ticket from this email." }
  ],
  "response_format": {
    "type": "json_schema",
    "json_schema": {
      "name": "support_ticket",
      "strict": true,
      "schema": {
        "type": "object",
        "properties": {
          "ticket_id": { "type": "string" },
          "priority": { "type": "string", "enum": ["low", "medium", "high"] },
          "summary": { "type": "string" }
        },
        "required": ["ticket_id", "priority", "summary"],
        "additionalProperties": false
      }
    }
  }
}

Mitstrict: true führt das Schema die Tokens zur Inferenzzeit — nicht erst erzeugen und hoffen, sondern nur Konformes erzeugen.

Zu ChatGPT- vs. Gemini-Setup und was JSON Mode vs. Strict Schema wirklich garantieren, sieheden 2026-Leitfaden zu AI Structured Output.

Ein Schema, zwei Einhängepunkte

Der Kern des Artikels: Schreiben Sie keine zwei driftenden Feldsätze für Argumente und Endantwort. Ein Ticket bleibt drei Felder. Nur der Einhängepunkt ändert sich.

TICKET_SCHEMA = {
    "type": "object",
    "properties": {
        "ticket_id": {"type": "string"},
        "priority": {"type": "string", "enum": ["low", "medium", "high"]},
        "summary": {"type": "string"},
    },
    "required": ["ticket_id", "priority", "summary"],
    "additionalProperties": False,
}

# 1) Function Calling: constrain tool arguments
tools = [{
    "type": "function",
    "function": {
        "name": "create_ticket",
        "description": "Create a support ticket.",
        "parameters": TICKET_SCHEMA,
    },
}]

# 2) Structured Output: constrain the final answer
response_format = {
    "type": "json_schema",
    "json_schema": {
        "name": "support_ticket",
        "strict": True,
        "schema": TICKET_SCHEMA,
    },
}

Ein Vertrag, drei Landungen:

1. 1
   Werkzeugaufruf

   Das Modell wählt create_ticket; arguments müssen zum Schema passen.

2. 2
   Endantwort

   Ohne Werkzeug bleibt das finale JSON dieselben Felder und kann direkt gespeichert werden.

3. 3
   Fachliche Prüfung

   Ob die Daten aus tool_calls oder message.content kommen: derselbe parse + validate.

Vier Wege wählen

2026 gibt es für strukturierte LLM-Daten meist vier Wege:

Wie die vier Agent-Schichten zusammenpassen (LLM, Function Calling, MCP, JSON Schema):2026 AI-Agent-Stack.

Produktionsschreiben und Validierung

Erfolgsraten von Structured Output und Function Calling hängen von der Schemaqualität ab. Die Fachschicht prüft trotzdem.

1. 1
   Jedes property bekommt eine description

   Das Modell liest description, um Werte zu füllen. „Support ticket ID, e.g. TCK-1042“ schlägt einen nackten Feldnamen.

2. 2
   enum statt Prosa-Hinweis

   „low/medium/high“ im Satz ist schwächer alsenum.

3. 3
   additionalProperties: false setzen

   OpenAI Strict verlangt das meist. Setzen SieadditionalProperties: false am Wurzelobjekt, damit das Modell keine undeclared Keys einschleust.

4. 4
   Nicht zu tief schachteln

   Mehr als drei Ebenen oder viel oneOf erhöht die Fehlerrate. Komplexe Formen auf mehrere Aufrufe teilen.

import json
from jsonschema import validate, ValidationError

def parse_model_json(raw: str, schema: dict) -> dict:
    try:
        data = json.loads(raw)
    except json.JSONDecodeError as e:
        raise ValueError(f"Invalid JSON: {e}") from e
    try:
        validate(instance=data, schema=schema)
    except ValidationError as e:
        raise ValueError(f"Schema mismatch: {e.message}") from e
    return data

Egal ob ChatGPT, Gemini oder DeepSeek: derselbe parse → validate → Fachlogik. In der Entwicklung Schema und Ausgabe in JSONNote kleben — schneller als print.

Modell-JSON in JSONNote debuggen

Der langsame Teil ist selten die API. Es ist zu sehen, wo das Modell-JSON den Vertrag bricht. JSONNote läuft lokal im Browser:

1. 1
   Schema gegen Ausgabe prüfen

   API-JSON und Schema auf dieJSON Schema-Seite kleben und sehen, welche Felder den Vertrag verfehlen.

2. 2
   API-Antwort formatieren

   Mit demJSON-Formatierer Syntax und Einrückung prüfen.

3. 3
   Zwei Aufrufe vergleichen

   MitJSON Diff zwei Structured Outputs oder Tool-Arguments für Regressionen vergleichen.

FAQ

Was ist der Unterschied zwischen Function Calling und Structured Output?

Function Calling bindet tool_calls.arguments (welches Werkzeug, welche Argumente). Structured Output bindet die JSON-Endantwort. Beide nutzen JSON Schema auf unterschiedlichen Schichten. Agenten kombinieren sie oft: tools für externe Aktionen, Structured Output für das strukturierte Endergebnis.

Reicht JSON Mode?

Nein. JSON Mode (response_format.type=json_object) garantiert nur ein gültiges JSON-Objekt, nicht Felder oder Typen. Für komplexe Produktionsformen Structured Output (json_schema + strict:true oder Gemini responseSchema) nutzen.

Muss ich bei Strict Schema trotzdem manuell prüfen?

Ja. API-Constraints ersetzen kein validate in der Fachschicht. Leerer Content, abgeschnittene Payloads und Randfälle bleiben — try/except-Parse + JSON-Schema-validate ist der Produktionsstandard.

Welche JSON-Schema-Version soll ich nutzen?

2026 vereinheitlichen große LLM-APIs und MCP-Werkzeugverträge auf JSON Schema 2020-12. Kernschlüssel sind type, properties, required, enum, items und additionalProperties.

Kann ein Schema für Werkzeuge und Endausgabe gelten?

Ja. Dieselbe Objektdefinition kann in tools[].parameters und response_format.json_schema.schema. Eine Wahrheit, damit die Verträge nicht divergieren.

Fazit

KI braucht JSON Schema, weil es Modellausgabe von „sieht aus wie Daten“ in einen maschinenprüfbaren Vertrag verwandelt.

JSON Schema ist die Sprache; Function Calling nutzt sie für Werkzeugargumente; Structured Output für die Endantwort.

Ein Schema schreiben, zweifach einhängen, in der Fachschicht validate. Lokal in JSONNote formatieren, prüfen, diffen — der kürzeste Weg vom Demo zur Produktion.

← Zurück zum Blog