Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Optimizirano pretakanje

Lekcija 5 od 20 Posodobljeno 28. julij 2026 Napredni
Na tej strani
  1. Kaj pretakanje dejansko spremeni
  2. Poraba toka na strani odjemalca
  3. Posredovanje toka v brskalnik
  4. Ohranjanje povezave skozi čas
  5. Ključne ugotovitve

Kaj pretakanje dejansko spremeni

Pretakanje ne pospeši modela: čakalno dobo le naredi znosno. Pri odzivu, ki ga model generira pet sekund, uporabnik brez pretakanja pet sekund gleda v prazen zaslon, preden prejme celoten blok besedila. S pretakanjem vidi prve besede po nekaj sto milisekundah in bere sočasno z modelom, ki piše. Skupno trajanje je enako, a zaznava je popolnoma drugačna. Zato je izpuščanje pretakanja v produkcijskem okolju skoraj vedno napaka v zasnovi, ne pa zavestna odločitev.

Vendar mora tok teči skozi celotno verigo. Tok, ki ga API pravilno generira, a ga aplikacijski strežnik kopiči ali obratni posrednik medpomni, pride do uporabnika kot en sam blok: plačali ste ceno kompleksnosti za pretakanje, ne da bi uživali njegove prednosti. Ta lekcija zato sledi celotni poti, od klica API-ja do brskalnika.

Poraba toka na strani odjemalca

Pri API-ju Responses nastavitev stream=True pretvori odziv v zaporedje tipiziranih dogodkov, skozi katere iterirate, ko prispevajo. Vsak fragment besedila prispe v dogodku response.output_text.delta; konec toka signalizira response.completed, ki nosi celoten objekt odziva, kar je koristno za pridobivanje porabe žetonov.

import openai

client = openai.OpenAI()

def generate_streaming(prompt: str):
    """Generiranje s pretakanjem prek API-ja Responses."""
    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()  # Nova vrstica na koncu
            return event.response

Zastavica flush=True ni kozmetična: brez nje Python sam medpomni izhod in končate z obnašanjem v blokih, ki ste se mu želeli izogniti. Ta podrobnost se ponavlja na vsaki ravni verige in predstavlja glavno težavo pri pretakanju.

Mehanizem zajema tudi klice funkcij. Argumenti orodij se gradijo postopoma in lahko jih prikažete med generiranjem, da uporabniku sporočite, da se oblikuje poizvedba, namesto da bi gledal v zamrznjen vmesnik, medtem ko model pripravlja svoj klic.

tools = [
    {
        "type": "function",
        "name": "search_product",
        "description": "Searches for a product in the catalog.",
        "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":
                # Argumenti funkcije, ki se trenutno generirajo
                print(f"[arg: {event.delta}]", end="")
            case "response.function_call_arguments.done":
                print(f"\n[Klic funkcije končan]")

Posredovanje toka v brskalnik

Vaš frontend ne komunicira neposredno z API-jem OpenAI – komunicira z vašim strežnikom, ki mora zato posredovati tok. Dogodki, poslani s strežnika (Server-Sent Events ali SSE), so za to naravna oblika: odziv HTTP, ki ostane odprt, kjer vsaka vrstica data: nosi fragment JSON. Spodnji primer posreduje besedilo, ko prispe, nato pa odda končno sporočilo s številom žetonov, kar vam omogoča obračunavanje ali beleženje brez dodatnega klica.

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",  # Pomembno za nginx
        },
    )

Tu je še obratni posrednik, običajni osumljenec, ko „pretakanje ne deluje v produkciji, čeprav je lokalno delovalo”. Nginx privzeto kopiči odziv zalednega strežnika, preden ga posreduje naprej. Spodnja konfiguracija to obnašanje onemogoči samo za določeno pot.

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

Ohranjanje povezave skozi čas

Pretok, odprt več deset sekund, je bolj izpostavljen kot kratek klic: izpad omrežja, dosežena kvota in generiranje se ustavi sredi stavka. Vaša strategija ponovnih poskusov mora razlikovati med tema dvema primeroma, saj zahtevata različne pristope. Napako povezave je treba ponoviti z eksponentnim zamikom, da omrežje dobi čas za obnovitev brez obremenjevanja API-ja; preseženo kvoto je treba ponoviti po fiksnem čakanju, saj se okno omejitve hitrosti redno ponastavi.

import openai

def resilient_streaming(prompt: str, max_attempts: int = 3):
    """Pretakanje z obravnavo napak in ponovnimi poskusi."""
    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  # Uspeh, izhod

        except openai.APIConnectionError:
            if attempt < max_attempts - 1:
                import time
                time.sleep(2 ** attempt)  # Eksponentni zamik
            else:
                raise
        except openai.RateLimitError:
            import time
            time.sleep(5)  # Fiksno čakanje zaradi omejitve hitrosti

Še ena zadnja prilagoditev izboljša udobje branja. Oddajanje vsakega žetona povzroči trzajoče besedilo, še posebej, če vaš vmesnik uporablja animacijo ali če rezultat gre v pretvorbo besedila v govor. Kopičenje do konca stavka daje ritem, bližji človeškemu branju, ob ceni rahle dodatne zamude pri prvem fragmentu.

def streaming_by_sentence(prompt: str):
    """Kopiči in oddaja po celih stavkih."""
    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
            # Iskanje konca stavka
            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()

Opazite končni if buffer.strip(): brez njega bi odziv, ki se ne konča z močnim ločilom, izgubil zadnje besede. Takšna spregledana podrobnost ostane neopažena pri testiranju in se v produkciji pokaže pri odzivih, okrnjenih z max_output_tokens.

Ključne ugotovitve

  • V produkciji vedno uporabite pretakanje za zmanjšanje zaznane zakasnitve
  • Nginx konfigurirajte z proxy_buffering off za SSE
  • Napake obravnavajte s ponovnimi poskusi in eksponentnim zamikom
  • Kopičite po stavkih za bolj naraven prikaz