Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Optimeret streaming

Lektion 5 af 20 Opdateret 28. juli 2026 Avanceret
På denne side
  1. Hvad streaming faktisk ændrer
  2. Forbrug af streamen på klientsiden
  3. Videresendelse af streamen til browseren
  4. Opretholdelse af forbindelsen over tid
  5. Vigtige pointer

Hvad streaming faktisk ændrer

Streaming gør ikke modellen hurtigere: det gør ventetiden udholdelig. Uden streaming stirrer brugeren på en tom skærm i fem sekunder, før de modtager en tekstblok, hvis svaret tager fem sekunder at generere. Med streaming ser de de første ord efter få hundrede millisekunder og læser med, mens modellen skriver. Den samlede varighed er identisk, men oplevelsen er fuldstændig anderledes. Derfor er det næsten altid en designfejl at udelade streaming i produktion frem for et bevidst valg.

Strømmen skal dog løbe gennem hele din kæde. En stream, der genereres korrekt af API’et, men akkumuleres af din applikationsserver eller buffres af din reverse proxy, når brugeren som én enkelt blok: du har betalt prisen for streamingens kompleksitet uden at høste fordelene. Denne lektion følger derfor den komplette vej, fra API-kaldet til browseren.

Forbrug af streamen på klientsiden

Med Responses API transformerer indstillingen stream=True svaret til en sekvens af typede begivenheder, som du itererer gennem, efterhånden som de ankommer. Hvert tekstfragment ankommer i en response.output_text.delta-begivenhed; slutningen af streamen signaleres af response.completed, som indeholder det fulde svarobjekt, nyttigt til at hente token-forbrug.

import openai

client = openai.OpenAI()

def generate_streaming(prompt: str):
    """Streaming-generering med Responses API."""
    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)
        elif event.type == "response.completed":
            print()  # Ny linje til sidst
            return event.response

Flaget flush=True er ikke kosmetisk: uden det buffrer Python selv outputtet, og du ender med den blok-adfærd, du forsøgte at undgå. Denne detalje gentages på hvert lag i kæden, og det er hovedudfordringen ved streaming.

Mekanismen dækker også funktionskald. Værktøjsargumenter opbygges gradvist, og du kan vise dem, efterhånden som de genereres, for at signalere til brugeren, at en søgning er under udarbejdelse, i stedet for at lade dem stirre på en frossen grænseflade, mens modellen forbereder sit kald.

tools = [
    {
        "type": "function",
        "name": "search_product",
        "description": "Søger efter et produkt i kataloget.",
        "parameters": {
            "type": "object",
            "properties": {
                "query": {"type": "string"},
                "category": {"type": "string"},
            },
            "required": ["query"],
        },
    }
]

def streaming_with_tools(prompt: str):
    stream = client.responses.create(
        model="gpt-5.6-terra",
        input=prompt,
        tools=tools,
        stream=True,
    )

    for event in stream:
        match event.type:
            case "response.output_text.delta":
                print(event.delta, end="", flush=True)
            case "response.function_call_arguments.delta":
                # Funktionsargumenter, der genereres lige nu
                print(f"[arg: {event.delta}]", end="")
            case "response.function_call_arguments.done":
                print(f"\n[Funktionskald fuldført]")

Videresendelse af streamen til browseren

Din frontend taler ikke direkte med OpenAI API – den taler med din server, som derfor skal videresende streamen. Server-Sent Events (SSE) er det naturlige format til dette: et HTTP-svar, der holdes åbent, hvor hver data:-linje bærer et JSON-fragment. Eksemplet nedenfor videresender tekst, efterhånden som den ankommer, og udsender derefter en endelig besked, der indeholder antallet af tokens, så du kan fakturere eller logge uden et ekstra kald.

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

app = FastAPI()
client = openai.OpenAI()

@app.post("/api/chat")
async def chat_streaming(request: dict):
    prompt = request["message"]

    async def generate():
        stream = client.responses.create(
            model="gpt-5.6-terra",
            input=prompt,
            stream=True,
        )

        for event in stream:
            if event.type == "response.output_text.delta":
                data = json.dumps({"text": event.delta})
                yield f"data: {data}\n\n"
            elif event.type == "response.completed":
                usage = event.response.usage
                data = json.dumps({
                    "end": True,
                    "input_tokens": usage.input_tokens,
                    "output_tokens": usage.output_tokens,
                })
                yield f"data: {data}\n\n"

    return StreamingResponse(
        generate(),
        media_type="text/event-stream",
        headers={
            "Cache-Control": "no-cache",
            "X-Accel-Buffering": "no",  # Vigtigt for nginx
        },
    )

Så er der reverse proxyen, den sædvanlige mistænkte, når „streaming ikke virker i produktion, selvom det virkede lokalt”. Som standard akkumulerer nginx backend-svaret, før det transmitteres. Konfigurationen nedenfor deaktiverer denne adfærd kun for den specifikke rute.

location /api/chat {
    proxy_pass http://127.0.0.1:8000;
    proxy_buffering off;
    proxy_cache off;
    proxy_set_header Connection "";
    chunked_transfer_encoding on;
}

Opretholdelse af forbindelsen over tid

En stream, der er åben i flere titusinder af sekunder, er mere udsat end et kort kald: et netværksudfald, en kvoteoverskridelse, og genereringen stopper midt i en sætning. Din genforsøgsstrategi skal skelne mellem disse to tilfælde, da de kræver forskellige tilgange. En forbindelsesfejl bør genforsøges med eksponentiel backoff, hvilket giver netværket tid til at komme sig uden at hamre på API’et; en kvoteoverskridelse bør genforsøges efter en fast ventetid, da vinduet for hastighedsbegrænsning nulstilles med jævne mellemrum.

import openai

def resilient_streaming(prompt: str, max_attempts: int = 3):
    """Streaming med fejlhåndtering og genforsøg."""
    for attempt in range(max_attempts):
        try:
            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
                    yield event.delta

            return  # Succes, afslut

        except openai.APIConnectionError:
            if attempt < max_attempts - 1:
                import time
                time.sleep(2 ** attempt)  # Eksponentiel backoff
            else:
                raise
        except openai.RateLimitError:
            import time
            time.sleep(5)  # Fast ventetid for hastighedsbegrænsning

Én sidste justering forbedrer læsekomforten. Udsendelse af hvert enkelt token producerer hakket tekst, især hvis din grænseflade anvender en animation, eller hvis resultatet går til tekst-til-tale. Akkumulering op til slutningen af en sætning giver en rytme, der ligner menneskelig læsning, på bekostning af en lille ekstra forsinkelse på det første fragment.

def streaming_by_sentence(prompt: str):
    """Akkumulerer og udsender pr. komplet sætning."""
    buffer = ""

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

    for event in stream:
        if event.type == "response.output_text.delta":
            buffer += event.delta
            # Kig efter slutningen af en sætning
            for separator in [".\n", "!\n", "?\n", ". ", "! ", "? "]:
                if separator in buffer:
                    parts = buffer.split(separator, 1)
                    yield parts[0] + separator.rstrip()
                    buffer = parts[1] if len(parts) > 1 else ""

    if buffer.strip():
        yield buffer.strip()

Bemærk det sidste if buffer.strip(): uden det ville et svar, der ikke slutter med stærk tegnsætning, miste sine sidste ord. Denne type overset bemærkes ikke under test og manifesterer sig i produktion på svar, der er trunkerede af max_output_tokens.

Vigtige pointer

  • Brug altid streaming i produktion for at reducere den oplevede latenstid
  • Konfigurer nginx med proxy_buffering off til SSE
  • Håndtér fejl med genforsøg og eksponentiel backoff
  • Akkumulér pr. sætning for en mere naturlig visning