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

Strömning optimerad

Lektion 5 av 20 Uppdaterad 28 juli 2026 Avancerad
På denna sida
  1. Vad strömning faktiskt ändrar
  2. Konsumera strömmen på klientsidan
  3. Vidarebefordra strömmen till webbläsaren
  4. Upprätthålla anslutningen över tid
  5. Viktiga punkter

Vad strömning faktiskt ändrar

Strömning gör inte modellen snabbare: den gör väntan uthärdlig. För ett svar som tar fem sekunder att generera, stirrar en användare utan strömning på en tom skärm i fem sekunder innan hen får ett textblock. Med strömning ser hen de första orden efter några hundra millisekunder och läser medan modellen skriver. Den totala varaktigheten är identisk, men upplevelsen är helt annorlunda. Därför är det nästan alltid ett designfel att utelämna strömning i produktion, snarare än ett medvetet val.

Strömmen måste dock flyta genom hela din kedja. En ström som genereras korrekt av API:t men ackumuleras av din applikationsserver eller buffras av din reverse proxy når användaren som ett enda block: du har betalat komplexitetspriset för strömning utan att skörda fördelarna. Denna lektion följer därför hela vägen, från API-anropet till webbläsaren.

Konsumera strömmen på klientsidan

Med Responses API:t omvandlar inställningen stream=True svaret till en sekvens av typade händelser som du itererar över när de anländer. Varje textfragment anländer i en händelse response.output_text.delta; slutet på strömmen signaleras av response.completed, som bär på hela svarsobjektet, vilket är användbart för att hämta tokenanvändning.

import openai

client = openai.OpenAI()

def generate_streaming(prompt: str):
    """Strömmande generering med Responses API:t."""
    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 rad på slutet
            return event.response

Flaggan flush=True är inte kosmetisk: utan den buffrar Python utmatningen själv, och du hamnar med blockbeteendet du försökte undvika. Denna detalj upprepas på varje lager i kedjan, och det är huvudsvårigheten med strömning.

Mekanismen täcker även funktionsanrop. Argument för verktyg byggs progressivt, och du kan visa dem medan de genereras för att signalera till användaren att en sökning formuleras, istället för att låta hen stirra på ett fruset gränssnitt medan modellen förbereder sitt anrop.

tools = [
    {
        "type": "function",
        "name": "search_product",
        "description": "Söker efter en produkt i katalogen.",
        "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":
                # Funktionsargument som genereras just nu
                print(f"[arg: {event.delta}]", end="")
            case "response.function_call_arguments.done":
                print(f"\n[Funktionsanrop slutfört]")

Vidarebefordra strömmen till webbläsaren

Din frontend pratar inte direkt med OpenAI:s API – den pratar med din server, som därför måste vidarebefordra strömmen. Server-Sent Events (SSE) är det naturliga formatet för detta: ett HTTP-svar som hålls öppet, där varje rad data: bär på ett JSON-fragment. Följande exempel vidarebefordrar text när den anländer och skickar sedan ett slutmeddelande som innehåller tokenantallet, vilket låter dig fakturera eller logga utan ett andra anrop.

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",  # Viktigt för nginx
        },
    )

Sedan har vi reverse-proxyn, den vanliga boven när “strömning inte fungerar i produktion även om det fungerade lokalt”. Som standard ackumulerar nginx backend-svaret innan det skickas vidare. Konfigurationen nedan inaktiverar detta beteende endast för den specifika routen.

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;
}

Upprätthålla anslutningen över tid

En ström som är öppen i flera tiotals sekunder är mer utsatt än ett kort anrop: ett nätverksavbrott, en kvotöverskridning, och genereringen stoppar mitt i en mening. Din strategi för återförsök måste skilja mellan dessa två fall, eftersom de kräver olika tillvägagångssätt. Ett anslutningsfel bör försökas igen med exponentiell backoff, vilket ger nätverket tid att återhämta sig utan att hamra mot API:t; en kvotöverskridning bör försökas igen efter en fast väntetid, eftersom tidsfönstret för hastighetsbegränsning återställs med jämna mellanrum.

import openai

def resilient_streaming(prompt: str, max_attempts: int = 3):
    """Strömning med felhantering och återförsök."""
    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  # Lyckades, avsluta

        except openai.APIConnectionError:
            if attempt < max_attempts - 1:
                import time
                time.sleep(2 ** attempt)  # Exponentiell backoff
            else:
                raise
        except openai.RateLimitError:
            import time
            time.sleep(5)  # Fast väntetid för hastighetsbegränsning

En sista finjustering förbättrar läskomforten. Att skicka varje token ger hackig text, särskilt om ditt gränssnitt applicerar en animation eller om resultatet går till text-till-tal. Att ackumulera upp till slutet av en mening ger en rytm närmare mänsklig läsning, till priset av en liten ytterligare fördröjning på det första fragmentet.

def streaming_by_sentence(prompt: str):
    """Ackumulerar och skickar per hel mening."""
    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
            # Leta efter slutet på en mening
            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()

Notera det sista if buffer.strip(): utan det skulle ett svar som inte slutar med stark interpunktion förlora sina sista ord. Denna typ av förbiseende går obemärkt förbi vid testning och visar sig i produktion på svar som trunkerats av max_output_tokens.

Viktiga punkter

  • Använd alltid strömning i produktion för att minska den upplevda latensen
  • Konfigurera nginx med proxy_buffering off för SSE
  • Hantera fel med återförsök och exponentiell backoff
  • Ackumulera per mening för en mer naturlig visning