Ir al contenido principal
Español— Elegir un idioma
Menú

Modo en segundo plano

Lección 9 de 20 Actualizado el 28 de julio de 2026 Avanzado
En esta página
  1. Una tercera vía entre síncrono y por lotes
  2. Lanzamiento y recuperación
  3. Tareas de razonamiento prolongado
  4. Elegir el modo adecuado
  5. Puntos clave

Una tercera vía entre síncrono y por lotes

El modo en segundo plano de la API Responses ocupa un nicho específico en tu caja de herramientas. Una llamada síncrona te da la respuesta de inmediato, pero te obliga a mantener la conexión abierta durante toda la generación. La API Batch procesa miles de solicitudes a la mitad de precio, pero los resultados tardan horas. El modo en segundo plano se sitúa entre ambos: gestiona solicitudes individuales a la tarifa estándar sin necesidad de una conexión abierta. Envías la solicitud, recibes un ID y recuperas el resultado cuando está listo.

Este compromiso apunta a un caso de uso preciso: una única solicitud que tarda demasiado para una llamada bloqueante, pero que no puede esperar hasta mañana. Este es exactamente el escenario al ejecutar un modelo de alto razonamiento sobre un documento complejo.

Lanzamiento y recuperación

La activación requiere solo un parámetro. La respuesta inmediata no contiene texto; devuelve un ID y un estado, típicamente queued o in_progress.

import openai

client = openai.OpenAI()

# Lanzar la solicitud en segundo plano
response = client.responses.create(
    model="gpt-5.6-sol",  # Ideal para tareas lentas (alto razonamiento)
    input="Analiza las implicaciones económicas de la regulación europea de IA "
          "para las pymes francesas. Propón un plan de acción de 10 puntos.",
    background=True,  # Modo en segundo plano
)

print(f"ID de respuesta: {response.id}")
print(f"Estado: {response.status}")  # "queued" o "in_progress"

Este ID es tu único vínculo con el trabajo en curso: persistelo antes de hacer cualquier otra cosa. Perderlo significa pagar por una generación que nunca recuperarás. La recuperación implica sondear la API hasta que el estado sea terminal, gestionando el fallo y la cancelación por separado, ya que tienen consecuencias comerciales distintas.

import time

def wait_for_response(response_id: str, interval: int = 5) -> str:
    """Espera a que se complete una respuesta en segundo plano."""
    while True:
        response = client.responses.retrieve(response_id)

        match response.status:
            case "completed":
                return response.output_text
            case "failed":
                raise RuntimeError(
                    f"Solicitud fallida: {response.error}"
                )
            case "cancelled":
                raise RuntimeError("La solicitud fue cancelada.")
            case _:
                print(f"Estado: {response.status}...")
                time.sleep(interval)

Tareas de razonamiento prolongado

Un modelo como GPT-5.6 Sol con alto razonamiento activado puede tardar entre 30 segundos y dos minutos antes de producir su primer token visible. En una llamada síncrona, estas duraciones alcanzan los tiempos de espera predeterminados de clientes HTTP, proxies y pasarelas. El modo en segundo plano elimina este problema de raíz y, de paso, te permite lanzar varios análisis pesados sin ocupar tantas conexiones.

async def deep_analysis(document: str) -> str:
    """Lanza un análisis con GPT-5.6 Sol sin bloquear."""
    response = client.responses.create(
        model="gpt-5.6-sol",
        input=f"Realiza un análisis jurídico exhaustivo de este contrato. "
              f"Identifica todos los riesgos potenciales, cláusulas problemáticas "
              f"y propone modificaciones.\n\n{document}",
        background=True,
    )
    return response.id

# Lanzar múltiples análisis en paralelo
task_ids = []
for doc in documents:
    task_id = await deep_analysis(doc)
    task_ids.append(task_id)

# Recuperar resultados más tarde
results = {}
for task_id in task_ids:
    results[task_id] = wait_for_response(task_id)

Este patrón se extiende naturalmente a los webhooks cuando el llamador es otro servicio. Tu punto de acceso lanza la solicitud, devuelve el ID y delega una tarea en segundo plano para monitorizar la finalización y enviar notificaciones. El llamador no sondea; recibe una notificación.

from fastapi import FastAPI, BackgroundTasks
import httpx

app = FastAPI()

@app.post("/api/long-analysis")
async def launch_analysis(request: dict, background_tasks: BackgroundTasks):
    """Lanza un análisis y notifica mediante webhook al finalizar."""
    response = client.responses.create(
        model="gpt-5.6-sol",
        input=request["prompt"],
        background=True,
    )

    # Monitorizar en segundo plano
    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):
    """Monitoriza una solicitud en segundo plano y notifica mediante 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,
        })

Elegir el modo adecuado

La regla de decisión se reduce a dos preguntas. ¿Cuántas solicitudes? ¿Y está el usuario esperando? Más allá de cien solicitudes sin requisito de inmediatez, la API Batch gana en precio: resultados en horas a la mitad de coste. Si alguien está esperando frente a su pantalla, las llamadas síncronas siguen siendo la única opción aceptable a la tarifa estándar. El modo en segundo plano cubre el resto del espacio: pocas solicitudes, resultados en minutos, precio estándar. Merece la pena codificar esta lógica una vez en lugar de replantearla para cada nuevo servicio.

def choose_mode(
    num_requests: int,
    urgency: str,
    budget: str,
) -> str:
    """Recomienda el modo de ejecución óptimo."""
    if num_requests > 100 and urgency != "immediate":
        return "batch"
    elif urgency == "immediate":
        return "synchronous"
    else:
        return "background"

Por último, planifica una vía de escape. Una solicitud en segundo plano que excede con mucho su duración esperada bloquea presupuesto y retrasa el resto de tu canalización; la API te permite cancelarla explícitamente. Establece este límite en el doble de la duración que observes en la práctica, no en la media, o te arriesgarás a cancelar solicitudes que estaban a punto de tener éxito.

def cancel_if_too_long(response_id: str, timeout: int = 120):
    """Cancela una solicitud si supera el tiempo de espera."""
    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)

    # Tiempo de espera excedido — cancelar
    client.responses.cancel(response_id)
    raise TimeoutError(
        f"Solicitud {response_id} cancelada tras {timeout}s."
    )

Puntos clave

  • El modo en segundo plano lanza solicitudes sin mantener una conexión abierta
  • Ideal para configuraciones de alto razonamiento (GPT-5.6 Sol) y tareas largas
  • Combínalo con un webhook para una arquitectura dirigida por eventos
  • Persiste el ID de respuesta: es tu único vínculo con el trabajo en curso
  • Para procesamiento masivo de bajo coste, prefiere la API Batch