---
title: "प्राइवेट LLM एंडपॉइंट की प्लानिंग: पहले क्या तय करें"
description: "प्राइवेट LLM एंडपॉइंट माँगने से पहले क्या तय करें: वर्कलोड, प्रति सेकंड टोकन, समानांतर अनुरोध, कॉन्टेक्स्ट, रीजन, लाइसेंस और बजट, फिर उसे टेस्ट कैसे करें।"
url: https://broadrouter.com/hi/blog/private-endpoint-planning/
lang: hi
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

यह पेज अंग्रेज़ी से AI की मदद से अनुवाद किया गया है। [अंग्रेज़ी मूल पढ़ें](https://broadrouter.com/blog/private-endpoint-planning/) (2026-11-15 को अपडेट किया गया).

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

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

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

## मुख्य बातें

-   क्षमता का अनुरोध उतना ही अच्छा है जितने उसके आँकड़े: पीक पर प्रति सेकंड अनुरोध, अंदर और बाहर के टोकन, और स्वीकार्य लेटेंसी।
-   समानांतर अनुरोध Little's law से निकलते हैं: एक साथ चल रहे अनुरोध = आने की दर × हर अनुरोध का समय। हर अनुरोध का समय पहले ट्रायल पर मापें।
-   BroadNet सार्वजनिक रूप से प्राइवेट एंडपॉइंट को आपके ट्रैफ़िक के हिसाब से कीमत वाली रिज़र्व GPU क्षमता बताता है, आपकी अपनी key, सीमाओं और रीजन के साथ, जिस तक प्राइवेट मॉडल ID से पहुँचा जाता है। बाक़ी सब BroadNet के साथ तय होता है।
-   BroadNet की शर्तें कहती हैं कि सेल्फ़-सर्व पर उपलब्धता की कोई प्रतिबद्धता नहीं है, और प्राइवेट एंडपॉइंट और रिज़र्व क्षमता एक अलग लिखित समझौते के तहत आते हैं।
-   प्रोडक्शन से पहले मिले हुए एंडपॉइंट को टेस्ट करें: मॉडल ID, स्ट्रीमिंग, तय किए गए समानांतर अनुरोध और ग़लत मॉडल ID पर आने वाला एरर।

**इस पेज पर**

1.  प्राइवेट एंडपॉइंट कब समझदारी है?
2.  वर्कलोड के बारे में क्या तय करें?
3.  वॉल्यूम को प्रति सेकंड टोकन और समानांतर अनुरोधों में कैसे बदलें?
4.  रीजन, रेज़िडेंसी और सीमाओं का क्या?
5.  कौन-सा मॉडल, और किस लाइसेंस के तहत?
6.  बजट कैसे तय करें?
7.  पूछताछ कैसे भेजें?
8.  मिले हुए एंडपॉइंट की जाँच कैसे करें?
9.  BroadNet Inference कहाँ काम आता है

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

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

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

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

-   **सेल्फ़-सर्व सीमाओं से ज़्यादा ट्रैफ़िक।** BroadNet का API रेफ़रंस उपयोग के अनुसार भुगतान वाली key के लिए प्रति मिनट 30 अनुरोध और एक साथ 4 अनुरोध प्रकाशित करता है। इससे ऊपर का स्थिर वर्कलोड क्षमता का सवाल है, रीट्राई का नहीं। ([429 सँभालना](https://broadrouter.com/hi/blog/handle-llm-api-429-rate-limits/) छोटे उछालों को कवर करता है।)
-   **ऐसा मॉडल जो पब्लिक सूची में नहीं है।** BroadNet का कैटलॉग कुछ मॉडलों पर “available on request” (अनुरोध पर उपलब्ध) लिखता है, जिनमें Qwen3-VL 30B-A3B, Qwen3-VL 8B और Cohere Transcribe Arabic का BroadNet फ़ाइन-ट्यून शामिल हैं। [मॉडल कैटलॉग कैसे पढ़ें](https://broadrouter.com/hi/blog/understand-model-status/) फ़र्क़ समझाता है।
-   **प्रोसेसिंग की जगह जिस पर आपका नियंत्रण ज़रूरी है।** डेटा रेज़िडेंसी के नियम, जैसे [सऊदी और UAE PDPL चेकलिस्ट](https://broadrouter.com/hi/blog/saudi-uae-pdpl-llm-api-checklist/) वाले, ऐसा रीजन माँग सकते हैं जो आपने लिखित में तय किया हो।
-   **अनुमान लगाने लायक़ लेटेंसी।** साझा क्षमता दूसरे यूज़र्स के लोड से बदलती है। रिज़र्व क्षमता यह अनिश्चितता हटा देती है, हालाँकि नेटवर्क की दूरी या आपके अपने प्रॉम्प्ट के आकार को नहीं।

अगर इनमें से कुछ भी लागू नहीं, तो सेल्फ़-सर्व key आसान है। और अगर आपका वॉल्यूम बहुत ज़्यादा और स्थिर है, तो इसे ख़ुद चलाने से तुलना करें: [सेल्फ़-होस्टिंग बनाम API लागत](https://broadrouter.com/hi/blog/self-hosting-llm-vs-api-cost/) में तरीक़ा है।

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

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

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

टोकन की संख्या असली सैंपल पर मापें, अंदाज़े से नहीं। एक ही टेक्स्ट के लिए अरबी को अक्सर अंग्रेज़ी से ज़्यादा टोकन चाहिए; [अरबी टोकन काउंटर](https://broadrouter.com/tools/arabic-token-counter/) और [भाषा के हिसाब से असली लागत](https://broadrouter.com/data/real-cost-by-language/) दिखाते हैं कि अलग-अलग टोकनाइज़र पर कितने ज़्यादा। इमेज के लिए [इमेज टोकन कैलकुलेटर](https://broadrouter.com/tools/image-token-calculator/) पहला अनुमान देता है।

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

पीक पर प्रति सेकंड अनुरोध, सबसे व्यस्त घंटे का वॉल्यूम भाग 3,600 है। समानांतर अनुरोध, यानी एक साथ चल रहे अनुरोधों की संख्या, [Little’s law](https://en.wikipedia.org/wiki/Little%27s_law) से निकलती है: किसी सिस्टम में औसत संख्या, आने की दर गुणा हर एक के वहाँ बिताए औसत समय के बराबर है। API के लिए यह है प्रति सेकंड अनुरोध × हर अनुरोध के सेकंड।

```python
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 और थ्रूपुट](https://broadrouter.com/hi/blog/llm-latency-ttft-throughput/) वाली पोस्ट बताती है कि क्या मापें।

दो सावधानियाँ। फ़ॉर्मूला प्रॉम्प्ट प्रोसेसिंग का समय छोड़ देता है, इसलिए लंबे प्रॉम्प्ट या बड़ी इमेज असली अनुरोधों को धीमा करती हैं और समानांतर अनुरोध बढ़ाती हैं। और औसत उछालों को छिपा देते हैं: प्रोवाइडर को सिर्फ़ औसत नहीं, अपने 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 की तुलना](https://broadrouter.com/hi/blog/llm-api-sla-uptime-compared/) पढ़ें।
5.  क्या रखा जाता है? BroadNet के इन्फ़रेंस API के लिए प्रकाशित स्थिति यह है: इन्फ़रेंस कंटेंट रखा नहीं जाता; ज़रूरी अकाउंट, बिलिंग और सुरक्षा मेटाडेटा उसके [प्राइवेसी स्टेटमेंट](https://www.broadnet.ai/inference-privacy) के अनुसार रखा जाता है। पुष्टि करें कि आपके एंडपॉइंट पर भी यही लागू है।

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

सटीक मॉडल और वर्ज़न का नाम लिखें, और जाँचें कि उसका लाइसेंस आपके इस्तेमाल और 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, जो अनुरोध पर है। [कॉन्टेक्स्ट विंडो कैलकुलेटर](https://broadrouter.com/tools/context-window-calculator/) को अपने सबसे बड़े अनुरोध पर चलाएँ, औसत पर नहीं।

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

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

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

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” (अनुवाद: आपका मॉडल, भाषाएँ और ट्रैफ़िक की ज़रूरतें) माँगता है। अपना एक पेज का ब्रीफ़ [संपर्क पेज](https://broadrouter.com/hi/contact/#private) से भेजें, बिना API key या ग्राहक डेटा के। साइज़िंग का आउटपुट, रीजन, मॉडल और लाइसेंस, लेटेंसी का लक्ष्य, बजट की ऊपरी सीमा और अपनी समय-सीमा शामिल करें।

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

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

```python
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 से; कीमतें [कीमतों के पेज](https://broadrouter.com/hi/pricing/) पर हैं। प्राइवेट एंडपॉइंट, क्षेत्रीय प्रोसेसिंग, फ़ाइन-ट्यून और “on request” (अनुरोध पर) लिस्ट किए गए मॉडल सेल्फ़-सर्व नहीं हैं: ये पूछताछ हैं जिनका BroadNet कोटेशन देता है और जिन्हें लिखित में तय करता है। यह पोस्ट नहीं बता सकती कि BroadNet आपके वर्कलोड के लिए क्या ऑफ़र करेगा। साफ़ ब्रीफ़ ही यह जानने का तरीक़ा है।

इस विषय के मुफ़्त टूल (अंग्रेज़ी में)

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[मुफ़्त टूल (अंग्रेज़ी में)](https://broadrouter.com/tools/)

## इस लेख के शब्द

[टोकन (token)](https://broadrouter.com/hi/glossary/token/)

टोकन टेक्स्ट की वह इकाई है जिसे लैंग्वेज मॉडल पढ़ता और लिखता है: कोई शब्द, शब्द का हिस्सा, विराम चिह्न या बाइट का क्रम, जो मॉडल का टोकनाइज़र बनाता है। LLM API इस्तेमाल को टोकन में गिनते हैं, उसी में लिमिट लगाते हैं और आम तौर पर बिल भी बनाते हैं।

[कॉन्करेंसी (concurrency)](https://broadrouter.com/hi/glossary/concurrency/)

कॉन्करेंसी, किसी क्लाइंट के एक ही समय पर चल रहे (in-flight) अनुरोधों की संख्या है। LLM API अक्सर इसकी सीमा हर key या प्लान पर, प्रति मिनट अनुरोधों से अलग रखते हैं, क्योंकि हर खुला अनुरोध जवाब पूरा होने तक GPU क्षमता घेरे रहता है।

[लेटेंसी (latency)](https://broadrouter.com/hi/glossary/latency/)

लैंग्वेज मॉडल API के लिए लेटेंसी वह समय है जो किसी अनुरोध के भेजे जाने से अंतिम आउटपुट टोकन मिलने तक लगता है। यह पहले टोकन तक के समय और जनरेशन टाइम का जोड़ है, और आम तौर पर औसत के बजाय p50 और p95 जैसे परसेंटाइल में बताई जाती है।

[उपयोग के अनुसार भुगतान (pay-as-you-go)](https://broadrouter.com/hi/glossary/pay-as-you-go/)

उपयोग के अनुसार भुगतान (pay-as-you-go) एक प्राइसिंग मॉडल है जिसमें आप सिर्फ़ उतना देते हैं जितना इस्तेमाल करते हैं, जिसे टोकन, अनुरोध या ऑडियो मिनट जैसी इकाइयों में मापा जाता है, बिना सब्सक्रिप्शन या न्यूनतम प्रतिबद्धता के। ज़्यादातर LLM API इसी तरह बिल बनाते हैं, प्रीपेड बैलेंस या समय-समय पर बनने वाले इनवॉइस से।

[टूल कॉलिंग (tool calling)](https://broadrouter.com/hi/glossary/tool-calling/)

टूल कॉलिंग, जिसे function calling भी कहते हैं, LLM API की वह सुविधा है जिसमें मॉडल डेवलपर के तय किए किसी फ़ंक्शन को चलाने का एक स्ट्रक्चर्ड अनुरोध, JSON आर्ग्युमेंट के साथ, लौटाता है। ऐप्लिकेशन फ़ंक्शन चलाकर नतीजा वापस भेजता है; मॉडल ख़ुद कभी कोड नहीं चलाता।

[इनपुट और आउटपुट टोकन (input and output tokens)](https://broadrouter.com/hi/glossary/input-and-output-tokens/)

इनपुट टोकन वे टोकन हैं जिन्हें लैंग्वेज मॉडल किसी अनुरोध में पढ़ता है, जिनमें सिस्टम प्रॉम्प्ट, बातचीत का इतिहास, टूल डेफ़िनिशन और इमेज शामिल हैं। आउटपुट टोकन वे हैं जो वह जवाब में बनाता है, रीज़निंग समेत। LLM API आम तौर पर दोनों की कीमत अलग रखते हैं, और आउटपुट आम तौर पर महँगा होता है।

[कॉन्टेक्स्ट विंडो (context window)](https://broadrouter.com/hi/glossary/context-window/)

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

[पहले टोकन तक का समय (TTFT, time to first token)](https://broadrouter.com/hi/glossary/time-to-first-token/)

Time to first token (TTFT) वह समय है जो लैंग्वेज मॉडल को अनुरोध भेजने से पहला आउटपुट टोकन आने तक लगता है। इसमें नेटवर्क का समय, सर्वर पर कतार और prefill शामिल हैं, यानी वह चरण जिसमें मॉडल पूरा प्रॉम्प्ट पढ़ता है, इसलिए यह प्रॉम्प्ट की लंबाई और लोड के साथ बढ़ता है।

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

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

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

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

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

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

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

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

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

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

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

## आगे पढ़ें

-   [LLM सेल्फ़-होस्ट करें या API लें: असली लागत और ब्रेक-ईवन](https://broadrouter.com/hi/blog/self-hosting-llm-vs-api-cost/)
-   [LLM लेटेंसी: TTFT, टोकन प्रति सेकंड और एंड-टू-एंड समय](https://broadrouter.com/hi/blog/llm-latency-ttft-throughput/)
-   [सऊदी और UAE PDPL और LLM API: cross-border डेटा ट्रांसफ़र चेकलिस्ट](https://broadrouter.com/hi/blog/saudi-uae-pdpl-llm-api-checklist/)
-   [LLM API प्रोवाइडर कैसे चुनें: 20 सवालों की चेकलिस्ट](https://broadrouter.com/hi/blog/choose-llm-api-provider-checklist/)
-   [फ़ीचर लॉन्च से पहले LLM API की लागत का अनुमान कैसे लगाएँ](https://broadrouter.com/hi/blog/estimate-llm-api-cost-before-launch/)
-   [LLM API में 429 एरर कैसे सँभालें: बैकऑफ़, जिटर और लिमिटर](https://broadrouter.com/hi/blog/handle-llm-api-429-rate-limits/)
-   [Live, on request, research: मॉडल कैटलॉग को साफ़-साफ़ कैसे पढ़ें](https://broadrouter.com/hi/blog/understand-model-status/)
-   [BroadNet का GPU हार्डवेयर और सर्विंग का तरीक़ा, BroadNet के शब्दों में](https://broadrouter.com/hi/blog/broadnet-gpu-fleet-and-serving/)
-   [LLM API रिस्पॉन्स कैश करके लागत घटाएँ: Python में एक्ज़ैक्ट-मैच कैश](https://broadrouter.com/hi/blog/cache-llm-responses-cut-cost/)
-   [गाइड: BroadNet Inference के एरर कोड और रीट्राई कब करें](https://broadrouter.com/hi/guides/errors-and-retries/)
-   [गाइड: IP allow-list से API key को अपने सर्वर तक सीमित करें](https://broadrouter.com/hi/guides/api-keys-ip-allow-lists/)

इसे अपने असली वर्कलोड पर आज़माएँ। नए अकाउंट Gemma और ट्रांसक्रिप्शन के लिए US$5 के क्रेडिट से शुरू होते हैं। DeepSeek, GLM, और Qwen3.8 के लिए टॉप-अप ज़रूरी है।

[शुरू करें](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-private-endpoint-planning&utm_content=page-cta) ·

**स्रोत**

-   [BroadNet Inference का परिचय: प्राइवेट एंडपॉइंट "Reserved GPU, priced to your traffic", अनुरोध पर क्षेत्रीय प्रोसेसिंग (जाँचा गया 2026-11-15) (अंग्रेज़ी में)](https://www.broadnet.ai/inference)
-   [BroadNet मॉडल कैटलॉग: अनुरोध पर उपलब्ध, हर ग्राहक के हिसाब से साइज़ किए गए मल्टी-GPU प्राइवेट एंडपॉइंट (जाँचा गया 2026-11-15) (अंग्रेज़ी में)](https://www.broadnet.ai/inference/models)
-   [BroadNet मॉडल पेज, Qwen3-VL 30B-A3B Instruct: अनुरोध पर, हर ग्राहक को प्राइवेट ID, 16K कॉन्टेक्स्ट (जाँचा गया 2026-11-15) (अंग्रेज़ी में)](https://www.broadnet.ai/inference/models/qwen3-vl-30b-a3b)
-   [BroadNet मॉडल पेज, Gemma 4 VL 26B: आपकी अपनी key, सीमाओं और रीजन वाला प्राइवेट एंडपॉइंट (जाँचा गया 2026-11-15) (अंग्रेज़ी में)](https://www.broadnet.ai/inference/models/gemma-4-vl-26b)
-   [BroadNet सेवा की शर्तें, §7.3a होस्टिंग और प्रोसेसिंग की जगहें और §7.4 उपलब्धता, आख़िरी अपडेट 23 सितंबर 2026 (जाँचा गया 2026-11-15) (अंग्रेज़ी में)](https://www.broadnet.ai/terms)
-   [BroadNet Inference API रेफ़रंस: प्राइवेट ID, उपयोग के अनुसार भुगतान की सीमाएँ, स्ट्रीमिंग, एरर (जाँचा गया 2026-11-15) (अंग्रेज़ी में)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-private-endpoint-planning&utm_content=sources)
-   [BroadNet Inference प्राइवेसी और डेटा रिटेंशन स्टेटमेंट: प्रोसेसिंग कहाँ होती है (जाँचा गया 2026-11-15) (अंग्रेज़ी में)](https://www.broadnet.ai/inference-privacy)
-   [Little's law, L = λW (Wikipedia, जाँचा गया 2026-11-15)](https://en.wikipedia.org/wiki/Little%27s_law)
