अगर आप Chat Completions इस्तेमाल करते हैं, तो किसी ऐप को OpenAI से OpenAI-कम्पैटिबल प्रोवाइडर पर ले जाना कोड का छोटा-सा बदलाव है, और अगर Responses API इस्तेमाल करते हैं, तो दोबारा लिखना पड़ता है। यह पोस्ट Python, Node और cURL में सटीक diff दिखाती है, बताती है कि Responses, टूल, स्ट्रक्चर्ड आउटपुट और embeddings के साथ क्या करें, और एक स्मोक टेस्ट देती है जो कोई भी ट्रैफ़िक बदलने से पहले चलाना चाहिए। उदाहरणों में https://inference.broadnet.ai/v1 पर BroadNet Inference इस्तेमाल हुआ है; यही कदम किसी भी प्रोवाइडर पर लागू होते हैं।
यह माइग्रेशन चेकलिस्ट का कोड वाला साथी है, जो रेट लिमिट, एरर और कटओवर की योजना समझाती है। दूसरे प्रोवाइडर के base URL के लिए OpenAI-कम्पैटिबल base URL, जाँचे हुए देखें।
क्लाइंट सेटअप में क्या बदलता है?
तीन मान: base URL, API key और मॉडल 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."}]}'
पाथ पर ध्यान दें: base URL पहले से /v1 पर ख़त्म होता है, इसलिए SDK उसमें /chat/completions जोड़ता है। /v1 दो बार लिख देना सबसे आम पहली ग़लती है।
क्या कोड छुए बिना बदलाव हो सकता है?
हाँ, Chat Completions वाले कोड के लिए। जब कोई base_url पास नहीं किया जाता, तो Python SDK OPENAI_BASE_URL पढ़ता है, और Node क्लाइंट का baseURL डिफ़ॉल्ट रूप से process.env['OPENAI_BASE_URL'] होता है। दोनों OPENAI_API_KEY पढ़ते हैं। दो एनवायरनमेंट वेरिएबल सेट करने से हर कॉल बदल जाती है।
जोखिम भी यही है। हर कॉल बदलती है, embeddings, moderation, फ़ाइल अपलोड और ऐसी हर चीज़ समेत जो शायद नए प्रोवाइडर के पास न हो। एनवायरनमेंट वाला तरीक़ा सिर्फ़ तब इस्तेमाल करें जब आपका ऐप चैट कॉल के अलावा कुछ नहीं करता।
अगर मेरा कोड Responses API इस्तेमाल करता है तो?
OpenAI के SDK README अब Responses API को मुख्य API कहते हैं; Python README, Chat Completions को “the previous standard (supported indefinitely)” (अनुवाद: पिछला मानक (अनिश्चित काल तक सपोर्टेड)) कहता है। कई कम्पैटिबल प्रोवाइडर सिर्फ़ Chat Completions लागू करते हैं। BroadNet, POST /v1/chat/completions और POST /v1/audio/transcriptions डॉक्यूमेंट करता है, इसलिए Responses कॉल दोबारा लिखनी होंगी। मैपिंग:
| Responses API | Chat Completions |
|---|---|
client.responses.create(...) |
client.chat.completions.create(...) |
instructions="..." |
पहला संदेश {"role": "system", "content": "..."} |
input="..." या आइटम की सूची |
messages=[...] |
response.output_text |
response.choices[0].message.content |
max_output_tokens |
max_tokens (BroadNet का डॉक्यूमेंटेशन) या max_completion_tokens |
text={"format": {...}} |
response_format={...} |
previous_response_id, conversations |
पूरा संदेश इतिहास ख़ुद दोबारा भेजें |
टूल {"type": "function", "name": ...} |
टूल {"type": "function", "function": {"name": ...}} |
आउटपुट आइटम function_call, जवाब function_call_output और call_id के साथ |
message.tool_calls, जवाब role tool और tool_call_id के साथ |
| बिल्ट-इन टूल (वेब सर्च, फ़ाइल सर्च) | उपलब्ध नहीं; अपना टूल चलाएँ |
एक सरल कॉल का पहले और बाद का रूप:
# 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
सबसे बड़ा ढाँचागत बदलाव स्टेट का है। Responses, previous_response_id से बातचीत का स्टेट OpenAI की तरफ़ रख सकता है। Chat Completions में सर्वर पर कोई स्टेट नहीं होता, इसलिए आपका कोड संदेशों की सूची सहेजता है और हर टर्न पर पूरी सूची भेजता है। इसका बजट रखें: पूरा इतिहास हर कॉल पर इनपुट टोकन है।
टूल कॉल कैसे बदलती हैं?
Chat Completions में टूल डेफ़िनिशन, फ़ंक्शन को function key के अंदर नेस्ट करती है, और जवाब 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)
ढाँचे से ज़्यादा मॉडल मायने रखता है। BroadNet का डॉक्यूमेंटेशन टूल सिर्फ़ GLM 5.3 और Qwen3.8 27B के लिए दिखाता है। टूल लूप को ऐसे मॉडल पर न लगाएँ जिसके डॉक्यूमेंटेशन में टूल नहीं हैं, और कुछ भी चलाने से पहले आर्ग्युमेंट वैलिडेट करें। ओपन मॉडल के साथ टूल कॉलिंग में वैलिडेशन वाला पूरा लूप है।
स्ट्रक्चर्ड आउटपुट का क्या?
client.chat.completions.parse(..., response_format=MyPydanticModel) और Node का zodResponseFormat, दोनों JSON schema के साथ response_format भेजते हैं। ये तभी काम करते हैं जब प्रोवाइडर उस मॉडल पर यह ढाँचा स्वीकार करता हो। BroadNet, GLM 5.3 और Qwen3.8 27B के लिए स्ट्रक्चर्ड आउटपुट दिखाता है, लेकिन अनुरोध का पैरामीटर नहीं बताता। JSON mode बनाम json_schema वाला चार कदमों का टेस्ट हर मॉडल पर एक बार चलाएँ, और प्रोवाइडर चाहे जो वादा करे, पार्स किए गए नतीजे को वैलिडेट करते रहें।
embeddings का क्या होता है?
अगर आप किसी साझा क्लाइंट पर base URL बदलते हैं और प्रोवाइडर के पास embeddings एंडपॉइंट नहीं है, तो हर client.embeddings.create कॉल फ़ेल होगी। BroadNet embeddings नहीं बेचता। दो क्लाइंट रखें:
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)))
एक इंडेक्स में दो embedding मॉडल के वेक्टर कभी न मिलाएँ। अगर आप embedding प्रोवाइडर भी बदलते हैं, तो पूरे कॉर्पस को दोबारा embed करें। embedding कॉस्ट कैलकुलेटर उसकी कीमत निकालता है।
यही बात हर उस चीज़ पर लागू होती है जो चैट नहीं है: इमेज जेनरेशन, टेक्स्ट-टू-स्पीच, moderation, Batch API और फ़ाइल स्टोरेज। BroadNet इनमें से कुछ नहीं देता। स्पीच-टू-टेक्स्ट ज़रूर बदला जा सकता है: client.audio.transcriptions.create, WAV या MP3 और एक language फ़ील्ड के साथ /v1/audio/transcriptions पर काम करता है (अरबी स्पीच-टू-टेक्स्ट गाइड)।
स्ट्रीमिंग कोड कैसे बदलता है?
Responses API टाइप किए गए इवेंट स्ट्रीम करता है, जैसे response.output_text.delta और response.completed। Chat Completions चंक स्ट्रीम करता है, और टेक्स्ट choices[0].delta.content में होता है। usage तब तक नहीं भेजा जाता जब तक आप उसे न माँगें, और फिर वह ख़ाली choices सूची वाले आख़िरी चंक में आता है।
// 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
}
बदलाव के बाद दो आदतें स्ट्रीम कोड को सुरक्षित रखती हैं। choices[0] की जाँच करें, क्योंकि usage वाले चंक में कोई choice नहीं होता। और जो स्ट्रीम आख़िरी data: [DONE] लाइन से पहले ख़त्म हो जाए, उसे अधूरा मानें; BroadNet का डॉक्यूमेंटेशन कहता है कि X-Request-ID दर्ज करें और तय करें कि नया अनुरोध सुरक्षित है या नहीं। स्ट्रीमिंग chat completions में Python में पूरा पैटर्न है।
क्या एरर हैंडलिंग और रीट्राई बदलते हैं?
SDK की एरर क्लास वही रहती हैं: 401 के लिए AuthenticationError, 429 के लिए RateLimitError, बाक़ी के लिए APIStatusError। बदलता यह है कि नए प्रोवाइडर पर हर स्टेटस का मतलब क्या है। BroadNet पर 401 का मतलब सिर्फ़ ग़लत key नहीं, उपयोग के अनुसार भुगतान का ख़त्म हुआ अलाउंस भी हो सकता है, और 402 का मतलब है किसी ख़रीद के लिए अपर्याप्त बैलेंस। दोनों में से कोई रीट्राई से ठीक नहीं होता। 429 रेट, कॉन्करेंसी, टोकन-रेट या ख़र्च की सीमा से आ सकता है। 429 और 5xx को बैकऑफ़ के साथ रीट्राई करें, और बाक़ी सब ठीक करें। एरर और रीट्राई गाइड में पूरी टेबल है।
SDK कनेक्शन एरर, 408, 409, 429 और 5xx को डिफ़ॉल्ट रूप से दो बार रीट्राई करता है। अगर आप अपना रीट्राई लूप जोड़ते हैं, तो क्लाइंट पर max_retries=0 सेट करें ताकि दोनों एक के ऊपर एक न चढ़ें।
कौन-से पैरामीटर अलग व्यवहार करते हैं?
| पैरामीटर | क्या जाँचें |
|---|---|
max_tokens / max_completion_tokens |
OpenAI, max_tokens को डेप्रिकेट करता है; BroadNet का डॉक्यूमेंटेशन इसे इस्तेमाल करता है। रीज़निंग मॉडल पर इसमें थिंकिंग शामिल होती है, इसलिए छोटे मान ख़ाली जवाब लौटाते हैं (क्यों) |
reasoning_effort |
BroadNet low डॉक्यूमेंट करता है; दूसरे मानों पर भरोसा करने से पहले उन्हें टेस्ट करें |
stream_options: {"include_usage": true} |
BroadNet ने डॉक्यूमेंट किया है; usage आख़िरी चंक में आता है |
n, logprobs, seed, logit_bias |
BroadNet के डॉक्यूमेंटेशन में नहीं; टेस्ट करें, या हटा दें |
store, metadata |
OpenAI के स्टोरेज फ़ीचर; इन्हें हटा दें |
image_url कंटेंट पार्ट |
सिर्फ़ इमेज वाले मॉडल पर: DeepSeek V4.1 Flash, Qwen3.8 27B, Gemma 4 VL 26B |
बदलाव को कैसे टेस्ट करें?
कोई भी ट्रैफ़िक बदलने से पहले नए प्रोवाइडर पर एक छोटा स्मोक टेस्ट चलाएँ। यह सामान्य चैट, स्ट्रीमिंग usage, रीज़निंग बजट और ऑथेंटिकेशन जाँचता है। अगर आप टूल इस्तेमाल करते हैं, तो एक टूल-कॉल केस जोड़ें।
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")
फिर सिर्फ़ ढाँचे की नहीं, क्वालिटी की तुलना करें। असली प्रॉम्प्ट का एक सैंपल दोनों प्रोवाइडर पर दोबारा चलाएँ और जवाबों को स्कोर करें; बदलने से पहले LLM का मूल्यांकन इसका तरीक़ा बताता है। OpenAI से BroadNet माइग्रेशन टूल किसी स्निपेट को दोबारा लिखने में मदद करता है और बताता है कि वह कौन-से फ़ीचर इस्तेमाल करता है।
सबसे ज़्यादा क्या टूटता है?
- ग्लोबल base URL, जो embeddings और फ़ाइल कॉल को भी बदल देता है।
- सिर्फ़ Responses वाले हेल्पर, जैसे
output_text, जो उस कोड में छूट गए जो अब Chat Completions कॉल करता है। - मॉडल ID।
gpt-...नाम दूसरी जगह मौजूद नहीं हैं। BroadNet पर वेbroadnet/glm-5.3जैसे दिखते हैं। - ख़ाली जवाब, छोटे
max_tokensवाले रीज़निंग मॉडल से। - रेट लिमिट। BroadNet की उपयोग के अनुसार भुगतान वाली key प्रति मिनट 30 अनुरोध और एक साथ 4 चालू अनुरोध की अनुमति देती है। बड़े जॉब को क्यू चाहिए (429 को सँभालना)।
BroadNet Inference कहाँ फ़िट होता है
BroadNet Inference उन ऐप के लिए ठीक है जिनका OpenAI उपयोग चैट और ट्रांसक्रिप्शन है: असिस्टेंट, एक्सट्रैक्शन, सारांश, अनुवाद और अरबी स्पीच। यह उन ऐप के लिए भी ठीक है जो एजेंट के लिए फ़्लैट रेट वाले DeepSeek V4.1 Flash प्लान चाहते हैं। अगर आप Responses API के सर्वर-साइड स्टेट, बिल्ट-इन टूल, embeddings, इमेज जेनरेशन, टेक्स्ट-टू-स्पीच, रियलटाइम वॉइस या Batch API पर निर्भर हैं, तो यह सही जगह नहीं है। इन्हें उन प्रोवाइडर पर ले जाएँ जो ये देते हैं, या इन्हें OpenAI पर रहने दें और सिर्फ़ चैट कॉल बदलें। Gemma 4 VL 26B और दोनों ट्रांसक्रिप्शन मॉडल $5 के शुरुआती क्रेडिट पर चलते हैं; GLM 5.3, Qwen3.8 27B और DeepSeek V4.1 Flash के लिए पहले टॉप-अप ज़रूरी है।
