Baggrundstilstand
På denne side
En tredje vej mellem synkron og batch
Baggrundstilstanden i Responses API udfylder en specifik niche i dit værktøjssæt. Et synkront kald giver dig svaret øjeblikkeligt, men tvinger dig til at holde forbindelsen åben under hele genereringen. Batch API’en behandler tusindvis af anmodninger til halv pris, men resultaterne tager flere timer. Baggrundstilstanden ligger midt imellem: den håndterer individuelle anmodninger til standardtaksten uden en åben forbindelse. Du indsender anmodningen, modtager et ID og henter resultatet, når det er klart.
Dette kompromis målretter et præcist brugstilfælde: en enkelt anmodning, der tager for lang tid til et blokerende kald, men ikke kan vente til i morgen. Dette er netop scenariet, når du kører en høj-resonnerende model på et komplekst dokument.
Start og hentning
Aktivering kræver kun én parameter. Det øjeblikkelige svar indeholder ingen tekst; det returnerer et ID og en status, typisk queued eller in_progress.
import openai
client = openai.OpenAI()
# Start anmodningen i baggrunden
response = client.responses.create(
model="gpt-5.6-sol", # Ideel til langsomme opgaver (høj ræsonnement)
input="Analyser de økonomiske konsekvenser af europæisk AI-regulering "
"for franske SMV'er. Foreslå en handlingsplan med 10 punkter.",
background=True, # Baggrundstilstand
)
print(f"Svar-ID: {response.id}")
print(f"Status: {response.status}") # "queued" eller "in_progress"
Dette ID er dit eneste link til det igangværende arbejde: gem det, før du gør noget andet. Mister du det, betyder det, at du betaler for en generering, du aldrig får hentet. Hentning indebærer derefter at spørge API’en løbende, indtil status bliver terminal, hvor du håndterer fejl og annullering separat, da de har forskellige forretningsmæssige konsekvenser.
import time
def wait_for_response(response_id: str, interval: int = 5) -> str:
"""Venter på, at et baggrundssvar bliver færdigt."""
while True:
response = client.responses.retrieve(response_id)
match response.status:
case "completed":
return response.output_text
case "failed":
raise RuntimeError(
f"Anmodning mislykkedes: {response.error}"
)
case "cancelled":
raise RuntimeError("Anmodning blev annulleret.")
case _:
print(f"Status: {response.status}...")
time.sleep(interval)
Lange ræsonnementsopgaver
En model som GPT-5.6 Sol med aktiveret høj ræsonnement kan tage 30 sekunder til to minutter, før den producerer sit første synlige token. I et synkront kald rammer disse varigheder standard-timeouts for HTTP-klienter, proxyer og gateways. Baggrundstilstanden eliminerer dette problem ved roden og giver dig tilfældigvis mulighed for at starte flere tunge analyser uden at binde lige så mange forbindelser.
async def deep_analysis(document: str) -> str:
"""Starter en analyse med GPT-5.6 Sol uden blokering."""
response = client.responses.create(
model="gpt-5.6-sol",
input=f"Udfør en grundig juridisk analyse af denne kontrakt. "
f"Identificer alle potentielle risici, problematiske klausuler, "
f"og foreslå ændringer.\n\n{document}",
background=True,
)
return response.id
# Start flere analyser parallelt
task_ids = []
for doc in documents:
task_id = await deep_analysis(doc)
task_ids.append(task_id)
# Hent resultater senere
results = {}
for task_id in task_ids:
results[task_id] = wait_for_response(task_id)
Dette mønster udvides naturligt til webhooks, når kalderen er en anden tjeneste. Dit endpoint starter anmodningen, returnerer ID’et og delegerer en baggrundsopgave til at overvåge fuldførelse og sende notifikationer. Kalden spørger ikke løbende; den får besked.
from fastapi import FastAPI, BackgroundTasks
import httpx
app = FastAPI()
@app.post("/api/long-analysis")
async def launch_analysis(request: dict, background_tasks: BackgroundTasks):
"""Starter en analyse og notifierer via webhook, når den er færdig."""
response = client.responses.create(
model="gpt-5.6-sol",
input=request["prompt"],
background=True,
)
# Overvåg i baggrunden
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):
"""Overvåger en baggrundsanmodning og notifierer via 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,
})
Valg af den rigtige tilstand
Beslutningsreglen koges ned til to spørgsmål. Hvor mange anmodninger? Og venter brugeren? Ved over hundrede anmodninger uden krav om øjeblikkelighed vinder Batch API’en på prisen: resultater på timer til halv pris. Hvis nogen venter ved deres skærm, forbliver synkrone kald det eneste acceptable valg til standardtaksten. Baggrundstilstanden udfylder resten af rummet: få anmodninger, resultater på minutter, standardpris. Det kan betale sig at kodificere denne logik én gang frem for at genopfinde den for hver ny tjeneste.
def choose_mode(
num_requests: int,
urgency: str,
budget: str,
) -> str:
"""Anbefaler den optimale kørselstilstand."""
if num_requests > 100 and urgency != "immediate":
return "batch"
elif urgency == "immediate":
return "synchronous"
else:
return "background"
Planlæg endelig en nødudgang. En baggrundsanmodning, der overstiger sin forventede varighed langt, binder budget og forsinker resten af din pipeline; API’en lader dig annullere den eksplicit. Sæt dette loft til det dobbelte af den varighed, du observerer i praksis, ikke gennemsnittet, ellers risikerer du at annullere anmodninger, der var ved at lykkes.
def cancel_if_too_long(response_id: str, timeout: int = 120):
"""Annullerer en anmodning, hvis den overstiger timeout."""
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)
# Timeout overskredet — annuller
client.responses.cancel(response_id)
raise TimeoutError(
f"Anmodning {response_id} annulleret efter {timeout}s."
)
Vigtige pointer
- Baggrundstilstand starter anmodninger uden at holde en forbindelse åben
- Ideel til indstillinger med høj ræsonnement (GPT-5.6 Sol) og lange opgaver
- Kombiner med en webhook til en event-drevet arkitektur
- Gem svar-ID’et: det er dit eneste link til det igangværende arbejde
- Til billig massebehandling bør du foretrække Batch API’en