BroadRouter
Magsimula

Paglipat mula sa OpenAI API: code walkthrough sa Python, Node, cURL

Ng BroadNet Inference team · 6 minutong basa · Nailathala

Palitan ang base URL, API key at model ID ng client. Sapat na iyon para sa mga Chat Completions call. Kailangang isulat ulit sa Chat Completions ang code na nasa Responses API: nagiging messages ang input, nagiging choices[0].message.content ang output_text, at nababawasan ng isang level ng nesting ang tools. Panatilihin ang embeddings sa hiwalay na client kung wala nito ang bagong provider, saka magpatakbo ng smoke test bago ilipat ang traffic.

Maliit na pagbabago sa code ang paglipat ng app mula OpenAI papunta sa isang OpenAI-compatible provider kung Chat Completions ang gamit mo, at rewrite naman kung Responses API. Ipinapakita ng post na ito ang eksaktong mga diff sa Python, Node at cURL, kung ano ang gagawin sa Responses, tools, structured output at embeddings, at isang smoke test na patatakbuhin bago mo ilipat ang anumang traffic. BroadNet Inference sa https://inference.broadnet.ai/v1 ang gamit sa mga halimbawa; pareho ang mga hakbang para sa anumang provider.

Ito ang code na kasama ng migration checklist, na sumasaklaw sa rate limit, errors at pagpaplano ng cutover. Para sa base URL ng ibang provider, tingnan ang mga OpenAI-compatible base URL, sinuri.

Ano ang nagbabago sa client setup?

Tatlong value: base URL, API key at model ID.

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."}]}'

Pansinin ang path: nagtatapos na sa /v1 ang base URL, kaya /chat/completions ang idinadagdag ng SDK. Ang pagdodoble ng /v1 ang pinakakaraniwang unang error.

Puwede ba akong lumipat nang hindi ginagalaw ang code?

Oo, para sa Chat Completions code. Binabasa ng Python SDK ang OPENAI_BASE_URL kapag walang ipinasang base_url, at process.env['OPENAI_BASE_URL'] ang default na baseURL ng Node client. Parehong binabasa ang OPENAI_API_KEY. Inililipat ng pag-set ng dalawang environment variable ang bawat call.

Iyan din ang panganib. Bawat call ang lumilipat, kasama ang embeddings, moderation, file upload at anumang iba pa na puwedeng wala sa bagong provider. Gamitin lang ang environment switch kapag chat call lang ang ginagawa ng app mo at wala nang iba.

Paano kung Responses API ang gamit ng code ko?

Tinatawag na ngayon ng mga README ng SDK ng OpenAI ang Responses API bilang pangunahing API; tinatawag naman ng Python README ang Chat Completions na “the previous standard (supported indefinitely)” (salin: ang dating standard (suportado nang walang katapusan)). Maraming compatible provider ang Chat Completions lang ang ipinapatupad. Dinodokumento ng BroadNet ang POST /v1/chat/completions at POST /v1/audio/transcriptions, kaya kailangang isulat ulit ang mga Responses call. Ang katumbasan:

Responses API Chat Completions
client.responses.create(...) client.chat.completions.create(...)
instructions="..." Unang mensahe {"role": "system", "content": "..."}
input="..." o listahan ng items messages=[...]
response.output_text response.choices[0].message.content
max_output_tokens max_tokens (docs ng BroadNet) o max_completion_tokens
text={"format": {...}} response_format={...}
previous_response_id, conversations Ikaw mismo ang magpapadala ulit ng buong message history
Tool {"type": "function", "name": ...} Tool {"type": "function", "function": {"name": ...}}
Output item na function_call, sagot gamit ang function_call_output at call_id message.tool_calls, sagot gamit ang role na tool at tool_call_id
Built-in na tools (web search, file search) Hindi available; patakbuhin ang sarili mong tool

Ang bago at pagkatapos para sa isang simpleng call:

# 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

Ang pinakamalaking pagbabago sa istruktura ay ang state. Puwedeng itago ng Responses ang conversation state sa panig ng OpenAI gamit ang previous_response_id. Walang server-side state ang Chat Completions, kaya ang code mo ang nag-iimbak ng listahan ng mensahe at nagpapadala ng lahat ng ito sa bawat turn. Isama iyan sa budget: input token ang buong history sa bawat call.

Paano nagbabago ang mga tool call?

Sa Chat Completions, naka-nest ang function sa ilalim ng function key sa isang tool definition, at ibinabalik ang sagot bilang tool message:

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)

Mas mahalaga ang model kaysa sa hugis. Para lang sa GLM 5.3 at Qwen3.8 27B nakalista ang tools sa docs ng BroadNet. Huwag ituro ang isang tool loop sa model na walang nakalistang tools sa docs nito, at i-validate ang mga argument bago magpatakbo ng kahit ano. May buong validating loop sa tool calling gamit ang mga open model.

Paano naman ang structured output?

Parehong nagpapadala ng response_format na may JSON schema ang client.chat.completions.parse(..., response_format=MyPydanticModel) at ang zodResponseFormat ng Node. Gumagana lang ang mga ito kung tinatanggap ng provider ang hugis na iyon sa model na iyon. Nakalista sa BroadNet ang structured output para sa GLM 5.3 at Qwen3.8 27B pero hindi nito pinapangalanan ang request parameter. Patakbuhin ang four-step na test sa JSON mode vs json_schema nang isang beses kada model, at patuloy na i-validate ang na-parse na resulta anuman ang ipangako ng provider.

Ano ang mangyayari sa embeddings?

Kung binago mo ang base URL sa isang shared na client at walang embeddings endpoint ang provider, papalya ang bawat client.embeddings.create call. Hindi nagbebenta ng embeddings ang BroadNet. Gumamit ng dalawang client:

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)))

Huwag kailanman paghaluin sa iisang index ang mga vector mula sa dalawang embedding model. Kung magpapalit ka rin ng embedding provider, i-embed ulit ang buong corpus. Kinukuwenta ng embedding cost calculator ang presyo niyan.

Ganoon din sa anumang hindi chat: image generation, text-to-speech, moderation, ang Batch API at file storage. Wala sa mga ito ang inaalok ng BroadNet. Lumilipat naman ang speech-to-text: gumagana ang client.audio.transcriptions.create laban sa /v1/audio/transcriptions gamit ang WAV o MP3 at isang language field (gabay sa Arabic speech-to-text).

Paano nagbabago ang streaming code?

Nag-i-stream ang Responses API ng mga typed event, gaya ng response.output_text.delta at response.completed. Chunks naman ang ini-stream ng Chat Completions, at nasa choices[0].delta.content ang text. Hindi ipinapadala ang usage maliban kung hihingin mo, at kapag hiningi, dumarating ito sa huling chunk na may walang lamang choices list.

// 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
}

Dalawang gawi ang nagpapanatiling ligtas sa stream code pagkatapos lumipat. Bantayan ang choices[0], dahil walang choices ang usage chunk. At ituring na hindi kumpleto ang stream na natapos bago ang huling linyang data: [DONE]; sinasabi ng docs ng BroadNet na i-record ang X-Request-ID at magpasya kung ligtas ang bagong request. Nasa streaming chat completions ang buong pattern sa Python.

Nagbabago ba ang error handling at retries?

Pareho pa rin ang mga error class ng SDK: AuthenticationError para sa 401, RateLimitError para sa 429, APIStatusError para sa iba. Ang nagbabago ay kung ano ang ibig sabihin ng bawat status sa bagong provider. Sa BroadNet, puwedeng ang ibig sabihin ng 401 ay ubos na ang pay-as-you-go allowance, hindi lang maling key, at ang 402 ay kulang ang balance para sa isang pagbili. Hindi maaayos ng retry ang alinman sa dalawa. Puwedeng galing sa rate, concurrency, token-rate o spend limit ang 429. I-retry ang 429 at 5xx gamit ang backoff, at ayusin ang lahat ng iba. Nasa gabay sa errors at retries ang buong table.

Nire-retry ng SDK ang connection error, 408, 409, 429 at 5xx nang dalawang beses by default. Kung magdadagdag ka ng sarili mong retry loop, i-set ang max_retries=0 sa client para hindi magpatong ang dalawa.

Aling mga parameter ang iba ang behavior?

Parameter Ano ang i-check
max_tokens / max_completion_tokens Dine-deprecate ng OpenAI ang max_tokens; ito ang ginagamit ng docs ng BroadNet. Sa mga reasoning model, kasama rito ang pag-iisip, kaya walang lamang sagot ang ibinabalik ng maliliit na value (bakit)
reasoning_effort low ang dinodokumento ng BroadNet; i-test ang ibang value bago umasa sa mga ito
stream_options: {"include_usage": true} Dinodokumento ng BroadNet; dumarating ang usage sa huling chunk
n, logprobs, seed, logit_bias Wala sa docs ng BroadNet; i-test, o alisin
store, metadata Mga storage feature ng OpenAI; tanggalin
image_url content parts Sa mga model lang na nakalistang may larawan: DeepSeek V4.1 Flash, Qwen3.8 27B, Gemma 4 VL 26B

Paano i-test ang paglipat?

Magpatakbo ng maikling smoke test laban sa bagong provider bago ilipat ang anumang traffic. Chine-check nito ang simpleng chat, streaming usage, reasoning budget at authentication. Magdagdag ng tool-call na kaso kung gumagamit ka ng tools.

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")

Pagkatapos, ikumpara ang kalidad, hindi lang ang hugis. I-replay ang sample ng totoong mga prompt sa parehong provider at i-score ang mga sagot; ipinapakita ng i-evaluate ang LLM bago lumipat kung paano. Tinutulungan ka ng OpenAI to BroadNet migration tool na isulat ulit ang isang snippet at inililista nito kung aling mga feature ang ginagamit nito.

Ano ang pinakamadalas masira?

  • Isang global na base URL na naglilipat din sa embeddings at file call.
  • Mga helper na para lang sa Responses gaya ng output_text na naiwan sa code na tumatawag na ngayon sa Chat Completions.
  • Mga model ID. Wala sa ibang lugar ang mga pangalang gpt-.... Sa BroadNet, ganito ang hitsura nila: broadnet/glm-5.3.
  • Walang lamang sagot mula sa mga reasoning model na maliit ang max_tokens.
  • Mga rate limit. Ang pay-as-you-go key ng BroadNet ay may 30 request kada minuto at 4 in flight. Kailangan ng queue ang mga bulk job (paghawak ng 429).

Saan pumapasok ang BroadNet Inference

Bagay ang BroadNet Inference sa mga app na chat at transcription ang gamit sa OpenAI: mga assistant, extraction, pag-summarize, translation at Arabic na pananalita. Bagay rin ito sa mga app na gusto ng flat-rate na DeepSeek V4.1 Flash plan para sa mga agent. Hindi ito ang tamang target kung umaasa ka sa server-side state ng Responses API, built-in na tools, embeddings, image generation, text-to-speech, realtime voice o Batch API. Ilipat ang mga iyon sa mga provider na nag-aalok nito, o panatilihin sa OpenAI at ang mga chat call lang ang ilipat. Tumatakbo sa $5 na panimulang credit ang Gemma 4 VL 26B at ang parehong transcription model; kailangan munang mag-top up para sa GLM 5.3, Qwen3.8 27B at DeepSeek V4.1 Flash.

Mga tanong

Kailangan ko ba ng ibang SDK para gumamit ng OpenAI-compatible API?

Hindi. Panatilihin ang opisyal na openai package at magpasa ng ibang base_url (Python) o baseURL (Node), dagdag ang key ng bagong provider. Pareho pa rin ang request at response object para sa mga endpoint na sinusuportahan ng provider.

Sinusuportahan ba ng OpenAI-compatible API ang Responses API?

May ilan; marami ang Chat Completions lang ang sinusuportahan. I-check ang listahan ng endpoint ng provider. Dinodokumento ng BroadNet Inference ang /v1/chat/completions at /v1/audio/transcriptions, kaya kailangang isulat ulit sa Chat Completions ang Responses code.

Ano ang mangyayari sa embeddings ko kapag lumipat ako?

Masisira ang mga ito kung walang embeddings endpoint ang bagong provider at binago mo ang base URL nang global. Hindi nagbebenta ng embeddings ang BroadNet, kaya panatilihin ang isang embeddings client na nakaturo sa embeddings provider mo. Huwag kailanman paghaluin sa iisang index ang mga vector mula sa dalawang embedding model.

max_tokens ba o max_completion_tokens ang dapat kong ipadala?

Minamarkahan ng OpenAI na deprecated ang max_tokens pabor sa max_completion_tokens. Maraming compatible provider ang max_tokens ang dinodokumento, at max_tokens ang ginagamit ng docs ng BroadNet. Ipadala ang dinodokumento ng provider at kumpirmahin sa smoke test na gumagana ang limit.

Gagana pa ba ang structured output helpers ng OpenAI?

Kung tumatanggap lang ang provider ng response_format na may json_schema sa model na ginagamit mo. Nakalista sa BroadNet ang structured output para sa GLM 5.3 at Qwen3.8 27B pero hindi nito pinapangalanan ang request parameter, kaya i-test ito, at patuloy na i-validate ang na-parse na resulta.

Basahin bilang MarkdownTanungin ang ChatGPTTanungin ang ClaudeTanungin ang Perplexity