Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

Il-modalità fl-isfond

Lezzjoni 9 / 20 Aġġornat 28 ta’ Lulju 2026 Avvanzat
F'din il-paġna
  1. Triq terza bejn is-sinkronu u l-batch
  2. Tnedija u rikupru
  3. Kompiti ta’ raġunar twal
  4. Għażla tal-modalità t-tajba
  5. Punti Ewlenin

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