Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Hantering av fel

Lektion 10 av 14 Uppdaterad 2 november 2026 Utvecklare
På denna sida
  1. Fel är oundvikliga
  2. Dölj aldrig ett fel för modellen
  3. En exekverare som inte låter något slinka igenom
  4. Skilj på övergående och permanenta fel
  5. Mistral API kan också misslyckas
  6. Se vad som faktiskt händer
  7. Viktiga punkter

Fel är oundvikliga

I produktion misslyckas funktioner. Externa API:er går ner, ID:n finns inte, parametrar är ogiltiga och tidsgränser överskrids. Frågan är inte “kommer det att misslyckas?” utan “hur hanterar vi misslyckanden på ett snyggt sätt?”. En betalningsspårare som kraschar för att en användare skrev T9999 istället för T1001 är inte ett produktionssystem; det är en demo.

Den goda nyheten är att du här har en resurs som klassiska arkitekturer saknar: Mistral-modellen kan förstå felmeddelanden du skickar tillbaka och anpassa sitt svar därefter. Där en traditionell backend måste skapa ett UI-meddelande för varje felkod, kan du låta modellen översätta misslyckandet till en hjälpsam mening för användaren. Du behöver bara ge den informationen.

Dölj aldrig ett fel för modellen

Detta är den gyllene regeln i denna lektion. Returnera ett fel i tool-meddelandet exakt som du skulle göra med ett normalt resultat: som strukturerad JSON. Den motsatta reflexen – att fånga undantaget och returnera en tom sträng eller null – får modellen att tro att funktionen lyckades men helt enkelt inte hade något att säga. Detta ger de mest förvirrande svar som är möjliga.

def retrieve_payment_status(df, transaction_id: str) -> str:
    """Hämtar status med fullständig felhantering."""
    try:
        if transaction_id not in df["transaction_id"].values:
            return json.dumps({
                "error": "transaction_not_found",
                "message": f"Transaktion {transaction_id} finns inte i databasen."
            })

        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"Fel vid hämtning av data: {str(e)}"
        })

Två fält räcker: en maskinkod i error och en människoläsbar förklaring i message. Koden låter ditt övervakningssystem räkna förekomster; förklaringen låter modellen formulera ett hjälpsamt svar. Se vad som händer med en transaktion som inte finns.

# Användaren begär en transaktion som inte finns
messages = [{"role": "user", "content": "Status för betalning T9999?"}]

# Modellen anropar retrieve_payment_status(transaction_id="T9999")
# Din funktion returnerar: {"error": "transaction_not_found", ...}

# Modellen formulerar:
# → "Jag kunde inte hitta någon transaktion med ID T9999.
#     Kan du kontrollera numret och försöka igen?"

Ingen skrev den meningen. Den härstammar från felkoden, och den föreslår till och med en korrigerande åtgärd för användaren.

En exekverare som inte låter något slinka igenom

Att skydda en funktion räcker inte: lagret som distribuerar tool_calls har sina egna felfall, oberoende av din affärslogik. Modellen kan hallucinera ett funktionsnamn som inte finns i din ordbok. Den kan producera felaktigt formaterade JSON-argument – ett sällsynt men verkligt fall med komplexa scheman. Den kan också tillhandahålla giltig JSON vars nycklar inte matchar Python-signaturen, vilket orsakar ett TypeError under **function_params. Vart och ett av dessa tre fall förtjänar sin egen felkod eftersom varje kräver en annan åtgärd från din sida.

def execute_tool_call(tool_call, available_functions):
    """Exekverar ett tool_call med fullständig felhantering."""
    function_name = tool_call.function.name

    # Kontrollera om funktionen finns
    if function_name not in available_functions:
        return {
            "role": "tool",
            "name": function_name,
            "content": json.dumps({
                "error": "function_not_found",
                "message": f"Funktionen {function_name} är inte tillgänglig."
            }),
            "tool_call_id": tool_call.id
        }

    # Parsa argument
    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"Ogiltiga JSON-argument: {str(e)}"
            }),
            "tool_call_id": tool_call.id
        }

    # Exekvera funktion
    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"Inkompatibla parametrar: {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"Exekveringsfel: {str(e)}"
            }),
            "tool_call_id": tool_call.id
        }

Lägg märke till att varje gren, inklusive falgrenar, returnerar ett komplett tool-meddelande med sitt tool_call_id. Detta är avgörande: API:t avvisar en historik där ett tool_call förblir obesvarat, och ett tyst misslyckande skulle orsaka ett valideringsfel vid nästa tur, långt från den verkliga orsaken.

Skilj på övergående och permanenta fel

Inte alla fel är lika. En saknad transaktion kommer fortfarande att saknas vid andra försöket; att försöka igen slösar bara tid. En nätverkstidsgräns eller en tillfälligt överbelastad tjänst löser sig dock ofta av sig själv. För denna andra kategori ger ett försök med exponentiell backoff – en sekund, sedan två, sedan fyra – tjänsten tid att återhämta sig utan att hamra den med förfrågningar. Efter att ha uttömt försöken faller du tillbaka till det vanliga beteendet: en fel-JSON avsedd för modellen.

import time

def execute_with_retry(func, params, max_retries=3, base_delay=1.0):
    """Exekverar en funktion med exponentiellt återförsök."""
    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"Tjänsten inte tillgänglig efter {max_retries} försök.",
                    "details": str(e)
                })

Mistral API kan också misslyckas

Allt ovanstående gäller dina funktioner. Själva anropet till Mistral API är en separat felpunkt som hanteras separat: här finns det ingen modell att förklara problemet för, eftersom modellen precis är det som inte går att nå. Ett HTTPValidationError signalerar vanligtvis ett fel i din struktur för meddelanden eller verktyg, vilket du måste åtgärda i koden; andra undantag rör nätverket eller tjänsten och hanteras med samma logik för återförsök som ovan.

from mistralai.client import Mistral
from mistralai.client.errors import HTTPValidationError

def safe_chat_complete(client, model, messages, tools):
    """Mistral API-anrop med felhantering."""
    try:
        return client.chat.complete(
            model=model,
            messages=messages,
            tools=tools
        )
    except HTTPValidationError as e:
        print(f"Valideringsfel: {e}")
        return None
    except Exception as e:
        print(f"API-fel: {e}")
        return None

Se vad som faktiskt händer

Ett system för funktionsanrop är svårt att felsöka i efterhand om du inte vet vilken funktion som anropades, med vilka argument och vad den returnerade. Loggning är ingen lyx; det är så du upptäcker att en tvetydig beskrivning får modellen att förväxla två funktioner, eller att en av fem användare systematiskt utlöser ett transaction_not_found. Logga anropet före exekvering, sedan resultatet, och skilj på nivån info från nivån error så att dina varningar kan filtrera effektivt.

import logging

logger = logging.getLogger("function_calling")

def execute_and_log(tool_call, available_functions):
    """Exekverar och loggar resultatet."""
    function_name = tool_call.function.name
    function_params = json.loads(tool_call.function.arguments)

    logger.info(f"Anrop: {function_name}({function_params})")

    result = execute_tool_call(tool_call, available_functions)
    content = json.loads(result["content"])

    if "error" in content:
        logger.error(f"Misslyckande {function_name}: {content['error']} - {content['message']}")
    else:
        logger.info(f"Lyckades {function_name}: {content}")

    return result

Viktiga punkter

  • Returnera alltid fel till modellen i tool-meddelandet – den vet hur den ska tolka dem
  • Använd strukturerade felkoder (transaction_not_found, invalid_arguments, etc.)
  • Implementera återförsök med backoff för övergående fel
  • Hantera fel i dina funktioner och fel i Mistral API separat
  • Logga varje anrop och varje fel för övervakning i produktion