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

Tiempo de espera y robustez en producción

Lección 15 de 16 Actualizado el 30 de julio de 2026 Desarrollador
En esta página
  1. Prepara tu aplicación para el mundo real
  2. El tiempo de espera de 3600 segundos
  3. Gestión de errores
  4. Arquitectura asíncrona
  5. Interruptor de circuito (Circuit Breaker)
  6. Puntos clave

Prepara tu aplicación para el mundo real

En producción, las solicitudes a la API de Responses pueden tardar cierto tiempo, especialmente con modelos de razonamiento que «piensan» extensamente antes de responder. Una gestión deficiente del tiempo de espera puede provocar fallos silenciosos o degradar la experiencia del usuario.

El tiempo de espera de 3600 segundos

xAI recomienda un tiempo de espera mínimo de 3600 segundos (1 hora) para las solicitudes dirigidas a modelos de razonamiento. Esto es significativamente más largo que en las API estándar, lo cual impacta directamente en tu arquitectura.

¿Por qué tanto tiempo?

Los modelos de razonamiento Grok-4.5 pueden consumir cientos de miles de tokens de razonamiento internos antes de generar una respuesta. En problemas complejos (matemáticas avanzadas, análisis de código, razonamiento en múltiples pasos), el modelo puede estar «pensando» durante varios minutos.

Configuración del lado del cliente

import httpx
from openai import OpenAI

# SDK de OpenAI con tiempo de espera extendido
client = OpenAI(
    api_key="xai-...",
    base_url="https://api.x.ai/v1",
    timeout=httpx.Timeout(3600.0, connect=10.0)
)

En curl:

curl --max-time 3600 https://api.x.ai/v1/responses \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{...}'

Gestión de errores

Errores comunes

Código HTTPCausaAcción
401Clave de API no válidaVerifica la clave
429Límite de tasa alcanzadoReintenta con retroceso exponencial
500Error del servidor de xAIReintenta tras unos segundos
503Servicio no disponibleReintenta tras 30 segundos
TimeoutSolicitud demasiado largaAumenta el tiempo de espera o simplifica el prompt

Patrón de reintento con retroceso

import time

def call_with_retry(client, max_retries=3, **kwargs):
    for attempt in range(max_retries):
        try:
            return client.responses.create(**kwargs)
        except Exception as e:
            if attempt == max_retries - 1:
                raise
            wait = 2 ** attempt  # 1 s, 2 s, 4 s
            print(f"Error: {e}. Reintentando en {wait} s...")
            time.sleep(wait)

Limitación de tasa (Rate Limiting)

xAI aplica límites de tasa según tu plan. Implementa un limitador de tasa del lado del cliente:

import time
from collections import deque

class RateLimiter:
    def __init__(self, max_requests_per_minute=60):
        self.max_rpm = max_requests_per_minute
        self.timestamps = deque()

    def wait_if_needed(self):
        now = time.time()
        # Elimina marcas de tiempo anteriores a un minuto
        while self.timestamps and self.timestamps[0] < now - 60:
            self.timestamps.popleft()
        if len(self.timestamps) >= self.max_rpm:
            sleep_time = 60 - (now - self.timestamps[0])
            time.sleep(max(0, sleep_time))
        self.timestamps.append(time.time())

Arquitectura asíncrona

Para aplicaciones web, no bloquees el hilo principal durante 3600 segundos. Utiliza una arquitectura asíncrona:

import asyncio
from openai import AsyncOpenAI

client = AsyncOpenAI(
    api_key="xai-...",
    base_url="https://api.x.ai/v1"
)

async def process_request(user_input):
    response = await client.responses.create(
        model="grok-4.20-0309-reasoning",
        input=user_input,
        stream=True
    )
    async for event in response:
        if event.type == "response.output_text.delta":
            yield event.delta

El streaming es el mejor enfoque para aplicaciones interactivas: los usuarios ven los primeros tokens en segundos, incluso si la generación completa tarda más.

Interruptor de circuito (Circuit Breaker)

Para proteger tu aplicación de interrupciones en la API de xAI:

class CircuitBreaker:
    def __init__(self, failure_threshold=5, reset_timeout=60):
        self.failures = 0
        self.threshold = failure_threshold
        self.reset_timeout = reset_timeout
        self.last_failure = 0
        self.is_open = False

    def call(self, func, *args, **kwargs):
        if self.is_open:
            if time.time() - self.last_failure > self.reset_timeout:
                self.is_open = False
                self.failures = 0
            else:
                raise Exception("Circuit open — API unavailable")

        try:
            result = func(*args, **kwargs)
            self.failures = 0
            return result
        except Exception as e:
            self.failures += 1
            self.last_failure = time.time()
            if self.failures >= self.threshold:
                self.is_open = True
            raise

Puntos clave

  • Configura un tiempo de espera mínimo de 3600 segundos para los modelos de razonamiento.
  • Implementa reintentos con retroceso exponencial para los errores 429 y 500.
  • Usa streaming para aplicaciones interactivas: los usuarios ven los tokens de inmediato.
  • Gestiona la limitación de tasa del lado del cliente para evitar errores 429.
  • Considera un interruptor de circuito para proteger tu aplicación de caídas de la API.