Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Način delovanja v ozadju

Lekcija 9 od 20 Posodobljeno 28. julij 2026 Napredni
Na tej strani
  1. Tretja pot med sinhronim in serijskim načinom
  2. Zagon in pridobivanje
  3. Dolge naloge sklepanja
  4. Izbira pravega načina
  5. Ključne ugotovitve

Tretja pot med sinhronim in serijskim načinom

Način delovanja v ozadju (background mode) API-ja Responses zapolnjuje specifično nišo v tvojem orodjarniku. Sinhroni klic ti vrne odgovor takoj, vendar te prisili, da ohranjaš povezavo odprto skozi celotno generiranje. API za serijsko obdelavo (Batch API) obdela na tisoče zahtevkov za polovično ceno, vendar rezultati prispejo šele čez nekaj ur. Način v ozadju leži nekje vmes: obravnava posamezne zahtevke po standardni tarifi brez potrebe po odprti povezavi. Zahtevek oddaš, prejmeš ID in rezultat pridobiš, ko je ta pripravljen.

Ta kompromis cilja na natančen primer uporabe: posamezen zahtevek, ki traja predolgo za blokirajoč klic, a ne more čakati do jutri. To je točno scenarij, ko izvajaš model z visoko stopnjo sklepanja na kompleksnem dokumentu.

Zagon in pridobivanje

Aktivacija zahteva le en parameter. Takojšnji odgovor ne vsebuje besedila; vrne ID in stanje, običajno queued (v čakalni vrsti) ali in_progress (v teku).

import openai

client = openai.OpenAI()

# Zagon zahtevka v ozadju
response = client.responses.create(
    model="gpt-5.6-sol",  # Idealno za počasne naloge (visoko sklepanje)
    input="Analyze the economic implications of European AI regulation "
          "for French SMEs. Propose a 10-point action plan.",
    background=True,  # Način delovanja v ozadju
)

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

Ta ID je tvoja edina povezava do dela v teku: shrani ga, preden narediš karkoli drugega. Če ga izgubiš, pomeni, da boš plačal generiranje, ki ga nikoli ne boš pridobil. Pridobivanje nato vključuje periodično preverjanje (polling) API-ja, dokler stanje ne postane končno, pri čemer ločeno obravnavaš napake in preklice, saj imajo različne poslovne posledice.

import time

def wait_for_response(response_id: str, interval: int = 5) -> str:
    """Čaka na zaključek odziva v ozadju."""
    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)

Dolge naloge sklepanja

Model, kot je GPT-5.6 Sol z omogočenim visokim sklepanjem, lahko potrebuje od 30 sekund do dveh minut, preden proizvede prvi vidni žeton. Pri sinhronem klicu ti časi udarijo ob privzete časovne omejitve (timeouts) odjemalcev HTTP, posredniških strežnikov in prehodov. Način v ozadju odpravi to težavo pri korenu in mimogrede ti omogoča zagon več težkih analiz, ne da bi zavezal toliko povezav.

async def deep_analysis(document: str) -> str:
    """Začne analizo z GPT-5.6 Sol brez blokiranja."""
    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

# Zagon več analiz vzporedno
task_ids = []
for doc in documents:
    task_id = await deep_analysis(doc)
    task_ids.append(task_id)

# Poznejše pridobivanje rezultatov
results = {}
for task_id in task_ids:
    results[task_id] = wait_for_response(task_id)

Ta vzorec se naravno razširi na spletne kljuke (webhooks), ko je klicatelj druga storitev. Tvoja končna točka zažene zahtevek, vrne ID in delegira nalogo v ozadju, ki spremlja zaključek in pošilja obvestila. Klicatelj ne izvaja periodičnega preverjanja; prejme obvestilo.

from fastapi import FastAPI, BackgroundTasks
import httpx

app = FastAPI()

@app.post("/api/long-analysis")
async def launch_analysis(request: dict, background_tasks: BackgroundTasks):
    """Začne analizo in obvesti preko spletne kljuke, ko je končano."""
    response = client.responses.create(
        model="gpt-5.6-sol",
        input=request["prompt"],
        background=True,
    )

    # Spremljanje v ozadju
    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):
    """Spremlja zahtevek v ozadju in obvesti preko spletne kljuke."""
    result = wait_for_response(response_id)

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

Izbira pravega načina

Pravilo odločanja se свede na dve vprašanji. Koliko zahtevkov imaš? In ali uporabnik čaka? Pri več kot sto zahtevkih brez potrebe po takojšnjosti zmaga API za serijsko obdelavo (Batch API) glede na ceno: rezultati v nekaj urah za polovično ceno. Če nekdo čaka pred zaslonom, ostajajo sinhroni klici edina sprejemljiva izbira po standardni tarifi. Način v ozadju zapolni preostali prostor: malo zahtevkov, rezultati v nekaj minutah, standardna cena. Splača se to logiko enkrat kodificirati, namesto da jo znova in znova obnavljaš za vsako novo storitev.

def choose_mode(
    num_requests: int,
    urgency: str,
    budget: str,
) -> str:
    """Priporoča optimalni način izvajanja."""
    if num_requests > 100 and urgency != "immediate":
        return "batch"
    elif urgency == "immediate":
        return "synchronous"
    else:
        return "background"

Na koncu načrtuj izhod v sili. Zahtevek v ozadju, ki bistveno preseže pričakovano trajanje, zaveže proračun in zavira preostanek tvojega procesa; API ti omogoča, da ga izrecno prekličeš. To zgornjo mejo nastavi na dvojnik trajanja, ki ga opaziš v praksi, ne na povprečje, sicer tvegaš preklic zahtevkov, ki bi bili tik pred uspehom.

def cancel_if_too_long(response_id: str, timeout: int = 120):
    """Prekliče zahtevek, če preseže časovno omejitev."""
    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)

    # Časovna omejitev presežena — preklic
    client.responses.cancel(response_id)
    raise TimeoutError(
        f"Request {response_id} cancelled after {timeout}s."
    )

Ključne ugotovitve

  • Način v ozadju zažene zahtevke brez ohranjanja odprte povezave
  • Idealno za nastavitve visokega sklepanja (GPT-5.6 Sol) in dolge naloge
  • Združi s spletno kljuko (webhook) za arhitekturo, gonjeno z dogodki
  • Shrani ID odziva: to je tvoja edina povezava do dela v teku
  • Za poceni obdelavo velikih količin raje uporabi API za serijsko obdelavo (Batch API)