Limiti tar-rata, kwoti u livelli
F'din il-paġna
Limiti tar-rata, kwoti u livelli
Il-limiti tar-rata jiddefinixxu kemm-il talba tista’ tibgħat lill-API kull minuta. Li tifhem u timmaniġġja dawn il-limiti huwa kruċjali biex tevita interruzzjonijiet tas-servizz fil-produzzjoni. L-agħar xenarju dejjem ikun l-istess: integrazzjoni li ħadmet bla tfixkil fl-iżvilupp, fejn ibgħatt tliet talbiet kull minuta, tmur live u f’daqqa waħda tipproċessja kju ta’ diversi eluf ta’ dokumenti. Żbalji 429 jaslu bħala għargħar, u nofs l-ipproċessar jintilef għax il-fluss ma ġiex antiċipat.
Is-sistema tal-livelli
OpenAI torganizza l-limiti f’livelli (stadi) ibbażati fuq l-istorja tal-ħlasijiet tiegħek. Inti ma tagħżilx il-livell tiegħek; tiftaħlu l-bieb billi takkumula nefqa u tistenna li jgħaddi ċertu perjodu ta’ żmien. Din il-progressjoni għandha konsegwenza prattika importanti: kont maħluq apposta għal demo għal klijent ma jkollux l-istess kapaċità bħall-kont tal-produzzjoni tiegħek, anke jekk il-kodiċi jkun identiku.
# Il-livelli jiddeterminaw il-limiti tiegħek
# Livell 1: Wara l-ewwel ħlas suċċess
# Livell 2: Wara $50 ta' nefqa kumulattiva + 7 ijiem
# Livell 3: Wara $100 ta' nefqa kumulattiva + 7 ijiem
# Livell 4: Wara $250 ta' nefqa kumulattiva + 14-il jum
# Livell 5: Wara $1000 ta' nefqa kumulattiva + 30 jum
# Il-limiti jiżdiedu b'mod sinifikanti ma' kull livell
Tipi ta’ limiti tar-rata
Tliet kontituri japplikaw simultanjament, u l-ewwel wieħed li tilħaq jimblokkak. L-ipproċessar ta’ testi qosra se jissatura r-RPM ferm qabel it-TPM; bil-kontra, l-analiżi ta’ dokumenti twal se teħles it-TPM anke jekk tkun ibgħatt ftit u xejn talbiet. Dejjem iċċekkja l-ordni tal-kobor tal-prompts tiegħek qabel ma tiddimensjona l-paralleliżmu tiegħek.
# 1. RPM — Talbiet Kull Minuta
# 2. TPM — Tokens Kull Minuta
# 3. RPD — Talbiet Kull Jum
# Ordni tal-kobor għal Livell 3 (iċċekkja l-limiti attwali tiegħek
# fuq platform.openai.com > Settings > Limits):
# RPM: 5,000 talba/minuta
# TPM: 2,000,000 token/minuta
# RPD: 10,000 talba/jum
Qari tal-intestaturi tal-limiti tar-rata
M’għandekx bżonn tissuspetta l-konsum tiegħek: kull tweġiba ġġorrha fl-intestaturi HTTP tagħha. L-SDK jħbihom b’mod predefinit biex jirritorna biss l-oġġett ipparzjat, iżda with_raw_response jagħtik aċċess għat-tweġiba mhux ipproċessata, u parse() jerġa’ jibni l-oġġett tas-soltu. Dashboard imħaddem minn dawn il-valuri jwissik hekk kif toqrob lejn is-saqaf minflok ma jħallik tiskoprih permezz ta’ żball.
from openai import OpenAI
client = OpenAI()
response = client.responses.create(
model="gpt-5.6-terra",
input="Hello!"
)
# Aċċessa l-intestaturi permezz tat-tweġiba HTTP mhux ipproċessata
# Bl-użu tal-modalità with_raw_response
raw = client.responses.with_raw_response.create(
model="gpt-5.6-terra",
input="Hello!"
)
print(f"Limitu RPM: {raw.headers.get('x-ratelimit-limit-requests')}")
print(f"RPM li fadal: {raw.headers.get('x-ratelimit-remaining-requests')}")
print(f"Limitu TPM: {raw.headers.get('x-ratelimit-limit-tokens')}")
print(f"TPM li fadal: {raw.headers.get('x-ratelimit-remaining-tokens')}")
print(f"Irrisettja f': {raw.headers.get('x-ratelimit-reset-requests')}")
response = raw.parse()
print(f"Tweġiba: {response.output_text}")
Limitazzjoni tar-rata fuq in-naħa tal-klijent
Huwa aħjar li tbaxxi l-veloċità tiegħek stess milli tiġi miċħud. Żewġ implimentazzjonijiet ikopru l-biċċa l-kbira tal-ħtiġijiet.
Limitazzjoni tal-fluss b’semafur
L-ewwel waħda tgħaqqad semafur, li jillimita n-numru ta’ sejħiet simultanji, ma’ dewmien ikkalkulat mill-fluss fil-mira. Fl-eżempju, ħamsin sommarju jitnedew fl-istess ħin iżda biss ħamsa jipproċedu b’mod parallel, spazjati mid-dewmien korrispondenti għal 100 talba kull minuta. Il-kodiċi li jsejjaħ jibqa’ sempliċi asyncio.gather: id-dixxiplina kollha hija inkapsulata fil-klassi.
import asyncio
from openai import AsyncOpenAI
async_client = AsyncOpenAI()
class RateLimiter:
"""Tillimita n-numru ta' talbiet simultanji."""
def __init__(self, max_concurrent: int = 10, rpm: int = 500):
self.semaphore = asyncio.Semaphore(max_concurrent)
self.rpm = rpm
self.delay = 60.0 / rpm # Dewmien bejn kull talba
async def call(self, prompt: str) -> str:
async with self.semaphore:
await asyncio.sleep(self.delay)
response = await async_client.responses.create(
model="gpt-5.6-terra",
input=prompt
)
return response.output_text
async def batch_processing():
limiter = RateLimiter(max_concurrent=5, rpm=100)
prompts = [f"Agħmel sommarju tal-kunċett {i}" for i in range(50)]
tasks = [limiter.call(p) for p in prompts]
results = await asyncio.gather(*tasks)
for i, r in enumerate(results):
print(f"Riżultat {i}: {r[:50]}...")
# asyncio.run(batch_processing())
Barmil sempliċi tat-tokens
Il-barmil tat-tokens huwa aktar flessibbli għax jippermetti splużjonijiet (bursts). Il-barmil jimtela b’rata kostanti u jitbattal ma’ kull sejħa: jekk l-applikazzjoni tiegħek ilha mistrieħa għal minuta, tista’ terġa’ tibda bil-veloċità sħiħa għal ħamsin talba, imbagħad naturalment terġa’ lura għar-rata ta’ mimli. Dan huwa eżattament l-imġiba li trid għal servizz li jalternat bejn quċċati u perjodi ta’ kwiet, u jaħdem f’ambjenti multi-thread grazzi għall-lock.
import time
import threading
class TokenBucket:
"""Limitatur tar-rata bbażat fuq l-algoritmu tal-barmil tat-tokens."""
def __init__(self, tokens_per_second: float, max_capacity: int):
self.tokens_per_second = tokens_per_second
self.max_capacity = max_capacity
self.tokens = max_capacity
self.last_refill = time.monotonic()
self.lock = threading.Lock()
def wait(self, tokens_needed: int = 1):
"""Jistenna sakemm ikun hemm biżżejjed tokens disponibbli."""
while True:
with self.lock:
now = time.monotonic()
elapsed = now - self.last_refill
self.tokens = min(
self.max_capacity,
self.tokens + elapsed * self.tokens_per_second
)
self.last_refill = now
if self.tokens >= tokens_needed:
self.tokens -= tokens_needed
return
time.sleep(0.1)
# Użu: massimu ta' 50 talba kull minuta
bucket = TokenBucket(tokens_per_second=50/60, max_capacity=50)
def limited_call(prompt: str) -> str:
bucket.wait(1)
response = client.responses.create(
model="gpt-5.6-terra",
input=prompt
)
return response.output_text
Strateġiji għal volumi għoljin
1. Distribuzzjoni fuq proġetti multipli
Kull proġett għandu l-limiti tar-rata tiegħu stess. Jekk tilħaq is-saqaf tiegħek waqt li diġà qiegħed fuq livell għoli, id-distribuzzjoni tas-sejħiet fuq proġetti multipli timmultiplika mekkanikament il-kapaċità disponibbli. Ir-round-robin hawn taħt juri l-prinċipju; fil-produzzjoni, mexxi ċ-ċiklu barra mill-funzjoni biex jippersisti bejn is-sejħiet.
from openai import OpenAI
# Kull proġett għandu l-limiti tar-rata tiegħu stess
clients = [
OpenAI(project="proj-aaaa"), # Proġett 1
OpenAI(project="proj-bbbb"), # Proġett 2
OpenAI(project="proj-cccc"), # Proġett 3
]
def round_robin_call(prompt: str, clients: list) -> str:
"""Jiddistribwixxi s-sejħiet fuq proġetti multipli."""
import itertools
client_cycle = itertools.cycle(clients)
client = next(client_cycle)
return client.responses.create(
model="gpt-5.6-terra",
input=prompt
).output_text
2. Użu tal-mudell it-tajjeb għall-volum it-tajjeb
L-għażla tal-mudell hija wkoll deċiżjoni ta’ kapaċità, mhux biss ta’ kwalità. Ir-riżerva tal-mudelli l-aktar tqal għal kompiti kritiċi u r-routing tal-volum lejn mudell b’limiti ogħla jħalli liberu l-fluss fejn verament teħtieġu.
# Il-mudelli ekonomiċi (gpt-5.6-luna) għandhom l-ogħla limiti
# Użahom għal kompiti b'volum għoli
# Il-mudell ewlieni (gpt-5.6-sol) għandu l-inqas limiti
# Irriżervah għal kompiti kritiċi
3. Kjuwing (Queuing)
Fl-aħħar nett, il-kjuwing jissepara l-produzzjoni tat-talbiet mill-konsum. Thread wieħed iħalli l-kju b’pass fiss filwaqt li l-bqija tal-applikazzjoni tissottometti liberament; is-sejjaħ jimblokka fuq avveniment sakemm jasal ir-riżultat tiegħu. Dan il-mudell jassorbi l-quċċati mingħajr qatt ma jaqbeż il-fluss ikkonfigurat.
import queue
import threading
class APIQueue:
"""Kju għas-sejħiet tal-API."""
def __init__(self, rpm: int = 100):
self.queue = queue.Queue()
self.delay = 60.0 / rpm
self.running = True
self.worker = threading.Thread(target=self._process, daemon=True)
self.worker.start()
def _process(self):
while self.running:
try:
prompt, future = self.queue.get(timeout=1)
response = client.responses.create(
model="gpt-5.6-terra",
input=prompt
)
future["result"] = response.output_text
future["event"].set()
time.sleep(self.delay)
except queue.Empty:
continue
def submit(self, prompt: str) -> str:
future = {"result": None, "event": threading.Event()}
self.queue.put((prompt, future))
future["event"].wait()
return future["result"]
Punti Ewlenin
- Il-limiti tar-rata japplikaw simultanjament f’RPM, TPM u RPD
- Il-livell tiegħek jiddetermina l-limiti tiegħek—jiżdied man-nefqa kumulattiva tiegħek
- Aqra l-intestaturi
x-ratelimit-*biex tkun taf il-konsum tiegħek f’ħin reali - Implimenta limitatur tar-rata fuq in-naħa tal-klijent biex tevita żbalji 429
- Iddistribwixxi t-tagħbija fuq proġetti għal volumi għoljin
- Luna joffri l-ogħla limiti tar-rata għall-ipproċessar bil-kwantità