Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Strömning: Ta emot svar i realtid

Lektion 8 av 22 Uppdaterad 29 juli 2026 Utvecklare
På denna sida
  1. Strömning: Ta emot svar i realtid
  2. Varför strömma
  3. Typade händelser, inte en odifferentierad ström
  4. Strömning och funktionsanrop
  5. Det asynkrona fallet
  6. Fel mitt i strömmen
  7. Viktiga punkter

Strömning: Ta emot svar i realtid

Strömning låter dig ta emot svaret token för token istället för att vänta på att hela genereringen ska bli klar. Det här är inte bara en kosmetisk detalj i gränssnittet: det är skillnaden mellan en chattbot som känns trög och en som känns snabb, även om serverprestandan är densamma.

Varför strömma

Utan strömning får användaren ibland stirra på en tom skärm i tio till trettio sekunder innan hela svaret dyker upp på en gång. Med strömning visas de första orden på under en sekund, och läsningen kan börja medan genereringen fortsätter. Den totala tiden är densamma; upplevelsen är det inte. För att aktivera det krävs bara en parameter, stream=True, vilket gör att returvärdet från create() blir en händelseiterator.

from openai import OpenAI
client = OpenAI()

# UTAN strömning — vänta på allt
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Write a paragraph about artificial intelligence."
)
print(response.output_text)  # Visas allt på en gång efter väntan

# MED strömning — token för token
stream = client.responses.create(
    model="gpt-5.6-terra",
    input="Write a paragraph about artificial intelligence.",
    stream=True
)

for event in stream:
    if event.type == "response.output_text.delta":
        print(event.delta, end="", flush=True)
print()  # Ny rad på slutet

Typade händelser, inte en odifferentierad ström

Strömmen innehåller inte bara text. Den notifierar dig när svaret skapas, när varje utmatningsobjekt läggs till, när fragment anländer och när genereringen är klar – den sista händelsen inkluderar användningsstatistik. Du filtrerar på event.type för att veta vad du hanterar. Denna struktur låter dig exempelvis visa en laddningsindikator så snart response.created triggar och summera tokens på slutet utan ett andra API-anrop.

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

for event in stream:
    match event.type:
        case "response.created":
            print(f"[Svar skapat] ID: {event.response.id}")
        case "response.output_item.added":
            print(f"[Nytt utmatningsobjekt]")
        case "response.output_text.delta":
            print(f"[Text] {event.delta}", end="")
        case "response.output_text.done":
            print(f"\n[Text klar]")
        case "response.completed":
            print(f"[Klar] Tokens: {event.response.usage.total_tokens}")

# Utmatning:
# [Svar skapat] ID: resp_abc123
# [Nytt utmatningsobjekt]
# [Text] Hej[Text] ! [Text] Hur[Text] kan[Text] jag...
# [Text klar]
# [Klar] Tokens: 25

I en riktig applikation vill du nästan alltid göra två saker samtidigt: visa fragmenten och återskapa hela texten så att du kan arkivera den eller returnera den till anroparen. Regeln är enkel: ackumulera medan du itererar, eftersom strömmen inte kan spolas tillbaka när den väl är konsumerad.

def stream_and_collect(prompt: str) -> str:
    """Strömma svaret samtidigt som det samlas in."""
    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()  # Ny rad
    return full_text

result = stream_and_collect("List 3 European capitals.")
print(f"\nInsamlad text ({len(result)} tecken)")

Strömning och funktionsanrop

Funktionsanrop strömmas också, med egna händelser: argument anländer i fragment via response.function_call_arguments.delta, och response.function_call_arguments.done signalerar att JSON:en är komplett. Detta har en viktig praktisk konsekvens – försök aldrig deserialisera argumenten före händelsen done, annars har du bara en trunkerad JSON.

stream = client.responses.create(
    model="gpt-5.6-terra",
    input="What time is it in Tokyo?",
    tools=[{
        "type": "function",
        "name": "get_time",
        "description": "Get the time in a city",
        "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"[Arg] {event.delta}", end="")
        case "response.function_call_arguments.done":
            print(f"\n[Funktionsanrop klart]")

# Utmatning:
# [Arg] {"city": "Tokyo"}
# [Funktionsanrop klart]

Det asynkrona fallet

Så snart din applikation betjänar flera användare samtidigt bör du byta till AsyncOpenAI: den synkrona klienten skulle blockera händelseloopen under hela genereringen, vilket får dina andra förfrågningar att vänta. Syntaxen skiljer sig bara med två nyckelord – await vid skapandet och async for vid iterationen.

from openai import AsyncOpenAI
import asyncio

async_client = AsyncOpenAI()

async def stream_async(prompt: str):
    """Asynkron strömning av svaret."""
    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("Tell a short joke."))

På webben är strömning värdelös om den stannar vid din server: du måste utöka den till webbläsaren. FastAPI möjliggör detta med StreamingResponse, matad av en generator som vidarebefordrar fragment i takt med att de anländer.

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")

Fel mitt i strömmen

En detalj förtjänar din uppmärksamhet: vid strömning kan ett fel uppstå efter att fragment redan har visats. Användaren ser då ett svar som börjar men blir avklippt. Därför bör du omsluta själva iterationen med en felhantering, inte bara skapandet av strömmen, så att du tydligt kan signalera avbrottet istället för att lämna en mening hängande.

from openai import APIError

def stream_with_errors(prompt: str):
    """Strömning med robust felhantering."""
    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-fel under strömning: {e.message}")
    except Exception as e:
        print(f"\nOväntat fel: {e}")

stream_with_errors("Explain streaming in 2 sentences.")

Viktiga punkter

  • Aktivera strömning med stream=True för en upplevelse i realtid
  • Filtrera händelser efter event.type för att hantera varje datatyp korrekt
  • response.output_text.delta innehåller textfragment
  • response.completed signalerar slutet och inkluderar användningsstatistik
  • Använd AsyncOpenAI för strömning i asynkrona applikationer
  • Hantera alltid fel, även i strömningsläge