Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Batch API ja tootmise kontrollnimekiri

Õppetund 12 / 12 Värskendatud 2. november 2026 Edasijõudnutele
Sellel lehel
  1. Batch API alternatiiv: 20% soodsamad tokenid
  2. Lähenemisviiside võrdlus
  3. Tootmise kontrollnimekiri
  4. Soovitatav arhitektuur
  5. Peamised punktid
  6. Testi oma teadmisi

Batch API alternatiiv: 20% soodsamad tokenid

Kui reaalajas töötlemine ei ole kohustuslik, pakub xAI Batch API 20% hinnaalandust kõigile sobivatele tekst mudelitele (alates grok-4.3 kuni grok-4.7 seisuga 2. november 2026, vastavalt xAI batch hindadele). Päringute ükshaaval saatmise ja samaaegsuse haldamise asemel esitad oma päringud partiides kas API kaudu või JSONL-failina ning tood tulemused kätte niipea, kui töötlemine lõpeb – tavaliselt 24 tunni jooksul. Batch päringuid ei arvestata kiirusepiirangute (rate limits) hulka. Kursus Batch API: hulgiline töötlemine kirjeldab töövoogu üksikasjalikult.

Millal kasutada Batch API-d

  • Tootekataloogide töötlemine (tuhanded kirjeldused)
  • tugipiletite hulgiline liigitamine
  • Kokkuvõtete genereerimine dokumendibaasi jaoks
  • Igasugune ülesanne, kus mõnetunnine viivitus on vastuvõetav

Millal jääda klassikalise asünkroonse lähenemise juurde

  • Interaktiivne vestlusrobot (reaalajas vastus)
  • Torustik, kus iga samm sõltub eelmisest
  • Reaalajas jälgimine ja hoiatused
  • Igasugune juhtum, kus Batch API viivitus on vastuvõetamatu

Lähenemisviiside võrdlus

Kriteerium Async + Semaphore Batch API
Kulu Tavahind -20% tokenite hinnast sobivatele mudelitele
Latentsus Sekunditest minutiteni Minutitest tundideni
Kontroll Reaalajas, kohesed vead Tulemused töötlemise lõppedes, vead päringu kohta
Komplekssus Semaphore, tagasipöördumine (backoff), gather Päringute partii või JSONL-fail, loenduri jälgimine
Kiirusepiirangud Alluvad RPM/TPM piirangutele Haldab xAI

Tootmise kontrollnimekiri

Enne asünkroonse päringusüsteemi tootmisse viimist kontrolli iga punkti selles nimekirjas:

Konfiguratsioon

  • Aegumine on mõtlemismudelite jaoks seatud 3600 sekundile
  • Semaphore on suurusega vastavalt tegelikele kiirusepiirangutele (mitte hinnangutele)
  • Eksponentsiaalne tagasipöördumine (backoff) on rakendatud jitteriga 429 vigade jaoks
  • API võtmed laaditakse keskkonnamuutujatest, mitte kunagi koodi sisse kodeerituna
  • Mitmevooruliste vestluste jaoks kasutatakse päist x-grok-conv-id

Vigade käsitlemine

  • return_exceptions=True on kasutatud asyncio.gather funktsioonis vigade isoleerimiseks
  • 429, aegumise ja ühenduse vead käivitavad uuesti proovimise
  • Vigased päringud (BadRequestError) ei käivita uuesti proovimist
  • Ebaõnnestunud päringud on tuvastatud ja neid saab uuesti proovida
  • Logid sisaldavad vea tüüpi, katse numbrit ja uuesti proovimise viivitust

Jälgimine

  • Tarbitud tokenite arv on jälgitav läbi response.usage
  • Vahemälu tabamuste määra mõõdetakse, et valideerida x-grok-conv-id kasutamist
  • Kulusid hinnatakse reaalajas funktsiooniga cost_in_usd_ticks
  • Ülejäänud kiirusepiiranguid jälgitakse, et kohandada semaphore’i dünaamiliselt

Jõudlus

  • Tükeldamist (chunking) kasutatakse partiide puhul, mis on suuremad kui 100 päringut
  • Vaheetapid salvestatakse alampartiide vahel
  • Pikaajaliste tööde jaoks kuvatakse edenemist
  • Semaphore’i kohandatakse vastavalt kasutatavale mudelile (mõtlemine = madalam)

Turvalisus

  • API võtmeid ei avaldata logides ega veateadetes
  • Tundlikke andmeid sisaldavaid vastuseid töödeldakse mälus, mitte ei kirjutata kettagle
  • Kaugsalvestus (store_messages) on konfidentsiaalsete andmete jaoks keelatud
  • use_encrypted_content on lubatud, kui on vaja mõtlemise konfidentsiaalsust

Soovitatav arhitektuur

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)

See klass kapseldab kõik selles kursuses käsitletud mustrid: asünkroonne klient, semaphore, tagasipöördumine (backoff), vahemälu ja vigade käsitlemine. See pakub kindlat lähtepunkti sinu tootmisprojektide jaoks.

Peamised punktid

  • Batch API pakub sobivatele mudelitele 20% soodsamat hinda, kuid seab sisse töötlemise viivituse
  • Vali reaalaja asünkroonsuse ja batchi vahel vastavalt oma latentsuspiirangutele
  • Tootmise kontrollnimekiri hõlmab konfiguratsiooni, vigu, jälgimist, jõudlust ja turvalisust
  • Klass GrokAsyncProcessor kapseldab kõik kursuse mustrid ühte abstraktsiooni
  • Testi oma konfiguratsiooni alati väikese partiiga enne hulgilise töötlemise käivitamist

Testi oma teadmisi

Async, piirangud, vahemälu: tootmismustrid viies küsimuses.

1. Millal on async eelistatav sünkroonsele lähenemisele?

Vastus: Alati, kui käsitledakse mitut sõltumatut päringut: AsyncClient (või AsyncOpenAI) kattub võrgu ooteaegadega – läbilaskevõime korrutub ilma lõimede arvu suurendamata.

2. Kuidas töödelda partiid ilma piirangute rikkumiseta?

Vastus: asyncio.gather paralleelsuse jaoks, semaphore samaaegsete päringute piiramiseks ja eksponentsiaalne tagasipöördumine (backoff) HTTP 429 korral – austades konsooli RPM/TPM piiranguid.

3. Kuidas käsitleda suurel skaalal mitmevoorulist konteksti?

Vastus: Serveripoolse vastuste salvestamise ja uuesti kasutatava krüpteeritud mõtlemise kaudu – olek asub API poolel, sinu kood jälgib ainult identifikaatoreid.

4. Mida pead teadma vahemälu ja aegumiste kohta?

Vastus: Vestluse vahemälu (x-grok-conv-id) kiirendab järgnevaid lõngu ja mõtlemispäringud nõuavad kohandatud aegumisi – kaks seadet, mis muudavad tootmise.

5. Mida sisaldab kursuse tootmise kontrollnimekiri?

Vastus: Omandatud async, austatud piirangud (semaphore + backoff), batch külma mahu jaoks, konfigureeritud aegumised ja uuesti proovimised, jälgitud kulud – töökindlus kontrollnimekirjana.

Piiratud samaaegsus, planeeritud tõrked, serveripoolne olek: asünkroonsed mustrid muudavad sinu skriptid teenusteks – lõplik kontrollnimekiri lukustab need kindlalt.