Най-добри практики и продукционна среда
На тази страница
- От доказателство на концепцията до продукционна среда
- Контролен списък за внедряване
- Писане на описания, които карат модела да работи
- Избор на правилния модел
- Структуриране на системното съобщение
- Управление на разходите в продукционна среда
- Тестване на извикването на функции
- Мониторинг в продукционна среда
- Следващи стъпки
- Ключови изводи
- Проверете знанията си
От доказателство на концепцията до продукционна среда
Сега разполагате с всички градивни елементи, за да изградите системи за извикване на функции с 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) прилагат точно тези правила – вашите собствени интеграции ще следват същия шаблон.