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

Най-добри практики и продукционна среда

Урок 14 от 14 Обновен 29 юли 2026 г. Програмист
На тази страница
  1. От доказателство на концепцията до продукционна среда
  2. Контролен списък за внедряване
  3. Писане на описания, които карат модела да работи
  4. Избор на правилния модел
  5. Структуриране на системното съобщение
  6. Управление на разходите в продукционна среда
  7. Тестване на извикването на функции
  8. Мониторинг в продукционна среда
  9. Следващи стъпки
  10. Ключови изводи
  11. Проверете знанията си

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

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

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

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

Архитектурата гарантира, че механизмът работи правилно. Връщането на JSON низове във веригата и наличието на пълен речник за диспечиране са двете най-чести причини за сривове при първото реално извикване.

  • Всички функции връщат JSON низове (никога сурови Python обекти)
  • Речникът за диспечиране е пълен и актуален
  • Функциите обработват случаите на грешки и връщат използваеми съобщения
  • Системното съобщение е ясно, точно и тествано
  • Цикълът на разговора обработва последователни и паралелни извиквания

Сигурността приема, че аргументите идват от потребител, никога от вашето приложение.

  • Аргументите се валидират преди изпълнение (формат, тип, стойности)
  • SQL заявките използват параметри (без конкатенация)
  • Бял списък ограничава наличните функции
  • Деструктивните действия изискват потвърждение
  • Ограничаването на честотата (rate limiting) е внедрено за всяка функция и за всеки потребител
  • Резултатите се почистват (никакви чувствителни данни не се връщат на модела)

Надеждността се справя със случаите на неуспех, без никой да е виновен.

  • Грешките се връщат на модела в структуриран формат
  • Внедрено е повторно опитване с експоненциално забавяне (backoff) за преходни грешки
  • Таймаутите са конфигурирани за всяка външна функция
  • Размерът на историята е ограничен, за да се избегне превишаване на токени

Мониторингът, накрая, е това, което ви позволява да диагностицирате проблеми без предположения.

  • Всяко извикване на функция се логира (име, аргументи, резултат, продължителност)
  • Грешките задействат известия (Slack, PagerDuty и др.)
  • Събират се метрики (коефициент на успех, латентност, разходи за API)

Писане на описания, които карат модела да работи

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

# Модел 1: Описание с бизнес контекст
{
    "description": "Retrieves payment status. "
                   "Possible statuses: paid, pending, failed, refunded. "
                   "Use this function when the user asks "
                   "about a payment's status or whether it was received."
}

# Модел 2: Параметри с примери
{
    "transaction_id": {
        "type": "string",
        "description": "Unique ID in format T followed by 4 digits (e.g., T1001, T2345)"
    }
}

# Модел 3: Enum за ограничени стойности
{
    "status": {
        "type": "string",
        "enum": ["paid", "pending", "failed", "refunded"],
        "description": "Filter by payment status"
    }
}

Избор на правилния модел

Изборът на модел представлява компромис между точност и разходи и няма универсален отговор: това зависи от броя на изложените функции и сложността на техните схеми. Сложен случай с много функции и вложени параметри оправдава използването на Mistral Large 3, който е по-надежден при избора на функции, но по-скъп. Стандартен случай с няколко прости функции във високопропусклива продукционна среда работи много добре с Mistral Small 4, който е бърз и икономичен. За прототипиране и тестване, Mistral Medium 3.5 предлага добър компромис.

# Сложни случаи: много функции, вложени параметри
# -> Mistral Large 3 (по-надежден, по-скъп)
model = "mistral-large-latest"

# Стандартни случаи: малко прости функции, високопропусклива продукционна среда
# -> Mistral Small 4 (бърз, икономичен)
model = "mistral-small-latest"

# Случаи за разработка: прототипиране, тестване
# -> Mistral Medium 3.5 (добър компромис)
model = "mistral-medium-latest"

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

Структуриране на системното съобщение

Едно добро системно съобщение прави разликата между посредствен асистент и отличен. Това илюстрира доказана структура: изявление за ролята, блок с императивни правила, след което напомняне за наличните инструменти. Двете най-рентабилни правила тук са „Ако потребителят не предостави необходим ID, попитайте учтиво“ и „Никога не猜测вайте transaction ID“ – заедно те елиминират най-вредното поведение от всички, а именно извикването на функция с измислен ID.

system_message = {
    "role": "system",
    "content": """You are a payment management assistant for Acme Corporation.

Rules:
- Always respond in English
- Format amounts in euros with the symbol and 2 decimal places
- If the user doesn't provide a required ID, ask politely
- Never guess a transaction ID
- When a transaction fails, offer to check the details

Available tools:
- retrieve_payment_status: to check a payment's status
- retrieve_payment_date: to check a payment's date
- retrieve_payment_details: to get all details of a transaction
- list_customer_transactions: to view all transactions for a customer"""
}

Управление на разходите в продукционна среда

Всяко извикване за функция консумира токени и сметката нараства чрез два подценени канала: дефинициите на инструментите се изпращат с всяка заявка, а историята расте с всеки завой. Филтрирането на функциите по контекст решава първия пункт – няма нужда да изпращате и дванадесетте инструмента, когато въпросът е ясно свързан с плащания. Съкращаването на историята над определен праг решава втория. И когато всички необходими данни вече са в контекста, tool_choice="none" избягва допълнително обръщане.

# 1. Ограничете броя на функциите на заявка
# Предавайте само функции, релевантни за контекста
def get_relevant_tools(user_input: str, all_tools: list) -> list:
    """Filters tools based on context."""
    if "payment" in user_input.lower() or "transaction" in user_input.lower():
        return [t for t in all_tools if "payment" in t["function"]["name"]]
    if "contact" in user_input.lower() or "customer" in user_input.lower():
        return [t for t in all_tools if "contact" in t["function"]["name"]]
    return all_tools

# 2. Ограничете размера на историята
MAX_HISTORY = 20  # messages

# 3. Използвайте tool_choice="none", когато данните вече са налични

Тестване на извикването на функции

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

def test_payment_status():
    """Tests that the model calls the right function."""
    messages = [{"role": "user", "content": "Status of payment T1001?"}]

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

    message = response.choices[0].message
    assert message.tool_calls is not None
    assert len(message.tool_calls) == 1
    assert message.tool_calls[0].function.name == "retrieve_payment_status"

    args = json.loads(message.tool_calls[0].function.arguments)
    assert args["transaction_id"] == "T1001"


def test_no_function_for_greeting():
    """Tests that the model doesn't call a function for a greeting."""
    messages = [{"role": "user", "content": "Hello!"}]

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

    message = response.choices[0].message
    assert message.tool_calls is None or len(message.tool_calls) == 0
    assert message.content is not None

Мониторинг в продукционна среда

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

import time
import logging

logger = logging.getLogger("fc_monitor")

class FunctionCallingMonitor:
    def __init__(self):
        self.metrics = {
            "total_calls": 0,
            "successful_calls": 0,
            "failed_calls": 0,
            "total_latency_ms": 0,
            "calls_by_function": {}
        }

    def record(self, function_name: str, success: bool, latency_ms: float):
        self.metrics["total_calls"] += 1
        self.metrics["total_latency_ms"] += latency_ms

        if success:
            self.metrics["successful_calls"] += 1
        else:
            self.metrics["failed_calls"] += 1

        if function_name not in self.metrics["calls_by_function"]:
            self.metrics["calls_by_function"][function_name] = {
                "count": 0, "errors": 0
            }
        self.metrics["calls_by_function"][function_name]["count"] += 1
        if not success:
            self.metrics["calls_by_function"][function_name]["errors"] += 1

    def get_success_rate(self) -> float:
        if self.metrics["total_calls"] == 0:
            return 0.0
        return self.metrics["successful_calls"] / self.metrics["total_calls"]

    def get_avg_latency(self) -> float:
        if self.metrics["total_calls"] == 0:
            return 0.0
        return self.metrics["total_latency_ms"] / self.metrics["total_calls"]

monitor = FunctionCallingMonitor()

Следващи стъпки

Сега, след като овладяхте извикването на функции с Mistral, се отварят няколко направления. Най-естественото е изграждането на автономни агенти, комбиниращи извикването на функции с агентски цикъл, който планира и изпълнява сложни задачи; Mistral Agents API и неговият client.beta.agents.create() отиват още по-далеч, предлагайки постоянни агенти със състояние. Друга ос комбинира RAG и извикване на функции: моделът сам решава кога да направи заявка към векторна база данни, вместо търсенето да се задейства систематично предварително. От гледна точка на потребителското изживяване, стриймингът ви позволява да показвате отговори в реално време, докато функциите се изпълняват, променяйки възприятието за латентност при дълги вериги от извиквания. Накрая, мултимодулността отваря извикването на функции към визия за анализ на документи.

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

  • Контролният списък за внедряване обхваща архитектура, сигурност, надеждност и мониторинг
  • Точните описания с примери и enums подобряват точността на модела
  • Изберете правилния модел въз основа на сложността и бюджета (Large за надеждност, Small за пропускливост)
  • Системното съобщение е мощен лост за насочване на поведението
  • Тествайте извикванията на функции и поведението без функции систематично
  • Мониторинг на коефициента на успех, латентността и разходите в продукционна среда

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

Извикване на функции от край до край: пет проверки.

1. Кои са петте стъпки на извикването на функции?

Отговор: Дефиниране на функции (схеми), предоставянето им на API, моделът иска извикване със своите аргументи, вашият код изпълнява и връща резултата, моделът произвежда крайния отговор.

2. Какво прави една схема на функция добра?

Отговор: Строги типове и оперативни описания – ясно име, кога да се използва, формат на всеки параметър: това е текстът, който моделът чете, за да реши и попълни.

3. Какво позволяват паралелните извиквания?

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

4. За какво служи tool_choice?

Отговор: За задаване на свободата на модела: auto (той решава), any (трябва да използва инструмент) или принудителен инструмент – последното е ключово за надеждно структурирано извличане.

5. Какви са правилата за сигурност за изложените функции?

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

Двата работещи примера в този курс (тракер на плащания, CRM) прилагат точно тези правила – вашите собствени интеграции ще следват същия шаблон.