Retroceso exponencial ante HTTP 429
En esta página
Comprensión del error 429
Un error HTTP 429 indica que has superado los límites de tasa (rate limits) de la API. El servidor de xAI rechaza temporalmente tus solicitudes para proteger la infraestructura. Este error es normal en un contexto de procesamiento por lotes: simplemente señala que estás enviando peticiones con demasiada rapidez.
La reacción adecuada no es abandonar, sino esperar antes de reintentar. El retroceso exponencial es la estrategia estándar para gestionar esta situación.
Funcionamiento del retroceso exponencial
En lugar de reintentar de inmediato (lo que provocaría otro 429), esperas un tiempo de espera creciente entre cada intento:
- 1.º fallo: esperar 1 segundo
- 2.º fallo: esperar 2 segundos
- 3.º fallo: esperar 4 segundos
- 4.º fallo: esperar 8 segundos
- 5.º fallo: abandonar
El retraso se duplica en cada intento, de ahí el término «exponencial». Esto otorga al servidor tiempo para recuperar capacidad.
Implementación manual
import asyncio
import random
from openai import RateLimitError
async def request_with_backoff(
prompt: str,
max_retries: int = 5,
base_delay: float = 1.0
) -> str:
for attempt in range(max_retries):
try:
response = await client.chat.completions.create(
model="grok-4.5",
messages=[{"role": "user", "content": prompt}]
)
return response.choices[0].message.content
except RateLimitError:
if attempt == max_retries - 1:
raise # último intento, propagar el error
delay = base_delay * (2 ** attempt)
jitter = random.uniform(0, delay * 0.1)
wait_time = delay + jitter
print(f"Límite de tasa alcanzado, intento {attempt + 1}/{max_retries}. "
f"Esperando {wait_time:.1f}s")
await asyncio.sleep(wait_time)
El jitter (variación aleatoria) es crucial. Si varias corrutinas reciben un 429 al mismo tiempo, sin jitter todas reintentarían exactamente en el mismo instante, provocando otro 429. El jitter desincroniza los intentos.
Uso de la biblioteca tenacity
Para entornos de producción, la biblioteca tenacity simplifica la implementación:
from tenacity import (
retry,
stop_after_attempt,
wait_exponential,
retry_if_exception_type
)
from openai import RateLimitError
@retry(
stop=stop_after_attempt(5),
wait=wait_exponential(multiplier=1, min=1, max=60),
retry=retry_if_exception_type(RateLimitError)
)
async def robust_request(prompt: str) -> str:
response = await client.chat.completions.create(
model="grok-4.5",
messages=[{"role": "user", "content": prompt}]
)
return response.choices[0].message.content
El decorador @retry intercepta RateLimitError, espera un retraso exponencial (entre 1 y 60 segundos) y reintenta hasta 5 veces. El código de la función permanece limpio y legible.
Combinación de retroceso y semáforo
En la práctica, combinas el retroceso con un semáforo para un control total:
async def resilient_batch(prompts: list[str], max_concurrent: int = 5) -> list[str]:
sem = Semaphore(max_concurrent)
async def single_request(prompt: str) -> str:
async with sem:
return await request_with_backoff(prompt)
tasks = [single_request(p) for p in prompts]
return await asyncio.gather(*tasks, return_exceptions=True)
El semáforo evita sobrecargar la API, mientras que el retroceso gestiona los errores 429 residuales. Esta doble protección es la configuración recomendada para producción.
Adaptación del retroceso al tipo de error
No todos los errores justifican un reintento. Aquí tienes una clasificación:
from openai import RateLimitError, APITimeoutError, APIConnectionError, BadRequestError
async def smart_retry(prompt: str, max_retries: int = 5) -> str:
for attempt in range(max_retries):
try:
return await client.chat.completions.create(
model="grok-4.5",
messages=[{"role": "user", "content": prompt}]
)
except RateLimitError:
delay = 2 ** attempt
await asyncio.sleep(delay)
except (APITimeoutError, APIConnectionError):
delay = 2 ** attempt
await asyncio.sleep(delay)
except BadRequestError:
raise # error en el prompt, el reintento es inútil
Los errores 429 (límite de tasa), los tiempos de espera agotados y los errores de conexión merecen un reintento. Sin embargo, un BadRequestError (prompt no válido) no se resolverá reintentando.
Puntos clave
- Un error 429 es normal y esperado durante el procesamiento por lotes
- El retroceso exponencial duplica el retraso entre cada intento (1 s, 2 s, 4 s, 8 s…)
- El jitter desincroniza los nuevos intentos para evitar colisiones
- La biblioteca
tenacitysimplifica la implementación en producción - Combina siempre semáforo y retroceso para lograr la máxima resiliencia
- No reintentes errores de solicitud no válida (
BadRequestError)