Tiempo de espera y robustez en producción
En esta página
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 HTTP | Causa | Acción |
|---|---|---|
| 401 | Clave de API no válida | Verifica la clave |
| 429 | Límite de tasa alcanzado | Reintenta con retroceso exponencial |
| 500 | Error del servidor de xAI | Reintenta tras unos segundos |
| 503 | Servicio no disponible | Reintenta tras 30 segundos |
| Timeout | Solicitud demasiado larga | Aumenta 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.