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

Batch API in kontrolni seznam za produkcijo

Lekcija 12 od 12 Posodobljeno 2. november 2026 Napredni
Na tej strani
  1. Alternativa Batch API: 20 % manj žetonov
  2. Primerjava pristopov
  3. Kontrolni seznam za produkcijo
  4. Priporočena arhitektura
  5. Ključne ugotovitve
  6. Preveri svoje znanje

Alternativa Batch API: 20 % manj žetonov

Ko obdelava v realnem času ni nujna, Batch API ponudbe xAI zagotavlja 20-odstotno znižanje cene za vse žetone pri ustreznih besedilnih modelih (od grok-4.3 do grok-4.7, veljavno 2. novembra 2026, glede na cenik Batch API za xAI). Namesto pošiljanja zahtevkov enega za drugim in upravljanja sočasnosti, zahtevke predložiš v skupinah prek API-ja ali v datoteki JSONL, rezultate pa prejmeš, ko se obdelava konča – običajno v 24 urah. Zahtevki Batch se ne štejejo v omejitve hitrosti. Tečaj Batch API: množična obdelava podrobno opisuje delovni tok.

Kdaj uporabiti Batch API

  • Obdelava katalogov izdelkov (tisoči opisov)
  • Množična klasifikacija vstopnic za podporo
  • Generiranje povzetkov za zbirko dokumentov
  • Vsaka naloga, pri kateri je zamik nekaj ur sprejemljiv

Kdaj ostati pri klasičnem asinchronem načinu

  • Interaktivni klepetalni bot (odziv v realnem času)
  • Cevovod, kjer je vsak korak odvisen od prejšnjega
  • Nadzor in opozorila v realnem času
  • Vsak primer, kjer je zamik Batch API nesprejemljiv

Primerjava pristopov

Kriterij Async + Semaphore Batch API
Stroški Standardna tarifa -20 % na žetone za ustrezne modele
Zakasnitev Sekunde do minute Minute do ure
Nadzor V realnem času, takojšnje napake Rezultati ob zaključku obdelave, napake na zahtevek
Zahtevnost Semaphore, backoff, gather Skupina zahtevkov ali datoteka JSONL, sledenje števcu
Omejitve hitrosti Podvrženo RPM/TPM Upravlja xAI

Kontrolni seznam za produkcijo

Preden svoj sistem asinhronih zahtevkov uvedeš v produkcijo, preveri vsako točko na tem seznamu:

Konfiguracija

  • Časovna omejitev je nastavljena na 3600 sekund za modele za sklepanje
  • Semaphore je prilagojen tvojim dejanskim omejitvam hitrosti (ne ocenam)
  • Eksponentni backoff je implementiran z naključnim zamikom (jitter) za napake 429
  • Ključi API so naloženi iz spremenljivk okolja, nikoli trdo kodirani v kodi
  • Glava x-grok-conv-id se uporablja za pogovore z več krogi

Obravnava napak

  • V asyncio.gather se uporablja return_exceptions=True za izolacijo napak
  • Napake 429, časovne omejitve in napake povezave sprožijo ponovni poskus
  • Napake neveljavnega zahtevka (BadRequestError) ne sprožijo ponovnega poskusa
  • Neuspešni zahtevki so identificirani in jih je mogoče ponoviti
  • Dnevniki vključujejo vrsto napake, številko poskusa in zamik pred ponovnim poskusom

Spremljanje

  • Število porabljenih žetonov se sledi prek response.usage
  • Stopnja zadetkov predpomnilnika se meri za validacijo uporabe x-grok-conv-id
  • Stroški se ocenjujejo v realnem času s cost_in_usd_ticks
  • Preostale omejitve hitrosti se spremljajo za dinamično prilagajanje semaphora

Zmogljivost

  • Razčlenjevanje (chunking) se uporablja za skupine, večje od 100 zahtevkov
  • Vmesni rezultati se shranjujejo med podskupinami
  • Napredek se prikazuje za dolgotrajna opravila
  • Semaphore se prilagaja glede na uporabljeni model (sklepanje = nižje)

Varnost

  • Ključi API niso izpostavljeni v dnevnikih ali sporočilih o napakah
  • Odzivi, ki vsebujejo občutljive podatke, se obdelujejo v pomnilniku, ne zapisujejo na disk
  • Oddaljeno shranjevanje (store_messages) je onemogočeno za zaupne podatke
  • use_encrypted_content je omogočen, ko je zahtevana zaupnost sklepanja

Priporočena arhitektura

import os
import asyncio
import uuid
from asyncio import Semaphore
from openai import AsyncOpenAI, RateLimitError, APITimeoutError
import httpx

class GrokAsyncProcessor:
    def __init__(self, max_concurrent: int = 5):
        self.client = AsyncOpenAI(
            api_key=os.getenv("XAI_API_KEY"),
            base_url="https://api.x.ai/v1",
            timeout=httpx.Timeout(3600.0)
        )
        self.sem = Semaphore(max_concurrent)
        self.conv_id = str(uuid.uuid4())

    async def request(self, prompt: str, max_retries: int = 5) -> str:
        async with self.sem:
            for attempt in range(max_retries):
                try:
                    response = await self.client.chat.completions.create(
                        model="grok-4.5",
                        messages=[{"role": "user", "content": prompt}],
                        extra_headers={"x-grok-conv-id": self.conv_id}
                    )
                    return response.choices[0].message.content
                except RateLimitError:
                    if attempt == max_retries - 1:
                        raise
                    await asyncio.sleep(2 ** attempt)
                except APITimeoutError:
                    if attempt == max_retries - 1:
                        raise
                    await asyncio.sleep(2 ** attempt)

    async def batch(self, prompts: list[str]) -> list[str | Exception]:
        tasks = [self.request(p) for p in prompts]
        return await asyncio.gather(*tasks, return_exceptions=True)

Ta razred združuje vse vzorce, obravnavane v tem tečaju: asinhroni odjemalec, semaphore, backoff, predpomnilnik in obravnavo napak. Zagotavlja trdno izhodišče za tvoje produkcijske projekte.

Ključne ugotovitve

  • Batch API ponuja 20 % popusta na ustrezne modele, vendar nalaga zamik pri obdelavi
  • Izbira med asinhronim načinom v realnem času in batch temelji na tvojih omejitvah zakasnitve
  • Kontrolni seznam za produkcijo zajema konfiguracijo, napake, spremljanje, zmogljivost in varnost
  • Razred GrokAsyncProcessor združuje vse vzorce tečaja v eno samo abstrakcijo
  • Pred zagonom množične obdelave vedno preizkusi svojo konfiguracijo z majhno skupino

Preveri svoje znanje

Async, omejitve, predpomnilnik: produkcijski vzorci v petih vprašanjih.

1. Kdaj async prevlada nad sinhronim načinom?

Odgovor: Kadar koli obravnavaš več neodvisnih zahtevkov: AsyncClient (ali AsyncOpenAI) prekriva čakanja na omrežju – prepustnost se množi brez množenja niti.

2. Kako obdelati skupino, ne da bi dosegel omejitve?

Odgovor: asyncio.gather za paralelizem, semaphore za omejitev sočasnih zahtevkov in eksponentni backoff pri HTTP 429 – ob spoštovanju omejitev RPM/TPM v konzoli.

3. Kako upravljati kontekst z več krogi v velikem obsegu?

Odgovor: Prek shranjevanja odzivov na strežniški strani in ponovne uporabe šifriranega sklepanja – stanje živi na strani API-ja, tvoja koda sledi le identifikatorjem.

4. Kaj moraš vedeti o predpomnilniku in časovnih omejitvah?

Odgovor: Predpomnilnik pogovora (x-grok-conv-id) pospeši nadaljnje niti, zahtevki za sklepanje pa zahtevajo prilagojene časovne omejitve – dve nastavitvi, ki spremenita produkcijo.

5. Kaj vsebuje produkcijski kontrolni seznam tečaja?

Odgovor: Obvladan async, spoštovane omejitve (semaphore + backoff), batch za hladne volumne, konfigurirane časovne omejitve in ponovni poskusi, sledenje stroškom – robustnost kot kontrolni seznam.

Omejena sočasnost, načrtovane napake, stanje na strežniški strani: asinhroni vzorci tvoje skripte spremenijo v storitve – končni kontrolni seznam jih zaklene.