Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Optimizirano strujanje

Lekcija 5 od 20 Ažurirano 28. srpnja 2026. Napredno
Na ovoj stranici
  1. Što strujanje zapravo mijenja
  2. Trošenje toka na strani klijenta
  3. Proslijeđivanje toka u preglednik
  4. Održavanje veze tijekom vremena
  5. Ključne točke

Što strujanje zapravo mijenja

Strujanje ne ubrzava model: ono čekanje čini podnošljivim. Za odgovor koji se generira pet sekundi, korisnik bez strujanja gleda u prazan ekran pet sekundi prije nego što primi blok teksta. Uz strujanje, prve riječi vidi nakon nekoliko stotina milisekundi i čita ih dok ih model piše. Ukupno trajanje je isto, ali percepcija je potpuno drugačija. Zato je u produkciji izostavljanje strujanja gotovo uvijek dizajnerska pogreška, a ne svjesni izbor.

Međutim, tok mora teći kroz cijeli tvoj lanac. Tok koji API ispravno generira, ali ga tvoji aplikacijski poslužitelj akumulira ili obrnuti proxy međuspremi, stiže korisniku u jednom bloku: platio si cijenu složenosti strujanja, a nisi ubrao plodove. Ova lekcija stoga prati cijeli put, od API poziva do preglednika.

Trošenje toka na strani klijenta

Kod Responses API-ja, postavljanje stream=True pretvara odgovor u niz tipiziranih događaja kroz koje iteriraš kako stižu. Svaki fragment teksta dolazi u događaju response.output_text.delta; kraj toka signalizira response.completed, koji nosi cijeli objekt odgovora, koristan za dohvaćanje potrošnje tokena.

import openai

client = openai.OpenAI()

def generate_streaming(prompt: str):
    """Generiranje uz strujanje s Responses API-jem."""
    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()  # Novi red na kraju
            return event.response

Zastavica flush=True nije kozmetička: bez nje Python sam međuspremi izlaz i završavaš s ponašanjem u blokovima koje si htio izbjeći. Taj se detalj ponavlja na svakom sloju lanca i glavna je poteškoća strujanja.

Mehanizam također pokriva pozive funkcija. Argumenti alata grade se progresivno i možeš ih prikazivati kako se generiraju kako bi signalizirao korisniku da se formulira pretraga, umjesto da ga ostaviš gledati u zamrznuto sučelje dok model priprema svoj poziv.

tools = [
    {
        "type": "function",
        "name": "search_product",
        "description": "Pretražuje proizvod u katalogu.",
        "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 koji se trenutno generiraju
                print(f"[arg: {event.delta}]", end="")
            case "response.function_call_arguments.done":
                print(f"\n[Poziv funkcije završen]")

Proslijeđivanje toka u preglednik

Tvoj frontend ne razgovara izravno s OpenAI API-jem – razgovara s tvojim poslužiteljem, koji stoga mora proslijediti tok. Server-Sent Events (SSE) prirodni su format za to: HTTP odgovor koji ostaje otvoren, gdje svaki redak data: nosi JSON fragment. Sljedeći primjer proslijeđuje tekst kako stiže, a zatim emitira konačnu poruku koja sadrži broj tokena, što ti omogućuje naplatu ili bilježenje bez drugog poziva.

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",  # Važno za nginx
        },
    )

Tu je i obrnuti proxy, uobičajeni osumnjičenik kada „strujanje ne radi u produkciji iako je radilo lokalno“. Nginx prema zadanim postavkama akumulira odgovor pozadinskog sustava prije prijenosa. Donja konfiguracija onemogućuje ovo ponašanje samo za određenu rutu.

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

Održavanje veze tijekom vremena

Tok otvoren nekoliko desetaka sekundi izloženiji je od kratkog poziva: pad mreže, dosegnuta kvota i generiranje staje usred rečenice. Tvoja strategija ponovnog pokušaja mora razlikovati ova dva slučaja jer zahtijevaju različite pristupe. Pogrešku veze treba ponoviti s eksponencijalnim kašnjenjem, dajući mreži vremena za oporavak bez preopterećenja API-ja; premašenje kvote treba ponoviti nakon fiksnog čekanja jer se prozor ograničenja stope resetira u redovitim intervalima.

import openai

def resilient_streaming(prompt: str, max_attempts: int = 3):
    """Strujanje s rukovanjem pogreškama i ponovnim pokušajem."""
    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  # Uspjeh, izlaz

        except openai.APIConnectionError:
            if attempt < max_attempts - 1:
                import time
                time.sleep(2 ** attempt)  # Eksponencijalno kašnjenje
            else:
                raise
        except openai.RateLimitError:
            import time
            time.sleep(5)  # Fiksno čekanje za ograničenje stope

Jedna posljednja prilagodba poboljšava udobnost čitanja. Emitiranje svakog tokena proizvodi isprekidan tekst, posebno ako tvoje sučelje primjenjuje animaciju ili ako rezultat ide u tekst-u-govor. Akumuliranje do kraja rečenice daje ritam bliži ljudskom čitanju, uz cijenu blagog dodatnog kašnjenja na prvom fragmentu.

def streaming_by_sentence(prompt: str):
    """Akumulira i isporučuje po cijeloj rečenici."""
    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
            # Traženje kraja rečenice
            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()

Obrati pažnju na konačni if buffer.strip(): bez njega, odgovor koji ne završava jakim interpunkcijskim znakom izgubio bi posljednje riječi. Ova vrsta propusta ostaje nezapažena u testiranju, a manifestira se u produkciji na odgovorima skraćenima pomoću max_output_tokens.

Ključne točke

  • Uvijek koristi strujanje u produkciji kako bi smanjio percipiranu latenciju
  • Konfiguriraj nginx s proxy_buffering off za SSE
  • Rukuj pogreškama ponovnim pokušajem i eksponencijalnim kašnjenjem
  • Akumuliraj po rečenicama za prirodniji prikaz