BroadRouter
Comenzar

Migrar desde la API de OpenAI: el código en Python, Node y cURL

Por el equipo de BroadNet Inference · 6 min de lectura · Publicado

Cambie la URL base del cliente, la clave de API y el ID del modelo. Eso basta para las llamadas a Chat Completions. El código sobre la Responses API debe reescribirse a Chat Completions: input pasa a messages, output_text a choices[0].message.content y las herramientas pierden un nivel de anidación. Deje los embeddings en otro cliente si el nuevo proveedor no los ofrece y haga una prueba rápida antes de mover el tráfico.

Pasar una aplicación de OpenAI a un proveedor compatible con OpenAI es un cambio pequeño de código si usa Chat Completions, y una reescritura si usa la Responses API. Este artículo muestra los cambios exactos en Python, Node y cURL, qué hacer con Responses, las herramientas, la salida estructurada y los embeddings, y una prueba rápida que conviene ejecutar antes de mover cualquier tráfico. Los ejemplos usan BroadNet Inference en https://inference.broadnet.ai/v1; los mismos pasos sirven para cualquier proveedor.

Este es el complemento de código de la lista de verificación para migrar, que cubre límites de frecuencia, errores y la planificación del cambio. Para las URL base de otros proveedores, consulte URL base compatibles con OpenAI, verificadas.

¿Qué cambia en la configuración del cliente?

Tres valores: la URL base, la clave de API y el ID del modelo.

Python

import os
from openai import OpenAI

# before: client = OpenAI()  # reads OPENAI_API_KEY, calls api.openai.com
client = OpenAI(
    base_url="https://inference.broadnet.ai/v1",
    api_key=os.environ["BROADNET_API_KEY"],
)
r = client.chat.completions.create(
    model="broadnet/gemma-4-26b-a4b",          # was e.g. "gpt-..."
    messages=[{"role": "user", "content": "Reply with one short sentence."}],
)
print(r.choices[0].message.content)

Node

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://inference.broadnet.ai/v1",
  apiKey: process.env.BROADNET_API_KEY,
});
const r = await client.chat.completions.create({
  model: "broadnet/gemma-4-26b-a4b",
  messages: [{ role: "user", content: "Reply with one short sentence." }],
});
console.log(r.choices[0].message.content);

cURL

curl https://inference.broadnet.ai/v1/chat/completions \
  -H "Authorization: Bearer $BROADNET_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"broadnet/gemma-4-26b-a4b","messages":[{"role":"user","content":"Reply with one short sentence."}]}'

Fíjese en la ruta: la URL base ya termina en /v1, y el SDK añade /chat/completions. Duplicar /v1 es el primer error más habitual.

¿Puedo cambiar sin tocar el código?

Sí, en el código de Chat Completions. El SDK de Python lee OPENAI_BASE_URL cuando no se pasa base_url, y el cliente de Node toma por defecto baseURL de process.env['OPENAI_BASE_URL']. Ambos leen OPENAI_API_KEY. Configurar dos variables de entorno mueve todas las llamadas.

Ese es también el riesgo. Se mueven todas las llamadas, incluidos los embeddings, la moderación, la subida de archivos y cualquier otra cosa que el nuevo proveedor quizá no tenga. Use el cambio por entorno solo cuando su aplicación haga llamadas de chat y nada más.

¿Y si mi código usa la Responses API?

Los README de los SDK de OpenAI llaman ahora a la Responses API la API principal; el README de Python llama a Chat Completions “the previous standard (supported indefinitely)” (Traducción: «el estándar anterior (con soporte indefinido)»). Muchos proveedores compatibles solo implementan Chat Completions. BroadNet documenta POST /v1/chat/completions y POST /v1/audio/transcriptions, así que las llamadas a Responses deben reescribirse. La correspondencia:

Responses API Chat Completions
client.responses.create(...) client.chat.completions.create(...)
instructions="..." Primer mensaje {"role": "system", "content": "..."}
input="..." o una lista de elementos messages=[...]
response.output_text response.choices[0].message.content
max_output_tokens max_tokens (documentación de BroadNet) o max_completion_tokens
text={"format": {...}} response_format={...}
previous_response_id, conversaciones Reenvíe usted mismo el historial completo de mensajes
Herramienta {"type": "function", "name": ...} Herramienta {"type": "function", "function": {"name": ...}}
Elemento de salida function_call, respuesta con function_call_output y call_id message.tool_calls, respuesta con rol tool y tool_call_id
Herramientas integradas (búsqueda web, búsqueda en archivos) No disponibles; ejecute su propia herramienta

El antes y el después de una llamada sencilla:

# Before: Responses API
r = client.responses.create(model="gpt-...", instructions="Be brief.", input="What is RAG?")
text = r.output_text

# After: Chat Completions
r = client.chat.completions.create(
    model="broadnet/gemma-4-26b-a4b",
    messages=[{"role": "system", "content": "Be brief."},
              {"role": "user", "content": "What is RAG?"}],
)
text = r.choices[0].message.content

El mayor cambio estructural es el estado. Responses puede guardar el estado de la conversación del lado de OpenAI con previous_response_id. Chat Completions no tiene estado en el servidor, así que su código guarda la lista de mensajes y la envía completa en cada turno. Téngalo en cuenta en el presupuesto: todo el historial son tokens de entrada en cada llamada.

¿Cómo cambian las llamadas a herramientas?

En Chat Completions, la definición de una herramienta anida la función bajo una clave function, y la respuesta vuelve como un mensaje tool:

import json

tools = [{
    "type": "function",
    "function": {
        "name": "get_order",
        "description": "Look up an order by ID.",
        "parameters": {"type": "object",
                       "properties": {"order_id": {"type": "string"}},
                       "required": ["order_id"]},
    },
}]
messages = [{"role": "user", "content": "Where is order A-1042?"}]
r = client.chat.completions.create(model="broadnet/glm-5.3", messages=messages, tools=tools)
msg = r.choices[0].message
if msg.tool_calls:
    messages.append(msg)                                   # keep the assistant turn
    for call in msg.tool_calls:
        args = json.loads(call.function.arguments)         # a JSON string: parse and validate it
        messages.append({"role": "tool", "tool_call_id": call.id,
                         "content": json.dumps(lookup_order(args["order_id"]))})
    r = client.chat.completions.create(model="broadnet/glm-5.3", messages=messages, tools=tools)

El modelo importa más que la forma. La documentación de BroadNet lista herramientas solo para GLM 5.3 y Qwen3.8 27B. No conecte un bucle de herramientas a un modelo cuya documentación no las liste, y valide los argumentos antes de ejecutar nada. Llamadas a herramientas con modelos abiertos incluye un bucle completo con validación.

¿Y la salida estructurada?

client.chat.completions.parse(..., response_format=MyPydanticModel) y zodResponseFormat en Node envían response_format con un JSON Schema. Solo funcionan si el proveedor acepta esa forma en ese modelo. BroadNet lista salida estructurada para GLM 5.3 y Qwen3.8 27B, pero no nombra el parámetro de la solicitud. Ejecute una vez por modelo la prueba de cuatro pasos de modo JSON o json_schema y siga validando el resultado analizado, prometa lo que prometa el proveedor.

¿Qué pasa con los embeddings?

Si cambia la URL base en un cliente compartido y el proveedor no tiene endpoint de embeddings, todas las llamadas a client.embeddings.create fallan. BroadNet no vende embeddings. Mantenga dos clientes:

chat = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])
embed = OpenAI(api_key=os.environ["OPENAI_API_KEY"])   # or any embeddings provider

vec = embed.embeddings.create(model="text-embedding-3-small", input=query).data[0].embedding
answer = chat.chat.completions.create(model="broadnet/glm-5.3", messages=build_prompt(query, search(vec)))

Nunca mezcle vectores de dos modelos de embeddings en un mismo índice. Si también cambia de proveedor de embeddings, vuelva a generar los embeddings de todo el corpus. La calculadora de costos de embeddings calcula cuánto cuesta.

Lo mismo se aplica a todo lo que no es chat: generación de imágenes, texto a voz, moderación, la Batch API y el almacenamiento de archivos. BroadNet no ofrece ninguno. La voz a texto sí se mueve: client.audio.transcriptions.create funciona contra /v1/audio/transcriptions con WAV o MP3 y un campo language (guía de voz a texto en árabe).

¿Cómo cambia el código de streaming?

La Responses API transmite eventos tipados, como response.output_text.delta y response.completed. Chat Completions transmite fragmentos, y el texto está en choices[0].delta.content. El uso no se envía salvo que lo pida, y entonces llega en un fragmento final con una lista choices vacía.

// Before (Responses): for await (const e of stream) if (e.type === "response.output_text.delta") out(e.delta);
const stream = await client.chat.completions.create({
  model: "broadnet/gemma-4-26b-a4b",
  messages: [{ role: "user", content: "Count from one to three." }],
  stream: true,
  stream_options: { include_usage: true },
});
for await (const chunk of stream) {
  const text = chunk.choices[0]?.delta?.content;
  if (text) process.stdout.write(text);
  if (chunk.usage) console.log("\ntokens:", chunk.usage.total_tokens);   // last chunk
}

Dos hábitos mantienen seguro el código de streaming tras el cambio. Proteja el acceso a choices[0], porque el fragmento de uso no tiene choices. Y trate como incompleto un stream que termina antes de la línea final data: [DONE]; la documentación de BroadNet indica registrar el X-Request-ID y decidir si es seguro enviar una solicitud nueva. Streaming de chat completions muestra el patrón completo en Python.

¿Cambian el manejo de errores y los reintentos?

Las clases de error del SDK siguen siendo las mismas: AuthenticationError para 401, RateLimitError para 429 y APIStatusError para el resto. Lo que cambia es el significado de cada estado en el nuevo proveedor. En BroadNet, un 401 puede significar una asignación de pago por uso agotada, no solo una clave incorrecta, y un 402 significa saldo insuficiente para una compra. Ninguno se resuelve con un reintento. Un 429 puede venir del límite de frecuencia, de concurrencia, de tasa de tokens o de gasto. Reintente los 429 y 5xx con backoff, y corrija todo lo demás. La guía de errores y reintentos tiene la tabla completa.

El SDK reintenta por defecto dos veces los errores de conexión, 408, 409, 429 y 5xx. Si añade su propio bucle de reintentos, configure max_retries=0 en el cliente para que no se sumen.

¿Qué parámetros se comportan de forma distinta?

Parámetro Qué comprobar
max_tokens / max_completion_tokens OpenAI marca max_tokens como obsoleto; la documentación de BroadNet lo usa. En los modelos de razonamiento incluye el razonamiento, así que valores pequeños devuelven respuestas vacías (por qué)
reasoning_effort BroadNet documenta low; pruebe otros valores antes de depender de ellos
stream_options: {"include_usage": true} Documentado por BroadNet; el uso llega en el último fragmento
n, logprobs, seed, logit_bias No figuran en la documentación de BroadNet; pruébelos o elimínelos
store, metadata Funcionalidades de almacenamiento de OpenAI; elimínelas
Partes de contenido image_url Solo en los modelos que listan imágenes: DeepSeek V4.1 Flash, Qwen3.8 27B, Gemma 4 VL 26B

¿Cómo se prueba el cambio?

Ejecute una prueba rápida y breve contra el nuevo proveedor antes de mover tráfico. Esta comprueba el chat simple, el uso en streaming, el presupuesto de razonamiento y la autenticación. Añada un caso de llamada a herramienta si usa herramientas.

import os, openai
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"], max_retries=0)
FAST, REASONING = "broadnet/gemma-4-26b-a4b", "broadnet/qwen3.8-27b"
msg = [{"role": "user", "content": "Reply with the word ok."}]

# 1. Plain chat returns text and usage
r = client.chat.completions.create(model=FAST, messages=msg)
assert r.choices[0].message.content and r.usage.prompt_tokens > 0

# 2. Streaming reports usage in the last chunk
chunks = list(client.chat.completions.create(model=FAST, messages=msg, stream=True,
                                             stream_options={"include_usage": True}))
assert chunks[-1].usage is not None

# 3. A reasoning model needs room: a tiny budget can come back empty
r = client.chat.completions.create(model=REASONING, messages=msg, max_tokens=2000)
assert r.choices[0].finish_reason == "stop" and r.choices[0].message.content

# 4. A bad key raises AuthenticationError (401), which you should not retry
bad = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key="invalid", max_retries=0)
try:
    bad.chat.completions.create(model=FAST, messages=msg)
    raise AssertionError("expected 401")
except openai.AuthenticationError:
    pass
print("smoke test passed")

Después compare la calidad, no solo la forma. Reproduzca una muestra de prompts reales en ambos proveedores y puntúe las respuestas; evaluar un LLM antes de cambiar muestra cómo. La herramienta de migración de OpenAI a BroadNet le ayuda a reescribir un fragmento y lista las funcionalidades que usa.

¿Qué falla con más frecuencia?

  • Una URL base global que también mueve los embeddings y las llamadas de archivos.
  • Asistentes exclusivos de Responses, como output_text, que quedan en un código que ahora llama a Chat Completions.
  • ID de modelo. Los nombres gpt-... no existen en otros proveedores. En BroadNet se parecen a broadnet/glm-5.3.
  • Respuestas vacías de modelos de razonamiento con un max_tokens pequeño.
  • Límites de frecuencia. Una clave de pago por uso de BroadNet permite 30 solicitudes por minuto y 4 en curso. Los trabajos masivos necesitan una cola (manejo del error 429).

Dónde encaja BroadNet Inference

BroadNet Inference encaja con aplicaciones cuyo uso de OpenAI es chat y transcripción: asistentes, extracción, resúmenes, traducción y voz en árabe. También encaja con aplicaciones que quieren planes de tarifa plana de DeepSeek V4.1 Flash para sus agentes. No es el destino adecuado si depende del estado en el servidor de la Responses API, de las herramientas integradas, de embeddings, de generación de imágenes, de texto a voz, de voz en tiempo real o de la Batch API. Lleve esas funciones a proveedores que las ofrezcan, o manténgalas en OpenAI y mueva solo las llamadas de chat. Gemma 4 VL 26B y los dos modelos de transcripción funcionan con el crédito inicial de $5; GLM 5.3, Qwen3.8 27B y DeepSeek V4.1 Flash requieren antes una recarga.

Preguntas frecuentes

¿Necesito otro SDK para usar una API compatible con OpenAI?

No. Mantenga el paquete oficial openai y pase otra base_url (Python) o baseURL (Node), junto con la clave del nuevo proveedor. Los objetos de solicitud y respuesta no cambian en los endpoints que el proveedor admite.

¿Una API compatible con OpenAI admite la Responses API?

Algunas sí; muchas solo admiten Chat Completions. Revise la lista de endpoints del proveedor. BroadNet Inference documenta /v1/chat/completions y /v1/audio/transcriptions, así que el código de Responses debe reescribirse a Chat Completions.

¿Qué pasa con mis embeddings al cambiar?

Fallan si el nuevo proveedor no tiene endpoint de embeddings y usted cambió la URL base de forma global. BroadNet no vende embeddings, así que mantenga un cliente de embeddings apuntando a su proveedor de embeddings. Nunca mezcle vectores de dos modelos de embeddings en un mismo índice.

¿Debo enviar max_tokens o max_completion_tokens?

OpenAI marca max_tokens como obsoleto en favor de max_completion_tokens. Muchos proveedores compatibles documentan max_tokens, y la documentación de BroadNet usa max_tokens. Envíe lo que documente el proveedor y confirme en su prueba rápida que el límite se aplica.

¿Seguirán funcionando los asistentes de salida estructurada de OpenAI?

Solo si el proveedor acepta response_format con json_schema en el modelo que usa. BroadNet lista salida estructurada para GLM 5.3 y Qwen3.8 27B, pero no nombra el parámetro de la solicitud, así que pruébelo y siga validando el resultado analizado.

Leer en MarkdownPreguntar a ChatGPTPreguntar a ClaudePreguntar a Perplexity