Tempo limite e robustez em produção
Nesta página
Prepare a sua aplicação para o mundo real
Em produção, os pedidos à API de Respostas podem demorar — especialmente com modelos de raciocínio que pensam extensivamente antes de responder. Uma gestão inadequada do tempo limite pode causar falhas silenciosas ou degradar a experiência do utilizador.
O tempo limite de 3600 segundos
A xAI recomenda um tempo limite mínimo de 3600 segundos (1 hora) para pedidos dirigidos a modelos de raciocínio. Este valor é significativamente superior ao das APIs padrão, o que impacta a sua arquitetura.
Porquê tão longo?
Os modelos de raciocínio Grok-4.5 podem consumir centenas de milhares de tokens internos de raciocínio antes de produzirem uma resposta. Em problemas complexos (matemática avançada, análise de código, raciocínio em várias etapas), o modelo pode pensar durante vários minutos.
Configuração no lado do cliente
import httpx
from openai import OpenAI
# OpenAI SDK com tempo limite estendido
client = OpenAI(
api_key="xai-...",
base_url="https://api.x.ai/v1",
timeout=httpx.Timeout(3600.0, connect=10.0)
)
Em curl:
curl --max-time 3600 https://api.x.ai/v1/responses \
-H "Authorization: Bearer $XAI_API_KEY" \
-H "Content-Type: application/json" \
-d '{...}'
Gestão de erros
Erros comuns
| Código HTTP | Causa | Ação |
|---|---|---|
| 401 | Chave de API inválida | Verifique a chave |
| 429 | Limite de taxa atingido | Tente novamente com espera exponencial |
| 500 | Erro no servidor da xAI | Tente novamente após alguns segundos |
| 503 | Serviço indisponível | Tente novamente após 30 segundos |
| Tempo limite | Pedido demasiado longo | Aumente o tempo limite ou simplifique o prompt |
Padrão de nova tentativa com espera exponencial
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 # 1s, 2s, 4s
print(f"Error: {e}. Retrying in {wait}s...")
time.sleep(wait)
Limitação de taxa
A xAI impõe limites de taxa com base no seu plano. Implemente um limitador de taxa no lado do 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()
# Remove timestamps older than one minute
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())
Arquitetura assíncrona
Para aplicações web, não bloqueie o thread principal durante 3600 segundos. Utilize uma arquitetura assí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
O streaming é a melhor abordagem para aplicações interativas: os utilizadores veem os primeiros tokens em segundos, mesmo que a geração completa demore mais tempo.
Disjuntor (Circuit Breaker)
Para proteger a sua aplicação de indisponibilidades da API da 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
Pontos-chave
- Configure um tempo limite mínimo de 3600 segundos para modelos de raciocínio
- Implemente novas tentativas com espera exponencial para erros 429 e 500
- Utilize streaming para aplicações interativas — os utilizadores veem os tokens imediatamente
- Gerencie a limitação de taxa no lado do cliente para evitar erros 429
- Considere implementar um disjuntor para proteger a sua aplicação de indisponibilidades da API