Režim na pozadí
Na této stránce
Třetí cesta mezi synchronním a dávkovým zpracováním
Režim na pozadí (background mode) v Responses API zaplňuje specifickou mezeru ve tvém arzenálu nástrojů. Synchronní volání ti poskytne odpověď okamžitě, ale nutí tě udržovat připojení otevřené po celou dobu generování. Batch API zpracuje tisíce požadavků za poloviční cenu, ale výsledky si musíš počkat hodiny. Režim na pozadí leží přesně mezi nimi: zpracovává jednotlivé požadavky za standardní sazbu bez nutnosti udržovat otevřené připojení. Odešleš požadavek, obdržíš ID a výsledek si stáhneš, jakmile bude připraven.
Tento kompromis cílí na přesný případ použití: jediný požadavek, který trvá příliš dlouho na blokovací volání, ale nemůže čekat do zítřka. Přesně to nastává, když spouštíš model s vysokou úrovní logického uvažování (high-reasoning) na komplexním dokumentu.
Spuštění a získání výsledku
Aktivace vyžaduje pouze jeden parametr. Okamžitá odpověď neobsahuje žádný text; vrací ID a stav, typicky queued (ve frontě) nebo in_progress (probíhá).
import openai
client = openai.OpenAI()
# Spuštění požadavku na pozadí
response = client.responses.create(
model="gpt-5.6-sol", # Ideální pro pomalé úlohy (vysoké uvažování)
input="Analyze the economic implications of European AI regulation "
"for French SMEs. Propose a 10-point action plan.",
background=True, # Režim na pozadí
)
print(f"Response ID: {response.id}")
print(f"Status: {response.status}") # "queued" nebo "in_progress"
Toto ID je tvým jediným pojítkem k probíhající práci: ulož si ho hned, než uděláš cokoliv jiného. Jeho ztráta znamená, že zaplatíš za generování, které nikdy nezískáš. Získání výsledku následně zahrnuje dotazování (polling) API, dokud se stav nestane konečným. Selhání a zrušení musíš řešit odděleně, protože mají odlišné obchodní dopady.
import time
def wait_for_response(response_id: str, interval: int = 5) -> str:
"""Čeká na dokončení odpovědi na pozadí."""
while True:
response = client.responses.retrieve(response_id)
match response.status:
case "completed":
return response.output_text
case "failed":
raise RuntimeError(
f"Request failed: {response.error}"
)
case "cancelled":
raise RuntimeError("Request was cancelled.")
case _:
print(f"Status: {response.status}...")
time.sleep(interval)
Úlohy s dlouhým uvažováním
Model jako GPT-5.6 Sol s povoleným vysokým uvažováním může potřebovat 30 sekund až dvě minuty, než vygeneruje první viditelný token. Při synchronním volání tyto délky narážejí na výchozí časové limity HTTP klientů, proxy serverů a bran. Režim na pozadí tento problém eliminuje u kořene a mimochodem ti umožňuje spustit několik náročných analýz, aniž bys blokoval tolik připojení.
async def deep_analysis(document: str) -> str:
"""Spustí analýzu s GPT-5.6 Sol bez blokování."""
response = client.responses.create(
model="gpt-5.6-sol",
input=f"Perform a thorough legal analysis of this contract. "
f"Identify all potential risks, problematic clauses, "
f"and propose modifications.\n\n{document}",
background=True,
)
return response.id
# Spuštění více analýz paralelně
task_ids = []
for doc in documents:
task_id = await deep_analysis(doc)
task_ids.append(task_id)
# Získání výsledků později
results = {}
for task_id in task_ids:
results[task_id] = wait_for_response(task_id)
Tento vzor se přirozeně rozšiřuje na webhooky, pokud je volajícím jiná služba. Tvůj endpoint spustí požadavek, vrátí ID a deleguje úlohu na pozadí, která monitoruje dokončení a odešle oznámení. Volající neprovádí dotazování; dostane upozornění.
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í přes webhook."""
response = client.responses.create(
model="gpt-5.6-sol",
input=request["prompt"],
background=True,
)
# Monitorování 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žadavek na pozadí a upozorní přes 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ýběr správného režimu
Pravidlo rozhodování se redukuje na dvě otázky. Kolik je požadavků? A čeká uživatel? Při více než sto požadavcích bez nutnosti okamžitého výsledku vítězí Batch API cenově: výsledky za hodiny za poloviční cenu. Pokud někdo čeká u obrazovky, zůstávají synchronní volání jedinou přijatelnou volbou za standardní sazbu. Režim na pozadí vyplňuje zbytek prostoru: málo požadavků, výsledky za minuty, standardní cena. Vyplatí se tuto logiku zakódovat jednou provždy, místo abys ji pokaždé znovu řešil pro každou novou službu.
def choose_mode(
num_requests: int,
urgency: str,
budget: str,
) -> str:
"""Doporučí optimální režim spuštění."""
if num_requests > 100 and urgency != "immediate":
return "batch"
elif urgency == "immediate":
return "synchronous"
else:
return "background"
Nakonec si naplánuj únikovou cestu (escape hatch). Požadavek na pozadí, který výrazně překročí očekávanou dobu, váže rozpočet a zdržuje zbytek tvého pipeline; API ti umožňuje takový požadavek explicitně zrušit. Tento strop nastav na dvojnásobek doby, kterou pozoruješ v praxi, nikoliv na průměr, jinak riskuješ zrušení požadavků, které byly těsně před úspěchem.
def cancel_if_too_long(response_id: str, timeout: int = 120):
"""Zruší požadavek, pokud překročí č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 překročen — zrušení
client.responses.cancel(response_id)
raise TimeoutError(
f"Request {response_id} cancelled after {timeout}s."
)
Klíčové poznatky
- Režim na pozadí spouští požadavky bez udržování otevřeného připojení
- Ideální pro nastavení s vysokým uvažováním (GPT-5.6 Sol) a dlouhé úlohy
- Kombinuj s webhookem pro architekturu řízenou událostmi
- Ulož si ID odpovědi: je to tvé jediné pojítko k probíhající práci
- Pro hromadné zpracování s nízkými náklady upřednostni Batch API