Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Gedimų valdymas

Paskaita 10 iš 14 Atnaujinta 2026 m. lapkričio 2 d. Kūrėjas
Šiame puslapyje
  1. Klaidos yra neišvengiamos
  2. Niekada neslėpk klaidos nuo modelio
  3. Vykdytojas, kuris nepraleidžia nieko
  4. Atskirk laikinus gedimus nuo nuolatinių
  5. Mistral API taip pat gali stringti
  6. Matyk, kas iš tikrųjų vyksta
  7. Svarbiausi punktai

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_arguments ir 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