Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Režīms fonā

Nodarbība 9 no 20 Atjaunota 2026. gada 28. jūlijs Augstākais
Šajā lapā
  1. Trešais ceļš starp sinhrono un paketes apstrādi
  2. Palaišana un rezultātu iegūšana
  3. Ilgi spriešanas uzdevumi
  4. Pareizā režīma izvēle
  5. Galvenās atziņas

Trešais ceļš starp sinhrono un paketes apstrādi

Responses API režīms fonā aizpilda specifisku nišu tavā rīku komplektā. Sinhrons izsaukums dod atbildi uzreiz, bet liek uzturēt savienojumu atvērtu visu ģenerēšanas laiku. Batch API apstrādā tūkstošiem pieprasījumu uz pusi lētāk, taču rezultāti ir gatavi pēc stundām. Režīms fonā atrodas pa vidu: tas apstrādā individuālus pieprasījumus par standarta tarifu, neprasaot atvērtu savienojumu. Tu iesniedz pieprasījumu, saņem ID un iegūsti rezultātu, kad tas ir gatavs.

Šis kompromiss ir paredzēts precīzam lietojumam: vienots pieprasījums, kas ir par ilgu bloķējošam izsaukumam, bet nevar gaidīt līdz rītdienai. Tas ir tieši tas scenārijs, kad palaid augsta spriešanas modeli sarežģīta dokumenta apstrādei.

Palaišana un rezultātu iegūšana

Aktivizēšanai pietiek ar vienu parametru. Tūlītējā atbildē nav teksta; tā satur tikai ID un statusu, parasti queued vai in_progress.

import openai

client = openai.OpenAI()

# Palaid pieprasījumu fonā
response = client.responses.create(
    model="gpt-5.6-sol",  # Ideāls lēniem uzdevumiem (augsta spriešana)
    input="Analyze the economic implications of European AI regulation "
          "for French SMEs. Propose a 10-point action plan.",
    background=True,  # Režīms fonā
)

print(f"Response ID: {response.id}")
print(f"Status: {response.status}")  # "queued" vai "in_progress"

Šis ID ir tava vienīgā saite ar notiekošo darbu: saglabā to, pirms dari jebko citu. To pazaudējot, tu samaksāsi par ģenerēšanu, ko nekad neiegūsi. Rezultātu iegūšana prasa aptaujāt API, līdz statuss kļūst termināls, atsevišķi apstrādājot kļūmes un atcelšanu, jo tām ir atšķirīgas biznesa sekas.

import time

def wait_for_response(response_id: str, interval: int = 5) -> str:
    """Gaida, kamēr fona atbilde ir pabeigta."""
    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)

Ilgi spriešanas uzdevumi

Tāds modelis kā GPT-5.6 Sol ar ieslēgtu augstu spriešanu var prasīt no 30 sekundēm līdz divām minūtēm, pirms tiek ģenerēts pirmais redzamais tokens. Sinhronā izsaukumā šādi ilgumi sasniedz HTTP klientu, starpniekserveru un vārteju noklusējuma noildzes. Režīms fonā novērš šo problēmu pie saknēm un vienlaikus ļauj palaist vairākas smagas analīzes, neaizņemot tik daudz savienojumu.

async def deep_analysis(document: str) -> str:
    """Palaiž analīzi ar GPT-5.6 Sol, nebloķējot izpildi."""
    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

# Palaid vairākas analīzes paralēli
task_ids = []
for doc in documents:
    task_id = await deep_analysis(doc)
    task_ids.append(task_id)

# Iegūsti rezultātus vēlāk
results = {}
for task_id in task_ids:
    results[task_id] = wait_for_response(task_id)

Šis modelis dabiski paplašināms uz webhookiem, ja izsaucošā puse ir cits serviss. Tavs galapunkts palaiž pieprasījumu, atgriež ID un deleģē fona uzdevumu, kas uzrauga pabeigšanu un sūta paziņojumus. Izsaucošais serviss neveic aptauju; tas saņem paziņojumu.

from fastapi import FastAPI, BackgroundTasks
import httpx

app = FastAPI()

@app.post("/api/long-analysis")
async def launch_analysis(request: dict, background_tasks: BackgroundTasks):
    """Palaiž analīzi un paziņo, izmantojot webhook, kad tā ir pabeigta."""
    response = client.responses.create(
        model="gpt-5.6-sol",
        input=request["prompt"],
        background=True,
    )

    # Uzraugi fonā
    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):
    """Uzrauga fona pieprasījumu un paziņo, izmantojot 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,
        })

Pareizā režīma izvēle

Lēmuma pieņemšanas noteikums balstās uz diviem jautājumiem. Cik daudz pieprasījumu? Un vai lietotājs gaida? Pārsniedzot simts pieprasījumus bez nepieciešamības pēc tūlītējas atbildes, Batch API uzvar cenas ziņā: rezultāti stundu laikā par pusi zemākām izmaksām. Ja kāds gaida pie ekrāna, sinhroni izsaukumi paliek vienīgā pieņemamā izvēle par standarta tarifu. Režīms fonā aizpilda pārējo telpu: maz pieprasījumu, rezultāti minūšu laikā, standarta cena. Ir vērts šo loģiku kodificēt vienreiz, nevis atkārtot to katram jaunam servisam.

def choose_mode(
    num_requests: int,
    urgency: str,
    budget: str,
) -> str:
    """Iesak optimālo izpildes režīmu."""
    if num_requests > 100 and urgency != "immediate":
        return "batch"
    elif urgency == "immediate":
        return "synchronous"
    else:
        return "background"

Visbeidzot, izplāno izejas stratēģiju. Fona pieprasījums, kas ievērojami pārsniedz paredzēto ilgumu, sasalda budžetu un aizkavē pārējo cauruļvadu; API ļauj to tieši atcelt. Iestati šo griestus pie dubulta ilguma, ko novēro praksē, nevis pie vidējā rādītāja, pretējā gadījumā riskē atcelt pieprasījumus, kas bija tuvu veiksmīgai pabeigšanai.

def cancel_if_too_long(response_id: str, timeout: int = 120):
    """Atceļ pieprasījumu, ja tas pārsniedz noildi."""
    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)

    # Noilde pārsniegta — atcel
    client.responses.cancel(response_id)
    raise TimeoutError(
        f"Request {response_id} cancelled after {timeout}s."
    )

Galvenās atziņas

  • Režīms fonā palaiž pieprasījumus, neuzturot atvērtu savienojumu
  • Ideāls augstas spriešanas iestatījumiem (GPT-5.6 Sol) un ilgiem uzdevumiem
  • Apvieno ar webhook notikumu virzītai arhitektūrai
  • Saglabā atbildes ID: tā ir tava vienīgā saite ar notiekošo darbu
  • Lētu masveida apstrādei dod priekšroku Batch API