Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Geriausios praktikos ir gamyba

Paskaita 14 iš 14 Atnaujinta 2026 m. liepos 29 d. Kūrėjas
Šiame puslapyje
  1. Nuo koncepcijos įrodymo iki gamybos
  2. Diegimo kontrolinis sąrašas
  3. Aprašymų rašymas, kad modelis veiktų
  4. Tinkamo modelio pasirinkimas
  5. Sistemos žinutės struktūravimas
  6. Išlaidų valdymas gamyboje
  7. Funkcijų kvietimo testavimas
  8. Stebėsena gamyboje
  9. Kiti žingsniai
  10. Svarbiausi punktai
  11. Patikrink savo žinias

Nuo koncepcijos įrodymo iki gamybos

Dabar turi visus statybinius blokus, kad sukurtum funkcijų kvietimo sistemas su „Mistral“. Tavo prototipą nuo paruošto gamybai serviso skiria ne trūkstamos funkcijos, o patikrų ir derinimo žingsnių seka, kurią dažniausiai atrandi tik įvykus incidentui. Šioje paskutinėje pamokoje sujungsime geriausias praktikas, dažnas klaidas ir kontrolinį sąrašą, kad į gamybą pereitum užtikrintai.

Diegimo kontrolinis sąrašas

Tai vienintelė kurso vieta, kur sąrašo formatas yra privalomas: prieš paleidžiant sistemą, reikia pažymėti varneles. Reikia apimti keturias sritis, kiekviena atsakanti į skirtingą klausimą.

Architektūra užtikrina, kad mechanizmai veiktų stabiliai. JSON eilučių grąžinimas grandinėje ir pilnas dispatch žodynas yra dvi dažniausios pirmojo realaus kvietimo gedimo priežastys.

  • Visos funkcijos grąžina JSON eilutes (niekada ne „raw“ Python objektus)
  • Dispatch žodynas yra pilnas ir atnaujintas
  • Funkcijos apdoroja klaidų atvejus ir grąžina naudotinus pranešimus
  • Sistemos žinutė yra aiški, tiksli ir ištestuota
  • Pokalbio ciklas valdo nuoseklius ir lygiagrečius kvietimus

Saugumas daro prielaidą, kad argumentai ateina iš naudotojo, o niekada iš tavo programos.

  • Argumentai patikrinami prieš vykdymą (formatas, tipas, reikšmės)
  • SQL užklausos naudoja parametrus (jokio sujungimo)
  • Baltasis sąrašas riboja prieinamas funkcijas
  • Destruktyvūs veiksmai reikalauja patvirtinimo
  • Taikomas užklausų ribojimas (rate limiting) kiekvienai funkcijai ir naudotojui
  • Rezultatai valomi (jokių konfidencialių duomenų negrąžinama modeliui)

Patikimumas tvarko situacijas, kai kas nors nepavyksta niekam nekaltam esant.

  • Klaidos grąžinamos modeliui struktūruotu formatu
  • Įgyvendintas kartojimas su delsa (retry with backoff) laikinoms klaidoms
  • Kiekvienai išorinei funkcijai nustatytos laiko limito (timeout) reikšmės
  • Istorijos dydis ribojamas, kad būtų išvengta tokenų viršijimo

Stebėsena, galiausiai, tai, kas leidžia diagnozuoti problemas neatspėjant.

  • Kiekvienas funkcijos kvietimas registruojamas (pavadinimas, argumentai, rezultatas, trukmė)
  • Klaidos sukelia įspėjimus („Slack“, „PagerDuty“ ir kt.)
  • Renkami metrikos duomenys (sėkmės rodiklis, delsos laikas, API kaina)

Aprašymų rašymas, kad modelis veiktų

Aprašymų kokybė tiesiogiai veikia tikslumą, ir tai dažnai yra pigiausias svertas, kurį galima panaudoti. Tarp komandų, pasižyminčių dideliu teisingų kvietimų rodikliu, pasikartoja trys šablonai. Pirmasis įtvirtina aprašymą verslo kontekste: vietoj to, kad perteiktum funkcijos pavadinimą savo žodžiais, išvardink galimas grąžinamas reikšmes ir aiškiai nurodyk, kada ją kviesti. Antrasis įterpia formato pavyzdžius į parametro aprašymą, kas išsprendžia daugumą ID ištraukimo klaidų. Trečiasis pakeičia natūralios kalbos instrukciją į enum, kas yra vienintelis būdas tikrai uždrausti reikšmę, nepatenkančią į sąrašą.

# 1 šablonas: Aprašymas su verslo kontekstu
{
    "description": "Gauna mokėjimo būseną. "
                   "Galimos būsenos: paid, pending, failed, refunded. "
                   "Naudokite šią funkciją, kai naudotojas klausia "
                   "apie mokėjimo būseną arba ar jis buvo gautas."
}

# 2 šablonas: Parametrai su pavyzdžiais
{
    "transaction_id": {
        "type": "string",
        "description": "Unikalus ID formatu T, po kurio eina 4 skaitmenys (pvz., T1001, T2345)"
    }
}

# 3 šablonas: Enum ribotoms reikšmėms
{
    "status": {
        "type": "string",
        "enum": ["paid", "pending", "failed", "refunded"],
        "description": "Filtruoti pagal mokėjimo būseną"
    }
}

Tinkamo modelio pasirinkimas

Modelio pasirinkimas sveria tikslumą prieš kainą, ir nėra universalaus atsakymo: tai priklauso nuo atvirų funkcijų skaičiaus ir jų schemų sudėtingumo. Sudėtingas atvejis su daugybe funkcijų ir įdėtųjų parametrų pateisina „Mistral Large 3“ naudojimą, kuris yra patikimesnis renkantis funkcijas, bet brangesnis. Standartinis atvejis su keliomis paprastomis funkcijomis didelės apimties gamyboje labai gerai veikia su „Mistral Small 4“, kuris yra greitas ir ekonomiškas. Prototipų kūrimui ir testavimui „Mistral Medium 3.5“ siūlo gerą kompromisą.

# Sudėtingi atvejai: daug funkcijų, įdėtieji parametrai
# -> Mistral Large 3 (patikimesnis, brangesnis)
model = "mistral-large-latest"

# Standartiniai atvejai: kelios paprastos funkcijos, didelės apimties gamyba
# -> Mistral Small 4 (greitas, ekonomiškas)
model = "mistral-small-latest"

# Kūrimo atvejai: prototipų kūrimas, testavimas
# -> Mistral Medium 3.5 (geras kompromisas)
model = "mistral-medium-latest"

Metodas yra toks pat svarbus kaip ir rezultatas: gamyboje pradėkite nuo pajėgiausio modelio, išmatuokite teisingų kvietimų rodiklį, tada palaipsniui mažinkite, kad rastumėte geriausią kainos ir našumo santykį. Atvirkštinis būdas – pradėti nuo pigiausio modelio – atima iš jūsų bazinį lygį, būtiną norint suprasti, ar degradacija kyla dėl modelio, ar dėl jūsų aprašymų.

Sistemos žinutės struktūravimas

Gera sistemos žinutė lemia skirtumą tarp vidutiniško ir puikaus asistento. Ši iliustruoja įrodytą struktūrą: vaidmens apibrėžimas, imperatyvių taisyklių blokas, tada priminimas apie prieinamus įrankius. Dvi efektyviausios taisyklės čia yra „Jei naudotojas nepateikia reikalingo ID, mandagiai paprašykite“ ir „Niekada nespekuliuokite dėl sandorio ID“ – kartu jos pašalina pačią žalingiausią elgseną – funkcijos kvietimą su sugalvotu ID.

system_message = {
    "role": "system",
    "content": """Esate „Acme Corporation“ mokėjimų valdymo asistentas.

Taisyklės:
- Visada atsakykite anglų kalba
- Sumas formatuokite eurais su simboliu ir 2 skaitmenimis po kablelio
- Jei naudotojas nepateikia reikalingo ID, mandagiai paprašykite
- Niekada nespekuliuokite dėl sandorio ID
- Kai sandoris nepavyksta, pasiūlykite patikrinti detales

Prieinami įrankiai:
- retrieve_payment_status: patikrinti mokėjimo būseną
- retrieve_payment_date: patikrinti mokėjimo datą
- retrieve_payment_details: gauti visas sandorio detales
- list_customer_transactions: peržiūrėti visus kliento sandorius"""
}

Išlaidų valdymas gamyboje

Kiekvienas funkcijų kvietimas sunaudoja tokenus, o sąskaita auga dėl dviejų neįvertintų kanalų: įrankių apibrėžimai siunčiami su kiekviena užklausa, o istorija didėja su kiekvienu ėjimu. Funkcijų filtravimas pagal kontekstą išsprendžia pirmąjį punktą – nereikia siųsti visų dvylikos įrankių, kai klausimas akivaizdžiai susijęs su mokėjimais. Istorijos trumpinimas viršijus slenkstį išsprendžia antrąjį. O kai visi būtini duomenys jau yra kontekste, tool_choice="none" leidžia išvengti papildomo užklausos rato.

# 1. Riboti funkcijų skaičių vienai užklausai
# Siųsti tik kontekstui aktualias funkcijas
def get_relevant_tools(user_input: str, all_tools: list) -> list:
    """Filtruoja įrankius pagal 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. Riboti istorijos dydį
MAX_HISTORY = 20  # žinutės

# 3. Naudoti tool_choice="none", kai duomenys jau prieinami

Funkcijų kvietimo testavimas

Testai yra būtini norint išvengti regresijų, ir čia jie taikomi neįprastam objektui: tikrinate ne savo funkcijos grąžinamą reikšmę, o modelio sprendimą. Dvi testų šeimos apima esminius dalykus. Pirmoji patikrina, ar verslo klausimas suaktyvina tinkamą funkciją su teisingai ištrauktais argumentais. Antroji, vienodai svarbi ir dažnai pamirštama, patikrina, ar pasisveikinimas nesukelia jokio kvietimo – šis testas atskleidžia per daug plačius aprašymus, kurie skatina modelį kviesti funkciją bet kokiomis aplinkybėmis.

def test_payment_status():
    """Testuoja, ar modelis iškviečia tinkamą funkciją."""
    messages = [{"role": "user", "content": "Mokėjimo T1001 būsena?"}]

    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():
    """Testuoja, ar modelis neiškviečia funkcijos pasisveikinimui."""
    messages = [{"role": "user", "content": "Labas!"}]

    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

Stebėsena gamyboje

Dabar reikia žinoti, ką jūsų sistema veikia paleista į laukines sąlygas. Toliau pateikta klasė agreguoja tris signalus, kurie kartu papasakoja beveik visą istoriją: bendrą sėkmės rodiklį, vidutinę delsą ir suskirstymą pagal funkcijas. Paskutinysis praktiškai yra pats informatyviausias – funkcija, kurios klaidų skaitiklis izoliuotai didėja, rodo specifinę problemą, tuo tarpu suprastėjęs bendras rodiklis nieko nepasako apie tai, kur ieškoti.

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

Kiti žingsniai

Dabar, kai įvaldei funkcijų kvietimą su „Mistral“, atsiveria kelios kryptys. Natūraliausia yra kurti autonominius agentus, derinant funkcijų kvietimą su agento ciklu, kuris planuoja ir vykdo sudėtingas užduotis; „Mistral Agents API“ ir jo client.beta.agents.create() eina dar toliau, siūlydami nuolatinius agentus su būsena. Kita kryptis derina RAG ir funkcijų kvietimą: modelis pats nusprendžia, kada užklausti vektorių duomenų bazę, vietoj to, kad paieška būtų sistemingai inicijuojama iš anksto. Vartotojo patirties požiūriu srautinis perdavimas (streaming) leidžia rodyti atsakymus realiuoju laiku vykstant funkcijų vykdymui, keičiant delsos suvokimą ilgose kvietimų grandinėse. Galiausiai, multimodalumas atveria funkcijų kvietimą regai dokumentų analizei.

Svarbiausi punktai

  • Diegimo kontrolinis sąrašas apima architektūrą, saugumą, patikimumą ir stebėseną
  • Tikslūs aprašymai su pavyzdžiais ir enum reikšmėmis gerina modelio tikslumą
  • Pasirink tinkamą modelį pagal sudėtingumą ir biudžetą („Large“ patikimumui, „Small“ našumui)
  • Sistemos žinutė yra galingas svertas elgsenai nukreipti
  • Testuok funkcijų kvietimus ir elgseną be funkcijų sistemingai
  • Stebėk sėkmės rodiklį, delsos laiką ir išlaidas gamyboje

Patikrink savo žinias

End-to-end funkcijų kvietimas: penkios patikros.

1. Kokie yra penki funkcijų kvietimo žingsniai?

Atsakymas: Apibrėžti funkcijas (schemas), pateikti jas API, modelis prašo įvykdyti kvietimą su savo argumentais, tavo kodas įvykdo ir grąžina rezultatą, modelis sukuria galutinį atsakymą.

2. Kas sudaro gerą funkcijos schemą?

Atsakymas: Griežti tipai ir operaciniai aprašymai – aiškus pavadinimas, kada ją naudoti, kiekvieno parametro formatas: tai tekstas, kurį modelis skaito norėdamas nuspręsti ir užpildyti.

3. Ką leidžia lygiagretūs kvietimai?

Atsakymas: Modelis viename atsakyme prašo kelių funkcijų, kai jos yra nepriklausomos – mažiau užklausų ratų, su sąlyga, kad kiekvieną rezultatą sutapdini su jo kvietimu.

4. Kam skirtas tool_choice?

Atsakymas: Nustatyti modelio laisvės laipsnį: auto (jis sprendžia), any (privalo naudoti įrankį) arba priverstinis įrankis – pastarasis yra raktas į patikimą struktūruotą ištraukimą.

5. Kokios saugumo taisyklės atviroms funkcijoms?

Atsakymas: Patikrinti gautus argumentus, riboti kiekvienos funkcijos apimtį, registruoti kvietimus ir palikti žmogaus patvirtinimą veiksmams įvykdyti – modelis siūlo, tavo kodas disponuoja.

Du šiame kurse nagrinėti pavyzdžiai (mokėjimų sekimas, CRM) tiksliai taiko šias taisykles – tavo paties integracijos laikysis to paties šablono.