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

Caché de x-grok-conv-id y tiempo de espera para razonamiento

Lección 11 de 12 Actualizado el 30 de julio de 2026 Avanzado
En esta página
  1. Optimización de costes mediante caché
  2. La cabecera x-grok-conv-id
  3. Tiempo de espera de 3600 segundos para razonamiento
  4. Nota sobre grok-4.5 y el razonamiento
  5. Comprobación del impacto del caché
  6. Puntos clave

Optimización de costes mediante caché

Cada solicitud enviada a la API de xAI se factura al precio estándar por token. Sin embargo, cuando envías varias solicitudes relacionadas (misma conversación, mismo tema), parte del contexto se repite. La cabecera x-grok-conv-id permite a xAI identificar estas solicitudes relacionadas y aumentar la tasa de aciertos de caché, lo que reduce tus costes.

La cabecera x-grok-conv-id

Para activar el caché conversacional, añade una cabecera personalizada con un UUID v4 único por conversación:

import uuid

conversation_id = str(uuid.uuid4())

# Con el SDK de OpenAI
response = await client.chat.completions.create(
    model="grok-4.5",
    messages=[{"role": "user", "content": prompt}],
    extra_headers={
        "x-grok-conv-id": conversation_id
    }
)

Todas las solicitudes que compartan el mismo x-grok-conv-id se benefician de una mayor tasa de aciertos de caché. Los tokens en caché se facturan a una tarifa reducida en comparación con los tokens estándar.

Reglas de uso

  • Genera un nuevo UUID para cada conversación o sesión lógica.
  • Reutiliza el mismo UUID para todas las solicitudes dentro de la misma conversación.
  • No reutilices un UUID en conversaciones diferentes (esto degrada el rendimiento del caché).
# Patrón para un chatbot
class ConversationManager:
    def __init__(self):
        self.conv_id = str(uuid.uuid4())
        self.messages = []

    async def send(self, user_message: str) -> str:
        self.messages.append({"role": "user", "content": user_message})

        response = await client.chat.completions.create(
            model="grok-4.5",
            messages=self.messages,
            extra_headers={"x-grok-conv-id": self.conv_id}
        )

        assistant_message = response.choices[0].message.content
        self.messages.append({"role": "assistant", "content": assistant_message})
        return assistant_message

Tiempo de espera de 3600 segundos para razonamiento

Los modelos de razonamiento (grok-4.20-0309-reasoning y similares) realizan un proceso de razonamiento interno antes de responder. Este razonamiento puede durar varios minutos en problemas complejos. El tiempo de espera predeterminado de la mayoría de clientes HTTP (30-120 segundos) es insuficiente.

# Configuración correcta para razonamiento
from openai import AsyncOpenAI
import httpx

client = AsyncOpenAI(
    api_key=os.getenv("XAI_API_KEY"),
    base_url="https://api.x.ai/v1",
    timeout=httpx.Timeout(
        connect=10.0,     # conexión rápida
        read=3600.0,      # 1 hora para lectura
        write=30.0,       # envío del prompt
        pool=10.0         # espera de conexión
    )
)

El valor read=3600.0 es crítico. Este es el retraso máximo permitido entre el momento en que el servidor comienza a procesar tu solicitud y el momento en que recibes la respuesta. Para un modelo de razonamiento que piensa durante 5 minutos, necesitas este margen.

Cuándo reducir el tiempo de espera

El tiempo de espera de 3600 segundos no siempre es necesario:

  • grok-4.5 (no razonamiento): un tiempo de espera de 120-300 segundos suele ser suficiente.
  • Solicitudes simples: incluso con un modelo de razonamiento, las preguntas cortas responden en menos de un minuto.
  • Entorno de pruebas: un tiempo de espera de 60 segundos permite detectar problemas rápidamente.
# Cliente para solicitudes rápidas
fast_client = AsyncOpenAI(
    api_key=os.getenv("XAI_API_KEY"),
    base_url="https://api.x.ai/v1",
    timeout=httpx.Timeout(120.0)
)

# Cliente para razonamiento complejo
reasoning_client = AsyncOpenAI(
    api_key=os.getenv("XAI_API_KEY"),
    base_url="https://api.x.ai/v1",
    timeout=httpx.Timeout(3600.0)
)

Utilizar dos clientes con diferentes tiempos de espera es un patrón habitual en producción.

Nota sobre grok-4.5 y el razonamiento

El modelo grok-4.5 no devuelve el campo reasoning_content en texto plano en la respuesta. El razonamiento interno se realiza, pero permanece opaco. Si necesitas conservar el proceso de razonamiento entre solicitudes sin poder leerlo, utiliza use_encrypted_content=True, o bien emplea grok-4.20-0309-reasoning, que expone más detalles de su proceso.

Comprobación del impacto del caché

Para medir la eficiencia del caché, compara el campo usage entre solicitudes con y sin x-grok-conv-id:

response = await client.chat.completions.create(
    model="grok-4.5",
    messages=messages,
    extra_headers={"x-grok-conv-id": conv_id}
)

usage = response.usage
if hasattr(usage, 'prompt_tokens_details'):
    cached = usage.prompt_tokens_details.cached_tokens
    total = usage.prompt_tokens
    print(f"Acierto de caché: {cached}/{total} tokens ({cached/total*100:.0f}%)")

Una alta tasa de aciertos de caché significa que tus tokens de contexto se reutilizan en lugar de reprocesarse, lo que reduce directamente tu factura.

Puntos clave

  • x-grok-conv-id con un UUID v4 activa el caché conversacional para solicitudes relacionadas.
  • Los tokens en caché se facturan a una tarifa reducida.
  • Un tiempo de espera de 3600 segundos es necesario para los modelos de razonamiento.
  • Utiliza clientes separados para solicitudes rápidas y solicitudes de razonamiento.
  • grok-4.5 no devuelve reasoning_content en texto plano.
  • Supervisa la tasa de aciertos de caché en usage.prompt_tokens_details para validar la optimización.