Spring til hovedindhold
Dansk— Vælg et sprog
Menu

5-trinsprocessen

Lektion 2 af 14 Opdateret 2. november 2026 Udvikler
På denne side
  1. En klar protokol mellem dig og modellen
  2. Flowet i detaljer
  3. Flow-mønstre
  4. Vigtige pointer

En klar protokol mellem dig og modellen

Mistrals funktionskald følger en veldefineret proces på fem trin. Det, der gør denne protokol læsbar, er, at hvert trin har én enkelt ejer: enten dig (udvikleren), modellen eller brugeren. Intet trin deles, og intet er tvetydigt. Tag dig tid til at memorere denne arbejdsfordeling, før du skriver en eneste linje kode: de fleste fejl ved funktionskald opstår, når en udvikler forventer, at modellen håndterer et trin, der faktisk er dit ansvar.

1

Definér funktionerne (Udvikler)

Du beskriver hver tilgængelig funktion med et JSON-skema: navn, beskrivelse, parametre, typer og påkrævede felter. Modellen ser kun denne specifikation, ikke din kode.

2

Brugeren stiller et spørgsmål (Bruger)

Brugeren stiller sit spørgsmål på naturligt sprog. Du sender denne anmodning til Mistral-modellen sammen med listen over tilgængelige værktøjer.

3

Generér argumenter (Model)

Modellen analyserer anmodningen, vælger den passende funktion og genererer argumenterne i JSON-format. Den udfører ikke funktionen – den fortæller dig blot, hvad du skal kalde, og med hvilke parametre.

4

Udfør funktionen (Udvikler)

Din kode udtrækker funktionsnavnet og argumenterne fra modellens svar, kører den tilsvarende funktion og henter resultatet.

5

Generér det endelige svar (Model)

Du sender funktionsresultatet tilbage til modellen. Den integrerer resultatet i samtalekonteksten og formulerer et naturligt svar til brugeren.

Flowet i detaljer

Disse fem trin mapper direkte til kode. Lad os gennemgå dem ved hjælp af et enkelt, bevidst minimalt eksempel: en bruger ønsker at kende status for betaling T1001. Vi vil bruge dette samme eksempel som vores røde tråd gennem hele afsnittet „Python-implementering”, så sæt dig ind i dets identifikatorer nu.

Trin 1: Du definerer værktøjerne

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_payment_status",
            "description": "Retrieves the status of a payment given its transaction ID",
            "parameters": {
                "type": "object",
                "properties": {
                    "transaction_id": {
                        "type": "string",
                        "description": "The unique transaction identifier (e.g., T1001)"
                    }
                },
                "required": ["transaction_id"]
            }
        }
    }
]

Intet her er eksekverbar kode: det er en beskrivelse. Modellen lærer, at en funktion ved navn get_payment_status eksisterer, hvad den gør, og at den kræver en transaction_id af typen string. Den lærer aldrig, hvordan funktionen er implementeret.

Trin 2: Brugeren stiller sit spørgsmål

messages = [
    {"role": "user", "content": "What is the status of payment T1001?"}
]

Trin 3: Modellen genererer argumenterne

from mistralai.client import Mistral

client = Mistral(api_key="your-api-key")
response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools
)

# The model returns a tool_call:
# function.name = "get_payment_status"
# function.arguments = '{"transaction_id": "T1001"}'

Modellen udtrak „T1001” fra sætningen og placerede det i det korrekte felt. Bemærk, at arguments ankommer som en string, ikke som et dictionary: du håndterer den detalje i næste trin.

Trin 4: Du udfører funktionen

import json

tool_call = response.choices[0].message.tool_calls[0]
args = json.loads(tool_call.function.arguments)
result = get_payment_status(**args)
# → {"status": "paid", "date": "2026-03-15"}

Trin 5: Modellen formulerer svaret

messages.append(response.choices[0].message)
messages.append({
    "role": "tool",
    "name": "get_payment_status",
    "content": json.dumps(result),
    "tool_call_id": tool_call.id
})

final = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools
)
print(final.choices[0].message.content)
# → "Payment T1001 was made on March 15, 2026."

To beskeder føjes til historikken, aldrig kun én: assistent-beskeden, der bærer kaldanmodningen, efterfulgt af beskeden, der bærer resultatet. tool_call_id linker de to. Udelad enten den ene eller den anden, og API’et vil afvise anmodningen, eller også vil modellen svare uden for emnet.

Flow-mønstre

Afhængigt af anmodningens kompleksitet kan dette flow tage forskellige former. Det enkleste tilfælde er, når ingen funktion er involveret: brugeren stiller et generelt spørgsmål – „Hvad kan du?” – og modellen svarer direkte uden nogensinde at røre værktøjerne. Dernæst kommer det simple kald, vi lige har gennemgået: én funktion, ét resultat, ét svar.

De næste to former er mere interessante. I en sekventiel kæde kalder modellen en første funktion, læser resultatet og bruger det til at beslutte et andet kald – typisk for at hente et kunde-ID, før man spørger til deres fakturaer. I et parallelt kald anmoder den om udførelse af flere funktioner på én gang, fordi ingen af dem afhænger af de andre. Vi vil vie hele lektioner til disse to mønstre; husk foreløbigt, at begge hviler på præcis de fem trin ovenfor, blot gentaget.

Vigtige pointer

  • Funktionskald følger en 5-trinsproces med klare ansvarsområder
  • Modellen kan aldrig udføre en funktion direkte – den genererer kun argumenter
  • Din kode er portvagten: den beslutter, om funktionen skal udføres eller ej
  • Funktionsresultatet sendes tilbage til modellen, så den kan formulere et naturligt svar
  • Flowet kan være simpelt (ét kald) eller komplekst (sekventielt, parallelt)