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

SDK de OpenAI con base_url de xAI

Lección 5 de 12 Actualizado el 3 de noviembre de 2026 Desarrollador
En esta página
  1. Uso del SDK de OpenAI para acceder a Grok
  2. Configuración
  3. Llamadas idénticas a las de OpenAI
  4. Streaming con el SDK de OpenAI
  5. JavaScript / TypeScript
  6. Cambio entre proveedores
  7. Qué no se transfiere entre proveedores
  8. Puntos clave

Actualizado el 3 de noviembre de 2026. Según la referencia de Chat Completions de xAI, la compatibilidad con el SDK de OpenAI no es del «100 %»: varios parámetros no son compatibles con los modelos de razonamiento, son ignorados por los modelos recientes o no son soportados por ningún modelo. Fuente: xAI, Chat Completions.

Uso del SDK de OpenAI para acceder a Grok

Una de las principales ventajas del extremo (endpoint) de Chat Completions de xAI es su compatibilidad con el SDK de OpenAI. Puedes utilizar el paquete openai que ya conoces, cambiando simplemente el base_url para que apunte a los servidores de xAI.

Este enfoque es ideal si estás migrando una aplicación existente desde OpenAI hacia Grok, o si deseas cambiar entre proveedores con modificaciones mínimas.

Configuración

La instalación es la misma que para cualquier proyecto que utilice el SDK de OpenAI:

pip install openai

La única diferencia reside en la creación del cliente, donde especificas la URL base y la clave de API de xAI:

from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("XAI_API_KEY"),
    base_url="https://api.x.ai/v1"
)

Los dos parámetros esenciales son:

  • api_key: Tu clave de API de xAI (no una clave de OpenAI)
  • base_url: https://api.x.ai/v1; esto redirige las solicitudes a xAI en lugar de a OpenAI

Llamadas idénticas a las de OpenAI

Una vez configurado el cliente, el uso es el mismo que con el SDK estándar de OpenAI, salvo por los parámetros que xAI no admite, detallados más abajo:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("XAI_API_KEY"),
    base_url="https://api.x.ai/v1"
)

response = client.chat.completions.create(
    model="grok-4.20-0309-reasoning",
    messages=[
        {"role": "system", "content": "Eres un asistente técnico."},
        {"role": "user", "content": "¿Cuál es la diferencia entre TCP y UDP?"}
    ],
    temperature=0.7,
    max_tokens=1000
)

print(response.choices[0].message.content)

La única diferencia visible es el nombre del modelo: grok-4.20-0309-reasoning en lugar de gpt-5.6, por ejemplo.

Streaming con el SDK de OpenAI

El streaming funciona exactamente igual:

stream = client.chat.completions.create(
    model="grok-4.20-0309-reasoning",
    messages=[
        {"role": "user", "content": "Explica el concepto de microservicios."}
    ],
    stream=True
)

for chunk in stream:
    content = chunk.choices[0].delta.content
    if content:
        print(content, end="", flush=True)

JavaScript / TypeScript

El SDK de OpenAI para Node.js funciona de la misma manera:

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.XAI_API_KEY,
  baseURL: "https://api.x.ai/v1",
});

const response = await client.chat.completions.create({
  model: "grok-4.20-0309-reasoning",
  messages: [
    { role: "system", content: "Eres un asistente útil." },
    { role: "user", content: "Hola, ¿cómo estás?" },
  ],
});

console.log(response.choices[0].message.content);

Ten en cuenta que la propiedad es baseURL (con U mayúscula) en JavaScript, mientras que en Python es base_url.

Cambio entre proveedores

La principal ventaja de este enfoque es la capacidad de cambiar de proveedor modificando una única variable:

import os
from openai import OpenAI

provider = os.getenv("LLM_PROVIDER", "xai")

configs = {
    "xai": {
        "api_key": os.getenv("XAI_API_KEY"),
        "base_url": "https://api.x.ai/v1",
        "model": "grok-4.20-0309-reasoning"
    },
    "openai": {
        "api_key": os.getenv("OPENAI_API_KEY"),
        "base_url": "https://api.openai.com/v1",
        "model": "gpt-5.6"
    }
}

config = configs[provider]
client = OpenAI(api_key=config["api_key"], base_url=config["base_url"])

Esta arquitectura multiproveedor es habitual en aplicaciones de producción que desean mantener flexibilidad.

Qué no se transfiere entre proveedores

Compatible no significa idéntico. La referencia del extremo de xAI señala varios parámetros que los modelos de razonamiento no admiten: frequency_penalty, presence_penalty (al igual que grok-3) y stop. logprobs y top_logprobs son ignorados sin generar error por grok-4.20 y modelos posteriores, y logit_bias no es compatible. El código que establece estos parámetros para OpenAI deberá eliminarlos para Grok. Los campos ignorados silenciosamente son los más complicados, ya que nada indica que no tengan efecto. Las herramientas alojadas también difieren entre proveedores: la búsqueda web de OpenAI no es la de xAI. Por último, xAI clasifica ahora Chat Completions como un extremo heredado (legacy) y recomienda la API de Responses (lecciones 11 y 12).

Puntos clave

  • El SDK de OpenAI funciona con xAI cambiando simplemente base_url a https://api.x.ai/v1
  • Los métodos y los formatos de respuesta son los mismos, pero algunos parámetros no son compatibles (frequency_penalty, presence_penalty, stop en modelos de razonamiento, logit_bias) o son ignorados (logprobs desde grok-4.20 en adelante)
  • Adapta la clave de API, el nombre del modelo y los parámetros no compatibles
  • Este enfoque simplifica la migración desde OpenAI y permite cambiar entre proveedores
  • El streaming y las tipificaciones del SDK de OpenAI funcionan; las herramientas alojadas son específicas de cada proveedor