BroadRouter

प्राइवेट एंडपॉइंट की शुरुआत साफ़ वर्कलोड से होती है

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

प्राइवेट एंडपॉइंट माँगने से पहले वर्कलोड लिख लें: हर दिन और पीक पर अनुरोध, अंदर और बाहर के टोकन, उनसे निकलने वाले समानांतर अनुरोध, ज़रूरी कॉन्टेक्स्ट, प्रोसेसिंग रीजन, मॉडल और उसका लाइसेंस, और बजट। रीजन और सीमाएँ लिखित में तय करें, फिर असली डेटा से पहले मिले हुए एंडपॉइंट का स्मोक टेस्ट करें।

“हमें एक डेडिकेटेड एंडपॉइंट चाहिए” बातचीत की शुरुआत है, स्पेसिफ़िकेशन नहीं। प्रोवाइडर आपके आँकड़ों के बिना क्षमता का आकार, जगह या कीमत तय नहीं कर सकता, और उनके बिना आप उसके जवाब को परख भी नहीं सकते। यह पोस्ट बताती है कि पूछने से पहले क्या तय करें, इनवॉइस से डेटा निकालने के एक हल किए हुए उदाहरण के साथ, और आख़िर में एक स्क्रिप्ट देती है जो आपको मिले एंडपॉइंट की जाँच करती है।

यह किसी भी प्रोवाइडर पर लागू होती है। जहाँ यह BroadNet के ऑफ़र का वर्णन करती है, वहाँ सिर्फ़ उतना कहती है जितना BroadNet सार्वजनिक रूप से कहता है, 15 नवंबर 2026 को जाँचा हुआ। इसके आगे की हर बात BroadNet से पूछने का सवाल है।

प्राइवेट एंडपॉइंट कब समझदारी है?

आम तौर पर चार में से किसी एक वजह से:

  • सेल्फ़-सर्व सीमाओं से ज़्यादा ट्रैफ़िक। BroadNet का API रेफ़रंस उपयोग के अनुसार भुगतान वाली key के लिए प्रति मिनट 30 अनुरोध और एक साथ 4 अनुरोध प्रकाशित करता है। इससे ऊपर का स्थिर वर्कलोड क्षमता का सवाल है, रीट्राई का नहीं। (429 सँभालना छोटे उछालों को कवर करता है।)
  • ऐसा मॉडल जो पब्लिक सूची में नहीं है। BroadNet का कैटलॉग कुछ मॉडलों पर “available on request” (अनुरोध पर उपलब्ध) लिखता है, जिनमें Qwen3-VL 30B-A3B, Qwen3-VL 8B और Cohere Transcribe Arabic का BroadNet फ़ाइन-ट्यून शामिल हैं। मॉडल कैटलॉग कैसे पढ़ें फ़र्क़ समझाता है।
  • प्रोसेसिंग की जगह जिस पर आपका नियंत्रण ज़रूरी है। डेटा रेज़िडेंसी के नियम, जैसे सऊदी और UAE PDPL चेकलिस्ट वाले, ऐसा रीजन माँग सकते हैं जो आपने लिखित में तय किया हो।
  • अनुमान लगाने लायक़ लेटेंसी। साझा क्षमता दूसरे यूज़र्स के लोड से बदलती है। रिज़र्व क्षमता यह अनिश्चितता हटा देती है, हालाँकि नेटवर्क की दूरी या आपके अपने प्रॉम्प्ट के आकार को नहीं।

अगर इनमें से कुछ भी लागू नहीं, तो सेल्फ़-सर्व key आसान है। और अगर आपका वॉल्यूम बहुत ज़्यादा और स्थिर है, तो इसे ख़ुद चलाने से तुलना करें: सेल्फ़-होस्टिंग बनाम API लागत में तरीक़ा है।

वर्कलोड के बारे में क्या तय करें?

एक पेज का ब्रीफ़ लिखें। प्रोवाइडर को ये आँकड़े चाहिए:

चीज़ क्या लिखें उदाहरण
काम मॉडल क्या करता है, एक वाक्य में इनवॉइस की फ़ोटो पढ़ना, JSON फ़ील्ड लौटाना
वॉल्यूम हर दिन के अनुरोध, और सबसे व्यस्त घंटे का हिस्सा हर दिन 40,000, पीक घंटे में 15%
टोकन औसत और 95वें पर्सेंटाइल के इनपुट और आउटपुट टोकन 1,800 अंदर (एक पेज की इमेज + प्रॉम्प्ट), 350 बाहर
कॉन्टेक्स्ट सबसे बड़ा अकेला अनुरोध, प्रॉम्प्ट और जवाब मिलाकर 4,000 टोकन
लेटेंसी पहले टोकन और पूरे जवाब तक का स्वीकार्य समय पूरा जवाब 10 सेकंड के अंदर
स्ट्रीमिंग चाहिए या नहीं नहीं चाहिए (बैच जैसा)
इनपुट टेक्स्ट, इमेज, ऑडियो; फ़ॉर्मैट और आकार JPEG और PNG, हर एक एक पेज
भाषाएँ कौन-सी, और हर एक का हिस्सा अरबी और अंग्रेज़ी, 60/40
बढ़त 6 और 12 महीने में अपेक्षित वॉल्यूम 12 महीने में दोगुना

टोकन की संख्या असली सैंपल पर मापें, अंदाज़े से नहीं। एक ही टेक्स्ट के लिए अरबी को अक्सर अंग्रेज़ी से ज़्यादा टोकन चाहिए; अरबी टोकन काउंटर और भाषा के हिसाब से असली लागत दिखाते हैं कि अलग-अलग टोकनाइज़र पर कितने ज़्यादा। इमेज के लिए इमेज टोकन कैलकुलेटर पहला अनुमान देता है।

वॉल्यूम को प्रति सेकंड टोकन और समानांतर अनुरोधों में कैसे बदलें?

पीक पर प्रति सेकंड अनुरोध, सबसे व्यस्त घंटे का वॉल्यूम भाग 3,600 है। समानांतर अनुरोध, यानी एक साथ चल रहे अनुरोधों की संख्या, Little’s law से निकलती है: किसी सिस्टम में औसत संख्या, आने की दर गुणा हर एक के वहाँ बिताए औसत समय के बराबर है। API के लिए यह है प्रति सेकंड अनुरोध × हर अनुरोध के सेकंड।

import math

def size(requests_per_day: int, peak_share_of_day_in_busiest_hour: float,
         in_tokens: int, out_tokens: int, out_tok_per_s_per_stream: float) -> dict:
    """Rough peak numbers to put in a capacity enquiry. Measure your own inputs; these are not provider specs."""
    peak_rps = requests_per_day * peak_share_of_day_in_busiest_hour / 3600
    seconds_per_request = out_tokens / out_tok_per_s_per_stream        # ignores queueing and prompt time
    concurrency = peak_rps * seconds_per_request                      # Little's law: L = λ × W
    return {
        "peak_requests_per_second": round(peak_rps, 2),
        "seconds_per_request": round(seconds_per_request, 1),
        "concurrent_requests_at_peak": math.ceil(concurrency),
        "peak_input_tokens_per_second": round(peak_rps * in_tokens),
        "peak_output_tokens_per_second": round(peak_rps * out_tokens),
        "monthly_tokens_millions": round(requests_per_day * 30 * (in_tokens + out_tokens) / 1e6, 1),
    }

# 40,000 invoice extractions a day, 15% of them in the busiest hour,
# 1,800 tokens in, 350 out, 60 tokens/s per stream measured on a trial.
print(size(40_000, 0.15, 1_800, 350, 60))

इसने पीक पर प्रति सेकंड 1.67 अनुरोध, हर अनुरोध लगभग 5.8 सेकंड, 10 समानांतर अनुरोध, प्रति सेकंड 3,000 इनपुट और 583 आउटपुट टोकन, और हर महीने 2,580 मिलियन टोकन छापे। प्रति सेकंड 60 टोकन इस उदाहरण की एक धारणा है; जिस मॉडल को आप इस्तेमाल करेंगे, उस पर अपना ख़ुद मापें, क्योंकि स्पीड मॉडल, प्रॉम्प्ट की लंबाई और लोड के हिसाब से बदलती है। लेटेंसी, TTFT और थ्रूपुट वाली पोस्ट बताती है कि क्या मापें।

दो सावधानियाँ। फ़ॉर्मूला प्रॉम्प्ट प्रोसेसिंग का समय छोड़ देता है, इसलिए लंबे प्रॉम्प्ट या बड़ी इमेज असली अनुरोधों को धीमा करती हैं और समानांतर अनुरोध बढ़ाती हैं। और औसत उछालों को छिपा देते हैं: प्रोवाइडर को सिर्फ़ औसत नहीं, अपने 95वें पर्सेंटाइल का अनुरोध आकार और छोटे उछालों का प्रोफ़ाइल दें। इस उदाहरण का पीक (प्रति मिनट लगभग 100 अनुरोध और एक साथ 10) एक उपयोग के अनुसार भुगतान वाली key की प्रकाशित सेल्फ़-सर्व सीमाओं से काफ़ी ऊपर है, और ठीक यही वह मौक़ा है जब क्षमता पर बातचीत करना फ़ायदेमंद है।

रीजन, रेज़िडेंसी और सीमाओं का क्या?

किसी भी नियमित डेटा के जाने से पहले इन्हें साफ़ तौर पर, लिखित में तय करें। BroadNet की शर्तें (§7.3a) कहती हैं: “Contact us to agree processing locations for your deployment before sending data with residency requirements,” (अनुवाद: रेज़िडेंसी की ज़रूरत वाला डेटा भेजने से पहले अपने डिप्लॉयमेंट के लिए प्रोसेसिंग की जगहें तय करने को हमसे संपर्क करें) और यह भी कि पार्टनर-होस्टेड और बैकअप प्रोसेसिंग में दूसरे प्रोसेसर शामिल होते हैं, और सबप्रोसेसर की मौजूदा सूची ग्राहकों को अनुरोध पर मिलती है। उसका प्राइवेसी स्टेटमेंट कहता है कि BroadNet के अपने और होस्ट किए गए ओपन-वेट मॉडल अमेरिका में BroadNet के अपने या लीज़ पर लिए हार्डवेयर पर चलते हैं, बैकअप के लिए पार्टनर क्षमता के साथ, और उसका परिचय पेज कहता है कि MENA या यूरोप में क्षेत्रीय प्रोसेसिंग अनुरोध पर उपलब्ध है।

तो किसी भी प्रोवाइडर से ये सवाल हैं:

  1. कौन-सा रीजन अनुरोध प्रोसेस करता है, और कौन-सा रीजन बैकअप क्षमता रखता है?
  2. कौन-से सबप्रोसेसर ट्रैफ़िक को छू सकते हैं, फ़ेलओवर या ओवरफ़्लो के लिए भी?
  3. एंडपॉइंट की दर, समानांतर अनुरोध और टोकन की सीमाएँ क्या हैं, और उनसे ऊपर क्या होता है?
  4. उपलब्धता और सपोर्ट की कौन-सी शर्तें लागू हैं, और वे कहाँ लिखी हैं? BroadNet की शर्तें (§7.4) कहती हैं कि सेल्फ़-सर्व पर उपलब्धता की कोई प्रतिबद्धता नहीं है, और प्राइवेट एंडपॉइंट और रिज़र्व क्षमता आपके अलग लिखित समझौते के तहत आते हैं। दूसरे प्रोवाइडर्स के लिखित SLA क्या कवर करते हैं, यह देखने के लिए LLM API SLA की तुलना पढ़ें।
  5. क्या रखा जाता है? BroadNet के इन्फ़रेंस API के लिए प्रकाशित स्थिति यह है: इन्फ़रेंस कंटेंट रखा नहीं जाता; ज़रूरी अकाउंट, बिलिंग और सुरक्षा मेटाडेटा उसके प्राइवेसी स्टेटमेंट के अनुसार रखा जाता है। पुष्टि करें कि आपके एंडपॉइंट पर भी यही लागू है।

कौन-सा मॉडल, और किस लाइसेंस के तहत?

सटीक मॉडल और वर्ज़न का नाम लिखें, और जाँचें कि उसका लाइसेंस आपके इस्तेमाल और API से सर्व करने की अनुमति देता है। BroadNet के मॉडल पेज Gemma 4 26B, Qwen3-VL 30B-A3B और Cohere Transcribe के बेस वेट के लिए Apache-2.0 लिस्ट करते हैं, और Cohere Transcribe Arabic का BroadNet फ़ाइन-ट्यून “under contract” (अनुबंध के तहत) है। उसकी शर्तें कहती हैं कि मॉडल अपने लाइसेंस से चलते हैं, और पार्टनर-होस्टेड होने पर भी DeepSeek V4.1 Flash का लाइसेंस लागू रहता है।

कॉन्टेक्स्ट विंडो भी तय करें। कॉन्टेक्स्ट की सीमाएँ मॉडल और डिप्लॉयमेंट पर निर्भर हैं, सिर्फ़ बेस मॉडल की अधिकतम सीमा पर नहीं: BroadNet अपने पब्लिक API पर Gemma 4 VL 26B के लिए 32K टोकन लिस्ट करता है और Qwen3-VL 30B-A3B के लिए 16K, जो अनुरोध पर है। कॉन्टेक्स्ट विंडो कैलकुलेटर को अपने सबसे बड़े अनुरोध पर चलाएँ, औसत पर नहीं।

बजट कैसे तय करें?

BroadNet प्राइवेट एंडपॉइंट की कोई कीमत प्रकाशित नहीं करता; उसका परिचय पेज कहता है “Reserved GPU, priced to your traffic. Ask for a quote.” (अनुवाद: रिज़र्व GPU, आपके ट्रैफ़िक के हिसाब से कीमत। कोटेशन माँगें।) इसलिए पहले अपनी ख़ुद की ऊपरी सीमा तय करें। उसी वर्कलोड की सेल्फ़-सर्व कीमत LLM API लागत कैलकुलेटर में निकालें, साइज़िंग स्क्रिप्ट के महीने के टोकन इस्तेमाल करते हुए, और तय करें कि अनुमान लगाने लायक़ क्षमता, कोई रीजन या ग़ैर-पब्लिक मॉडल आपके लिए उसके ऊपर कितना मूल्य रखता है। सेल्फ़-सर्व आँकड़े से कम कोटेशन बोनस है; उससे बहुत ज़्यादा कोटेशन के लिए आपकी ज़रूरतों की सूची से कोई कारण चाहिए।

पूछताछ कैसे भेजें?

BroadNet का API रेफ़रंस कहता है: “Private endpoints, our Arabic fine-tunes and other models on request are reached with a private ID issued with the endpoint.” (अनुवाद: प्राइवेट एंडपॉइंट, हमारे अरबी फ़ाइन-ट्यून और अनुरोध पर मिलने वाले दूसरे मॉडल एंडपॉइंट के साथ जारी किए गए प्राइवेट ID से इस्तेमाल होते हैं।) उसका परिचय पेज “your model, languages and traffic requirements” (अनुवाद: आपका मॉडल, भाषाएँ और ट्रैफ़िक की ज़रूरतें) माँगता है। अपना एक पेज का ब्रीफ़ संपर्क पेज से भेजें, बिना API key या ग्राहक डेटा के। साइज़िंग का आउटपुट, रीजन, मॉडल और लाइसेंस, लेटेंसी का लक्ष्य, बजट की ऊपरी सीमा और अपनी समय-सीमा शामिल करें।

मिले हुए एंडपॉइंट की जाँच कैसे करें?

प्रोडक्शन ट्रैफ़िक से पहले एंडपॉइंट को उस पर टेस्ट करें जो तय हुआ था। यह स्क्रिप्ट सिर्फ़ Python स्टैंडर्ड लाइब्रेरी इस्तेमाल करती है। यह जाँचती है कि प्राइवेट मॉडल ID काम करता है, कि स्ट्रीमिंग BroadNet के डॉक्स में बताए data: [DONE] मार्कर पर ख़त्म होती है, कि तय किए गए समानांतर अनुरोध बिना 429 के चलते हैं, और कि ग़लत मॉडल ID अस्वीकार होता है।

import json, os, sys, time, urllib.error, urllib.request
from concurrent.futures import ThreadPoolExecutor

BASE = os.environ["ENDPOINT_BASE_URL"].rstrip("/")    # from your agreement, e.g. https://.../v1
KEY = os.environ["ENDPOINT_API_KEY"]
MODEL = os.environ["ENDPOINT_MODEL_ID"]                # the private ID issued with the endpoint
AGREED_CONCURRENCY = int(os.environ.get("AGREED_CONCURRENCY", "4"))

def post(payload: dict, stream=False):
    req = urllib.request.Request(f"{BASE}/chat/completions", data=json.dumps(payload).encode(),
        headers={"Authorization": f"Bearer {KEY}", "Content-Type": "application/json"})
    t0 = time.monotonic()
    try:
        with urllib.request.urlopen(req, timeout=120) as r:
            body = r.read().decode()
            return r.status, r.headers.get("X-Request-ID"), body, time.monotonic() - t0
    except urllib.error.HTTPError as e:
        return e.code, e.headers.get("X-Request-ID"), e.read().decode(), time.monotonic() - t0

def main() -> int:
    msg = [{"role": "user", "content": "Reply with the word OK."}]
    results = {}
    code, rid, body, secs = post({"model": MODEL, "messages": msg, "max_tokens": 1000})
    ok = code == 200 and "usage" in json.loads(body)
    results["model_id_accepted"] = (ok, f"HTTP {code}, request ID {rid}, {secs:.2f}s")
    code, _, body, _ = post({"model": MODEL, "messages": msg, "stream": True,
                             "stream_options": {"include_usage": True}})
    results["stream_ends_with_DONE"] = (code == 200 and body.rstrip().endswith("data: [DONE]"), f"HTTP {code}")
    with ThreadPoolExecutor(AGREED_CONCURRENCY) as pool:
        codes = list(pool.map(lambda _: post({"model": MODEL, "messages": msg, "max_tokens": 1000})[0],
                              range(AGREED_CONCURRENCY)))
    results["agreed_concurrency_no_429"] = (all(c == 200 for c in codes), f"codes {sorted(codes)}")
    code, _, _, _ = post({"model": MODEL + "-typo", "messages": msg})
    results["unknown_model_rejected"] = (code in (400, 403, 404), f"HTTP {code}")
    for name, (passed, note) in results.items():
        print(f"{'PASS' if passed else 'FAIL'}  {name}: {note}")
    return 0 if all(p for p, _ in results.values()) else 1

if __name__ == "__main__":
    sys.exit(main())

हमने इसे एक लोकल मॉक सर्वर (कोई असली एंडपॉइंट नहीं) पर चलाया जो एक साथ 8 अनुरोधों की अनुमति देता है। AGREED_CONCURRENCY=8 के साथ चारों जाँचें पास हुईं। 12 के साथ समानांतर अनुरोधों वाली जाँच आठ 200 और चार 429 के साथ फ़ेल हुई, और यही नतीजा आप लॉन्च से पहले देखना चाहते हैं, बाद में नहीं। max_tokens=1000 reasoning मॉडलों के लिए जगह छोड़ता है, जो जवाब देने से पहले बजट का कुछ हिस्सा ख़र्च करते हैं।

स्मोक टेस्ट के बाद, असली आकार के प्रॉम्प्ट के साथ अपने मापे हुए पीक पर एक छोटा लोड टेस्ट चलाएँ, और एंडपॉइंट का पहले टोकन तक का समय और पूरे जवाब की लेटेंसी दर्ज करें। अनुरोध ID रखें; BroadNet के डॉक्स सपोर्ट अनुरोधों में X-Request-ID, टाइमस्टैम्प, रूट और स्टेटस माँगते हैं।

BroadNet Inference कहाँ काम आता है

BroadRouter, BroadNet की अपनी साइट है। BroadNet Inference पब्लिक मॉडलों तक सेल्फ़-सर्व एक्सेस बेचता है: टोकन के हिसाब से, ऑडियो मिनट के हिसाब से, सेशन प्लान से और घंटे वाली key से; कीमतें कीमतों के पेज पर हैं। प्राइवेट एंडपॉइंट, क्षेत्रीय प्रोसेसिंग, फ़ाइन-ट्यून और “on request” (अनुरोध पर) लिस्ट किए गए मॉडल सेल्फ़-सर्व नहीं हैं: ये पूछताछ हैं जिनका BroadNet कोटेशन देता है और जिन्हें लिखित में तय करता है। यह पोस्ट नहीं बता सकती कि BroadNet आपके वर्कलोड के लिए क्या ऑफ़र करेगा। साफ़ ब्रीफ़ ही यह जानने का तरीक़ा है।

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

प्राइवेट LLM एंडपॉइंट क्या होता है?

ऐसा API एंडपॉइंट जिसके पीछे एक ग्राहक के लिए रिज़र्व क्षमता हो, न कि हर सेल्फ़-सर्व यूज़र के साथ साझा। BroadNet अपने संस्करण को आपके चुने मॉडल वाला रिज़र्व GPU या नोड बताता है, आपकी अपनी key और सीमाओं और ज़रूरी रीजन के साथ, जिस तक प्राइवेट मॉडल ID से पहुँचा जाता है।

मुझे कितने समानांतर अनुरोध चाहिए, इसका अंदाज़ा कैसे लगाऊँ?

Little's law इस्तेमाल करें: समानांतर अनुरोध = पीक पर प्रति सेकंड अनुरोध × हर अनुरोध के सेकंड। प्रति सेकंड 1.67 अनुरोध, हर एक लगभग 5.8 सेकंड का, मतलब एक साथ लगभग 10 अनुरोध। हर अनुरोध के सेकंड असली मॉडल पर अपने असली प्रॉम्प्ट से मापें।

क्या मैं BroadNet का प्राइवेट एंडपॉइंट सेल्फ़-सर्व ख़रीद सकता हूँ?

नहीं। BroadNet प्राइवेट एंडपॉइंट, क्षेत्रीय प्रोसेसिंग और बिना लिस्ट वाले मॉडल को पूछताछ के रूप में रखता है: आप वर्कलोड बताते हैं और BroadNet कोटेशन देता है। उसकी शर्तें कहती हैं कि प्राइवेट एंडपॉइंट और रिज़र्व क्षमता एक अलग लिखित समझौते के तहत आते हैं।

क्या प्राइवेट एंडपॉइंट के साथ SLA मिलता है?

सिर्फ़ तभी जब आपका लिखित समझौता ऐसा कहे। BroadNet की शर्तें कहती हैं कि सेल्फ़-सर्व पर उपलब्धता की कोई प्रतिबद्धता नहीं है और सर्विस लेवल सिर्फ़ एक अलग लिखित समझौते में होते हैं। उन पर भरोसा करने से पहले सटीक शर्तें माँगें।

मेरा डेटा कहाँ प्रोसेस होगा?

डेटा भेजने से पहले इसे तय करें। BroadNet की शर्तें रेज़िडेंसी की ज़रूरत वाले ग्राहकों से पहले प्रोसेसिंग की जगहें तय करने को कहती हैं, और बताती हैं कि पार्टनर-होस्टेड और बैकअप प्रोसेसिंग में दूसरे प्रोसेसर शामिल होते हैं, और सबप्रोसेसर की सूची ग्राहकों को अनुरोध पर मिलती है।

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

स्रोत