Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Taustrežiim

Õppetund 9 / 20 Värskendatud 28. juuli 2026 Edasijõudnutele
Sellel lehel
  1. Kolmas tee sünkroonse ja pakettrežiimi vahel
  2. Käivitamine ja tulemuse hankimine
  3. Pika arutlusvõimega ülesanded
  4. Õige režiimi valimine
  5. Peamised punktid

Kolmas tee sünkroonse ja pakettrežiimi vahel

Responses API taustrežiim täidab sinu tööriistakastis kindlat nišši. Sünkroonne päring annab vastuse kohe, kuid sunnib sind hoidma ühendust avatuna kogu genereerimise vältel. Batch API töötleb tuhandeid päringuid poole odavamalt, kuid tulemuste ootamine võtab tunde. Taustrežiim asub nende kahe vahel: see haldab üksikuid päringuid tavahinnaga ilma avatud ühendust nõudmata. Sa esitad päringu, saad ID ja tood tulemuse, kui see on valmis.

See kompromiss on mõeldud täpseks kasutusjuhuks: üksik päring, mis on blokeeriva kõne jaoks liiga pikk, kuid ei saa oodata homseni. See on täpselt see stsenaarium, kui käivitad kõrge arutlusvõimega mudeli keerulise dokumendi analüüsiks.

Käivitamine ja tulemuse hankimine

Aktiveerimiseks piisab ühest parameetrist. Kohene vastus teksti ei sisalda; see tagastab ID ja oleku, tavaliselt queued või in_progress.

import openai

client = openai.OpenAI()

# Käivita päring taustal
response = client.responses.create(
    model="gpt-5.6-sol",  # Ideaalne aeglaste ülesannete jaoks (kõrge arutlusvõime)
    input="Analüüsi Euroopa AI-määruse majanduslikke mõjusid "
          "Prantsuse VKEdele. Tee ettepanek 10-punktiliseks tegevuskavaks.",
    background=True,  # Taustrežiim
)

print(f"Vastuse ID: {response.id}")
print(f"Olek: {response.status}")  # "queued" või "in_progress"

See ID on ainus side lüli poolelioleva tööga: salvesta see enne kui teed midagi muud. Selle kaotamine tähendab, et maksad genereerimise eest, mida sa kunagi kätte ei saa. Tulemuse hankimine eeldab API pidevat pärimist (polling), kuni olek muutub lõplikuks. Tõrkeid ja tühistamisi tuleb käsitleda eraldi, kuna neil on erinevad ärilised tagajärjed.

import time

def wait_for_response(response_id: str, interval: int = 5) -> str:
    """Ootab taustavastuse valmimist."""
    while True:
        response = client.responses.retrieve(response_id)

        match response.status:
            case "completed":
                return response.output_text
            case "failed":
                raise RuntimeError(
                    f"Päring ebaõnnestus: {response.error}"
                )
            case "cancelled":
                raise RuntimeError("Päring tühistati.")
            case _:
                print(f"Olek: {response.status}...")
                time.sleep(interval)

Pika arutlusvõimega ülesanded

Mudel nagu GPT-5.6 Sol, millel on kõrge arutlusvõime sisse lülitatud, võib võtta 30 sekundist kahe minutini enne esimese nähtava tokeni loomist. Sünkroonses kõnes põhjustavad need kestused HTTP-klientide, prokside ja väravate vaikimisi ajalõppe. Taustrežiim kõrvaldab selle probleemi juurest ja võimaldab muu hulgas käivitada mitu mahukat analüüsi, sidumata seejuures nii palju ühendusi.

async def deep_analysis(document: str) -> str:
    """Käivitab analüüsi mudeliga GPT-5.6 Sol ilma blokeerimata."""
    response = client.responses.create(
        model="gpt-5.6-sol",
        input=f"Teosta selle lepingu põhjalik õiguslik analüüs. "
              f"Identifitseeri kõik potentsiaalsed riskid, problemaatilised klauslid "
              f"ja tee ettepanekud muudatusteks.\n\n{document}",
        background=True,
    )
    return response.id

# Käivita mitu analüüsi paralleelselt
task_ids = []
for doc in documents:
    task_id = await deep_analysis(doc)
    task_ids.append(task_id)

# Hangi tulemused hiljem
results = {}
for task_id in task_ids:
    results[task_id] = wait_for_response(task_id)

See muster laiendub loomulikult webhookidele, kui kutsujaks on teine teenus. Sinu lõpp-punkt käivitab päringu, tagastab ID ja delegeerib taustategevusele lõpuleviimise jälgimise ja teavituste saatmise. Kutsuja ei tegele pärimisega; ta saab teavituse.

from fastapi import FastAPI, BackgroundTasks
import httpx

app = FastAPI()

@app.post("/api/long-analysis")
async def launch_analysis(request: dict, background_tasks: BackgroundTasks):
    """Käivitab analüüsi ja teavitab webhooki kaudu, kui töö on tehtud."""
    response = client.responses.create(
        model="gpt-5.6-sol",
        input=request["prompt"],
        background=True,
    )

    # Jälgi taustal
    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):
    """Jälgib taustapäringut ja teavitab webhooki kaudu."""
    result = wait_for_response(response_id)

    async with httpx.AsyncClient() as http:
        await http.post(webhook_url, json={
            "response_id": response_id,
            "result": result,
        })

Õige režiimi valimine

Otsus taandub kahele küsimusele. Kui palju päringuid on? Ja kas kasutaja ootab? Üle saja päringu puhul, kui vahetut vajadust pole, võidab Batch API hinnas: tulemused tundidega poole odavamalt. Kui keegi ootab oma ekraani ees, jäävad sünkroonsed kõned tavahinnaga ainsaks vastuvõetavaks valikuks. Taustrežiim täidab ülejäänud ruumi: vähe päringuid, tulemused minutitega, tavahind. Seda loogikat tasub kodeerida üks kord, mitte arutada seda iga uue teenuse puhul uuesti.

def choose_mode(
    num_requests: int,
    urgency: str,
    budget: str,
) -> str:
    """Soovitab optimaalset täitmise režiimi."""
    if num_requests > 100 and urgency != "immediate":
        return "batch"
    elif urgency == "immediate":
        return "synchronous"
    else:
        return "background"

Lõpuks planeeri varuväljapääs. Taustapäring, mis ületab oluliselt eeldatavat kestust, seob eelarvet ja lükkab edasi ülejäänud töövoogu; API võimaldab selle sõnaselgelt tühistada. Määra see ülempiir kahekordseks praktikas täheldatud kestusest, mitte keskmisest, vastasel juhul riskid tühistada päringuid, mis olid just õnnestumas.

def cancel_if_too_long(response_id: str, timeout: int = 120):
    """Tühistab päringu, kui see ületab ajalõpu."""
    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)

    # Ajalõpp ületatud — tühistamine
    client.responses.cancel(response_id)
    raise TimeoutError(
        f"Päring {response_id} tühistati pärast {timeout}s."
    )

Peamised punktid

  • Taustrežiim käivitab päringuid ilma ühendust avatuna hoidmata
  • Ideaalne kõrge arutlusvõimega seadistuste (GPT-5.6 Sol) ja pikkade ülesannete jaoks
  • Kombineeri webhookiga sündmustepõhise arhitektuuri loomiseks
  • Salvesta vastuse ID: see on ainus side lüli poolelioleva tööga
  • Madala hinnaga mahutöötluse eelista Batch API-d