Optimizirano strujanje
Na ovoj stranici
Š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 offza SSE - Rukuj pogreškama ponovnim pokušajem i eksponencijalnim kašnjenjem
- Akumuliraj po rečenicama za prirodniji prikaz