Osvědčené postupy a nasazení do produkce
Na této stránce
Od prototypu k produkci
Nyní máš všechny stavební kameny k vytvoření systémů volání funkcí s Mistralem. To, co odlišuje tvůj prototyp od služby připravené k nasazení, nejsou chybějící funkce, ale série kontrol a ladění, na které obvykle narazíš až při řešení incidentu. Tato závěrečná lekce shrnuje osvědčené postupy, časté pasti a kontrolní seznam, abys mohl s jistotou přejít do produkce.
Kontrolní seznam pro nasazení
Toto je jediné místo v tomto kurzu, kde je formát seznamu nezbytný: před spuštěním musíš odškrtávat položky. Je třeba pokrýt čtyři oblasti, z nichž každá odpovídá na jinou otázku.
Architektura zajišťuje, že mechanika funguje. Vracení JSON řetězců v řetězci a mít kompletní dispatch slovník jsou dvě nejčastější příčiny pádů při prvním reálném volání.
- Všechny funkce vracejí JSON řetězce (nikdy ne syrové Python objekty)
- Dispatch slovník je kompletní a aktuální
- Funkce zpracovávají chybové případy a vracejí použitelné zprávy
- Systémová zpráva je jasná, přesná a otestovaná
- Smyčka konverzace zvládá sekvenční i paralelní volání
Bezpečnost vychází z předpokladu, že argumenty pocházejí od uživatele, nikdy z tvé aplikace.
- Argumenty jsou validovány před provedením (formát, typ, hodnoty)
- SQL dotazy používají parametry (žádná konkatenace)
- Whitelist omezuje dostupné funkce
- Destruktivní akce vyžadují potvrzení
- Omezování rychlosti (rate limiting) je nastaveno pro každou funkci i uživatele
- Výsledky jsou sanitizovány (žádná citlivá data se nevracejí modelu)
Spolehlivost řeší situace, kdy něco selže, aniž by za to někdo mohl.
- Chyby se modelu vracejí ve strukturovaném formátu
- Opakování s exponenciálním backoffem je implementováno pro přechodné chyby
- Časové limity (timeouts) jsou nastaveny pro každou externí funkci
- Velikost historie je omezena, aby se předešlo překročení limitu tokenů
Monitoring je nakonec to, co ti umožní diagnostikovat problémy bez hádání.
- Každé volání funkce je logováno (název, argumenty, výsledek, doba trvání)
- Chyby spouští alerty (Slack, PagerDuty atd.)
- Sbírají se metriky (míra úspěšnosti, latence, náklady na API)
Psaní popisů, díky kterým model funguje
Kvalita popisů má přímý dopad na přesnost a často je to ten nejlevnější nástroj, který můžeš použít. Mezi týmy s vysokou mírou správných volání se opakují tři vzorce. První ukotvuje popis v obchodním kontextu: místo parafrázování názvu funkce vypiš možné návratové hodnoty a explicitně uveď, kdy ji použít. Druhý vkládá příklady formátu přímo do popisu parametru, což řeší většinu chyb při extrakci ID. Třetí nahrazuje instrukci v přirozeném jazyce výčtem enum, což je jediný způsob, jak skutečně zakázat hodnotu mimo seznam.
# Vzorec 1: Popis s obchodním kontextem
{
"description": "Načte stav platby. "
"Možné stavy: paid, pending, failed, refunded. "
"Tuto funkci použij, když se uživatel ptá "
"na stav platby nebo zda byla přijata."
}
# Vzorec 2: Parametry s příklady
{
"transaction_id": {
"type": "string",
"description": "Unikátní ID ve formátu T následované 4 číslicemi (např. T1001, T2345)"
}
}
# Vzorec 3: Enum pro omezené hodnoty
{
"status": {
"type": "string",
"enum": ["paid", "pending", "failed", "refunded"],
"description": "Filtrovat podle stavu platby"
}
}
Výběr správného modelu
Volba modelu je kompromisem mezi přesností a náklady a neexistuje univerzální odpověď: záleží na počtu vystavených funkcí a složitosti jejich schémat. Složitý případ s mnoha funkcemi a vnořenými parametry ospravedlňuje použití Mistral Large 3, který je spolehlivější při výběru funkcí, ale dražší. Standardní případ s několika jednoduchými funkcemi ve vysoce zatížené produkci běží velmi dobře na Mistral Small 4, který je rychlý a ekonomický. Pro prototypování a testování nabízí Mistral Medium 3.5 dobrý kompromis.
# Složité případy: mnoho funkcí, vnořené parametry
# -> Mistral Large 3 (spolehlivější, dražší)
model = "mistral-large-latest"
# Standardní případy: několik jednoduchých funkcí, vysoce zatížená produkce
# -> Mistral Small 4 (rychlý, ekonomický)
model = "mistral-small-latest"
# Vývojové případy: prototypování, testování
# -> Mistral Medium 3.5 (dobrý kompromis)
model = "mistral-medium-latest"
Záleží na metodě stejně jako na výsledku: v produkci začni s nejschopnějším modelem, změř svou míru správných volání a poté postupně přecházej na slabší, abys našel nejlepší poměr cena/výkon. Opak – začít s nejlevnějším modelem – tě připraví o výchozí bod potřebný k tomu, abys věděl, zda degradace pochází z modelu, nebo z tvých popisů.
Strukturování systémové zprávy
Dobrá systémová zpráva dělá rozdíl mezi průměrným asistentem a vynikajícím. Tato ilustruje osvědčenou strukturu: prohlášení o roli, blok imperativních pravidel a poté připomenutí dostupných nástrojů. Dvě nejefektivnější pravidla z hlediska nákladů jsou zde „Pokud uživatel neposkytne požadované ID, zdvořile se zeptej“ a „Nikdy nehádej ID transakce“ – společně eliminují to nejškodlivější chování ze všech, tedy volání funkce s vymyšleným ID.
system_message = {
"role": "system",
"content": """Jsi asistent pro správu plateb společnosti Acme Corporation.
Pravidla:
- Vždy odpovídej v angličtině
- Částky formátuj v eurech se symbolem a 2 desetinnými místy
- Pokud uživatel neposkytne požadované ID, zdvořile se zeptej
- Nikdy nehádej ID transakce
- Když transakce selže, nabídni ověření podrobností
Dostupné nástroje:
- retrieve_payment_status: ke kontrole stavu platby
- retrieve_payment_date: ke kontrole data platby
- retrieve_payment_details: k získání všech podrobností o transakci
- list_customer_transactions: k zobrazení všech transakcí pro zákazníka"""
}
Správa nákladů v produkci
Každé volání funkce spotřebovává tokeny a účet roste dvěma podceňovanými kanály: definice nástrojů se odesílají s každým požadavkem a historie roste s každým kolem. Filtrování funkcí podle kontextu řeší první bod – není třeba odesílat všech dvanáct nástrojů, když je otázka zjevně o platbách. Zkrácení historie nad určitý práh řeší druhý bod. A když jsou všechna potřebná data již v kontextu, tool_choice="none" zabrání zbytečnému dalšímu kolu komunikace.
# 1. Omezit počet funkcí na požadavek
# Předat pouze funkce relevantní pro kontext
def get_relevant_tools(user_input: str, all_tools: list) -> list:
"""Filtruje nástroje na základě kontextu."""
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. Omezit velikost historie
MAX_HISTORY = 20 # zprávy
# 3. Použít tool_choice="none", když jsou data již dostupná
Testování volání funkcí
Testy jsou nezbytné k prevenci regrese a zde cílí na neobvyklý objekt: nekontroluješ návratovou hodnotu své funkce, ale rozhodnutí modelu. Dvě rodiny testů pokrývají to podstatné. První ověřuje, že obchodní dotaz spustí správnou funkci se správně extrahovanými argumenty. Druhá, stejně důležitá a často zapomínaná, ověřuje, že pozdrav nespustí žádné volání – tento test odhalí příliš obecné popisy, které nutí model volat funkci za každých okolností.
def test_payment_status():
"""Testuje, zda model zavolá správnou funkci."""
messages = [{"role": "user", "content": "Stav platby 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():
"""Testuje, zda model nezavolá funkci pro pozdrav."""
messages = [{"role": "user", "content": "Ahoj!"}]
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
Monitoring v produkci
Nyní potřebuješ vědět, co tvůj systém dělá, jakmile je vypuštěn do divočiny. Níže uvedená třída agreguje tři signály, které společně vypovídají téměř celý příběh: celkovou míru úspěšnosti, průměrnou latenci a rozpis podle funkcí. Ten poslední je v praxi nejpříznačnější – funkce, jejíž čítač chyb roste izolovaně, ukazuje na konkrétní problém, zatímco zhoršená celková míra ti nic neřekne o tom, kde hledat.
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()
Další kroky
Nyní, když jsi zvládl volání funkcí s Mistralem, otevírá se několik směrů. Nej přirozenější je budování autonomních agentů, kombinující volání funkcí se smyčkou agenta, která plánuje a执行uje složité úkoly; Mistral Agents API a jeho client.beta.agents.create() jdou ještě dál nabídkou perzistentních agentů se stavem. Další osa kombinuje RAG a volání funkcí: model se sám rozhodne, kdy dotazovat vektorovou databázi, místo aby bylo vyhledávání spouštěno systematicky předem. Na straně uživatelské zkušenosti ti streaming umožní zobrazovat odpovědi v reálném čase, zatímco se funkce vykonávají, což mění vnímání latence u dlouhých řetězců volání. Nakonec multimodálnost otevírá volání funkcí pro vision při analýze dokumentů.
Klíčové poznatky
- Kontrolní seznam pro nasazení pokrývá architekturu, bezpečnost, spolehlivost a monitoring
- Přesné popisy s příklady a enumy zlepšují přesnost modelu
- Vyber správný model na základě složitosti a rozpočtu (Large pro spolehlivost, Small pro propustnost)
- Systémová zpráva je silný nástroj pro řízení chování
- Systematicky testuj volání funkcí i chování bez volání funkcí
- V produkci monitoruj míru úspěšnosti, latenci a náklady
Ověř si své znalosti
Komplexní volání funkcí: pět kontrol.
1. Jakých je pět kroků volání funkcí?
Odpověď: Definuj funkce (schémata), poskytni je API, model požádá o volání se svými argumenty, tvůj kód provede funkci a vrátí výsledek, model vytvoří konečnou odpověď.
2. Co dělá dobré schéma funkce?
Odpověď: Přísné typy a operativní popisy – jasný název, kdy ji použít, formát každého parametru: toto je text, který model čte, aby se rozhodl a vyplnil hodnoty.
3. Co umožňují paralelní volání?
Odpověď: Model požaduje více funkcí v jedné odpovědi, když jsou nezávislé – méně kol komunikace, za předpokladu, že každý výsledek přiřadíš správnému volání.
4. K čemu slouží tool_choice?
Odpověď: K nastavení svobody modelu: auto (rozhodne se sám), any (musí použít nástroj) nebo vynucený nástroj – poslední je klíčové pro spolehlivou strukturovanou extrakci.
5. Jaká bezpečnostní pravidla platí pro vystavené funkce?
Odpověď: Validuj přijaté argumenty, omez rozsah každé funkce, loguj volání a ponech lidskou validaci pro potvrzující akce – model navrhuje, tvůj kód rozhoduje.
Dva propracované příklady v tomto kurzu (sledování plateb, CRM) přesně aplikují tato pravidla – tvé vlastní integrace budou následovat stejný vzor.