Gedimų valdymas
Šiame puslapyje
Klaidos yra neišvengiamos
Veikiančioje sistemoje funkcijos stringa. Išorinės API neveikia, ID neegzistuoja, parametrai neteisingi, o laukimo laikas baigiasi. Klausimas ne „ar tai stringa?“, o „kaip mandagiai tvarkyti nesėkmes?“. Mokėjimų sekimo sistema, kuri lūžta, nes vartotojas įvedė T9999 vietoj T1001, nėra veikianti sistema; tai tik demonstracija.
Gera žinia ta, kad turi išteklių, kurio neturi klasikinės architektūros: Mistral modelis gali suprasti klaidų pranešimus, kuriuos jam siunti, ir atitinkamai pritaikyti savo atsakymą. Kol tradicinė serverio dalis turi kurti vartotojo sąsajos žinutę kiekvienam klaidos kodui, tu gali leisti modeliui paversti nesėkmę naudinga sakinio formos instrukcija vartotojui. Tereikia pateikti jam reikiamą informaciją.
Niekada neslėpk klaidos nuo modelio
Tai yra auksinė šios pamokos taisyklė. Grąžink klaidą tool žinutėje tiksliai taip, kaip grąžintum įprastą rezultatą: kaip struktūrizuotą JSON. Priešingas refleksas – sugauti išimtį ir grąžinti tuščią eilutę arba null – priverčia modelį manyti, kad funkcija įvykdyta sėkmingai, tiesiog neturėjo ką pasakyti. Tai sukelia pačius painiausius įmanomus atsakymus.
def retrieve_payment_status(df, transaction_id: str) -> str:
"""Retrieves status with full error handling."""
try:
if transaction_id not in df["transaction_id"].values:
return json.dumps({
"error": "transaction_not_found",
"message": f"Transaction {transaction_id} does not exist in the database."
})
status = df[df["transaction_id"] == transaction_id]["payment_status"].values[0]
return json.dumps({"status": status, "transaction_id": transaction_id})
except Exception as e:
return json.dumps({
"error": "internal_error",
"message": f"Error retrieving data: {str(e)}"
})
Pakanka dviejų laukų: mašininio kodo lauke error ir žmogui suprantamo paaiškinimo lauke message. Kodas leidžia tavo stebėsenos sistemai skaičiuoti pasikartojimus; paaiškinimas leidžia modeliui suformuluoti naudingą atsakymą. Pažiūrėk, kas nutinka bandant rasti neegzistuojantį sandorį.
# User requests a non-existent transaction
messages = [{"role": "user", "content": "Status of payment T9999?"}]
# Model calls retrieve_payment_status(transaction_id="T9999")
# Your function returns: {"error": "transaction_not_found", ...}
# Model formulates:
# → "I couldn't find a transaction with ID T9999.
# Could you check the number and try again?"
Niekas nerašė to sakinio. Jis gimsta iš klaidos kodo ir netgi siūlo vartotojui taisomąjį veiksmą.
Vykdytojas, kuris nepraleidžia nieko
Apsaugoti funkcijos nepakanka: sluoksnis, kuris išsiunčia tool_calls, turi savo gedimo režimus, nepriklausomus nuo tavo verslo logikos. Modelis gali haliucinuoti funkcijos pavadinimą, kurio nėra tavo žodyne. Jis gali sugeneruoti neteisingai suformuotus JSON argumentus – retas, bet realus atvejis sudėtingoms schemoms. Jis taip pat gali pateikti teisingą JSON, kurio raktai neatitinka Python parašo, sukeldamas TypeError vykdant **function_params. Kiekvienas iš šių trijų atvejų nusipelno savo klaidos kodo, nes kiekvienam reikia skirtingo taisymo tavo pusėje.
def execute_tool_call(tool_call, available_functions):
"""Executes a tool_call with full error handling."""
function_name = tool_call.function.name
# Check if function exists
if function_name not in available_functions:
return {
"role": "tool",
"name": function_name,
"content": json.dumps({
"error": "function_not_found",
"message": f"Function {function_name} is not available."
}),
"tool_call_id": tool_call.id
}
# Parse arguments
try:
function_params = json.loads(tool_call.function.arguments)
except json.JSONDecodeError as e:
return {
"role": "tool",
"name": function_name,
"content": json.dumps({
"error": "invalid_arguments",
"message": f"Invalid JSON arguments: {str(e)}"
}),
"tool_call_id": tool_call.id
}
# Execute function
try:
result = available_functions[function_name](**function_params)
return {
"role": "tool",
"name": function_name,
"content": result,
"tool_call_id": tool_call.id
}
except TypeError as e:
return {
"role": "tool",
"name": function_name,
"content": json.dumps({
"error": "invalid_params",
"message": f"Incompatible parameters: {str(e)}"
}),
"tool_call_id": tool_call.id
}
except Exception as e:
return {
"role": "tool",
"name": function_name,
"content": json.dumps({
"error": "execution_error",
"message": f"Execution error: {str(e)}"
}),
"tool_call_id": tool_call.id
}
Atkreipk dėmesį, kad kiekviena šaka, įskaitant gedimo šakas, grąžina pilną tool žinutę su savo tool_call_id. Tai būtina: API atmeta istoriją, kurioje tool_call lieka be atsakymo, o tyli nesėkmė sukeltų validacijos klaidą kitame žingsnyje, toli nuo tikrosios priežasties.
Atskirk laikinus gedimus nuo nuolatinių
Ne visos klaidos yra vienodos. Trūkstamas sandoris antrojo bandymo metu vis tiek bus trūkstamas; kartojimas tik eikvoja laiką. Tuo tarpu tinklo laiko viršijimas arba trumpam perkrauta paslauga dažnai išsprendžia save. Šiai antrajai kategorijai kartojimas su eksponentine delsos didinimo strategija (viena sekundė, tada dvi, tada keturios) suteikia paslaugai laiko atsistatyti neužgriovus jos užklausomis. Išnaudojus bandymus, grįžti į įprastą elgseną: klaidos JSON, skirtas modeliui.
import time
def execute_with_retry(func, params, max_retries=3, base_delay=1.0):
"""Executes a function with exponential retry."""
for attempt in range(max_retries):
try:
result = func(**params)
return result
except ConnectionError as e:
if attempt < max_retries - 1:
delay = base_delay * (2 ** attempt)
time.sleep(delay)
else:
return json.dumps({
"error": "service_unavailable",
"message": f"Service unavailable after {max_retries} attempts.",
"details": str(e)
})
Mistral API taip pat gali stringti
Visa tai, kas išdėstyta aukščiau, susiję su tavo funkcijomis. Kvietimas į Mistral API yra atskiras gedimo taškas, tvarkomas atskirai: čia nėra modelio, kuriam galima būtų paaiškinti problemą, nes būtent modelis yra nepasiekiamas. HTTPValidationError dažniausiai signalizuoja klaidą tavo žinučių ar įrankių struktūroje, kurią turi ištaisyti kode; kitos išimtys susijusios su tinklu arba paslauga ir tvarkomos ta pačia kartojimo logika kaip ir aukščiau.
from mistralai.client import Mistral
from mistralai.client.errors import HTTPValidationError
def safe_chat_complete(client, model, messages, tools):
"""Mistral API call with error handling."""
try:
return client.chat.complete(
model=model,
messages=messages,
tools=tools
)
except HTTPValidationError as e:
print(f"Validation error: {e}")
return None
except Exception as e:
print(f"API error: {e}")
return None
Matyk, kas iš tikrųjų vyksta
Funkcijų kvietimo sistemą sunku derinti post factum, jei nežinai, kuri funkcija buvo iškviesta, su kokiais argumentais ir ką ji grąžino. Registravimas nėra prabanga; tai būdas, kaip atrasi, kad dviprasmiškas aprašymas verčia modelį supainioti dvi funkcijas, arba kad kas penktas vartotojas sistemingai sukelia transaction_not_found. Registruok kvietimą prieš vykdymą, tada rezultatą, atskirdamas info lygį nuo error lygio, kad tavo įspėjimai galėtų efektyviai filtruoti duomenis.
import logging
logger = logging.getLogger("function_calling")
def execute_and_log(tool_call, available_functions):
"""Executes and logs the result."""
function_name = tool_call.function.name
function_params = json.loads(tool_call.function.arguments)
logger.info(f"Call: {function_name}({function_params})")
result = execute_tool_call(tool_call, available_functions)
content = json.loads(result["content"])
if "error" in content:
logger.error(f"Failure {function_name}: {content['error']} - {content['message']}")
else:
logger.info(f"Success {function_name}: {content}")
return result
Svarbiausi punktai
- Visada grąžink klaidas modeliui
toolžinutėje – jis moka jas interpretuoti - Naudok struktūrizuotus klaidų kodus (
transaction_not_found,invalid_argumentsir kt.) - Įgyvendink kartojimą su delsos didinimu laikinoms klaidoms
- Atskirai tvarkyk klaidas savo funkcijose ir klaidas Mistral API
- Registruok kiekvieną kvietimą ir kiekvieną klaidą veikimo stebėsenai