Legjobb gyakorlatok és éles környezet
Ezen az oldalon
- Prototípustól az éles környezetig
- Telepítési ellenőrzőlista
- Olyan leírások írása, amelyek működésre bírják a modellt
- A megfelelő modell kiválasztása
- A rendszerüzenet felépítése
- Költségek kezelése éles környezetben
- A függvényhívás tesztelése
- Monitorozás éles környezetben
- Következő lépések
- Főbb megállapítások
- 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.