Премини към основното съдържание
Български— Изберете език
Меню

Режим на работа във фонов режим

Урок 9 от 20 Обновен 28 юли 2026 г. Напреднало
На тази страница
  1. Трети път между синхронния и пакетния режим
  2. Стартиране и извличане
  3. Дълги задачи за разсъждение
  4. Избор на правилния режим
  5. Ключови изводи

Трети път между синхронния и пакетния режим

Режимът на работа във фонов режим (background mode) на Responses API запълва специфична ниша във Вашия набор от инструменти. Синхронното извикване Ви дава отговора незабавно, но Ви принуждава да поддържате връзката отворена за цялото време на генериране. Batch API обработва хиляди заявки на половината цена, но резултатите отнемат часове. Режимът във фонов режим се позиционира между тях: той обработва индивидуални заявки по стандартната тарифа, без да изисква отворена връзка. Вие подавате заявката, получавате идентификатор и извличате резултата, когато е готов.

Този компромис цели конкретен случай на употреба: единична заявка, която отнема твърде много време за блокиращо извикване, но не може да чака до утре. Това е точно сценарият при стартиране на модел с високи възможности за разсъждение върху сложен документ.

Стартиране и извличане

Активирането изисква само един параметър. Незабавният отговор не съдържа текст; той връща идентификатор и статус, обикновено queued или in_progress.

import openai

client = openai.OpenAI()

# Стартиране на заявката във фонов режим
response = client.responses.create(
    model="gpt-5.6-sol",  # Идеален за бавни задачи (високо разсъждение)
    input="Анализирайте икономическите последици от европейското регулиране на изкуствения интелект "
          "за френските МСП. Предложете план за действие от 10 точки.",
    background=True,  # Режим на работа във фонов режим
)

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

Този идентификатор е единствената Ви връзка с работата в процес на изпълнение: запазете го, преди да направите каквото и да е друго. Загубата му означава да платите за генериране, което никога няма да извлечете. Извличането след това включва периодично запитване (polling) на API, докато статусът не стане окончателен, като обработвате грешките и отмяната отделно, тъй като те имат различни бизнес последици.

import time

def wait_for_response(response_id: str, interval: int = 5) -> str:
    """Изчаква завършването на отговор във фонов режим."""
    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)

Дълги задачи за разсъждение

Модел като GPT-5.6 Sol с активирано високо ниво на разсъждение може да отнеме от 30 секунди до две минути, преди да произведе първия си видим токен. При синхронно извикване тези продължителности надвишават стандартните таймаути за HTTP клиенти, проксита и гейтуеи. Режимът във фонов режим елиминира този проблем в основата му и между другото Ви позволява да стартирате няколко тежки анализа, без да ангажирате толкова много връзки.

async def deep_analysis(document: str) -> str:
    """Стартира анализ с GPT-5.6 Sol без блокиране."""
    response = client.responses.create(
        model="gpt-5.6-sol",
        input=f"Извършете задълбочен правен анализ на този договор. "
              f"Идентифицирайте всички потенциални рискове, проблемни клаузи "
              f"и предложете модификации.\n\n{document}",
        background=True,
    )
    return response.id

# Стартиране на множество анализи паралелно
task_ids = []
for doc in documents:
    task_id = await deep_analysis(doc)
    task_ids.append(task_id)

# Извличане на резултатите по-късно
results = {}
for task_id in task_ids:
    results[task_id] = wait_for_response(task_id)

Този шаблон естествено се разширява до уебхукове, когато caller-ът е друга услуга. Вашият крайна точка стартира заявката, връща идентификатора и делегира фонова задача да следи за завършване и да изпраща известия. Caller-ът не прави polling; той получава уведомление.

from fastapi import FastAPI, BackgroundTasks
import httpx

app = FastAPI()

@app.post("/api/long-analysis")
async def launch_analysis(request: dict, background_tasks: BackgroundTasks):
    """Стартира анализ и уведомява чрез уебхук при приключване."""
    response = client.responses.create(
        model="gpt-5.6-sol",
        input=request["prompt"],
        background=True,
    )

    # Мониторинг във фонов режим
    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):
    """Следи заявка във фонов режим и уведомява чрез уебхук."""
    result = wait_for_response(response_id)

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

Избор на правилния режим

Правилото за вземане на решение се свежда до два въпроса. Колко заявки има? И чака ли потребителят? При над сто заявки без изискване за незабавност, Batch API печели по цена: резултати след часове на половината цена. Ако някой чака пред екрана си, синхронните извиквания остават единственият приемлив избор по стандартната тарифа. Режимът във фонов режим запълва останалото пространство: малко заявки, резултати след минути, стандартна цена. Изплаща се да кодифицирате тази логика веднъж, вместо да я преразглеждате за всяка нова услуга.

def choose_mode(
    num_requests: int,
    urgency: str,
    budget: str,
) -> str:
    """Препоръчва оптималния режим на изпълнение."""
    if num_requests > 100 and urgency != "immediate":
        return "batch"
    elif urgency == "immediate":
        return "synchronous"
    else:
        return "background"

Накрая, планирайте изход в случай на авария (escape hatch). Заявка във фонов режим, която значително надвишава очакваната си продължителност, ангажира бюджета и забавя останалата част от Вашия конвейер; API Ви позволява да я отмените изрично. Задайте този лимит на двойната продължителност, която наблюдавате на практика, а не на средната стойност, в противен случай рискувате да отмените заявки, които са били на път да успеят.

def cancel_if_too_long(response_id: str, timeout: int = 120):
    """Отменя заявка, ако надвиши таймаута."""
    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)

    # Таймаутът е надвишен — отмяна
    client.responses.cancel(response_id)
    raise TimeoutError(
        f"Request {response_id} cancelled after {timeout}s."
    )

Ключови изводи

  • Режимът във фонов режим стартира заявки, без да поддържа отворена връзка
  • Идеален за настройки с високо разсъждение (GPT-5.6 Sol) и дълги задачи
  • Комбинирайте с уебхук за архитектура, базирана на събития
  • Запазете идентификатора на отговора: това е единствената Ви връзка с работата в процес
  • За масова обработка на ниска цена, предпочитайте Batch API