BroadRouter
शुरू करें

OpenAI API से माइग्रेशन: Python, Node और cURL में कोड वॉकथ्रू

BroadNet Inference टीम · 6 मिनट में पढ़ें · प्रकाशित

क्लाइंट का base URL, API key और मॉडल ID बदलें। Chat Completions कॉल के लिए इतना काफ़ी है। Responses API वाला कोड Chat Completions में दोबारा लिखना होगा: input, messages बन जाता है, output_text, choices[0].message.content बन जाता है, और टूल का एक नेस्टिंग स्तर बदलता है। नए प्रोवाइडर के पास embeddings न हों, तो उन्हें अलग क्लाइंट पर रखें, फिर ट्रैफ़िक बदलने से पहले स्मोक टेस्ट चलाएँ।

अगर आप 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 के लिए पहले टॉप-अप ज़रूरी है।

अक्सर पूछे जाने वाले सवाल

क्या OpenAI-कम्पैटिबल API के लिए अलग SDK चाहिए?

नहीं। आधिकारिक openai पैकेज ही रखें और अलग base_url (Python) या baseURL (Node) पास करें, साथ में नए प्रोवाइडर की key। प्रोवाइडर जिन एंडपॉइंट को सपोर्ट करता है, उनके लिए अनुरोध और रिस्पॉन्स ऑब्जेक्ट वही रहते हैं।

क्या OpenAI-कम्पैटिबल API, Responses API सपोर्ट करता है?

कुछ करते हैं; कई सिर्फ़ Chat Completions सपोर्ट करते हैं। प्रोवाइडर की एंडपॉइंट सूची देखें। BroadNet Inference, /v1/chat/completions और /v1/audio/transcriptions डॉक्यूमेंट करता है, इसलिए Responses वाला कोड Chat Completions में दोबारा लिखना होगा।

बदलने पर मेरे embeddings का क्या होगा?

अगर नए प्रोवाइडर के पास embeddings एंडपॉइंट नहीं है और आपने base URL हर जगह बदल दिया, तो वे टूट जाएँगे। BroadNet, embeddings नहीं बेचता, इसलिए embeddings क्लाइंट को अपने embeddings प्रोवाइडर की ओर ही रखें। एक इंडेक्स में दो embedding मॉडल के वेक्टर कभी न मिलाएँ।

max_tokens भेजूँ या max_completion_tokens?

OpenAI, max_tokens को डेप्रिकेटेड बताता है और उसकी जगह max_completion_tokens की सलाह देता है। कई कम्पैटिबल प्रोवाइडर इसकी जगह max_tokens डॉक्यूमेंट करते हैं, और BroadNet का डॉक्यूमेंटेशन max_tokens इस्तेमाल करता है। प्रोवाइडर जो डॉक्यूमेंट करता है वही भेजें, और अपने स्मोक टेस्ट में पक्का करें कि सीमा लागू हो रही है।

क्या OpenAI के स्ट्रक्चर्ड आउटपुट हेल्पर फिर भी काम करेंगे?

सिर्फ़ तब, जब प्रोवाइडर आपके मॉडल पर json_schema के साथ response_format स्वीकार करता हो। BroadNet, GLM 5.3 और Qwen3.8 27B के लिए स्ट्रक्चर्ड आउटपुट दिखाता है, लेकिन अनुरोध का पैरामीटर नहीं बताता, इसलिए इसे टेस्ट करें, और पार्स किए गए नतीजे को वैलिडेट करते रहें।

Markdown में पढ़ेंChatGPT से पूछेंClaude से पूछेंPerplexity से पूछें