Ang “kailangan namin ng dedicated na endpoint” ay simula ng usapan, hindi specification. Hindi masusukat, mailalagay o mapepresyuhan ng provider ang capacity nang wala ang mga numero mo, at hindi mo rin mahuhusgahan ang sagot nila nang wala ang mga iyon. Inililista ng post na ito kung ano ang dapat tukuyin bago ka humingi, gamit ang halimbawang invoice extraction, at nagtatapos sa script na nagche-check sa endpoint na ibinigay sa iyo.
Para ito sa anumang provider. Kapag inilalarawan nito ang alok ng BroadNet, nananatili ito sa pampublikong sinasabi ng BroadNet, na sinuri noong Nobyembre 15, 2026. Anumang lampas doon ay tanong para sa BroadNet.
Kailan makatwiran ang private endpoint?
Kadalasan dahil sa isa sa apat na dahilan:
- Traffic na lampas sa self-serve na limit. Inilalathala ng API reference ng BroadNet ang 30 request kada minuto at 4 request nang sabay para sa pay-as-you-go key. Ang tuloy-tuloy na workload na lampas diyan ay tanong sa capacity, hindi tanong sa retry. (Sinasaklaw ng paghawak sa mga 429 ang maiikling bugso.)
- Model na wala sa pampublikong listahan. Minamarkahan ng catalogue ng BroadNet ang ilang model na “available on request” (available kapag hiniling), kasama ang Qwen3-VL 30B-A3B, Qwen3-VL 8B at isang fine-tune ng BroadNet ng Cohere Transcribe Arabic. Ipinapaliwanag ng pagbasa ng model catalogue ang pagkakaiba.
- Lokasyon ng processing na kailangan mong kontrolin. Puwedeng mangailangan ang mga patakaran sa data residency, gaya ng nasa checklist sa PDPL ng Saudi at UAE, ng region na napagkasunduan nang nakasulat.
- Predictable na latency. Nag-iiba ang shared capacity ayon sa load ng ibang user. Inaalis ng reserved capacity ang variable na iyan, pero hindi ang layo ng network o ang laki ng sarili mong prompt.
Kung wala sa mga ito ang tumutugma, mas simple ang self-serve na key. At kung napakataas at tuloy-tuloy ang volume mo, ihambing ito sa pagpapatakbo mo mismo: nasa self-hosting vs gastos sa API ang paraan.
Ano ang dapat mong tukuyin tungkol sa workload?
Sumulat ng isang-pahinang brief. Ito ang mga numerong kailangan ng provider:
| Item | Ano ang isusulat | Halimbawa |
|---|---|---|
| Task | Ano ang ginagawa ng model, sa isang pangungusap | Basahin ang litrato ng invoice, ibalik ang mga JSON field |
| Volume | Request kada araw, at ang bahagi sa pinakaabalang oras | 40,000 kada araw, 15% sa peak hour |
| Token | Average at 95th-percentile na input at output token | 1,800 papasok (larawan ng isang page + prompt), 350 palabas |
| Context | Pinakamalaking iisang request, prompt kasama ang sagot | 4,000 token |
| Latency | Katanggap-tanggap na oras hanggang unang token at hanggang buong sagot | Buong sagot sa loob ng 10 segundo |
| Streaming | Kailangan o hindi | Hindi kailangan (parang batch) |
| Input | Text, larawan, audio; format at laki | JPEG at PNG, tig-iisang page |
| Wika | Alin, at ang bahagi ng bawat isa | Arabic at English, 60/40 |
| Paglago | Inaasahang volume sa loob ng 6 at 12 buwan | Doble sa loob ng 12 buwan |
Sukatin ang bilang ng token sa totoong sample, hindi sa hula. Kadalasang mas maraming token ang kailangan ng Arabic kaysa English para sa parehong text; ipinapakita ng Arabic token counter at totoong gastos kada wika kung gaano kalaki sa iba’t ibang tokenizer. Para sa mga larawan, nagbibigay ng unang tantiya ang image token calculator.
Paano gawing token kada segundo at concurrency ang volume?
Ang peak na request kada segundo ay ang volume sa pinakaabalang oras na hinati sa 3,600. Ang concurrency, ang bilang ng request na sabay na tumatakbo, ay sumusunod sa Little’s law: ang average na bilang sa isang sistema ay katumbas ng arrival rate na pinarami sa average na oras na ginugugol ng bawat isa roon. Para sa API, iyan ay request kada segundo × segundo kada request.
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))
Ang lumabas: 1.67 request kada segundo sa peak, mga 5.8 segundo kada request, 10 sabay na request, 3,000 input at 583 output token kada segundo, at 2,580 milyong token kada buwan. Palagay lang para sa halimbawa ang 60 token kada segundo; sukatin ang sarili mo sa model na gagamitin mo, dahil nag-iiba ang bilis ayon sa model, haba ng prompt at load. Ipinapaliwanag ng post na latency, TTFT at throughput kung ano ang dapat orasan.
Dalawang babala. Hindi isinasama ng formula ang oras ng pagproseso ng prompt, kaya pinababagal ng mahahabang prompt o malalaking larawan ang totoong request at itinutulak pataas ang concurrency. At itinatago ng average ang mga bugso: ibigay sa provider ang 95th-percentile na laki ng request mo at isang maikling profile ng bugso, hindi lang ang mean. Ang peak ng halimbawang ito (mga 100 request kada minuto at 10 nang sabay) ay lampas na lampas sa inilathalang self-serve na limit para sa iisang pay-as-you-go key, at iyan mismo ang panahong sulit ang usapan tungkol sa capacity.
Paano naman ang region, residency at mga limit?
Pagkasunduan ang mga ito nang tahasan, nang nakasulat, bago gumalaw ang anumang regulated na data. Sabi ng Terms ng BroadNet (§7.3a): “Contact us to agree processing locations for your deployment before sending data with residency requirements,” (salin: Makipag-ugnayan sa amin para pagkasunduan ang mga lokasyon ng processing para sa deployment mo bago magpadala ng data na may residency requirement,) at may kasamang ibang processor ang partner-hosted at backup na processing, na may kasalukuyang listahan ng subprocessor na makukuha ng mga customer kapag hiniling. Sabi ng privacy statement nito, tumatakbo ang sariling model ng BroadNet at ang mga hosted na open-weight model sa hardware na pag-aari o inuupahan ng BroadNet sa United States, na may partner capacity bilang backup, at sabi ng overview page nito, available kapag hiniling ang regional processing sa MENA o Europe.
Kaya ito ang mga tanong para sa anumang provider:
- Aling region ang nagpoproseso ng mga request, at aling region ang may hawak ng backup capacity?
- Aling mga subprocessor ang puwedeng humawak ng traffic, kasama para sa failover o overflow?
- Ano ang rate, concurrency at token limit ng endpoint, at ano ang nangyayari kapag lumampas?
- Anong mga tuntunin sa availability at support ang umiiral, at saan nakasulat ang mga ito? Sabi ng Terms ng BroadNet (§7.4), walang availability commitment ang self-serve, at sumusunod sa hiwalay mong nakasulat na kasunduan ang private endpoint at reserved capacity. Para makita kung ano ang sinasaklaw ng mga nakasulat na SLA ng ibang provider, basahin ang paghahambing ng SLA ng LLM API.
- Ano ang itinatago? Para sa inference API ng BroadNet, ito ang inilathalang posisyon: hindi itinatago ang inference content; itinatago ang kinakailangang metadata ng account, billing at seguridad ayon sa privacy statement nito. Kumpirmahing pareho rin ito para sa endpoint mo.
Aling model, at sa ilalim ng aling lisensya?
Pangalanan ang eksaktong model at bersyon, at tiyaking pinapayagan ng lisensya nito ang gamit mo at ang API serving. Inililista ng mga model page ng BroadNet ang Apache-2.0 para sa Gemma 4 26B, Qwen3-VL 30B-A3B at sa base weights ng Cohere Transcribe, at ang fine-tune ng BroadNet ng Cohere Transcribe Arabic ay “under contract” (sa ilalim ng kontrata). Sabi ng Terms nito, pinamamahalaan ng kanilang lisensya ang mga model, at umiiral pa rin ang lisensya ng DeepSeek V4.1 Flash kapag partner-hosted.
Pagkasunduan din ang context window. Nakadepende ang context limit sa model at sa deployment, hindi lang sa maximum ng base model: naglilista ang BroadNet ng 32K token para sa Gemma 4 VL 26B sa pampublikong API nito at 16K para sa Qwen3-VL 30B-A3B, na available kapag hiniling. Gamitin ang context window calculator sa pinakamalaki mong request, hindi sa average.
Paano magtakda ng budget?
Walang inilalathalang presyo ng private endpoint ang BroadNet; sabi ng overview page nito, “Reserved GPU, priced to your traffic. Ask for a quote.” (salin: Nakalaang GPU, may presyong ayon sa traffic mo. Humingi ng quote.) Kaya itakda muna ang sarili mong kisame. Presyuhan ang parehong workload sa self-serve gamit ang LLM API cost calculator, gamit ang buwanang bilang ng token mula sa sizing script, at pagpasyahan kung magkano ang halaga sa iyo ng predictable na capacity, isang region o isang model na hindi pampubliko, bilang dagdag. Bonus ang quote na mas mababa sa self-serve na numero; ang quote na malayong mas mataas ay nangangailangan ng dahilan mula sa listahan mo ng mga requirement.
Paano ipadala ang inquiry?
Sabi ng API reference ng BroadNet: “Private endpoints, our Arabic fine-tunes and other models on request are reached with a private ID issued with the endpoint.” (salin: Naaabot ang mga private endpoint, ang aming mga Arabic fine-tune at iba pang model na kapag hiniling gamit ang private ID na ibinibigay kasama ng endpoint.) Hinihingi ng overview page nito ang “your model, languages and traffic requirements” (salin: ang iyong model, mga wika at requirement sa traffic). Ipadala ang isang-pahinang brief mo sa contact page, nang walang API key o data ng customer. Isama ang output ng sizing, ang region, ang model at lisensya, ang target na latency, ang kisame ng budget mo at ang timeline mo.
Paano i-validate ang endpoint na ibinigay sa iyo?
Bago ang production traffic, i-test ang endpoint laban sa napagkasunduan. Python standard library lang ang gamit ng script na ito. Tinitingnan nito kung gumagana ang private model ID, kung nagtatapos ang streaming sa data: [DONE] marker na inilalarawan ng docs ng BroadNet, kung tumatakbo ang napagkasunduang concurrency nang walang 429, at kung tinatanggihan ang maling model 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())
Pinatakbo namin ito laban sa lokal na mock server (hindi totoong endpoint) na nagpapahintulot ng 8 request nang sabay. Sa AGREED_CONCURRENCY=8, pumasa ang apat na check. Sa 12, bumagsak ang concurrency check na may walong 200 at apat na 429, at iyan ang resultang gusto mong makita bago mag-launch, hindi pagkatapos. Nag-iiwan ng espasyo ang max_tokens=1000 para sa mga reasoning model, na gumagastos ng bahagi ng budget bago sumagot.
Pagkatapos ng smoke test, magpatakbo ng maikling load test sa sinukat mong peak gamit ang mga prompt na totoong laki, at i-record ang time to first token at latency hanggang buong sagot ng endpoint. Itago ang mga request ID; hinihingi ng docs ng BroadNet ang X-Request-ID, timestamp, route at status sa mga support request.
Saan pumapasok ang BroadNet Inference
Ang BroadRouter ay sariling website ng BroadNet. Nagbebenta ang BroadNet Inference ng self-serve na access sa mga pampublikong model kada token, kada minuto ng audio, kada session plan at kada hourly key; nasa pricing page ang mga presyo. Hindi self-serve ang private endpoint, regional processing, fine-tune at mga model na nakalistang “on request”: mga inquiry ang mga ito na binibigyan ng quote ng BroadNet at pinagkakasunduan nang nakasulat. Hindi masasabi ng post na ito kung ano ang iaalok ng BroadNet para sa workload mo. Ang malinaw na brief ang paraan para malaman mo.
