Lernpfad
Associate AI Engineer für Entwickler
26 Std.
Arbeiten mit der OpenAI API
Beginne deine Reise zur Entwicklung von KI-gestützten Anwendungen mit der OpenAI API.
Was ist die GPT-6 Astra API?
Über die GPT-6 Astra API greifst du über die Responses API auf OpenAIs neues Flaggschiffmodell zu, das am 3. September 2026 veröffentlicht wurde. Für dieses Tutorial zählt vor allem die Oberfläche: gpt-6-astra akzeptiert Text- und Bild-Eingaben über die Responses API von OpenAI. Der Reasoning-Aufwand reicht von low bis max, ohne Option none.
Die Beispiele in diesem Tutorial verwenden client.responses.create statt client.chat.completions.create, aber die Migration erfordert außerdem Änderungen an Request-, Output- und Tool-Result-Formaten. Entferne auch die benutzerdefinierten Einstellungen temperature, top_p und Log-Probabilities, da Astra sie nicht unterstützt. Bevor wir den ersten Call machen, schauen wir auf die Preise.
Was kostet GPT-6 Astra?
Für Requests mit höchstens 272.000 Input-Tokens gilt die Standardbepreisung von 10 $ pro Million gewöhnlicher Input-Tokens und 50 $ pro Million Output-Tokens. Zwischengespeicherter Input kostet 1 $ pro Million, und Cache-Writes kosten 12,50 $ pro Million.
Sobald ein Request diesen Schwellenwert überschreitet, wendet OpenAI einen 2×-Multiplikator auf Input- und Cache-Raten und einen 1,5×-Multiplikator auf die Output-Rate an. Die höheren Sätze gelten für den gesamten Request, nicht nur für die Tokens oberhalb des Schwellenwerts. Keiner der Läufe in diesem Tutorial kam in die Nähe des Limits.
Was bauen wir mit der GPT-6 Astra API?
Die Staging-App ist ein kleines Flask-Aufgabenboard: eine Startseite, ein Formular zum Hinzufügen einer Aufgabe, ein Button zum Abhaken und ein /health Endpoint. Der vollständige Code, inklusive Staging-App, steht in diesem GitHub-Repository.
Vor dem Testen sind drei Aufgaben vorbefüllt. Bild: Autor.
Die App hat einen eingebauten Fehler. Der Agent hat drei Checks, aber nur die Testsuite ist darauf ausgelegt, ihn zu finden.
Warum akzeptiert die App leere Aufgabentitel?
Der Endpoint zum Erstellen von Aufgaben lehnt einen leeren Titel nicht ab. Ich habe dieses Verhalten stehen lassen, damit der Agent einen bekannten Fehler finden kann, ohne ihn im Prompt zu verraten.
Welche Release-Checks kann der Agent ausführen?
Der Agent kann drei Tools aufrufen:
-
run_test_suiteführt pytest aus, inklusive eines Bulk-Imports mit rund 250 HTTP-Requests. -
check_ui_flownutzt Playwright, um eine Aufgabe hinzuzufügen und zu bestätigen, dass sie erscheint. -
check_staging_healthsendet einen GET-Request an/health.
Alle drei laufen gegen Staging, ohne Mocks. Der Browser-Check nutzt festen Code; die Demo für modellverfasste Computer Use folgt später.
So richtest du die GPT-6 Astra API in Python ein
Du brauchst einen OpenAI API-Key mit Zugriff auf gpt-6-astra. Erstelle einen Key unter platform.openai.com/api-keys und prüfe, dass dein Projekt gpt-6-astra aktiviert hat. In Enterprise-Workspaces ist Astra zum Launch standardmäßig deaktiviert.
Die folgenden Befehle nutzen Windows PowerShell und installieren alle Pakete für dieses Tutorial, inklusive OpenAIs realtime für die Steering-Demo.
python -m venv .venv
.venv\Scripts\Activate.ps1
Copy-Item .env.example .env
pip install "openai[realtime]" flask pytest playwright pydantic matplotlib python-dotenv streamlit
playwright install chromiumUnter macOS oder Linux ersetzt du den Aktivierungsbefehl durch source .venv/bin/activate und den Kopierbefehl durch cp .env.example .env.
Füge dann den API-Key in die neue .env-Datei ein: Öffne die soeben kopierte .env und ergänze OPENAI_API_KEY=sk-.... python-dotenv lädt ihn, und das SDK greift automatisch darauf zu, sodass du den Key nie im Code übergeben musst.
Wenn projektspezifische Abhängigkeiten oder .env-Dateien neu für dich sind, erklären unsere Guides zu virtuellen Umgebungen und Umgebungsvariablen die Grundlagen. Prüfe, ob der Key funktioniert, bevor du darauf aufbaust.
Wenn dein API-Key bereits mit der Responses API funktioniert, überspringe den nächsten Abschnitt und starte mit der synchronen Tool-Schleife. Der erste Request prüft nur das Setup.
Setze deinen ersten GPT-6 Astra API-Call ab
Sobald der Key gesetzt ist, muss er mit dotenv geladen werden. Danach kannst du einen OpenAI-Client erstellen und mit client.responses.create() deine erste Anfrage senden. Die kleinstmögliche Anfrage sieht so aus:
from dotenv import load_dotenv
from openai import OpenAI
load_dotenv()
client = OpenAI()
response = client.responses.create(
model="gpt-6-astra",
reasoning={"effort": "low"},
input="In one sentence, what is a staging environment used for?",
)
print(response.output_text)Das Feld usage der Antwort listet die Token-Zähler, die wir später für die Kostenberechnung brauchen.
Baue eine synchrone GPT-6 Astra Tool-Schleife
Die Snippets unten sind Auszüge; lauffähige Versionen findest du im zugehörigen GitHub-Repository.
Bevor ich irgendetwas mit Async angefasst habe, habe ich die normale Version gebaut:
-
Modell aufrufen
-
Auf ein
function_call-Item prüfen -
Passendes Tool ausführen
-
Ergebnis mit
previous_response_idzurücksenden -
Wiederholen, bis das Modell keine Tools mehr anfordert.
Diese blockierende Schleife ist die Baseline für den Async-Vergleich.
for turn in range(max_turns):
response = client.responses.create(
model="gpt-6-astra",
reasoning={"effort": "low"},
tools=TOOLS,
input=next_input,
previous_response_id=previous_response_id,
)
calls = [item for item in response.output if item.type == "function_call"]
if not calls:
final_text = response.output_text
break
outputs = [
{"type": "function_call_output", "call_id": call.call_id, "output": run_tool(call)}
for call in calls
]
next_input, previous_response_id = outputs, response.idWas der Baseline-Run gefunden hat
Im Baseline-Run rief das Modell jedes Tool der Reihe nach auf. Es fand den bekannten Validierungsfehler und gab eine No-Go-Entscheidung zurück. Über drei Läufe lag die durchschnittliche Gesamtzeit bei 23,40 Sekunden. Dieser Durchschnitt bezieht sich auf den gesamten Run, nicht auf einzelne Toolzeiten.
Wie funktioniert Async-Tool-Calling in GPT-6 Astra?
Markiere ein Tool mit "async": true in seinem Schema, und deine App kann dieses Ergebnis zurückstellen, während das Modell entweder weiterarbeitet oder wartet. Deine Anwendung führt das Tool weiterhin aus und verwaltet den Hintergrundjob.
So führst du unabhängige Checks parallel aus
Ich habe run_test_suite und check_ui_flow als async markiert und ein App-definiertes wait_for_tasks-Tool ohne Argumente ergänzt, da diese Demo immer nur eine Charge ausstehender Arbeit gleichzeitig hat. Dieses wartende No-Arg-Tool hält das Beispiel klein.
In einem produktiven Runner identifizierst du Jobs mit Handles, verknüpfst jedes Handle mit seiner ursprünglichen call_id und wartest nur, wenn der nächste Schritt von einem ausstehenden Ergebnis abhängt.
Gib jedes fertige Ergebnis unter seiner ursprünglichen call_id zurück und den Warte-Status unter der eigenen call_id des Wait-Tools.
TOOLS = [
{"type": "function", "name": "run_test_suite", "async": True, ...},
{"type": "function", "name": "check_ui_flow", "async": True, ...},
{"type": "function", "name": "check_staging_health", ...},
{"type": "function", "name": "wait_for_tasks", ...},
]Für diesen Lauf reichte die App jeden markierten Aufruf an einen Thread-Pool ein. Während die Hintergrund-Checks liefen, führte sie den schnellen synchronen Health-Check aus. Anschließend blockierte sie bei wait_for_tasks, bis die ausstehenden Checks abgeschlossen waren.
Reduziert Async-Tool-Calling die Gesamtzeit?
Über drei Läufe senkte Async die durchschnittliche Gesamtzeit um 19,1 % von 23,40 Sekunden auf 18,94 Sekunden. Der Durchschnitt wirkte eindeutig, bis die Einzelläufe kamen; das Diagramm unten zeigt, wie stark sie tatsächlich schwankten. Drei Läufe reichen, um zu zeigen, was hier passierte, nicht um Produktionslatenz vorherzusagen.
Laufzeiten variierten in beiden Modi. Bild: Autor.
Warum führten gleichzeitige Checks zu einer Race Condition?
Das parallele Ausführen des Browser-Checks und des Bulk-Import-Tests ließ die Assertion des Bulk-Imports gelegentlich fehlschlagen, weil beide Checks dieselbe In-Memory-Aufgabenliste veränderten. Das brach die Annahme des Tests über exklusiven Zugriff. Eine Isolierung der Daten entweder im Runner oder in den Tests würde das Race vermeiden.
Begrenzte GPT-6 Astra Computer Use für UI-Tests
Für Computer Use empfiehlt die Doku von GPT-6 Astra Codeausführung, während das strukturierte computer-Tool als Alternative weiter unterstützt wird. Mit Codeausführung kann ein Call mehrere Aktionen, Schleifen und Bedingungslogik kombinieren, während das computer-Tool jeweils eine strukturierte Maus- oder Tastaturaktion zurückgibt, die deine Anwendung übersetzt und abspielt.
So begrenzt du den Computer-Use-Runner
Ich nannte die Klasse BrowserSandbox, aber der Name übertreibt den Schutz. Sie gibt modellverfasstem Code eine Playwright-page, eine log()-Funktion und einen expect_text() Helper. Python kann weiterhin Built-ins in exec() injizieren, und die Seite kann zu einer anderen Origin navigieren.
sandbox_globals = {"page": self.page, "log": log, "expect_text": expect_text}
exec(code, sandbox_globals)Behandle das als Demo-Runner, nicht als Sicherheitsgrenze. Modellverfasster Code braucht einen isolierten Prozess oder Container mit Einschränkungen für Dateisystem, Prozesse, Netzwerk und Origins.
Was passierte im UI-Check?
Ich habe die Schleife auf acht Turns begrenzt, weil ein begrenzter Check einen harten Stopp braucht. Das Modell inspizierte die Seite, fand das Formulareingabefeld, erstellte den Titel „UI flow check, cobalt otter 73921“, übermittelte die Aufgabe und bestätigte, dass der Titel erschien. Das dauerte 13 Sekunden. Unser GPT-5.4 Computer Use Tutorial zeigt ein detailliertes Beispiel mit einem Vorgängermodell von Astra.
Wie funktioniert GPT-6 Astra Steering mitten im Turn?
Steering mitten im Turn ist nur für gpt-6-astra über eine WebSocket-Verbindung verfügbar.
Öffne eine Verbindung und erstelle eine Response, dann sende ein response.steer-Event mit neuen Anweisungen, während die Response generiert wird. Ein response.steer.accepted-Event bedeutet, dass das Update in der Warteschlange ist, nicht angewendet. Bevor die automatische Fortsetzung erstellt wird, beendet der Server das aktuelle Output-Item und alle bereits laufenden gehosteten Toolarbeiten.
Wenn noch ein Client-Tool-Ergebnis oder eine Freigabe fehlt, response.steer.pending identifiziert die fehlende Eingabe.
async with client.responses.connect() as connection:
await connection.response.create(model="gpt-6-astra", input=TASK)
async for event in connection:
if event.type == "response.created" and initial_response_id is None:
initial_response_id = event.response.id
await asyncio.sleep(1.0)
await connection.response.steer(
previous_response_id=initial_response_id,
input="Also add a rollback plan, but skip mobile.",
)Die Verzögerung von einer Sekunde entspricht dem Experimentcode und gibt der ersten Response Zeit zum Starten. Ohne diese Verzögerung würde hier ein anderer Punkt im Response-Lebenszyklus getestet.
Was bleibt beim Steering unverändert?
Steering überschreibt die ursprüngliche Response nicht. Wenn das Update sie unterbricht, endet diese Response mit status: "incomplete" und incomplete_details.reason: "steered". Eine Nachfolger-Response führt dann mit der neuen Anweisung fort.
Wenn die erste Response fertig ist, bevor das Update greift, bleibt sie abgeschlossen. Steering macht bereits gestartete Client-seitige Aktionen nicht rückgängig; das Verhalten liegt weiterhin bei deiner Anwendung. Wartende Steering-Updates existieren nur auf der aktuellen WebSocket-Verbindung, also protokolliere das Update, bevor du einen Reconnect versuchst.
Der Vergleichspfad lässt die erste Response fertig werden und sendet dann eine neue Anfrage mit den kombinierten Anweisungen. Über zwei Läufe lag Steering im Schnitt bei 26,91 Sekunden versus 50,02 Sekunden für diesen Finish-und-Neustart-Pfad. Dieser Vergleich deckt keine Cancel-und-Neustart-Policy ab und bewertet den finalen Text nicht auf Korrektheit.
Durchschnittswerte aus zwei Läufen für Zeit und Kosten. Bild: Autor.
Der Neustartpfad erzeugt zwei vollständige Responses, die Teile derselben Anforderungen abdecken. Das erklärt einen Teil der Zeitdifferenz, daher würde ich diese zwei Läufe nicht als generelle Benchmark für Steering sehen.
So änderst du den GPT-6 Astra Reasoning-Aufwand mitten im Gespräch
gpt-6-astra unterstützt Reasoning-Aufwand von low bis max. Höherer Aufwand kann den Einsatz von Reasoning-Tokens erhöhen, garantiert aber keine andere Antwort. Ein configuration_update ändert die nächste und spätere Responses, bis ein weiteres Update sie überschreibt, während die Request-Einstellung unverändert bleibt.
In dieser Pipeline beendet der Report das Gespräch, daher wirkt sich das Update nur auf diesen letzten Schritt aus.
response = client.responses.create(
model="gpt-6-astra",
previous_response_id=previous_id,
reasoning={"effort": "low"}, # default remains low
input=[
{"type": "configuration_update", "reasoning": {"effort": "high"}},
{"role": "user", "content": "Diagnose the root cause and recommend a fix."},
],
)Ich habe dieselbe Failure-Trace auf beiden Aufwandsstufen genutzt und Diagnose sowie Tokenverbrauch verglichen.
Eine Feinheit: Das Feld reasoning.effort der Antwort meldet weiterhin die Request-Einstellung, nicht den durch configuration_update gewählten Aufwand. Verlass dich nicht auf dieses Feld, um zu prüfen, ob das Update wirkte.
Hat hoher Reasoning-Aufwand die Diagnose verändert?
Im vollständigen kombinierten Lauf nutzte der eskalierte Schritt 108 Reasoning-Tokens. Jeder andere Schritt auf low nutzte null. In einem früheren isolierten Test mit längerer Failure-Trace nutzte niedriger Aufwand null Reasoning-Tokens, hoher Aufwand 318. Beide Versionen identifizierten den Validierungsfehler, also veränderte höherer Aufwand den Tokenverbrauch, nicht die Diagnose.
Configuration-Updates funktionieren nur in Standard-Requests mit einem einzelnen Agenten. Die API lehnt benachbarte Updates ab, und sie lassen sich nicht mit automatischer Kompaktierung oder automatischer Kürzung kombinieren.
So nutzt du strukturierte Ausgaben von GPT-6 Astra
Der letzte Schritt der Pipeline ruft client.responses.parse auf und ersetzt Freitext durch ein validiertes Pydantic-Modell.
class GoNoGoReport(BaseModel):
decision: str
summary: str
checks_completed: list[str]
failures: list[str]
risks: list[str]
follow_up_actions: list[str]
confidence: float
response = client.responses.parse(
model="gpt-6-astra",
previous_response_id=previous_id,
text_format=GoNoGoReport,
input=[...],
)Pydantic prüft hier die deklarierten Feldtypen. Es beweist nicht, dass der Report zur Evidenz passt, und diese Version beschränkt decision nicht auf zwei Werte und confidence nicht auf einen Bereich.
Was hat der Go/No-Go-Report erfasst?
Der Report gab decision: "no_go" zurück. Er ordnete den erwähnten Validierungsfehler unter failures und das Nebenläufigkeitsproblem unter risks ein. Für Letzteres schrieb er: „possible interference from concurrent UI checks against shared staging data.“ Der Prompt nannte dieses Risiko nicht.
Halte Latenz und Kosten außerhalb dieses Schemas und berechne sie im Code. Das Modell füllt die Report-Felder aus der Tool-Evidenz.
Die Streamlit-Oberfläche nutzt denselben Generator wie der Kommandozeilen-Runner. Sie rendert jedes Tool-Event beim Eintreffen und zeigt dann den geparsten Report in den Tabs Report und JSON an.
