Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Bedste praksis og produktion

Lektion 14 af 14 Opdateret 29. juli 2026 Udvikler
På denne side
  1. Fra Proof of Concept til produktion
  2. Tjekliste til implementering
  3. Skriv beskrivelser, der får modellen til at virke
  4. Valg af den rigtige model
  5. Strukturering af systembeskeden
  6. Håndtering af omkostninger i produktion
  7. Test af funktionskald
  8. Overvågning i produktion
  9. Næste skridt
  10. Vigtige pointer
  11. Test din viden

Fra Proof of Concept til produktion

Du har nu alle byggestenene til at konstruere systemer med funktionskald ved hjælp af Mistral. Det, der adskiller din prototype fra en produktionsklar tjeneste, er ikke manglende funktioner, men en række kontrolpunkter og justeringer, som du typisk opdager under en hændelse. Denne sidste lektion samler bedste praksis, almindelige faldgruber og en tjekliste for at gå i produktion med ro i maven.

Tjekliste til implementering

Dette er det eneste sted i dette kursus, hvor et listeformat er obligatorisk: Før du går live, skal du sætte flueben. Fire domæner skal dækkes, og hvert svarer på et andet spørgsmål.

Arkitektur sikrer, at mekanikken holder. At returnere JSON-strenge i kæden og have en komplet dispatch-ordbog er de to hyppigste årsager til nedbrud ved det første rigtige kald.

  • Alle funktioner returnerer JSON-strenge (aldrig rå Python-objekter)
  • Dispatch-ordbogen er komplet og opdateret
  • Funktioner håndterer fejltilfælde og returnerer brugbare beskeder
  • Systembeskeden er klar, præcis og testet
  • Samtaleløkken håndterer sekventielle og parallelle kald

Sikkerhed tager udgangspunkt i, at argumenter kommer fra en bruger, aldrig fra din applikation.

  • Argumenter valideres før eksekvering (format, type, værdier)
  • SQL-forespørgsler bruger parametre (ingen konkatenering)
  • En whitelist begrænser de tilgængelige funktioner
  • Destruktive handlinger kræver bekræftelse
  • Rate limiting er implementeret pr. funktion og pr. bruger
  • Resultater renses (ingen følsomme data returneres til modellen)

Pålidelighed håndterer det, der fejler, uden at nogen er skyld i det.

  • Fejl returneres til modellen i et struktureret format
  • Genforsøg med backoff er implementeret for midlertidige fejl
  • Timeouts er konfigureret for hver ekstern funktion
  • Historikstørrelsen begrænses for at undgå token-overløb

Overvågning er endelig det, der lader dig diagnosticere uden at gætte.

  • Hvert funktionskald logges (navn, argumenter, resultat, varighed)
  • Fejl udløser alarmer (Slack, PagerDuty osv.)
  • Metrikker indsamles (succesrate, latens, API-omkostninger)

Skriv beskrivelser, der får modellen til at virke

Kvaliteten af beskrivelser har en direkte indvirkning på nøjagtigheden, og det er ofte den billigste håndtag at trække i. Tre mønstre går igen hos teams med høje rater af korrekte kald. Det første forankrer beskrivelsen i en forretningsmæssig kontekst: I stedet for at parafrasere funktionsnavnet skal du liste mulige returværdier og eksplicit angive, hvornår funktionen skal kaldes. Det andet indsætter formatseksempler i parameterbeskrivelsen, hvilket løser de fleste fejl ved udtrækning af ID’er. Det tredje erstatter en instruktion på naturligt sprog med en enum, hvilket er den eneste måde at virkelig forbyde en værdi uden for listen på.

# Mønster 1: Beskrivelse med forretningskontekst
{
    "description": "Henter betalingsstatus. "
                   "Mulige statusser: paid, pending, failed, refunded. "
                   "Brug denne funktion, når brugeren spørger "
                   "om en betalings status, eller om den er modtaget."
}

# Mønster 2: Parametre med eksempler
{
    "transaction_id": {
        "type": "string",
        "description": "Unikt ID i formatet T efterfulgt af 4 cifre (f.eks. T1001, T2345)"
    }
}

# Mønster 3: Enum for begrænsede værdier
{
    "status": {
        "type": "string",
        "enum": ["paid", "pending", "failed", "refunded"],
        "description": "Filtrer efter betalingsstatus"
    }
}

Valg af den rigtige model

Valg af model er en afvejning mellem nøjagtighed og omkostninger, og der findes ikke ét universelt svar: Det afhænger af antallet af eksponerede funktioner og kompleksiteten af deres skemaer. En kompleks sag med mange funktioner og nestede parametre berettiger brugen af Mistral Large 3, som er mere pålidelig til funktionsvalg, men dyrere. En standardsag med få enkle funktioner i produktion med højt gennemløb kører meget godt på Mistral Small 4, som er hurtig og økonomisk. Til prototyping og test tilbyder Mistral Medium 3.5 et godt kompromis.

# Komplekse tilfælde: mange funktioner, nestede parametre
# -> Mistral Large 3 (mere pålidelig, dyrere)
model = "mistral-large-latest"

# Standardtilfælde: få enkle funktioner, højtydende produktion
# -> Mistral Small 4 (hurtig, økonomisk)
model = "mistral-small-latest"

# Udviklingstilfælde: prototyping, test
# -> Mistral Medium 3.5 (godt kompromis)
model = "mistral-medium-latest"

Metoden er lige så vigtig som resultatet: I produktion skal du starte med den mest capable model, måle din rate for korrekte kald og derefter trappe gradvist ned for at finde det bedste forhold mellem omkostninger og ydeevne. Det modsatte – at starte med den billigste model – fratager dig det benchmark, der er nødvendigt for at vide, om en forringelse skyldes modellen eller dine beskrivelser.

Strukturering af systembeskeden

En god systembesked gør forskellen mellem en middelmådig assistent og en fremragende en. Denne illustrerer en bevist struktur: En rolleerklæring, en blok med imperative regler og derefter en påmindelse om de tilgængelige værktøjer. De to mest omkostningseffektive regler her er „Hvis brugeren ikke angiver et påkrævet ID, så spørg høfligt” og „Gæt aldrig et transaktions-ID” – tilsammen eliminerer de den mest skadelige adfærd af alle, nemlig at kalde en funktion med et opdigtet ID.

system_message = {
    "role": "system",
    "content": """Du er en assistent til betalingsstyring for Acme Corporation.

Regler:
- Svar altid på engelsk
- Formater beløb i euro med symbolet og 2 decimaler
- Hvis brugeren ikke angiver et påkrævet ID, så spørg høfligt
- Gæt aldrig et transaktions-ID
- Når en transaktion fejler, så tilbyd at tjekke detaljerne

Tilgængelige værktøjer:
- retrieve_payment_status: til at tjekke en betalings status
- retrieve_payment_date: til at tjekke en betalings dato
- retrieve_payment_details: til at hente alle detaljer om en transaktion
- list_customer_transactions: til at se alle transaktioner for en kunde"""
}

Håndtering af omkostninger i produktion

Hvert funktionskald forbruger tokens, og regningen stiger gennem to undervurderede kanaler: Værktøjsdefinitioner sendes med hver anmodning, og historikken vokser med hver omgang. Filtrering af funktioner efter kontekst løser det første punkt – der er ingen grund til at sende alle tolv værktøjer, når spørgsmålet tydeligt handler om betalinger. Afkortning af historikken ud over en tærskel løser det andet. Og når alle nødvendige data allerede er i konteksten, undgår tool_choice="none" en ekstra rundtur.

# 1. Begræns antallet af funktioner pr. anmodning
# Send kun funktioner, der er relevante for konteksten
def get_relevant_tools(user_input: str, all_tools: list) -> list:
    """Filtrerer værktøjer baseret på kontekst."""
    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. Begræns historikstørrelse
MAX_HISTORY = 20  # beskeder

# 3. Brug tool_choice="none", når data allerede er tilgængelige

Test af funktionskald

Tests er afgørende for at undgå regressioner, og her retter de sig mod et usædvanligt objekt: Du tjekker ikke din funktions returværdi, men modellens beslutning. To testfamilier dækker det væsentlige. Den første verificerer, at et forretningsspørgsmål udløser den rigtige funktion med de rigtige udtrukne argumenter. Den anden, lige så vigtig og ofte glemt, verificerer, at en hilsen ikke udløser noget kald – denne test fanger alt for brede beskrivelser, der får modellen til at kalde en funktion under alle omstændigheder.

def test_payment_status():
    """Tester, at modellen kalder den rigtige funktion."""
    messages = [{"role": "user", "content": "Status for betaling T1001?"}]

    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():
    """Tester, at modellen ikke kalder en funktion ved en hilsen."""
    messages = [{"role": "user", "content": "Hej!"}]

    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

Overvågning i produktion

Nu skal du vide, hvad dit system laver, når det er sluppet løs i det virkelige liv. Klassen nedenfor aggregerer tre signaler, der tilsammen fortæller næsten hele historien: Samlet succesrate, gennemsnitlig latens og en opdeling pr. funktion. Den sidste er mest sigende i praksis – en funktion, hvis fejl-tæller driver isoleret, peger på et specifikt problem, mens en forringet samlet rate ikke fortæller dig noget om, hvor du skal kigge hen.

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()

Næste skridt

Nu hvor du har mestret funktionskald med Mistral, åbner flere retninger sig. Den mest naturlige er opbygning af autonome agenter, der kombinerer funktionskald med et agent-løkke, der planlægger og udfører komplekse opgaver; Mistral Agents API og dens client.beta.agents.create() går endnu videre ved at tilbyde persistente agenter med tilstand. En anden akse kombinerer RAG og funktionskald: Modellen beslutter selv, hvornår den skal spørge en vektordatabase, i stedet for at søgningen udløses systematisk upstream. På brugeroplevelsessiden giver streaming dig mulighed for at vise svar i realtid, mens funktioner eksekveres, hvilket ændrer opfattelsen af latens ved lange kaldkæder. Endelig åbner multimodal funktionskald op for vision til dokumentanalyse.

Vigtige pointer

  • Implementeringschecklisten dækker arkitektur, sikkerhed, pålidelighed og overvågning
  • Præcise beskrivelser med eksempler og enums forbedrer modellens nøjagtighed
  • Vælg den rigtige model baseret på kompleksitet og budget (Large til pålidelighed, Small til gennemløb)
  • Systembeskeden er et kraftfuldt håndtag til at styre adfærd
  • Test funktionskald og adfærd uden funktioner systematisk
  • Overvåg succesrate, latens og omkostninger i produktion

Test din viden

End-to-end funktionskald: fem tjekpunkter.

1. Hvad er de fem trin i funktionskald?

Svar: Definer funktioner (skemaer), lever dem til API’et, modellen anmoder om et kald med sine argumenter, din kode eksekverer og returnerer resultatet, modellen producerer det endelige svar.

2. Hvad kendetegner et godt funktionsskema?

Svar: Strikte typer og operationelle beskrivelser – klart navn, hvornår det skal bruges, formatet for hver parameter: Dette er den tekst, modellen læser for at beslutte og udfylde.

3. Hvad muliggør parallelle kald?

Svar: Modellen anmoder om flere funktioner i ét enkelt svar, når de er uafhængige – færre rundture, forudsat at du matcher hvert resultat med dets kald.

4. Hvad bruges tool_choice til?

Svar: Til at indstille modellens frihedsgrad: auto (den beslutter), any (den skal bruge et værktøj) eller et tvunget værktøj – det sidste er nøglen til pålidelig struktureret udtrækning.

5. Hvilke sikkerhedsregler gælder for eksponerede funktioner?

Svar: Valider modtagne argumenter, begræns hver funktions omfang, log kald, og behold menneskelig validering ved commit-handlinger – modellen foreslår, din kode disponerer.

De to gennemarbejdede eksempler i dette kursus (betalingstracker, CRM) anvender præcis disse regler – dine egne integrationer vil følge samme støbning.