Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

Limiti tar-rata, kwoti u livelli

Lezzjoni 13 / 22 Aġġornat 29 ta’ Lulju 2026 Zviluppatur
F'din il-paġna
  1. Limiti tar-rata, kwoti u livelli
  2. Is-sistema tal-livelli
  3. Tipi ta’ limiti tar-rata
  4. Qari tal-intestaturi tal-limiti tar-rata
  5. Limitazzjoni tar-rata fuq in-naħa tal-klijent
  6. Strateġiji għal volumi għoljin
  7. Punti Ewlenin

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à