Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Omejitve hitrosti, kvote in ravni

Lekcija 13 od 22 Posodobljeno 29. julij 2026 Razvijalec
Na tej strani
  1. Omejitve hitrosti, kvote in ravni
  2. Sistem ravni
  3. Vrste omejitev hitrosti
  4. Branje glav omejitev hitrosti
  5. Omejevanje hitrosti na strani odjemalca
  6. Strategije za velike količine
  7. Ključne ugotovitve

Omejitve hitrosti, kvote in ravni

Omejitve hitrosti določajo, koliko zahtev lahko pošljete API-ju na minuto. Razumevanje in upravljanje teh omejitev je ključnega pomena za preprečevanje prekinitev storitev v produkcijskem okolju. Nočna mora je vedno enaka: integracija, ki je brezhibno delovala v razvojnem okolju, kjer ste pošiljali tri zahteve na minuto, gre v produkcijo in nenadoma obdela čakalno vrsto več tisoč dokumentov. Napake 429 se usujejo kot plaz in polovica obdelave je izgubljena, ker pretok ni bil predviden.

Sistem ravni

OpenAI organizira omejitve v ravni (stopnje) glede na vašo zgodovino obračunavanja. Ravni ne izberete sami; odklenete jo z zbiranjem porabe in čakanjem določenega časovnega okna. Ta napredek ima pomembno praktično posledico: račun, ustvarjen zgolj za demonstracijo stranki, ne bo imel enake zmogljivosti kot vaš produkcijski račun, čeprav je koda identična.

# Tiers determine your limits
# Tier 1: After first successful payment
# Tier 2: After $50 cumulative spend + 7 days
# Tier 3: After $100 cumulative spend + 7 days
# Tier 4: After $250 cumulative spend + 14 days
# Tier 5: After $1000 cumulative spend + 30 days

# Limits increase significantly with each tier

Vrste omejitev hitrosti

Hkrati veljajo trije števci in prvi, ki ga dosežete, vas blokira. Obdelava kratkih besedil bo nasičila RPM (zahteve na minuto) dolgo pred TPM (žetoni na minuto); nasprotno pa bo analiza dolgih dokumentov izčrpala TPM, čeprav ste poslali le nekaj deset zahtev. Pred določanjem stopnje vzporednosti vedno preverite red velikosti svojih pozivov.

# 1. RPM — Requests Per Minute
# 2. TPM — Tokens Per Minute
# 3. RPD — Requests Per Day

# Order of magnitude for Tier 3 (check your actual limits
# at platform.openai.com > Settings > Limits):
# RPM: 5,000 requests/minute
# TPM: 2,000,000 tokens/minute
# RPD: 10,000 requests/day

Branje glav omejitev hitrosti

Porabe vam ni treba ugibati: vsak odgovor jo nosi v svojih HTTP glavah. SDK jih privzeto skrije, da vrne le razčlenjen objekt, vendar vam with_raw_response omogoča dostop do surovega odgovora, parse() pa rekonstruira običajni objekt. Nadzorna plošča, napajana s temi vrednostmi, vas opozori, ko se približujete zgornji meji, namesto da bi to odkrili šele ob napaki.

from openai import OpenAI
client = OpenAI()

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Hello!"
)

# Access headers via the raw HTTP response
# Using with_raw_response mode
raw = client.responses.with_raw_response.create(
    model="gpt-5.6-terra",
    input="Hello!"
)

print(f"RPM limit: {raw.headers.get('x-ratelimit-limit-requests')}")
print(f"RPM remaining: {raw.headers.get('x-ratelimit-remaining-requests')}")
print(f"TPM limit: {raw.headers.get('x-ratelimit-limit-tokens')}")
print(f"TPM remaining: {raw.headers.get('x-ratelimit-remaining-tokens')}")
print(f"Reset in: {raw.headers.get('x-ratelimit-reset-requests')}")

response = raw.parse()
print(f"Response: {response.output_text}")

Omejevanje hitrosti na strani odjemalca

Bolje je, da se sami upočasnite, kot da vas zavrnejo. Dve implementaciji pokrivata večino potreb.

Omejevanje pretoka s semaforjem

Prva kombinira semafor, ki omejuje število sočasnih klicev, z zamikom, izračunanim iz ciljnega pretoka. V primeru se petdeset povzetkov zažene hkrati, vendar jih le pet teče vzporedno, razmaknjenih z zamikom, ki ustreza 100 zahtevam na minuto. Klicna koda ostane preprost asyncio.gather: vsa disciplina je encapsulirana v razredu.

import asyncio
from openai import AsyncOpenAI

async_client = AsyncOpenAI()

class RateLimiter:
    """Limits the number of simultaneous requests."""

    def __init__(self, max_concurrent: int = 10, rpm: int = 500):
        self.semaphore = asyncio.Semaphore(max_concurrent)
        self.rpm = rpm
        self.delay = 60.0 / rpm  # Delay between each request

    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"Summarize concept {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"Result {i}: {r[:50]}...")

# asyncio.run(batch_processing())

Preprosto vedro žetonov

Vedro žetonov je bolj prilagodljivo, ker omogoča sunkovite obremenitve. Vedro se polni s stalno hitrostjo in prazni z vsakim klicem: če je vaša aplikacija minuto mirovala, lahko znova začne s polno hitrostjo za petdeset zahtev, nato pa se naravno vrne na hitrost polnjenja. To je točno obnašanje, ki ga želite za storitev, ki se izmenjuje med vrhunci in zatišji, in deluje v večnitnih okoljih zahvaljujoč zaklepu.

import time
import threading

class TokenBucket:
    """Rate limiter based on the token bucket algorithm."""

    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):
        """Waits until enough tokens are available."""
        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)

# Usage: max 50 requests per minute
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

Strategije za velike količine

1. Porazdelitev med več projektov

Vsak projekt ima svoje omejitve hitrosti. Če dosežete zgornjo mejo, čeprav ste že na visoki ravni, porazdelitev klicev med več projektov mehansko pomnoži razpoložljivo zmogljivost. Spodnji primer krožnega razporejanja (round-robin) ponazarja načelo; v produkciji premaknite cikel zunaj funkcije, da se ohrani med klici.

from openai import OpenAI

# Each project has its own rate limits
clients = [
    OpenAI(project="proj-aaaa"),  # Project 1
    OpenAI(project="proj-bbbb"),  # Project 2
    OpenAI(project="proj-cccc"),  # Project 3
]

def round_robin_call(prompt: str, clients: list) -> str:
    """Distributes calls across multiple projects."""
    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. Uporaba pravega modela za pravo količino

Izbira modela je tudi odločitev o zmogljivosti, ne le o kakovosti. Pridržanje najtežjih modelov za kritične naloge in preusmeritev obsega na model z višjimi omejitvami sprosti pretok tam, kjer ga dejansko potrebujete.

# Economy models (gpt-5.6-luna) have the highest limits
# Use them for high-volume tasks

# The flagship model (gpt-5.6-sol) has the lowest limits
# Reserve it for critical tasks

3. Čakanje v vrsti

Nazadnje čakanje v vrsti loči proizvodnjo zahtev od njihove porabe. Ena nit odstranjuje elemente iz vrste s fiksnim tempom, medtem ko preostanek aplikacije prosto oddaja zahteve; klicalec blokira na dogodku, dokler ne prispe njegov rezultat. Ta vzorec absorbira vrhunce, ne da bi kdajkoli presegel konfigurirani pretok.

import queue
import threading

class APIQueue:
    """Queue for API calls."""

    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"]

Ključne ugotovitve

  • Omejitve hitrosti veljajo hkrati za RPM, TPM in RPD
  • Vaša raven določa vaše omejitve – povečuje se z vašo kumulativno porabo
  • Berite glave x-ratelimit-*, da v realnem času poznate svojo porabo
  • Implementirajte omejevalnik hitrosti na strani odjemalca, da se izognete napakam 429
  • Za velike količine porazdelite obremenitev med projekte
  • Luna ponuja najvišje omejitve hitrosti za obsežno obdelavo