Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Streaming: Antworten in Echtzeit empfangen

Lektion 8 von 22 Aktualisiert am 29. Juli 2026 Entwickler
Auf dieser Seite
  1. Streaming: Antworten in Echtzeit empfangen
  2. Warum Streamen
  3. Typisierte Ereignisse, kein unsortierter Datenstrom
  4. Streaming und Funktionsaufrufe
  5. Der asynchrone Fall
  6. Fehler mitten im Stream
  7. Kernaussagen

Streaming: Antworten in Echtzeit empfangen

Mit Streaming können Sie die Antwort Token für Token empfangen, anstatt auf den Abschluss der gesamten Generierung zu warten. Dies ist nicht nur eine optische Verbesserung der Benutzeroberfläche: Es ist der entscheidende Faktor, der einen Chatbot, der sich träge anfühlt, von einem trennt, der sich flüssig und schnell anfühlt, selbst wenn die Serverleistung identisch ist.

Warum Streamen

Ohne Streaming müssen Benutzer manchmal zwischen zehn und dreißig Sekunden lang auf einen leeren Bildschirm starren, bevor die vollständige Antwort auf einmal erscheint. Mit Streaming erscheinen die ersten Wörter in weniger als einer Sekunde, und das Lesen beginnt, während die Generierung noch läuft. Die Gesamtdauer bleibt gleich; die Wahrnehmung jedoch nicht. Die Aktivierung erfordert lediglich einen Parameter, stream=True, der den Rückgabewert von create() in einen Ereignis-Iterator verwandelt.

from openai import OpenAI
client = OpenAI()

# OHNE Streaming — Warten auf alles
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Schreiben Sie einen Absatz über künstliche Intelligenz."
)
print(response.output_text)  # Erscheint alles auf einmal nach dem Warten

# MIT Streaming — Token für Token
stream = client.responses.create(
    model="gpt-5.6-terra",
    input="Schreiben Sie einen Absatz über künstliche Intelligenz.",
    stream=True
)

for event in stream:
    if event.type == "response.output_text.delta":
        print(event.delta, end="", flush=True)
print()  # Neue Zeile am Ende

Typisierte Ereignisse, kein unsortierter Datenstrom

Der Datenstrom transportiert nicht nur Text. Er benachrichtigt Sie darüber, wann die Antwort erstellt wird, wann jedes Ausgabe-Element hinzugefügt wird, wann Fragmente eintreffen und wann die Generierung abgeschlossen ist – das letzte Ereignis enthält Nutzungsmetriken. Sie filtern nach event.type, um zu wissen, welche Datenart Sie verarbeiten. Diese Struktur ermöglicht es Ihnen beispielsweise, einen Ladeindikator sofort anzuzeigen, sobald das Ereignis response.created ausgelöst wird, und die Token am Ende zu zählen, ohne eine zweite API-Anfrage zu stellen.

stream = client.responses.create(
    model="gpt-5.6-terra",
    input="Hallo!",
    stream=True
)

for event in stream:
    match event.type:
        case "response.created":
            print(f"[Antwort erstellt] ID: {event.response.id}")
        case "response.output_item.added":
            print(f"[Neues Ausgabe-Element]")
        case "response.output_text.delta":
            print(f"[Text] {event.delta}", end="")
        case "response.output_text.done":
            print(f"\n[Text vollständig]")
        case "response.completed":
            print(f"[Fertig] Tokens: {event.response.usage.total_tokens}")

# Ausgabe:
# [Antwort erstellt] ID: resp_abc123
# [Neues Ausgabe-Element]
# [Text] Hello[Text] ! [Text] Wie[Text] kann[Text] ich...
# [Text vollständig]
# [Fertig] Tokens: 25

In einer echten Anwendung möchten Sie fast immer zwei Dinge gleichzeitig tun: Die Fragmente anzeigen und den vollständigen Text rekonstruieren, damit Sie ihn archivieren oder an den Aufrufer zurückgeben können. Die Regel ist einfach: Akumulieren Sie während der Iteration, da der Datenstrom nach dem Verbrauch nicht zurückgespult werden kann.

def stream_and_collect(prompt: str) -> str:
    """Streamen der Antwort während der Sammlung."""
    stream = client.responses.create(
        model="gpt-5.6-terra",
        input=prompt,
        stream=True
    )

    full_text = ""
    for event in stream:
        if event.type == "response.output_text.delta":
            full_text += event.delta
            print(event.delta, end="", flush=True)

    print()  # Neue Zeile
    return full_text

result = stream_and_collect("Listen Sie 3 europäische Hauptstädte auf.")
print(f"\nGesammelter Text ({len(result)} Zeichen)")

Streaming und Funktionsaufrufe

Funktionsaufrufe werden ebenfalls gestreamt, mit eigenen Ereignissen: Argumente kommen in Fragmenten über response.function_call_arguments.delta an, und response.function_call_arguments.done signalisiert, dass das JSON vollständig ist. Dies hat eine wichtige praktische Konsequenz: Versuchen Sie niemals, die Argumente vor dem done-Ereignis zu deserialisieren, sonst erhalten Sie nur ein abgeschnittenes JSON.

stream = client.responses.create(
    model="gpt-5.6-terra",
    input="Wie spät ist es in Tokio?",
    tools=[{
        "type": "function",
        "name": "get_time",
        "description": "Holen Sie die Uhrzeit in einer Stadt",
        "parameters": {
            "type": "object",
            "properties": {
                "city": {"type": "string"}
            },
            "required": ["city"]
        }
    }],
    stream=True
)

for event in stream:
    match event.type:
        case "response.output_text.delta":
            print(event.delta, end="")
        case "response.function_call_arguments.delta":
            print(f"[Args] {event.delta}", end="")
        case "response.function_call_arguments.done":
            print(f"\n[Funktionsaufruf abgeschlossen]")

# Ausgabe:
# [Args] {"city": "Tokyo"}
# [Funktionsaufruf abgeschlossen]

Der asynchrone Fall

Sobald Ihre Anwendung mehrere Benutzer gleichzeitig bedient, wechseln Sie zu AsyncOpenAI: Der synchrone Client würde den Event-Loop für die gesamte Generierung blockieren und dazu führen, dass Ihre anderen Anfragen warten müssen. Die Syntax unterscheidet sich nur durch zwei Schlüsselwörter: await bei der Erstellung und async for bei der Iteration.

from openai import AsyncOpenAI
import asyncio

async_client = AsyncOpenAI()

async def stream_async(prompt: str):
    """Asynchrones Streaming der Antwort."""
    stream = await async_client.responses.create(
        model="gpt-5.6-terra",
        input=prompt,
        stream=True
    )

    async for event in stream:
        if event.type == "response.output_text.delta":
            print(event.delta, end="", flush=True)
    print()

asyncio.run(stream_async("Erzählen Sie einen kurzen Witz."))

Im Web ist Streaming nutzlos, wenn es auf Ihrem Server abbricht: Sie müssen es bis zum Browser erweitern. FastAPI ermöglicht dies mit StreamingResponse, das von einem Generator gespeist wird, der Fragmente weiterleitet, sobald sie eintreffen.

from fastapi import FastAPI
from fastapi.responses import StreamingResponse
from openai import OpenAI

app = FastAPI()
client = OpenAI()

@app.get("/chat")
async def chat(question: str):
    def generate():
        stream = client.responses.create(
            model="gpt-5.6-terra",
            input=question,
            stream=True
        )
        for event in stream:
            if event.type == "response.output_text.delta":
                yield event.delta

    return StreamingResponse(generate(), media_type="text/plain")

Fehler mitten im Stream

Ein Detail verdient Ihre Aufmerksamkeit: Beim Streaming kann ein Fehler auftreten, nachdem Fragmente bereits angezeigt wurden. Der Benutzer sieht dann eine Antwort, die beginnt, aber abgeschnitten wird. Daher sollten Sie die Iteration selbst umschließen, nicht nur die Erstellung des Datenstroms, damit Sie die Unterbreitung sauber signalisieren können, anstatt einen Satz in der Luft zu lassen.

from openai import APIError

def stream_with_errors(prompt: str):
    """Streaming mit robuster Fehlerbehandlung."""
    try:
        stream = client.responses.create(
            model="gpt-5.6-terra",
            input=prompt,
            stream=True
        )

        for event in stream:
            if event.type == "response.output_text.delta":
                print(event.delta, end="", flush=True)
        print()

    except APIError as e:
        print(f"\nAPI-Fehler während des Streamings: {e.message}")
    except Exception as e:
        print(f"\nUnerwarteter Fehler: {e}")

stream_with_errors("Erklären Sie Streaming in 2 Sätzen.")

Kernaussagen

  • Aktivieren Sie Streaming mit stream=True für ein Echtzeiterlebnis.
  • Filtern Sie Ereignisse nach event.type, um jede Datenart korrekt zu verarbeiten.
  • response.output_text.delta enthält Textfragmente.
  • response.completed signalisiert das Ende und enthält Nutzungsmetriken.
  • Verwenden Sie AsyncOpenAI für Streaming in asynchronen Anwendungen.
  • Behandeln Sie immer Fehler, auch im Streaming-Modus.