Il-modalità fl-isfond
F'din il-paġna
Triq terza bejn is-sinkronu u l-batch
Il-modalità fl-isfond tal-API tar-Risposti timla niċċa speċifika fil-kit ta’ għodod tiegħek. Sejħa sinkrona tagħtik it-tweġiba immedjatament iżda tifforzalek iżżomm il-konnessjoni miftuħa matul il-ġenerazzjoni kollha. L-API tal-Batch tipproċessa eluf ta’ talbiet bin-nofs tal-prezz, iżda r-riżultati jieħdu sigħat. Il-modalità fl-isfond toqgħod bejniethom: tittratta talbiet individwali bir-rata standard mingħajr konnessjoni miftuħa. Tibgħat it-talba, tirċievi ID, u tirrikupra r-riżultat meta jkun lest.
Dan il-kompromess jimmira każ ta’ użu preċiż: talba waħda li tieħu wisq żmien għal sejħa li timblokka iżda li ma tistax tistenna sa għada. Dan huwa eżattament ix-xenarju meta tħaddem mudell ta’ raġunar għoli fuq dokument kumpless.
Tnedija u rikupru
L-attivazzjoni teħtieġ biss parametru wieħed. Ir-rispons immedjat ma fih l-ebda test; jirritorna ID u status, tipikament queued jew in_progress.
import openai
client = openai.OpenAI()
# Launch the request in background
response = client.responses.create(
model="gpt-5.6-sol", # Ideal for slow tasks (high reasoning)
input="Analyze the economic implications of European AI regulation "
"for French SMEs. Propose a 10-point action plan.",
background=True, # Background mode
)
print(f"Response ID: {response.id}")
print(f"Status: {response.status}") # "queued" or "in_progress"
Dan l-ID huwa l-uniku rabta tiegħek max-xogħol għaddej: ippreżervah qabel ma tagħmel xejn ieħor. Li titlefu jfisser li tħallas għal ġenerazzjoni li qatt mhux se tirrikupra. Ir-rikupru mbagħad jinvolvi li tagħmel polling tal-API sakemm l-istatus isir terminali, u tittratta l-falliment u l-kanċellazzjoni separatament peress li għandhom konsegwenzi kummerċjali differenti.
import time
def wait_for_response(response_id: str, interval: int = 5) -> str:
"""Waits for a background response to complete."""
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)
Kompiti ta’ raġunar twal
Mudell bħal GPT-5.6 Sol b’raġunar għoli attivat jista’ jieħu bejn 30 sekonda u żewġ minuti qabel ma jipproduċi l-ewwel token viżibbli tiegħu. F’sejħa sinkrona, dawn id-durati jolqtu l-limiti ta’ żmien (timeouts) default għall-klijenti HTTP, il-proxies u l-gateways. Il-modalità fl-isfond telimina din il-problema mill-għerq u, inċidentalment, jħallik tniedi diversi analiżijiet tqal mingħajr ma torbot daqshekk konnessjonijiet.
async def deep_analysis(document: str) -> str:
"""Launches an analysis with GPT-5.6 Sol without blocking."""
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
# Launch multiple analyses in parallel
task_ids = []
for doc in documents:
task_id = await deep_analysis(doc)
task_ids.append(task_id)
# Retrieve results later
results = {}
for task_id in task_ids:
results[task_id] = wait_for_response(task_id)
Dan il-mudell jestendi naturalment għall-webhooks meta s-sejjaħ huwa servizz ieħor. L-endpoint tiegħek iniedi t-talba, jirritorna l-ID, u jiddelega kompitu fl-isfond biex jissorvelja t-tlestija u jibgħat notifiki. Is-sejjaħ ma jagħmilx polling; jiġi nnotifikat.
from fastapi import FastAPI, BackgroundTasks
import httpx
app = FastAPI()
@app.post("/api/long-analysis")
async def launch_analysis(request: dict, background_tasks: BackgroundTasks):
"""Launches an analysis and notifies via webhook when done."""
response = client.responses.create(
model="gpt-5.6-sol",
input=request["prompt"],
background=True,
)
# Monitor in background
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):
"""Monitors a background request and notifies 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,
})
Għażla tal-modalità t-tajba
Ir-regola tad-deċiżjoni tinżel għal żewġ mistoqsijiet. Kemm-il talba? U l-utent qed jistenna? Lil hinn minn mitt talba mingħajr rekwiżit ta’ immedjatezza, l-API tal-Batch tirbaħ fuq il-prezz: riżultati f’sigħat bin-nofs tal-ispiża. Jekk xi ħadd qed jistenna quddiem l-iskrin tiegħu, is-sejħiet sinkroni jibqgħu l-unika għażla aċċettabbli bir-rata standard. Il-modalità fl-isfond timla l-bqija tal-ispazju: ftit talbiet, riżultati f’minuti, prezz standard. Jiswa li tikkwifika din il-loġika darba minflok ma terġa’ tanalizzaha għal kull servizz ġdid.
def choose_mode(
num_requests: int,
urgency: str,
budget: str,
) -> str:
"""Recommends the optimal execution mode."""
if num_requests > 100 and urgency != "immediate":
return "batch"
elif urgency == "immediate":
return "synchronous"
else:
return "background"
Fl-aħħar nett, ippjana ħarġa ta’ emerġenza (escape hatch). Talba fl-isfond li taqbeż ħafna d-durata mistennija tagħha torbot il-baġit u ddewwar il-bqija tal-pipeline tiegħek; l-API jħallik tikkanċellaha b’mod espliċitu. Issalva dan il-limitu massimu f’doppju d-durata li tosserva fil-prattika, mhux il-medja, inkella tirriskja li tikkanċella talbiet li kienu se jirnexxu.
def cancel_if_too_long(response_id: str, timeout: int = 120):
"""Cancels a request if it exceeds the 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 exceeded — cancel
client.responses.cancel(response_id)
raise TimeoutError(
f"Request {response_id} cancelled after {timeout}s."
)
Punti Ewlenin
- Il-modalità fl-isfond tniedi talbiet mingħajr ma żżomm konnessjoni miftuħa
- Ideali għal settings ta’ raġunar għoli (GPT-5.6 Sol) u kompiti twal
- Ikkombina ma’ webhook għal arkitettura mmexxija mill-avvenimenti
- Ippreżerva l-ID tar-rispons: hija l-unika rabta tiegħek max-xogħol għaddej
- Għal ipproċessar bulk bi prezz baxx, ippreferi l-API tal-Batch