Chat Completions

Die Chat Completions API von OpenAI für jedes Textmodell: gleiche Anfragen und Antworten, gleiches Streaming, gleiche SDKs.

Anfrage

Antwort

{
  "id": "chatcmpl-AbC123...",
  "object": "chat.completion",
  "created": 1790870400,
  "model": "claude-opus-5-5",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Here's the summary..."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 1204,
    "completion_tokens": 312,
    "total_tokens": 1516,
    "prompt_tokens_details": { "cached_tokens": 1024 },
    "completion_tokens_details": { "reasoning_tokens": 128 }
  }
}

• model ist das Modell, das geantwortet hat. Es ist das angeforderte Modell, sofern nicht per Smart Routing eine Alternative geantwortet hat.
• Reasoning-Modelle können der Nachricht reasoning_content hinzufügen: ihre Gedankengänge, sofern sie diese teilen.
• usage ist die Grundlage deiner Abrechnung. cached_tokens sind Eingabe-Tokens aus dem Prompt-Cache des Modells. Falls das Modell einen Cache-Preis hat, werden sie zu diesem Preis abgerechnet.

Jede Antwort enthält außerdem diese Header:

Streaming

Mit stream: true kommt die Antwort als Server-Sent Events im Chunk-Format von OpenAI und endet mit data: [DONE]. Jedes SDK liest diese für dich.

import os
from openai import OpenAI
client = OpenAI(
    base_url="https://api.zurelay.com/v1",
    api_key=os.environ["ZURELAY_API_KEY"],
)
stream = client.chat.completions.create(
    model="claude-sonnet-5-5",
    messages=[
      {
        "role": "user",
        "content": "Write a limerick about databases."
      }
    ],
    stream=True,
    stream_options={
      "include_usage": True
    },
)
for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

• Die Antwort wird erst gesendet, wenn das Modell sein erstes Token erzeugt hat. So bleiben ein erneuter Versuch oder der Wechsel zu einem anderen Pfad für dich unsichtbar.
• Ruhige Phasen (wenn ein Modell zwischen Schritten nachdenkt) werden alle 15 Sekunden mit SSE-Kommentarzeilen (: keep-alive) überbrückt. Clients ignorieren sie; sie verhindern, dass Proxys die Verbindung schließen. Dauert es bis zum ersten Token länger als 20 Sekunden (wegen eines langen Prompts oder eines hängenden Pfads, der ersetzt wird), öffnet sich der Stream dann: Während du wartest, kommen die Header und Keep-alive-Kommentare. Jeder Pfad hat bis zu 3 Minuten Zeit für den Start (5 bei hohem Reasoning-Aufwand), bevor der nächste versucht wird. Setze das Timeout deines Clients daher auf 10 Minuten.
• Ein Stream, der vor dem ersten Token geöffnet wurde, enthält x-zurelay-model nur, wenn kein anderes Modell die Anfrage beantworten kann (Smart Routing aus). Tritt nach dem Öffnen ein Fehler auf, kommt er als Fehler-Event im Stream (im selben Format wie der Fehler-Body) statt als Fehlerstatus.
• Mit include_usage hat der letzte Chunk vor [DONE] eine leere choices-Liste und enthält usage.

Tool-Aufrufe

Beschreibe Funktionen in tools. Wenn das Modell eine aufrufen will, antwortet es mit tool_calls statt mit Text. Führe die Funktion aus und sende das Ergebnis als tool-Nachricht mit der ID des Aufrufs zurück. Dann macht das Modell weiter.

import os
from openai import OpenAI
client = OpenAI(
    base_url="https://api.zurelay.com/v1",
    api_key=os.environ["ZURELAY_API_KEY"],
)
response = client.chat.completions.create(
    model="gpt-6-sol",
    messages=[
      {
        "role": "user",
        "content": "What's the weather in Lisbon right now?"
      }
    ],
    tools=[
      {
        "type": "function",
        "function": {
          "name": "get_weather",
          "description": "Current weather for a city",
          "parameters": {
            "type": "object",
            "properties": {
              "city": {
                "type": "string"
              }
            },
            "required": [
              "city"
            ]
          }
        }
      }
    ],
)
print(response.choices[0].message.content)

Strukturierte Ausgabe

Fordere JSON mit response_format an. Ein json_schema sorgt bei Modellen, die es unterstützen, dafür, dass sie dein Schema einhalten; json_object fordert beliebiges gültiges JSON an (schreib das auch in deinen Prompt).

import os
from openai import OpenAI
client = OpenAI(
    base_url="https://api.zurelay.com/v1",
    api_key=os.environ["ZURELAY_API_KEY"],
)
response = client.chat.completions.create(
    model="gpt-6.1-sol",
    messages=[
      {
        "role": "user",
        "content": "Extract the people: 'Ana met Ben and Chloe in Porto.'"
      }
    ],
    response_format={
      "type": "json_schema",
      "json_schema": {
        "name": "people",
        "schema": {
          "type": "object",
          "properties": {
            "names": {
              "type": "array",
              "items": {
                "type": "string"
              }
            }
          },
          "required": [
            "names"
          ]
        }
      }
    },
)
print(response.choices[0].message.content)

Reasoning

Reasoning-Modelle denken nach, bevor sie antworten. Mit reasoning_effort bestimmst du, wie viel Tempo und Kosten du für mehr Tiefe in Kauf nimmst: Ein höheres Level denkt länger nach, braucht mehr Zeit und verbraucht mehr Output-Tokens. Jedes Modell unterstützt die von seinem Anbieter dokumentierten Level, von none (kein Nachdenken) über minimal, low, medium, high und xhigh (besonders hoch) bis max; die Tabelle unten zeigt sie. Lässt du die Angabe weg, nutzt das Modell seinen Standardwert. Das funktioniert mit jedem OpenAI SDK gleich. Im Playground des Dashboards kannst du jedes Level ausprobieren.

from openai import OpenAI
client = OpenAI(base_url="https://api.zurelay.com/v1", api_key="YOUR_ZURELAY_KEY")
response = client.chat.completions.create(
    model="zurelay-auto",
    reasoning_effort="high",
    messages=[{"role": "user", "content": "How many primes are there below 1,000?"}],
)
message = response.choices[0].message
print(getattr(message, "reasoning_content", None))  # the thinking, when the model shares it
print(message.content)

Bei Modellen, die ihre Gedanken ausgeben, kommen sie zusammen mit der Antwort in message.reasoning_content zurück (beim Streaming in delta.reasoning_content); einige nennen das Feld reasoning. Sie werden als Output-Tokens abgerechnet und sind immer in completion_tokens enthalten; completion_tokens_details.reasoning_tokens zählt sie separat, wenn das Modell sie ausweist. Bei hohem Denkaufwand kann es Minuten dauern, bis eine Antwort beginnt. Gib deinem Client deshalb ein großzügiges Timeout (siehe Zuverlässigkeit und Timeouts).

Level pro Modell

Basierend auf der Dokumentation der jeweiligen Anbieter. Unterstützt ein Modell ein Level nicht, nutzt es das nächstgelegene unterstützte Level (bei gleichem Abstand das niedrigere; das Nachdenken wird nur mit none abgeschaltet). So funktioniert dieselbe Anfrage mit jedem Modell, auch mit intelligentem Routing. Der Response-Header x-zurelay-reasoning-effort zeigt, welches Level verwendet wurde. Ein Wort, das kein Level ist, wird mit 400 abgelehnt; die Antwort nennt die Level des Modells.

So denkt Claude

Über diesen Endpunkt unterstützt Claude reasoning_effort wie jedes andere Modell: low, medium, high, xhigh oder max (Opus 4.6 unterstützt xhigh nicht). Im Format von Anthropic denkt Claude adaptiv auf einem bestimmten Level: Sende thinking: { type: "adaptive", display: "summarized" } mit output_config: { effort: "xhigh" } und lies die Denkblöcke aus. Siehe Anthropic Messages.