Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Legjobb gyakorlatok és éles környezet

14. lecke 14 közül Frissítve 2026. július 29. Fejlesztő
Ezen az oldalon
  1. Prototípustól az éles környezetig
  2. Telepítési ellenőrzőlista
  3. Olyan leírások írása, amelyek működésre bírják a modellt
  4. A megfelelő modell kiválasztása
  5. A rendszerüzenet felépítése
  6. Költségek kezelése éles környezetben
  7. A függvényhívás tesztelése
  8. Monitorozás éles környezetben
  9. Következő lépések
  10. Főbb megállapítások
  11. Teszteld a tudásod!

Prototípustól az éles környezetig

Most már rendelkezel minden építőkövvel, hogy Mistral alapú függvényhívó rendszereket hozz létre. Ami elválasztja a prototípusodat az éles környezetre kész szolgáltatástól, az nem a hiányzó funkciók, hanem azok az ellenőrzési és hangolási lépések, amelyeket általában egy incidens során fedezel fel. Ez az utolsó lecke összefoglalja a legjobb gyakorlatokat, a gyakori buktatókat és egy ellenőrzőlistát, hogy magabiztosan léphess éles környezetbe.

Telepítési ellenőrzőlista

Ez a tanfolyam egyetlen helye, ahol a listaformátum kötelező: élesítés előtt pipálod ki a tételeket. Négy területet kell lefedni, amelyek mindegyike más kérdésre ad választ.

Az architektúra biztosítja, hogy a mechanizmusok működőképesek maradjanak. A JSON-karakterláncok visszaadása a láncban és a teljes dispatch szótár megléte a két leggyakoribb oka az összeomlásoknak az első valódi hívás során.

  • Minden függvény JSON-karakterláncot ad vissza (soha nem nyers Python objektumot)
  • A dispatch szótár teljes és naprakész
  • A függvények kezelik a hibaeseteket, és használható üzeneteket adnak vissza
  • A rendszerüzenet világos, pontos és tesztelt
  • A beszélgetési ciklus kezeli a szekvenciális és párhuzamos hívásokat

A biztonság abból indul ki, hogy az argumentumok felhasználótól származnak, soha nem az alkalmazásodból.

  • Az argumentumokat végrehajtás előtt validálod (formátum, típus, értékek)
  • Az SQL-lekérdezések paramétereket használnak (nincs konkatenáció)
  • Egy whitelist korlátozza az elérhető függvényeket
  • A romboló műveletek megerősítést igényelnek
  • Sebességkorlátozás (rate limiting) van beállítva függvényenként és felhasználónként
  • Az eredményeket megtisztítod (nincs érzékeny adat visszaadva a modellnek)

A megbízhatóság kezeli azokat a helyzeteket, amikor valami meghibásodik anélkül, hogy bárki is hibás lenne.

  • A hibák strukturált formátumban kerülnek visszaadásra a modellnek
  • Átmeneti hibák esetén visszalépéses (backoff) újrapróbálkozás van implementálva
  • Időtúllépések (timeout) vannak konfigurálva minden külső függvényhez
  • Az előzmények mérete korlátozott a token-túllépések elkerülése érdekében

Végül a monitorozás az, ami lehetővé teszi a diagnosztizálást találgatás nélkül.

  • Minden függvényhívást naplózol (név, argumentumok, eredmény, időtartam)
  • A hibák riasztást váltanak ki (Slack, PagerDuty stb.)
  • Metrikákat gyűjtesz (sikerráta, késleltetés, API-költség)

Olyan leírások írása, amelyek működésre bírják a modellt

A leírások minősége közvetlen hatással van a pontosságra, és gyakran ez a legolcsóbban mozgatható kar. Három minta ismétlődik azoknál a csapatoknál, amelyeknél magas a helyes hívások aránya. Az első a leírást üzleti kontextusba helyezi: a függvény nevének újrafogalmazása helyett felsorolja a lehetséges visszatérési értékeket, és kifejezetten megadja, mikor kell hívni. A második formátumpéldákat csempész a paraméterleírásba, ami a legtöbb ID-kinyerési hibát kijavítja. A harmadik pedig természetes nyelvi utasítást helyettesít egy enum-mal, ami az egyetlen módja annak, hogy truly megtilts egy értéket a listán kívül.

# 1. minta: Leírás üzleti kontextussal
{
    "description": "Lekéri a fizetési státuszt. "
                   "Lehetséges státuszok: paid, pending, failed, refunded. "
                   "Akkor használd ezt a függvényt, amikor a felhasználó "
                   "egy fizetés státuszáról vagy annak megérkezéséről kérdez."
}

# 2. minta: Paraméterek példákkal
{
    "transaction_id": {
        "type": "string",
        "description": "Egyedi ID T betűvel és 4 számjeggyel (pl. T1001, T2345)"
    }
}

# 3. minta: Enum korlátozott értékekhez
{
    "status": {
        "type": "string",
        "enum": ["paid", "pending", "failed", "refunded"],
        "description": "Szűrés fizetési státusz szerint"
    }
}

A megfelelő modell kiválasztása

A modellválasztás a pontosság és a költség közötti kompromisszum, és nincs univerzális válasz: ez a kitett függvények számától és sémáik összetettségétől függ. Egy összetett eset, sok függvénnyel és beágyazott paraméterekkel indokolttá teszi a Mistral Large 3 használatát, amely megbízhatóbb a függvénykiválasztásban, de drágább. Egy szabványos eset, néhány egyszerű függvénnyel, nagy átviteli sebességű éles környezetben nagyon jól fut a Mistral Small 4-en, amely gyors és gazdaságos. Prototípuskészítéshez és teszteléshez a Mistral Medium 3.5 jó kompromisszumot kínál.

# Összetett esetek: sok függvény, beágyazott paraméterek
# -> Mistral Large 3 (megbízhatóbb, drágább)
model = "mistral-large-latest"

# Szabványos esetek: kevés egyszerű függvény, nagy átviteli sebességű éles környezet
# -> Mistral Small 4 (gyors, gazdaságos)
model = "mistral-small-latest"

# Fejlesztési esetek: prototípuskészítés, tesztelés
# -> Mistral Medium 3.5 (jó kompromisszum)
model = "mistral-medium-latest"

A módszer ugyanolyan fontos, mint az eredmény: éles környezetben kezdd a legképesebb modellel, mérd meg a helyes hívások arányát, majd fokozatosan lépj vissza, hogy megtaláld a legjobb költség/teljesítmény arányt. Az ellenkezője – a legolcsóbb modellel kezdés – megfoszt attól az alapvonaltól, amely alapján eldöntheted, hogy a romlás a modellből vagy a leírásaiból adódik.

A rendszerüzenet felépítése

Egy jó rendszerüzenet teszi a különbséget egy közepes és egy kiváló asszisztens között. Ez a példa egy bevált struktúrát illusztrál: egy szerepmeghatározás, egy blokk imperatív szabályokkal, majd az elérhető eszközök emlékeztetője. A két legköltséghatékonyabb szabály itt az „Ha a felhasználó nem ad meg egy szükséges azonosítót, kérdezz udvariasan“ és a „Soha ne találgass tranzakció azonosítót“ – együtt ezek szüntetik meg a legkárosabb viselkedést, mégpedig azt, amikor a modell kitalált azonosítóval hív meg egy függvényt.

system_message = {
    "role": "system",
    "content": """Te az Acme Corporation fizetéskezelő asszisztense vagy.

Szabályok:
- Mindig angolul válaszolj
- Az összegeket euróban, szimbólummal és 2 tizedesjeggyel formázd
- Ha a felhasználó nem ad meg egy szükséges azonosítót, kérdezz udvariasan
- Soha ne találgass tranzakció azonosítót
- Ha egy tranzakció sikertelen, ajánld fel a részletek ellenőrzését

Elérhető eszközök:
- retrieve_payment_status: egy fizetés státuszának ellenőrzésére
- retrieve_payment_date: egy fizetés dátumának ellenőrzésére
- retrieve_payment_details: egy tranzakció összes részletének lekérésére
- list_customer_transactions: egy ügyfél összes tranzakciójának megtekintésére"""
}

Költségek kezelése éles környezetben

Minden függvényhívás tokeneket fogyaszt, és a számla két alábecsült csatornán keresztül nő: az eszközdefiníciókat minden kéréssel elküldik, és az előzmények minden körrel nőnek. A függvények kontextus szerinti szűrése megoldja az első pontot – nincs szükség mind a tizenkét eszköz elküldésére, ha a kérdés egyértelműen a fizetésekre vonatkozik. Az előzmények egy küszöbérték feletti csonkolása megoldja a másodikat. És amikor minden szükséges adat már a kontextusban van, a tool_choice="none" elkerül egy extra kört.

# 1. A függvények számának korlátozása kérésenként
# Csak a kontextushoz releváns függvényeket add át
def get_relevant_tools(user_input: str, all_tools: list) -> list:
    """Szűri az eszközöket a kontextus alapján."""
    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. Az előzmények méretének korlátozása
MAX_HISTORY = 20  # üzenetek

# 3. A tool_choice="none" használata, amikor az adatok már rendelkezésre állnak

A függvényhívás tesztelése

A tesztek elengedhetetlenek a regressziók elkerüléséhez, és itt egy szokatlan tárgyat céloznak meg: nem a függvényed visszatérési értékét ellenőrzöd, hanem a modell döntését. Két tesztcsoport fedi le a lényeget. Az első azt ellenőrzi, hogy egy üzleti kérdés a megfelelő függvényt indítja-e el a helyesen kinyert argumentumokkal. A második, ugyanilyen fontos és gyakran elfelejtett teszt azt ellenőrzi, hogy egy köszönés nem vált ki hívást – ez a teszt fogja el azokat a túl tág leírásokat, amelyek arra késztetik a modellt, hogy minden körülmények között hívjon meg egy függvényt.

def test_payment_status():
    """Teszteli, hogy a modell a megfelelő függvényt hívja-e meg."""
    messages = [{"role": "user", "content": "A T1001-es fizetés státusza?"}]

    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():
    """Teszteli, hogy a modell nem hív meg függvényt köszönésre."""
    messages = [{"role": "user", "content": "Szia!"}]

    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

Monitorozás éles környezetben

Most már tudnod kell, mit tesz a rendszered, miután kikerült a vadonba. Az alábbi osztály három jelet aggregál, amelyek együtt szinte a teljes történetet elmesélik: az általános sikerráta, az átlagos késleltetés és a függvényenkénti lebontás. Ez utóbbi a gyakorlatban a legbeszédesebb – egy olyan függvény, amelynek hiba-számlálója elszigetelten növekszik, egy specifikus problémára utal, míg a romló általános ráta semmit nem árul el arról, hol kell keresgélni.

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

Következő lépések

Most, hogy elsajátítottad a függvényhívást Mistrallel, több irány is megnyílik előtted. A legtermészetesebb az autonóm ágensek építése, amelyek egyesítik a függvényhívást egy olyan ágensciklussal, amely összetett feladatokat tervez meg és hajt végre; a Mistral Agents API és annak client.beta.agents.create() módszere még tovább megy, mivel állapotmentes, perzisztens ágenseket kínál. Egy másik tengely a RAG és a függvényhívás kombinációja: a modell maga dönti el, mikor kérdezzen le egy vektoradatbázist, ahelyett, hogy a keresést szisztematikusan upstream indítanák el. A felhasználói élmény oldaláról a streaming lehetővé teszi a válaszok valós idejű megjelenítését a függvények végrehajtása közben, megváltoztatva a késleltetés érzékelését hosszú hívási láncok esetén. Végül a multimodális képességek a függvényhívást a látás felé nyitják meg dokumentumelemzés céljából.

Főbb megállapítások

  • A telepítési ellenőrzőlista kiterjed az architektúrára, biztonságra, megbízhatóságra és monitorozásra
  • A pontos leírások példákkal és enumokkal javítják a modell pontosságát
  • Válaszd ki a megfelelő modellt a komplexitás és a költségvetés alapján (Large a megbízhatósághoz, Small az átviteli sebességhez)
  • A rendszerüzenet egy erős kar a viselkedés irányításához
  • Teszteld szisztematikusan a függvényhívásokat és a „nincs hívás“ viselkedést
  • Monitorozd a sikerrátát, a késleltetést és a költségeket éles környezetben

Teszteld a tudásod!

Végpontok közötti függvényhívás: öt ellenőrzés.

1. Mi a függvényhívás öt lépése?

Válasz: Függvények definiálása (sémák), azok átadása az API-nak, a modell kér egy hívást az argumentumaival, a kódod végrehajtja és visszaadja az eredményt, a modell előállítja a végső választ.

2. Mitől jó egy függvényséma?

Válasz: Szigorú típusok és operatív leírások – világos név, mikor használd, minden paraméter formátuma: ez az a szöveg, amit a modell olvas a döntéshez és a kitöltéshez.

3. Mire tesznek lehetővé a párhuzamos hívások?

Válasz: A modell több függvényt kér egyszerre egy válaszban, amikor azok függetlenek – kevesebb kör, feltéve, hogy minden eredményt párosítasz a hívásához.

4. Mire való a tool_choice?

Válasz: A modell szabadságának beállítására: auto (ő dönt), any (eszközt kell használnia), vagy egy kényszerített eszköz – ez utóbbi kulcsfontosságú a megbízható strukturált kinyeréshez.

5. Milyen biztonsági szabályok vonatkoznak a kitett függvényekre?

Válasz: Validáld a kapott argumentumokat, korlátozd minden függvény hatókörét, naplózd a hívásokat, és tartsd meg az emberi jóváhagyást a véglegesítő műveleteknél – a modell javasol, a kódod dönt.

A tanfolyam két kidolgozott példája (fizetéskövető, CRM) pontosan ezeket a szabályokat alkalmazza – a saját integrációid is ezt a mintát fogják követni.