Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Ograničenja stope, kvote i razine

Lekcija 13 od 22 Ažurirano 29. srpnja 2026. Programer
Na ovoj stranici
  1. Ograničenja stope, kvote i razine
  2. Sustav razina
  3. Vrste ograničenja stope
  4. Čitanje zaglavlja ograničenja stope
  5. Ograničavanje stope na strani klijenta
  6. Strategije za velike volumene
  7. Ključne točke

Ograničenja stope, kvote i razine

Ograničenja stope definiraju koliko zahtjeva možeš poslati API-ju u minuti. Razumijevanje i upravljanje tim ograničenjima ključno je za izbjegavanje prekida usluge u produkcijskom okruženju. Noćna mora je uvijek ista: integracija koja je besprijekorno radila u razvoju, gdje si slao tri zahtjeva u minuti, krene u proizvodnju i odjednom obrađuje red od nekoliko tisuća dokumenata. Greške 429 preplave sustav, a pola obrade se izgubi jer propusnost nije bila predviđena.

Sustav razina

OpenAI organizira ograničenja u razine temeljem tvoje povijesti naplate. Ne biraš svoju razinu; otključavaš je akumuliranjem troškova i čekanjem određenog vremenskog prozora. Taj napredak ima važnu praktičnu posljedicu: račun stvoren samo za demonstraciju klijentu neće imati isti kapacitet kao tvoj produkcijski račun, čak i ako je kod identičan.

# Razine određuju tvoja ograničenja
# Razina 1: Nakon prve uspješne uplate
# Razina 2: Nakon 50 USD ukupne potrošnje + 7 dana
# Razina 3: Nakon 100 USD ukupne potrošnje + 7 dana
# Razina 4: Nakon 250 USD ukupne potrošnje + 14 dana
# Razina 5: Nakon 1000 USD ukupne potrošnje + 30 dana

# Ograničenja se značajno povećavaju sa svakom razinom

Vrste ograničenja stope

Tri brojača vrijede istovremeno, a prvi koji dosegneš blokira te. Obrada kratkih tekstova zasitit će RPM (zahtjeva u minuti) puno prije nego TPM (tokena u minuti); suprotno tome, analiza dugih dokumenata iscrpit će TPM čak i ako si poslao samo nekoliko desetaka zahtjeva. Uvijek provjeri red veličine svojih promptova prije nego što odrediš razinu paralelizma.

# 1. RPM — Zahtjeva u minuti (Requests Per Minute)
# 2. TPM — Tokena u minuti (Tokens Per Minute)
# 3. RPD — Zahtjeva dnevno (Requests Per Day)

# Red veličine za Razinu 3 (provjeri svoja stvarna ograničenja
# na platform.openai.com > Settings > Limits):
# RPM: 5.000 zahtjeva/minuti
# TPM: 2.000.000 tokena/minuti
# RPD: 10.000 zahtjeva/dnevno

Čitanje zaglavlja ograničenja stope

Ne moraš nagađati svoju potrošnju: svaki odgovor nosi je u svojim HTTP zaglavljima. SDK ih prema zadanim postavkama skriva kako bi vratio samo parsirani objekt, ali with_raw_response ti daje pristup sirovom odgovoru, a parse() rekonstruira uobičajeni objekt. Nadzorna ploča napunjena tim vrijednostima upozorit će te dok se približavaš stropu, umjesto da to otkriješ putem greške.

from openai import OpenAI
client = OpenAI()

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

# Pristup zaglavljima putem sirovog HTTP odgovora
# Korištenje načina with_raw_response
raw = client.responses.with_raw_response.create(
    model="gpt-5.6-terra",
    input="Hello!"
)

print(f"RPM ograničenje: {raw.headers.get('x-ratelimit-limit-requests')}")
print(f"RPM preostalo: {raw.headers.get('x-ratelimit-remaining-requests')}")
print(f"TPM ograničenje: {raw.headers.get('x-ratelimit-limit-tokens')}")
print(f"TPM preostalo: {raw.headers.get('x-ratelimit-remaining-tokens')}")
print(f"Ponovno postavljanje za: {raw.headers.get('x-ratelimit-reset-requests')}")

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

Ograničavanje stope na strani klijenta

Bolje je da se sam usporiš nego da budeš odbijen. Dvije implementacije pokrivaju većinu potreba.

Ograničavanje propusnosti semaforom

Prva kombinira semafor, koji ograničava broj istovremenih poziva, s kašnjenjem izračunatim iz ciljne propusnosti. U primjeru se pokreće pedeset sažetaka odjednom, ali samo pet teče paralelno, razmaknuto kašnjenjem koje odgovara 100 zahtjeva u minuti. Kod koji poziva ostaje jednostavan asyncio.gather: sva je disciplina encapsulirana u klasi.

import asyncio
from openai import AsyncOpenAI

async_client = AsyncOpenAI()

class RateLimiter:
    """Ograničava broj istovremenih zahtjeva."""

    def __init__(self, max_concurrent: int = 10, rpm: int = 500):
        self.semaphore = asyncio.Semaphore(max_concurrent)
        self.rpm = rpm
        self.delay = 60.0 / rpm  # Kašnjenje između svakog zahtjeva

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

# asyncio.run(batch_processing())

Jednostavna kanta s tokenima

Kanta s tokenima fleksibilnija je jer dopušta burstove (nagle skokove). Kanta se puni konstantnom brzinom i prazni sa svakim pozivom: ako je tvoja aplikacija mirovala minutu, može ponovno pokrenuti punom brzinom za pedeset zahtjeva, a zatim se prirodno vratiti na brzinu punjenja. To je točno ponašanje koje želiš za uslugu koja izmjenjuje vrhunce i zatišja, a funkcionira u višenitnim okruženjima zahvaljujući bravi.

import time
import threading

class TokenBucket:
    """Ograničivač stope temeljen na algoritmu kante s tokenima."""

    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):
        """Čeka dok nije dostupno dovoljno tokena."""
        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)

# Upotreba: maks. 50 zahtjeva u minuti
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 volumene

1. Distribucija na više projekata

Svaki projekt ima svoja vlastita ograničenja stope. Ako dosegneš strop dok si već na visokoj razini, distribucija poziva na više projekata mehanički množi dostupni kapacitet. Donji round-robin ilustrira princip; u proizvodnji premjesti ciklus izvan funkcije kako bi trajao između poziva.

from openai import OpenAI

# Svaki projekt ima svoja vlastita ograničenja stope
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:
    """Distribuira pozive na više projekata."""
    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. Korištenje ispravnog modela za ispravan volumen

Izbor modela također je odluka o kapacitetu, a ne samo o kvaliteti. Rezerviranje najtežih modela za kritične zadatke i usmjeravanje volumena na model s višim ograničenjima oslobađa propusnost tamo gdje ti je stvarno potrebna.

# Ekonomični modeli (gpt-5.6-luna) imaju najviša ograničenja
# Koristi ih za zadatke velikog volumena

# Vodeći model (gpt-5.6-sol) ima najniža ograničenja
# Rezerviraj ga za kritične zadatke

3. Stavljanje u red čekanja

Konačno, stavljanje u red čekanja odvaja proizvodnju zahtjeva od potrošnje. Jedna nit uklanja iz reda fiksnim tempom dok ostatak aplikacije slobodno podnosi zahtjeve; pozivatelj blokira na događaju dok ne stigne njegov rezultat. Ovaj obrazac apsorbira vrhunce bez ikakvog prekoračenja konfigurirane propusnosti.

import queue
import threading

class APIQueue:
    """Red čekanja za API pozive."""

    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 točke

  • Ograničenja stope vrijede istovremeno za RPM, TPM i RPD
  • Tvoja razina određuje tvoja ograničenja — povećava se s tvojom ukupnom potrošnjom
  • Čitaj zaglavlja x-ratelimit-* kako bi znao svoju potrošnju u stvarnom vremenu
  • Implementiraj ograničivač stope na strani klijenta kako bi izbjegao greške 429
  • Distribuiraj opterećenje na projekte za velike volumene
  • Luna nudi najviša ograničenja stope za masovnu obradu