Veahandlus
Sellel lehel
Vead on paratamatud
Tootmiskeskkonnas funktsioonid ebaõnnestuvad. Välised API-d lakkavad töötamast, ID-sid ei eksisteeri, parameetrid on vigased ja ajalõpud saabuvad. Küsimus ei ole selles, „kas see ebaõnnestub?“, vaid „kuidas me ebaõnnestumist sujuvalt käsitleme?“. Maksejälgija, mis jookseb kokku, sest kasutaja sisestas T9999 asemel T1001, ei ole tootmissüsteem; see on demo.
Hea uudis on see, et sul on siin ressurss, mida klassikalistel arhitektuuridel puudub: Mistrali mudel suudab mõista veateateid, mida sa talle tagasi saadad, ja kohandada oma vastust vastavalt. Kui traditsiooniline taustasüsteem peab iga veakoodi jaoks koostama kasutajaliidese teate, siis sina võid lasta mudelil tõlkida tõrge kasutajale abistavaks lauseks. Sa pead lihtsalt andma talle vajaliku info.
Ära kunagi peida viga mudeli eest
See on selle tunni kuldreegel. Tagasta viga sõnumis tool täpselt nii, nagu tagastaksid normaalse tulemuse: struktureeritud JSONina. Vastupidine refleks – erindi püüdmine ja tühja stringi või null-i tagastamine – paneb mudeli arvama, et funktsioon õnnestus, kuid sellel lihtsalt polnud midagi öelda. See tekitab kõige segasemaid võimalikke vastuseid.
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)}"
})
Kaks välja on piisavad: masinkood väljal error ja inimloetav selgitus väljal message. Kood võimaldab sinu monitoorimissüsteemil lugeda esinemisi; selgitus võimaldab mudelil formuleerida abistava vastuse. Vaata, mis juhtub olematu tehinguga.
# 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?"
Keegi ei kirjutanud seda lauset. See tuleneb veakoodist ja see isegi soovitab kasutajale parandavat tegevust.
Täitur, mis ei lase millelgi läbi libiseda
Funktsiooni kaitsmine ei ole piisav: kihist, mis jagab välja tool_calls-id, on omaenda tõrkeviisid, mis on sõltumatud sinu äriloogikast. Mudel võib hallutsineerida funktsiooninime, mida sinu sõnastikus ei eksisteeri. See võib toota vigase JSON-argumentidega – harv, kuid reaalne juhtum keerukate skeemide korral. Samuti võib see pakkuda kehtivat JSON-i, mille võtmed ei vasta Pythoni signatuurile, põhjustades TypeError-i ajal **function_params. Igaüks neist kolmest juhtumist väärib oma veakoodi, sest igaüks nõuab sinu poolt erinevat lahendust.
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
}
Pane tähele, et iga haru, kaasa arvatud tõrkeharrud, tagastab tervikliku tool-sõnumi koos oma tool_call_id-ga. See on hädavajalik: API lükkab tagasi ajaloo, kus tool_call jääb vastuseta, ja vaikne tõrge põhjustaks järgmises voorus valideerimisvea, mis on tegelikust põhjusest kaugel.
Erista ajutisi ja püsivaid tõrkeid
Kõik vead ei ole võrdsed. Puuduv tehing on puuduv ka teisel katsel; uuesti proovimine raiskab lihtsalt aega. Võrgu ajalõpp või hetkel ülekoormatud teenus aga lahendab end sageli ise. Selle teise kategooria jaoks annab eksponentsiaalse viivitusega (one second, then two, then four) uuesti proovimine teenusele aega taastuda, pommitamata seda päringutega. Pärast katsete ammendumist pöördud tagasi tavapärase käitumise juurde: mudelile mõeldud vea-JSON.
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)
})
Ka Mistrali API võib ebaõnnestuda
Kõik eelnev puudutab sinu funktsioone. Väljakutse Mistrali API-le on eraldi tõrkepunkt, mida käsitletakse eraldi: siin pole mudelit, kes probleemi seletaks, kuna mudel on täpselt see, mis on kättesaamatu. HTTPValidationError annab tavaliselt märku veast sinu sõnumi või tööriistade struktuuris, mille pead koodis parandama; muud erindid puudutavad võrku või teenust ja neid käsitletakse sama uuesti proovimise loogikaga nagu eespool.
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
Vaata, mis tegelikult toimub
Funktsioonide kutsumise süsteemi on raske järelkõlana siluda, kui sa ei tea, millist funktsiooni kutsuti, milliste argumentidega ja mida see tagastas. Logimine ei ole luksus; see on viis, kuidas avastad, et mitmetimõistetav kirjeldus ajendab mudelit segama kahte funktsiooni, või et iga viies kasutaja käivitab süstemaatiliselt transaction_not_found. Logi väljakutse enne täitmist ja seejärel otsus, eristades taset info tasemest error, et sinu hoiatused saaksid tõhusalt filtreerida.
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
Peamised punktid
- Tagasta alati vead mudelile sõnumis
tool– see teab, kuidas neid tõlgendada - Kasuta struktureeritud veakoode (
transaction_not_found,invalid_argumentsjne) - Rakenda uuesti proovimist viivitusega ajutiste tõrgete jaoks
- Käitle vigu oma funktsioonides ja vigu Mistrali API-s eraldi
- Logi iga väljakutse ja iga viga tootmise monitoorimiseks