Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Najboljše prakse in proizvodnja

Lekcija 14 od 14 Posodobljeno 29. julij 2026 Razvijalec
Na tej strani
  1. Od dokaza koncepta do proizvodnje
  2. Kontrolni seznam za uvajanje
  3. Pisanje opisov, ki spravijo model v pogon
  4. Izbira pravega modela
  5. Strukturiranje sistemskega sporočila
  6. Upravljanje stroškov v proizvodnji
  7. Testiranje klicanja funkcij
  8. Nadzor v proizvodnji
  9. Naslednji koraki
  10. Ključne ugotovitve
  11. Preveri svoje znanje

Od dokaza koncepta do proizvodnje

Zdaj imaš vse gradnike za izgradnjo sistemov klicanja funkcij z Mistralom. Razlika med tvojim prototipom in storitvijo, pripravljeno za proizvodnjo, niso manjkajoče funkcije, temveč niz preverjanj in korakov uglaševanja, ki jih običajno odkriješ med incidentom. Ta zadnja lekcija združuje najboljše prakse, pogoste napake in kontrolni seznam za samozavesten prehod v proizvodnjo.

Kontrolni seznam za uvajanje

To je edino mesto v tem tečaju, kjer je oblika seznama obvezna: preden greš v živo, moraš obkljukati polja. Pokriti je treba štiri področja, od katerih vsako odgovarja na drugačno vprašanje.

Arhitektura zagotavlja, da mehanika deluje. Vračanje nizov JSON v verigi in popoln slovar za usmerjanje sta dva najpogostejša vzroka za zrušitve ob prvem realnem klicu.

  • Vse funkcije vračajo nize JSON (nikoli surovih Python objektov)
  • Slovar za usmerjanje je popoln in posodobljen
  • Funkcije obravnavajo primere napak in vračajo uporabna sporočila
  • Sistemsko sporočilo je jasno, natančno in preizkušeno
  • Pogovorna zanka obravnava zaporedne in vzporedne klice

Varnost predpostavlja, da argumenti prihajajo od uporabnika, nikoli iz tvoje aplikacije.

  • Argumenti so potrjeni pred izvedbo (oblika, tip, vrednosti)
  • Poizvedbe SQL uporabljajo parametre (brez združevanja nizov)
  • Beli seznam omejuje razpoložljive funkcije
  • Destruktivna dejanja zahtevajo potrditev
  • Omejevanje hitrosti je vzpostavljeno na funkcijo in na uporabnika
  • Rezultati so očiščeni (modelu se ne vračajo občutljivi podatki)

Zanesljivost obravnava napake, ne da bi bil kdo kriv.

  • Napake se modelu vrnejo v strukturirani obliki
  • Ponovni poskusi z zamikom so implementirani za prehodne napake
  • Časovne omejitve so konfigurirane za vsako zunanjo funkcijo
  • Velikost zgodovine je omejena, da se prepreči presežek žetonov

Nadzor je tisto, kar ti omogoča diagnosticiranje brez ugibanja.

  • Vsak klic funkcije je zabeležen (ime, argumenti, rezultat, trajanje)
  • Napake sprožijo opozorila (Slack, PagerDuty itd.)
  • Metrike se zbirajo (stopnja uspešnosti, zakasnitev, stroški API-ja)

Pisanje opisov, ki spravijo model v pogon

Kakovost opisa ima neposreden vpliv na natančnost in je pogosto najcenejša vzvod, ki ga lahko potegneš. Pri ekipah z visoko stopnjo pravilnih klicev se ponavljajo trije vzorci. Prvi sidra opis v poslovni kontekst: namesto parafraziranja imena funkcije naštej možne vrednosti vračila in izrecno navedi, kdaj jo poklicati. Drugi vstavi primere oblike v opis parametra, kar odpravi večino napak pri ekstrakciji ID-jev. Tretji nadomesti navodilo v naravnem jeziku z enum, kar je edini način, da resnično prepoveš vrednost zunaj seznama.

# Vzorec 1: Opis s poslovnim kontekstom
{
    "description": "Pridobi stanje plačila. "
                   "Možna stanja: plačano, v teku, neuspešno, povrnjeno. "
                   "To funkcijo uporabi, ko uporabnik vpraša "
                   "o stanju plačila ali ali je bilo prejeto."
}

# Vzorec 2: Parametri s primeri
{
    "transaction_id": {
        "type": "string",
        "description": "Edinstveni ID v obliki T, ki mu sledijo 4 števke (npr. T1001, T2345)"
    }
}

# Vzorec 3: Enum za omejene vrednosti
{
    "status": {
        "type": "string",
        "enum": ["paid", "pending", "failed", "refunded"],
        "description": "Filtriraj po stanju plačila"
    }
}

Izbira pravega modela

Izbira modela tehtata med natančnostjo in stroški, univerzalnega odgovora pa ni: odvisno je od števila izpostavljenih funkcij in zapletenosti njihovih shem. Zapleten primer z mnogimi funkcijami in gnezdenimi parametri upravičuje Mistral Large 3, ki je zanesljivejši pri izbiri funkcij, a dražji. Standardni primer z nekaj preprostimi funkcijami v proizvodnji z visoko prepustnostjo zelo dobro deluje na Mistral Small 4, ki je hiter in ekonomičen. Za prototipiranje in testiranje Mistral Medium 3.5 ponuja dober kompromis.

# Zapleteni primeri: veliko funkcij, gnezdeni parametri
# -> Mistral Large 3 (bolj zanesljiv, dražji)
model = "mistral-large-latest"

# Standardni primeri: nekaj preprostih funkcij, proizvodnja z visoko prepustnostjo
# -> Mistral Small 4 (hiter, ekonomičen)
model = "mistral-small-latest"

# Razvojni primeri: prototipiranje, testiranje
# -> Mistral Medium 3.5 (dober kompromis)
model = "mistral-medium-latest"

Metoda je enako pomembna kot rezultat: v proizvodnji začni z najzmogljivejšim modelom, izmeri svojo stopnjo pravilnih klicev in nato postopoma prehajaj navzdol, da najdeš najboljše razmerje med stroški in zmogljivostjo. Obratno – začetek z najcenejšim modelom – te prikrajša za izhodišče, potrebno za ugotavljanje, ali poslabšanje izvira iz modela ali tvojih opisov.

Strukturiranje sistemskega sporočila

Dobro sistemsko sporočilo naredi razliko med povprečnim in odličnim asistentom. To prikazuje preizkušeno strukturo: izjava o vlogi, blok imperativnih pravil, nato opomnik na razpoložljiva orodja. Dve stroškovno najučinkovitejši pravili tukaj sta: „Če uporabnik ne navede zahtevanega ID-ja, vljudno vprašaj” in „Nikoli ne ugibaj ID-ja transakcije” – skupaj odpravita najbolj škodljivo vedenje od vseh, in sicer klicanje funkcije z izmišljenim ID-jem.

system_message = {
    "role": "system",
    "content": """Ti si asistent za upravljanje plačil za podjetje Acme Corporation.

Pravila:
- Vedno odgovarjaj v angleščini
- Zneske oblikuj v evrih s simbolom in 2 decimalnima mestoma
- Če uporabnik ne navede zahtevanega ID-ja, vljudno vprašaj
- Nikoli ne ugibaj ID-ja transakcije
- Ko transakcija ne uspe, ponudi preverjanje podrobnosti

Razpoložljiva orodja:
- retrieve_payment_status: za preverjanje stanja plačila
- retrieve_payment_date: za preverjanje datuma plačila
- retrieve_payment_details: za pridobitev vseh podrobnosti transakcije
- list_customer_transactions: za ogled vseh transakcij za stranko"""
}

Upravljanje stroškov v proizvodnji

Vsak klic klicanja funkcij porabi žetone, račun pa naraste prek dveh podcenjenih kanalov: definicije orodij se pošiljajo z vsako zahtevo, zgodovina pa raste z vsakim obratom. Filtriranje funkcij po kontekstu reši prvo točko – ni treba pošiljati vseh dvanajstih orodij, ko je vprašanje očitno vezano na plačila. Okrajšanje zgodovine prek določenega praga reši drugo. In ko so vsi potrebni podatki že v kontekstu, tool_choice="none" prepreči dodatno krožno potovanje.

# 1. Omeji število funkcij na zahtevo
# Posreduj le funkcije, pomembne za kontekst
def get_relevant_tools(user_input: str, all_tools: list) -> list:
    """Filtrira orodja glede na kontekst."""
    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. Omeji velikost zgodovine
MAX_HISTORY = 20  # sporočil

# 3. Uporabi tool_choice="none", ko so podatki že na voljo

Testiranje klicanja funkcij

Testi so bistveni za preprečevanje regresij, tukaj pa ciljajo na nenavaden objekt: ne preverjaš vrednosti vračila svoje funkcije, temveč odločitev modela. Dve družini testov pokrivata bistvo. Prva preveri, ali poslovno vprašanje sproži pravo funkcijo s pravilno izvlečenimi argumenti. Druga, enako pomembna in pogosto pozabljena, preveri, ali pozdrav ne sproži nobenega klica – ta test ujame preširoke opise, ki silijo model v klicanje funkcije v vsakih okoliščinah.

def test_payment_status():
    """Preveri, ali model pokliče pravo funkcijo."""
    messages = [{"role": "user", "content": "Stanje plačila 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():
    """Preveri, ali model ne pokliče funkcije za pozdrav."""
    messages = [{"role": "user", "content": "Pozdravljeni!"}]

    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

Nadzor v proizvodnji

Zdaj moraš vedeti, kaj tvoj sistem počne, ko je enkrat izpuščen v divjino. Spodnji razred združuje tri signale, ki skupaj povedo skoraj celotno zgodbo: splošno stopnjo uspešnosti, povprečno zakasnitev in razčlenitev po funkcijah. Zadnja je v praksi najbolj zgovorna – funkcija, katere števec napak osamljeno drsi, kaže na specifičen problem, medtem ko ti poslabšana splošna stopnja ne pove ničesar o tem, kam gledati.

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()

Naslednji koraki

Zdaj, ko si obvladal klicanje funkcij z Mistralom, se ti odprejo številne smeri. Najbolj naravna je gradnja avtonomnih agentov, ki združuje klicanje funkcij z zanko agenta, ki načrtuje in izvaja kompleksne naloge; Mistral Agents API in njegov client.beta.agents.create() gresta še dlje z ponudbo trajnih agentov s stanjem. Druga os združuje RAG in klicanje funkcij: model se sam odloči, kdaj poizvedovati v vektorski bazi podatkov, namesto da bi bilo iskanje sistematično sproženo vnaprej. Na strani uporabniške izkušnje pretakanje omogoča prikaz odgovorov v realnem času med izvajanjem funkcij, kar spremeni zaznavanje zakasnitve pri dolgih verigah klicev. Nazadnje, večmodalnost odpira klicanje funkcij za vid za analizo dokumentov.

Ključne ugotovitve

  • Kontrolni seznam za uvajanje pokriva arhitekturo, varnost, zanesljivost in nadzor
  • Natančni opisi s primeri in enumi izboljšajo natančnost modela
  • Izberi pravi model glede na zapletenost in proračun (Large za zanesljivost, Small za prepustnost)
  • Sistemsko sporočilo je močan vzvod za usmerjanje vedenja
  • Sistematično testiraj klice funkcij in vedenje brez funkcij
  • V proizvodnji nadziraj stopnjo uspešnosti, zakasnitev in stroške

Preveri svoje znanje

Klicanje funkcij od konca do konca: pet preverjanj.

1. Katerih je pet korakov klicanja funkcij?

Odgovor: Definiraj funkcije (sheme), jih posreduj API-ju, model zahteva klic s svojimi argumenti, tvoja koda izvede in vrne rezultat, model proizvede končni odgovor.

2. Kaj naredi dobro shemo funkcije?

Odgovor: Strogi tipi in operativni opisi – jasno ime, kdaj jo uporabiti, oblika vsakega parametra: to je besedilo, ki ga model prebere, da se odloči in izpolni podatke.

3. Kaj omogočajo vzporedni klici?

Odgovor: Model zahteva več funkcij v enem samem odgovoru, ko so neodvisne – manj krožnih potovanj, pod pogojem, da vsak rezultat ujemaš s svojim klicem.

4. Čemu služi tool_choice?

Odgovor: Za nastavitev svobode modela: auto (odloči se sam), any (mora uporabiti orodje) ali prisiljeno orodje – zadnje je ključno za zanesljivo strukturirano ekstrakcijo.

5. Katera varnostna pravila veljajo za izpostavljene funkcije?

Odgovor: Potrdi prejete argumente, omeji obseg vsake funkcije, beleži klice in ohrani človeško validacijo pri izvrševanju dejanj – model predlaga, tvoja koda razpolaga.

Dva obdelana primera v tem tečaju (sledilnik plačil, CRM) uporabljata točno ta pravila – tvoje lastne integracije bodo sledile istemu kalupu.