Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Limity rýchlosti, kvóty a úrovne

Lekcia 13 z 22 Aktualizované 29. júla 2026 Vývojár
Na tejto strane
  1. Limity rýchlosti, kvóty a úrovne
  2. Systém úrovní
  3. Typy limitov rýchlosti
  4. Čítanie hlavičiek limitov rýchlosti
  5. Obmedzovanie rýchlosti na strane klienta
  6. Stratégie pre vysoké objemy
  7. Kľúčové poznatky

Limity rýchlosti, kvóty a úrovne

Limity rýchlosti definujú, koľko požiadaviek môžeš odoslať do API za minútu. Pochopenie a správa týchto limitov sú kľúčové pre predchádzanie výpadkom služby v produkcii. Nočná mora vyzerá vždy rovnako: integrácia, ktorá bezchybne fungovala vo vývoji, kde si odosielal tri požiadavky za minútu, ide do ostrej prevádzky a zrazu spracováva front niekoľkých tisíc dokumentov. Chyby 429 prichádzajú v záplave a polovica spracovania sa stratí, pretože sa nepočítalo s priepustnosťou.

Systém úrovní

OpenAI organizuje limity do úrovní na základe tvojej histórie fakturácie. Úroveň si nevyberáš; odomkneš ju nahromadením útrat a vyčkaním určitého časového okna. Tento postup má dôležitý praktický dôsledok: účet vytvorený len pre demo klientovi nebude mať rovnakú kapacitu ako tvoj produkčný účet, aj keď je kód identický.

# Úrovne určujú tvoje limity
# Úroveň 1: Po prvej úspešnej platbe
# Úroveň 2: Po kumulatívnej útrate 50 $ + 7 dňoch
# Úroveň 3: Po kumulatívnej útrate 100 $ + 7 dňoch
# Úroveň 4: Po kumulatívnej útrate 250 $ + 14 dňoch
# Úroveň 5: Po kumulatívnej útrate 1000 $ + 30 dňoch

# Limity sa s každou úrovňou výrazne zvyšujú

Typy limitov rýchlosti

Súčasne platia tri počítadlá a prvé, ktoré dosiahneš, ťa zablokuje. Spracovanie krátkych textov nasýti RPM (požiadavky za minútu) dlho pred TPM (tokeny za minútu); naopak, analýza dlhých dokumentov vyčerpá TPM, aj keď si odoslal len niekoľko desiatok požiadaviek. Pred nastavením paralelizmu si vždy over rádové veľkosti svojich promptov.

# 1. RPM — Požiadavky za minútu (Requests Per Minute)
# 2. TPM — Tokeny za minútu (Tokens Per Minute)
# 3. RPD — Požiadavky za deň (Requests Per Day)

# Rádové veľkosti pre Úroveň 3 (skutočné limity si over
# na platform.openai.com > Settings > Limits):
# RPM: 5 000 požiadaviek/minútu
# TPM: 2 000 000 tokenov/minútu
# RPD: 10 000 požiadaviek/deň

Čítanie hlavičiek limitov rýchlosti

Netreba hádať tvoju spotrebu: každá odpoveď ju nesie vo svojich HTTP hlavičkách. SDK ich štandardne skrýva, aby vrátilo iba analyzovaný objekt, ale with_raw_response ti dá prístup k surovej odpovedi a parse() zrekonštruuje bežný objekt. Dashboard napájaný týmito hodnotami ťa upozorní, keď sa blížiš k stropu, namiesto toho, aby si to zistil až cez chybu.

from openai import OpenAI
client = OpenAI()

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

# Prístup k hlavičkám cez surovú HTTP odpoveď
# Použitie režimu with_raw_response
raw = client.responses.with_raw_response.create(
    model="gpt-5.6-terra",
    input="Hello!"
)

print(f"Limit RPM: {raw.headers.get('x-ratelimit-limit-requests')}")
print(f"Zostávajúce RPM: {raw.headers.get('x-ratelimit-remaining-requests')}")
print(f"Limit TPM: {raw.headers.get('x-ratelimit-limit-tokens')}")
print(f"Zostávajúce TPM: {raw.headers.get('x-ratelimit-remaining-tokens')}")
print(f"Reset za: {raw.headers.get('x-ratelimit-reset-requests')}")

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

Obmedzovanie rýchlosti na strane klienta

Je lepšie sa sám spomaliť, než byť odmietnutý. Dve implementácie pokrývajú väčšinu potrieb.

Obmedzenie priepustnosti pomocou semafóru

Prvá kombinuje semafor, ktorý obmedzuje počet súbežných volaní, s oneskorením vypočítaným z cieľovej priepustnosti. V príklade sa spustí päťdesiat zhrnutí naraz, ale paralelne prebiehajú iba päť, oddelené oneskorením zodpovedajúcim 100 požiadavkám za minútu. Volajúci kód zostáva jednoduchý asyncio.gather: celá disciplína je zapuzdrená v triede.

import asyncio
from openai import AsyncOpenAI

async_client = AsyncOpenAI()

class RateLimiter:
    """Obmedzuje počet súbežných požiadaviek."""

    def __init__(self, max_concurrent: int = 10, rpm: int = 500):
        self.semaphore = asyncio.Semaphore(max_concurrent)
        self.rpm = rpm
        self.delay = 60.0 / rpm  # Onesorenie medzi každou požiadavkou

    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"Zhrň koncept {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"Výsledok {i}: {r[:50]}...")

# asyncio.run(batch_processing())

Jednoduchý token bucket

Token bucket je flexibilnejší, pretože umožňuje nárazové špičky. Vedro sa plní konštantnou rýchlosťou a s každým volaním sa vyprázdňuje: ak tvoja aplikácia bola minútu nečinná, môže reštartovať plnou rýchlosťou na päťdesiat požiadaviek a potom prirodzene klesnúť na rýchlosť plnenia. Presne takéto správanie chceš pre službu, ktorá strieda špičky a poklesy, a vďaka zámku funguje aj v multivláknových prostrediach.

import time
import threading

class TokenBucket:
    """Obmedzovač rýchlosti založený na algoritme token bucket."""

    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):
        """Čaká, kým nie je k dispozícii dostatok tokenov."""
        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)

# Použitie: max 50 požiadaviek za minútu
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

Stratégie pre vysoké objemy

1. Distribúcia medzi viaceré projekty

Každý projekt má svoje vlastné limity rýchlosti. Ak dosiahneš strop, keď už si na vysokej úrovni, distribúcia volaní medzi viaceré projekty mechanicky znásobí dostupnú kapacitu. Nižšie uvedený round-robin ilustruje princíp; v produkcii presuň cyklus mimo funkcie, aby pretrvával medzi volaniami.

from openai import OpenAI

# Každý projekt má svoje vlastné limity rýchlosti
clients = [
    OpenAI(project="proj-aaaa"),  # Projekt 1
    OpenAI(project="proj-bbbb"),  # Projekt 2
    OpenAI(project="proj-cccc"),  # Projekt 3
]

def round_robin_call(prompt: str, clients: list) -> str:
    """Distribuuje volania medzi viaceré projekty."""
    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. Použitie správneho modelu pre správny objem

Výber modelu je tiež rozhodnutím o kapacite, nielen o kvalite. Vyhradenie najnáročnejších modelov pre kritické úlohy a smerovanie objemu na model s vyššími limitmi uvoľní priepustnosť tam, kde ju skutočne potrebuješ.

# Ekonomické modely (gpt-5.6-luna) majú najvyššie limity
# Použi ich pre úlohy s vysokým objemom

# Vlajkový model (gpt-5.6-sol) má najnižšie limity
# Vyhraď ho pre kritické úlohy

3. Fronty (Queuing)

Nakoniec, fronty oddeľujú produkciu požiadaviek od ich spotreby. Jediné vlákno vyberá položky frontu pevným tempom, zatiaľ čo zvyšok aplikácie odosiela voľne; volateľ blokuje na udalosti, kým nepríde jeho výsledok. Tento vzor absorbuje špičky bez toho, aby niekedy prekročil nastavenú priepustnosť.

import queue
import threading

class APIQueue:
    """Fronta pre volania 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"]

Kľúčové poznatky

  • Limity rýchlosti platia súčasne pre RPM, TPM a RPD
  • Tvoja úroveň určuje tvoje limity – zvyšuje sa s tvojou kumulatívnou útratou
  • Čítaj hlavičky x-ratelimit-*, aby si poznal svoju spotrebu v reálnom čase
  • Implementuj obmedzovač rýchlosti na strane klienta, aby si sa vyhol chybám 429
  • Pre vysoké objemy rozdeľ záťaž medzi projekty
  • Luna ponúka najvyššie limity rýchlosti pre hromadné spracovanie