Način delovanja v ozadju
Na tej strani
Tretja pot med sinhronim in serijskim načinom
Način delovanja v ozadju (background mode) API-ja Responses zapolnjuje specifično nišo v tvojem orodjarniku. Sinhroni klic ti vrne odgovor takoj, vendar te prisili, da ohranjaš povezavo odprto skozi celotno generiranje. API za serijsko obdelavo (Batch API) obdela na tisoče zahtevkov za polovično ceno, vendar rezultati prispejo šele čez nekaj ur. Način v ozadju leži nekje vmes: obravnava posamezne zahtevke po standardni tarifi brez potrebe po odprti povezavi. Zahtevek oddaš, prejmeš ID in rezultat pridobiš, ko je ta pripravljen.
Ta kompromis cilja na natančen primer uporabe: posamezen zahtevek, ki traja predolgo za blokirajoč klic, a ne more čakati do jutri. To je točno scenarij, ko izvajaš model z visoko stopnjo sklepanja na kompleksnem dokumentu.
Zagon in pridobivanje
Aktivacija zahteva le en parameter. Takojšnji odgovor ne vsebuje besedila; vrne ID in stanje, običajno queued (v čakalni vrsti) ali in_progress (v teku).
import openai
client = openai.OpenAI()
# Zagon zahtevka v ozadju
response = client.responses.create(
model="gpt-5.6-sol", # Idealno za počasne naloge (visoko sklepanje)
input="Analyze the economic implications of European AI regulation "
"for French SMEs. Propose a 10-point action plan.",
background=True, # Način delovanja v ozadju
)
print(f"Response ID: {response.id}")
print(f"Status: {response.status}") # "queued" ali "in_progress"
Ta ID je tvoja edina povezava do dela v teku: shrani ga, preden narediš karkoli drugega. Če ga izgubiš, pomeni, da boš plačal generiranje, ki ga nikoli ne boš pridobil. Pridobivanje nato vključuje periodično preverjanje (polling) API-ja, dokler stanje ne postane končno, pri čemer ločeno obravnavaš napake in preklice, saj imajo različne poslovne posledice.
import time
def wait_for_response(response_id: str, interval: int = 5) -> str:
"""Čaka na zaključek odziva v ozadju."""
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)
Dolge naloge sklepanja
Model, kot je GPT-5.6 Sol z omogočenim visokim sklepanjem, lahko potrebuje od 30 sekund do dveh minut, preden proizvede prvi vidni žeton. Pri sinhronem klicu ti časi udarijo ob privzete časovne omejitve (timeouts) odjemalcev HTTP, posredniških strežnikov in prehodov. Način v ozadju odpravi to težavo pri korenu in mimogrede ti omogoča zagon več težkih analiz, ne da bi zavezal toliko povezav.
async def deep_analysis(document: str) -> str:
"""Začne analizo z GPT-5.6 Sol brez blokiranja."""
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
# Zagon več analiz vzporedno
task_ids = []
for doc in documents:
task_id = await deep_analysis(doc)
task_ids.append(task_id)
# Poznejše pridobivanje rezultatov
results = {}
for task_id in task_ids:
results[task_id] = wait_for_response(task_id)
Ta vzorec se naravno razširi na spletne kljuke (webhooks), ko je klicatelj druga storitev. Tvoja končna točka zažene zahtevek, vrne ID in delegira nalogo v ozadju, ki spremlja zaključek in pošilja obvestila. Klicatelj ne izvaja periodičnega preverjanja; prejme obvestilo.
from fastapi import FastAPI, BackgroundTasks
import httpx
app = FastAPI()
@app.post("/api/long-analysis")
async def launch_analysis(request: dict, background_tasks: BackgroundTasks):
"""Začne analizo in obvesti preko spletne kljuke, ko je končano."""
response = client.responses.create(
model="gpt-5.6-sol",
input=request["prompt"],
background=True,
)
# Spremljanje v ozadju
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):
"""Spremlja zahtevek v ozadju in obvesti preko spletne kljuke."""
result = wait_for_response(response_id)
async with httpx.AsyncClient() as http:
await http.post(webhook_url, json={
"response_id": response_id,
"result": result,
})
Izbira pravega načina
Pravilo odločanja se свede na dve vprašanji. Koliko zahtevkov imaš? In ali uporabnik čaka? Pri več kot sto zahtevkih brez potrebe po takojšnjosti zmaga API za serijsko obdelavo (Batch API) glede na ceno: rezultati v nekaj urah za polovično ceno. Če nekdo čaka pred zaslonom, ostajajo sinhroni klici edina sprejemljiva izbira po standardni tarifi. Način v ozadju zapolni preostali prostor: malo zahtevkov, rezultati v nekaj minutah, standardna cena. Splača se to logiko enkrat kodificirati, namesto da jo znova in znova obnavljaš za vsako novo storitev.
def choose_mode(
num_requests: int,
urgency: str,
budget: str,
) -> str:
"""Priporoča optimalni način izvajanja."""
if num_requests > 100 and urgency != "immediate":
return "batch"
elif urgency == "immediate":
return "synchronous"
else:
return "background"
Na koncu načrtuj izhod v sili. Zahtevek v ozadju, ki bistveno preseže pričakovano trajanje, zaveže proračun in zavira preostanek tvojega procesa; API ti omogoča, da ga izrecno prekličeš. To zgornjo mejo nastavi na dvojnik trajanja, ki ga opaziš v praksi, ne na povprečje, sicer tvegaš preklic zahtevkov, ki bi bili tik pred uspehom.
def cancel_if_too_long(response_id: str, timeout: int = 120):
"""Prekliče zahtevek, če preseže časovno omejitev."""
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)
# Časovna omejitev presežena — preklic
client.responses.cancel(response_id)
raise TimeoutError(
f"Request {response_id} cancelled after {timeout}s."
)
Ključne ugotovitve
- Način v ozadju zažene zahtevke brez ohranjanja odprte povezave
- Idealno za nastavitve visokega sklepanja (GPT-5.6 Sol) in dolge naloge
- Združi s spletno kljuko (webhook) za arhitekturo, gonjeno z dogodki
- Shrani ID odziva: to je tvoja edina povezava do dela v teku
- Za poceni obdelavo velikih količin raje uporabi API za serijsko obdelavo (Batch API)