Režim na pozadí
Na tejto strane
Tretia cesta medzi synchronným a dávkovým spracovaním
Režim na pozadí (background mode) rozhrania Responses API vypĺňa špecifickú medzeru v tvojom nástrojári. Synchronné volanie ti poskytne odpoveď okamžite, ale núti ťa udržiavať spojenie otvorené počas celej generácie. Dávkové API (Batch API) spracuje tisíce požiadaviek za polovičnú cenu, no výsledky trvajú hodiny. Režim na pozadí stojí medzi nimi: spracúva jednotlivé požiadavky za štandardný sadzobník bez potreby otvoreného spojenia. Požiadavku odošleš, dostaneš ID a výsledok si stiahneš, keď bude pripravený.
Tento kompromis cieli na presný prípad použitia: jednotlivá požiadavka, ktorá trvá príliš dlho na blokujúce volanie, ale nemôže čakať do zajtra. Presne toto nastáva pri spúšťaní modelu s vysokou úrovňou logického uvažovania (high-reasoning) na komplexnom dokumente.
Spustenie a získanie výsledku
Aktivácia vyžaduje len jeden parameter. Okamžitá odpoveď neobsahuje žiadny text; vracia ID a stav, zvyčajne queued alebo in_progress.
import openai
client = openai.OpenAI()
# Spustiť požiadavku na pozadí
response = client.responses.create(
model="gpt-5.6-sol", # Ideálne pre pomalé úlohy (vysoké logické uvažovanie)
input="Analyzuj ekonomické dôsledky európskej regulácie AI "
"pre francúzske MSP. Navrhni 10-bodový akčný plán.",
background=True, # Režim na pozadí
)
print(f"ID odpovede: {response.id}")
print(f"Stav: {response.status}") # "queued" alebo "in_progress"
Toto ID je tvoja jediná väzba na prebiehajúcu prácu: ulož si ho skôr, než urobíš čokoľvek iné. Jeho stratou zaplatíš za generáciu, ktorú nikdy nezískaš. Následné získanie výsledku zahŕňa dotazovanie API (polling), kým sa stav nestane konečným. Zlyhanie a zrušenie ošetruj oddelene, keďže majú odlišné obchodné dopady.
import time
def wait_for_response(response_id: str, interval: int = 5) -> str:
"""Čaká na dokončenie odpovede na pozadí."""
while True:
response = client.responses.retrieve(response_id)
match response.status:
case "completed":
return response.output_text
case "failed":
raise RuntimeError(
f"Požiadavka zlyhala: {response.error}"
)
case "cancelled":
raise RuntimeError("Požiadavka bola zrušená.")
case _:
print(f"Stav: {response.status}...")
time.sleep(interval)
Úlohy s dlhým logickým uvažovaním
Model ako GPT-5.6 Sol so zapnutým vysokým logickým uvažovaním môže potrebovať 30 sekúnd až dve minúty, kým vygeneruje prvý viditeľný token. Pri synchronnom volaní tieto časy narážajú na predvolené časové limity HTTP klientov, proxy serverov a brán. Režim na pozadí odstraňuje tento problém priamo v koreni a mimochodom ti umožňuje spustiť niekoľko náročných analýz bez viazania toľkých spojení.
async def deep_analysis(document: str) -> str:
"""Spustí analýzu s GPT-5.6 Sol bez blokovania."""
response = client.responses.create(
model="gpt-5.6-sol",
input=f"Vykonaj dôkladnú právnu analýzu tejto zmluvy. "
f"Identifikuj všetky potenciálne riziká, problematické klauzuly "
f"a navrhni úpravy.\n\n{document}",
background=True,
)
return response.id
# Spustiť viacero analýz paralelne
task_ids = []
for doc in documents:
task_id = await deep_analysis(doc)
task_ids.append(task_id)
# Získať výsledky neskôr
results = {}
for task_id in task_ids:
results[task_id] = wait_for_response(task_id)
Tento vzor sa prirodzene rozširuje na webhooky, keď je volajúcim iná služba. Tvoj koncový bod spustí požiadavku, vráti ID a deleguje úlohu na pozadí, ktorá monitoruje dokončenie a odosiela oznámenia. Volajúci neprebieha cyklom dotazovania; dostane notifikáciu.
from fastapi import FastAPI, BackgroundTasks
import httpx
app = FastAPI()
@app.post("/api/long-analysis")
async def launch_analysis(request: dict, background_tasks: BackgroundTasks):
"""Spustí analýzu a po dokončení upozorní cez webhook."""
response = client.responses.create(
model="gpt-5.6-sol",
input=request["prompt"],
background=True,
)
# Monitorovať na pozadí
background_tasks.add_task(
monitor_and_notify,
response_id=response.id,
webhook_url=request["webhook_url"],
)
return {"response_id": response.id, "status": "launched"}
async def monitor_and_notify(response_id: str, webhook_url: str):
"""Monitoruje požiadavku na pozadí a upozorní cez webhook."""
result = wait_for_response(response_id)
async with httpx.AsyncClient() as http:
await http.post(webhook_url, json={
"response_id": response_id,
"result": result,
})
Výber správneho režimu
Pravidlo rozhodovania sa redukuje na dve otázky. Koľko je požiadaviek? A čaká používateľ? Pri viac ako sto požiadavkách bez potreby okamžitej odozvy vyhráva Dávkové API (Batch API) cenovo: výsledky za hodiny za polovičné náklady. Ak niekto čaká pred obrazovkou, synchronné volania zostávajú jedinou prijateľnou voľbou za štandardný sadzobník. Režim na pozadí vypĺňa zvyšok priestoru: málo požiadaviek, výsledky za minúty, štandardná cena. Oplatí sa túto logiku zakódovať raz, namiesto toho, aby si ju znova a znova riešil pre každú novú službu.
def choose_mode(
num_requests: int,
urgency: str,
budget: str,
) -> str:
"""Odporúča optimálny režim vykonávania."""
if num_requests > 100 and urgency != "immediate":
return "batch"
elif urgency == "immediate":
return "synchronous"
else:
return "background"
Nakoniec si naplánuj únikovú cestu. Požiadavka na pozadí, ktorá výrazne prekročí očakávanú dĺžku, viaže rozpočet a oneskoruje zvyšok tvojho pipeline; API ti umožňuje explicitne ju zrušiť. Tento strop nastav na dvojnásobok dĺžky, ktorú pozoruješ v praxi, nie na priemer, inak riskuješ zrušenie požiadaviek, ktoré boli tesne pred úspechom.
def cancel_if_too_long(response_id: str, timeout: int = 120):
"""Zruší požiadavku, ak prekročí časový limit."""
start = time.time()
while time.time() - start < timeout:
response = client.responses.retrieve(response_id)
if response.status == "completed":
return response.output_text
time.sleep(5)
# Časový limit prekročený — zrušiť
client.responses.cancel(response_id)
raise TimeoutError(
f"Požiadavka {response_id} zrušená po {timeout}s."
)
Kľúčové poznatky
- Režim na pozadí spúšťa požiadavky bez udržiavania otvoreného spojenia
- Ideálny pre nastavenia s vysokým logickým uvažovaním (GPT-5.6 Sol) a dlhé úlohy
- Kombinuj s webhookom pre architektúru riadenú udalosťami
- Ulož ID odpovede: je to tvoja jediná väzba na prebiehajúcu prácu
- Pre hromadné spracovanie s nízkymi nákladmi uprednostni Dávkové API (Batch API)