Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Osvědčené postupy a nasazení do produkce

Lekce 14 z 14 Aktualizováno 29. července 2026 Vývojář
Na této stránce
  1. Od prototypu k produkci
  2. Kontrolní seznam pro nasazení
  3. Psaní popisů, díky kterým model funguje
  4. Výběr správného modelu
  5. Strukturování systémové zprávy
  6. Správa nákladů v produkci
  7. Testování volání funkcí
  8. Monitoring v produkci
  9. Další kroky
  10. Klíčové poznatky
  11. Ověř si své znalosti

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.