Binibilang ng rate limit ang mga request sa loob ng isang panahon. Binibilang naman ng concurrency ang mga request sa iisang sandali. Puwedeng tumagal nang maraming segundo ang LLM request, kaya madalas na ang ikalawang limit ang unang tumatama.
Paano ito gumagana
Pinag-uugnay ng Little’s law ang tatlong numero:
requests in flight = request rate × average time per request
Ibig sabihin, ang bilang ng request na in flight ay katumbas ng bilis ng request na pinarami sa average na tagal ng bawat request. Halimbawa, isang hypothetical na key na pumapayag sa 5 request na in flight at 60 request kada minuto, kung saan 20 segundo ang bawat request. Ang concurrency cap ay pumapayag lang sa hanggang 5 ÷ 20 = 0.25 request kada segundo, o 15 kada minuto. Hindi mo kailanman maaabot ang 60 kada minuto, dahil concurrency ang tumatamang limit. Kung 2 segundo ang bawat request, 150 kada minuto ang papayagan ng parehong cap, at ang rate limit na ang tatama. Ginagawa ng rate limit calculator ang kuwentang ito gamit ang sarili mong mga numero.
Pinatatagal ng mahahabang output, reasoning token at mahahabang prompt ang mga request, kaya mas mabilis nilang nauubos ang concurrency. Hawak ng naka-stream na sagot ang slot nito hanggang matapos ito.
Bakit ito mahalaga
Nililimitahan ng mga provider ang concurrency dahil pinaghahatian ang GPU memory at compute. Ipinapakita ng mga benchmark ng NVIDIA na habang tumataas ang concurrency sa isang server, tumataas ang kabuuang output habang bumababa ang tokens per second ng bawat request. Pinipigilan ng cap kada key ang isang client na pabagalin ang lahat.
Para sa app mo, ang concurrency ang nagtatakda ng laki ng worker pool at kung ilang agent ang puwedeng sabay na tumakbo. Itugma ang pool sa cap, huwag lumampas, o puro 429 error lang ang makukuha ng mga sobrang worker.
Sa BroadNet Inference
| Access | Concurrency |
|---|---|
| Pay-as-you-go key | 4 request na in flight, at 30 request kada minuto |
| Hourly key | Isang stream |
| Unlimited plan | Isang request sa bawat pagkakataon kada session |
Concurrency mismo ang ibinebenta ng mga plan. Walang token meter ang isang session at isang request lang ang pinapatakbo nito sa bawat pagkakataon, gaya ng paggana ng isang agent. Pumipila sa isa’t isa ang mga request sa parehong session. Para magpatakbo ng mga agent nang parallel, bumili ng isang session kada agent: apat na session ang kailangan ng orchestrator at tatlong sub-agent. Puwedeng maglaman ng ilang session ang isang key.
Basahin ang paano gumagana ang mga unlimited session at paano magpatakbo ng parallel na coding agent sa flat rate. Malaking bahagi ng oras ng mga agent ay napupunta sa pagpapatakbo ng mga tool, kaya sukatin muna ang tunay na overlap bago bumili ng mas maraming session.
Mga karaniwang pagkakamali
- Pagsisimula ng isang worker kada task nang walang pool. Nagiging 100 sabay-sabay na request ang batch na 100 task.
- Pag-set ng client timeout na mas maikli kaysa sa mahabang reasoning na sagot. Sumusuko ang client habang okupado pa ang slot.