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

Най-добри практики и следващи стъпки

Урок 14 от 14 Обновен 2 ноември 2026 г. Програмист
На тази страница
  1. Обобщение на курса
  2. Сигурност на Вашите API ключове
  3. Обработка на грешки
  4. Работа с лимити на честотата
  5. Контрол на разходите
  6. Наблюдение на случващото се
  7. Какво следва
  8. Ключови изводи
  9. Проверете знанията си

Обобщение на курса

Вие обхванахте всички основи на работата с Mistral API: създаване на акаунт, управление на ключове, избор на план, инсталиране на Python и TypeScript SDK, стрийминг, многократни разговори, миграция от V1 към V2 и внедряване при основните облачни доставчици. Следващото вече не се отнася до самото изучаване на API, а до разликата между скрипт, който работи, и приложение, което издържа в продукционна среда.

Сигурност на Вашите API ключове

Това е най-честата причина за инциденти в продукционна среда, почти винаги по една и съща причина: ключ, вграден в кода „само за тестване“ и впоследствие забравен в commit. API ключът никога не трябва да се появява в изходния код; той принадлежи към променлива на средата или, още по-добре, в мениджър на тайни като AWS Secrets Manager, Azure Key Vault или HashiCorp Vault.

Следва сегрегацията. Използвайте по един ключ за всяка среда – разработка, тестване, продукция – за да предотвратите провалени тестове да изразходват квотата на Вашата работеща услуга. Използвайте по един ключ за всяко приложение, за да ограничите щетите: ако ключ изтече, ще анулирате само този за засегнатото приложение. Планирайте ротация на всеки 90 дни в продукционна среда и конфигурирайте известия в Mistral Console за необичайна употреба: компрометиран ключ първо се проявява като крива на употреба, която скача без причина.

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

В продукционна среда всяко API обаждане може да се провали. Въпросът не е дали това ще се случи, а кога. Четири статус кода покриват повечето ситуации, с които ще се сблъскате:

КодЗначениеДействие
401 UnauthorizedНевалиден или изтекъл API ключПроверете променливата на средата
429 Too Many RequestsДостигнат лимит на честотатаПовторен опит с експоненциално забавяне
500 Internal Server ErrorПроблем от страна на MistralАвтоматичен повторен опит след няколко секунди
503 Service UnavailableВременно претоварванеПовторен опит със забавяне

Разликата е важна: никога не оправяте грешка 401 чрез повторен опит; конфигурацията Ви е проблемът. Останалите три са временни и правилният отговор е повторен опит с прогресивно увеличаващи се закъснения – една секунда, после две, после четири. Незабавният повторен опит в цикъл при грешка 429 само влошава насищането, което изпитвате.

Ето модела на Python: максимум три опита, предаване на изключението, ако последният се провали, и удвояване на времето за изчакване след всеки неуспех чрез 2 ** attempt.

import time
import os
from mistralai.client import Mistral

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

def call_with_retry(messages, max_retries=3):
    for attempt in range(max_retries):
        try:
            response = client.chat.complete(
                model="mistral-small-latest",
                messages=messages,
            )
            return response
        except Exception as e:
            if attempt == max_retries - 1:
                raise
            waitTime = 2 ** attempt  # 1s, 2s, 4s
            print(f"Error: {e}. Retrying in {waitTime}s...")
            time.sleep(waitTime)

TypeScript реализацията следва точно същата логика, с изключение на това, че времето за изчакване се изразява в милисекунди, а паузата се реализира чрез promise и setTimeout:

async function callWithRetry(
  client: Mistral,
  messages: Array<{ role: string; content: string }>,
  maxRetries = 3
) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      return await client.chat.complete({
        model: 'mistral-small-latest',
        messages,
      });
    } catch (error) {
      if (attempt === maxRetries - 1) throw error;
      const waitTime = Math.pow(2, attempt) * 1000;
      console.log(`Error. Retrying in ${waitTime}ms...`);
      await new Promise((r) => setTimeout(r, waitTime));
    }
  }
}

Работа с лимити на честотата

Лимитите на честотата предпазват API от злоупотреба и логиката за повторен опит сама по себе си не е достатъчна, за да ги спазвате: тя оправя нещата постфактум. Проверете Вашите лимити в Mistral Console – заявки в секунда, токени в минута – след което внедрете ограничаване на клиента (throttling), за да предотвратите надвишаването им. Излишните заявки трябва да се поставят в опашка, а не да се изхвърлят: потребителят предпочита да изчака две секунди, отколкото да получи грешка.

Когато възникне грешка 429 въпреки най-добрите Ви усилия, отговорът включва хедър Retry-After, който показва кога да опитате отново; четенето му е по-добре от гадане. И ако легитимната Ви употреба последователно надвишава лимитите на плана Scale, поискайте увеличение на квотата чрез поддръжката, вместо да умножавате заобикалящи решения.

Контрол на разходите

Първият лост и далеч най-ефективният е изборът на модел. Класификация, извличане на полета или преформулиране не изискват сложни разсъждения: mistral-small-latest се справя с тях много добре. Запазете mistral-large-latest за задачи, при които качеството на разсъждението прави разликата – анализ, сложна синтезация, писане на дълги текстове – и използвайте codestral-latest за генериране на код. Не плащайте за Mistral Large 3, за да върши това, което Mistral Small може да направи също толкова добре: при обеми на продукция разликата се измерва в порядъци.

Вторият лост се отнася до броя разменени токени. Кратък промпт, лишен от излишни инструкции, натрупани през итерациите, струва по-малко при всяко обаждане. При многократни разговори изпращайте само необходимите съобщения: препредаването на история от тридесет размени за всеки въпрос бързо увеличава сметката. Настройте max_tokens според това, което действително очаквате, и кеширайте повтарящи се отговори – най-евтината заявка е тази, която не правите.

Наблюдение на случващото се

В продукционна среда записвайте в дневник всяко обаждане. Без това няма да знаете защо един отговор е бил отрязан или коя употреба обяснява месечната сметка. Функцията по-долу обгръща обаждането с два следа: какво излиза, после какво се връща, включително общия брой токени и причината за спиране.

import logging

logger = logging.getLogger("mistral")

def logged_call(client, messages, model="mistral-small-latest"):
    logger.info(f"API Call — model: {model}, messages: {len(messages)}")

    response = client.chat.complete(model=model, messages=messages)

    logger.info(
        f"Response — tokens: {response.usage.total_tokens}, "
        f"finish: {response.choices[0].finish_reason}"
    )

    return response

Тези два реда отговарят на повечето въпроси, които ще си зададете по-късно. finish_reason, сигнализиращ лимит за дължина, обяснява отговор, прекъснат по средата; drifting среден брой токени разкрива промпт, който е нараснал, или история, която не е била правилно изчистена.

Какво следва

С поставените основи се отварят няколко пътя. Извикването на функции позволява на модела да извиква Ваши собствени функции и API. RAG (Retrieval-Augmented Generation) обогатява отговорите с Вашите вътрешни данни, докато вгражданията (embeddings), които трансформират текста във вектори, формират основния градивен елемент за семантично търсене. Фината настройка (fine-tuning) адаптира модела към Вашата област, когато промптването вече не е достатъчно, агентите верижат обаждания, за да изградят автономни системи, а оценяването Ви дава начин да измерите качеството на отговорите, вместо да го преценявате на око.

Всяка от тези теми има специализирани курсове в каталога на Corsen Academy.

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

  • Защитете Вашите API ключове с мениджър на тайни и редовна ротация
  • Системно внедрявайте повторен опит с експоненциално забавяне
  • Избирайте най-лекия модел, способен да изпълни Вашата задача
  • Записвайте в дневник всяко API обаждане за диагностика и оптимизация на разходите
  • Mistral API е Вашата основа – следващите стъпки (извикване на функции, RAG, агенти) градят върху всичко, което сте научили

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

Console, SDK, облачни доставчици: основата на API налице ли е?

1. Какви рефлекси трябва да имате за API ключа веднага след създаването му?

Отговор: Съхранявайте го безопасно (показва се само веднъж), дръжте го извън кода чрез променливи на средата, използвайте по един ключ за всяка среда и го ротирайте при съмнение.

2. Какво отличава плановете Experiment и Scale?

Отговор: Квоти и ценообразуване: Experiment за откриване и прототипиране, Scale за продукция – проверете лимитите си в конзолата преди оразмеряване.

3. Какъв е скелетът на първо Python обаждане?

Отговор: Клиент, инициализиран с ключа, chat обаждане с модела и списъка със съобщения, четене на съдържанието на отговора – а стриймингът е активиран за прогресивно показване.

4. Как обработвате многократен разговор чрез API?

Отговор: Чрез поддържане на историята от Ваша страна: всяка заявка изпраща пълния списък със съобщения (потребител и асистент) – API е без състояние.

5. Какво трябва да знаете за внедряванията чрез Azure, Vertex или Bedrock?

Отговор: Моделите на Mistral са налични там с автентикацията и таксуването на избрания облак – същото семейство модели, различна точка на достъп, полезно за инфраструктурни ограничения.

Ключът е защитен, историята е управлявана, планът е адаптиран: крайните най-добри практики трансформират тази основа в продукционна база.