Премини към основното съдържание
Български— Изберете език
Меню

Batch API и контролен списък за продукция

Урок 12 от 12 Обновен 2 ноември 2026 г. Напреднало
На тази страница
  1. Алтернативата Batch API: 20% отстъпка от токените
  2. Сравнение на подходите
  3. Контролен списък за продукция
  4. Препоръчителна архитектура
  5. Ключови изводи
  6. Проверете знанията си

Алтернативата Batch API: 20% отстъпка от токените

Когато обработката в реално време не е задължителна, Batch API на xAI предлага намаление от 20% за всички токени при подходящите текстови модели (от grok-4.3 до grok-4.7 към 2 ноември 2026 г., според цените на xAI за пакетна обработка). Вместо да изпращате заявките една по една и да управлявате конкурентността, Вие подавате заявките си на пакети чрез API или във файл във формат JSONL, а резултатите се извличат след приключване на обработката – обикновено в рамките на 24 часа. Пакетните заявки не се броят към лимитите на честотата. Курсът Batch API: Масова обработка описва подробно работния процес.

Кога да използвате Batch API

  • Обработка на продуктови каталози (хиляди описания)
  • Масова класификация на тикети за поддръжка
  • Генериране на обобщения за база документи
  • Всяка задача, при която забавяне от няколко часа е приемливо

Кога да останете при класическия асинхронен подход

  • Интерактивен чатбот (отговор в реално време)
  • Поток, при който всяка стъпка зависи от предишната
  • Мониторинг и известия в реално време
  • Всеки случай, при който забавянето на Batch API е неприемливо

Сравнение на подходите

Критерий Асинхронност + Семафор Batch API
Разходи Стандартна тарифа -20% върху токените за подходящи модели
Латентност Секунди до минути Минути до часове
Контрол В реално време, незабавни грешки Резултати при приключване на обработката, грешки за всяка заявка
Сложност Семафор, експоненциално отстъпване, събиране (gather) Пакет от заявки или JSONL файл, проследяване на брояча
Лимити на честотата Подлежи на RPM/TPM Управлява се от xAI

Контролен списък за продукция

Преди да внедрите Вашата система за асинхронни заявки в продукция, проверете всяка точка от този списък:

Конфигурация

  • Таймаутът е зададен на 3600 секунди за моделите за разсъждение
  • Семафорът е оразмерен според действителните Ви лимити на честотата (не според оценки)
  • Експоненциалното отстъпване (backoff) е внедрено с добавяне на случайност (jitter) за грешки 429
  • API ключовете се зареждат от променливи на средата, никога не се вграждат директно в кода
  • Използва се хедърът x-grok-conv-id за многократни разговори

Обработка на грешки

  • Използва се return_exceptions=True във asyncio.gather, за да се изолират грешките
  • Грешки 429, таймаут и грешки във връзката задействат повторен опит
  • Грешки от невалидна заявка (BadRequestError) не задействат повторен опит
  • Неуспешните заявки се идентифицират и могат да бъдат повторени
  • Дневниците (logs) включват типа на грешката, номера на опита и забавянето преди повторния опит

Мониторинг

  • Броят на използваните токени се проследява чрез response.usage
  • Коефициентът на попадение в кеша (cache hit rate) се измерва, за да се валидира използването на x-grok-conv-id
  • Разходите се оценяват в реално време с cost_in_usd_ticks
  • Останалите лимити на честотата се наблюдават, за да се коригира динамично семафорът

Производителност

  • Използва се разделяне на части (chunking) за пакети, по-големи от 100 заявки
  • Междинните резултати се запазват между под-пакетите
  • Прогресът се показва за задачи с дълго време на изпълнение
  • Семафорът се коригира според използвания модел (разсъждение = по-ниска стойност)

Сигурност

  • API ключовете не се излагат в дневници или съобщения за грешки
  • Отговорите, съдържащи чувствителни данни, се обработват в паметта, а не се записват на диск
  • Отдалеченото съхранение (store_messages) е деактивирано за поверителни данни
  • use_encrypted_content е активирано, когато се изисква поверителност на разсъжденията

Препоръчителна архитектура

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)

Този клас обединява всички шаблони, разгледани в този курс: асинхронен клиент, семафор, експоненциално отстъпване, кеш и обработка на грешки. Той осигурява солидна отправна точка за Вашите проекти за продукция.

Ключови изводи

  • Batch API предлага 20% отстъпка за подходящи модели, но налага забавяне при обработката
  • Изберете между асинхронност в реално време и пакетна обработка въз основа на Вашите изисквания за латентност
  • Контролният списък за продукция обхваща конфигурация, грешки, мониторинг, производителност и сигурност
  • Класът GrokAsyncProcessor обединява всички шаблони от курса в една единствена абстракция
  • Винаги тествайте конфигурацията си с малък пакет, преди да стартирате масова обработка

Проверете знанията си

Асинхронност, лимити, кеш: шаблони за продукция в пет въпроса.

1. Кога асинхронността надделява над синхронния подход?

Отговор: Винаги при обработка на множество независими заявки: AsyncClient (или AsyncOpenAI) припокрива мрежовите изчаквания – пропускателната способност се умножава без умножаване на нишките.

2. Как обработвате пакет, без да достигнете лимитите?

Отговор: Използвайте asyncio.gather за паралелизъм, семафор за ограничаване на едновременните заявки и експоненциално отстъпване при HTTP 429 – спазвайки лимитите RPM/TPM от конзолата.

3. Как управлявате контекста на многократни разговори в мащаб?

Отговор: Чрез съхранение на отговорите от страна на сървъра и повторно използване на криптирани разсъждения – състоянието остава от страната на API, Вашият код проследява само идентификаторите.

4. Какво трябва да знаете за кеша и таймаутите?

Отговор: Кешът на разговора (x-grok-conv-id) ускорява последващите нишки, а заявките за разсъждение изискват адаптирани таймаути – две настройки, които трансформират продукцията.

5. Какво съдържа контролният списък за продукция от курса?

Отговор: Усвоена асинхронност, спазени лимити (семафор + отстъпване), пакетна обработка за голям обем данни, конфигурирани таймаути и повторни опити, проследени разходи – надеждност като контролен списък.

Ограничена конкурентност, планирани откази, състояние от страна на сървъра: асинхронните шаблони трансформират Вашите скриптове в услуги – финалният контролен списък ги закрепва окончателно.