Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Tempo limite e robustez em produção

Aula 15 de 16 Atualizada a 30 de julho de 2026 Programador
Nesta página
  1. Prepare a sua aplicação para o mundo real
  2. O tempo limite de 3600 segundos
  3. Gestão de erros
  4. Arquitetura assíncrona
  5. Disjuntor (Circuit Breaker)
  6. Pontos-chave

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 HTTPCausaAção
401Chave de API inválidaVerifique a chave
429Limite de taxa atingidoTente novamente com espera exponencial
500Erro no servidor da xAITente novamente após alguns segundos
503Serviço indisponívelTente novamente após 30 segundos
Tempo limitePedido demasiado longoAumente 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