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

Anropa API:et med verktyg

Lektion 5 av 14 Uppdaterad 2 november 2026 Utvecklare
På denna sida
  1. Skicka verktyg till Mistral API
  2. Den första begäran
  3. Förstå modellens svar
  4. Parsa svaret och extrahera tool_calls
  5. När modellen begär saknad information
  6. Hantera systemmeddelandet
  7. Kompletterande kod för steg 2–3
  8. Viktiga punkter

Skicka verktyg till Mistral API

Du har definierat dina funktioner och deras JSON-specifikationer. Nu måste du skicka dem till Mistral API och, viktigare än så, förstå vad modellen returnerar. Vi befinner oss nu vid steg 2 och 3 i processen: modellen tar emot användarens begäran tillsammans med verktygen och producerar ett funktionsanrop – eller avstår från att göra ett, vilket är lika lärorikt.

Den första begäran

import os
import json
from mistralai.client import Mistral

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

# Tools defined in the previous lesson
tools = [
    {
        "type": "function",
        "function": {
            "name": "retrieve_payment_status",
            "description": "Retrieves the status of a payment based on the transaction ID.",
            "parameters": {
                "type": "object",
                "properties": {
                    "transaction_id": {
                        "type": "string",
                        "description": "Unique transaction identifier (e.g., T1001)"
                    }
                },
                "required": ["transaction_id"]
            }
        }
    }
]

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

# API call with tools
response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools
)

Förstå modellens svar

Svaret innehåller ett message-objekt som kan anta två former, och din kod måste hantera båda från dag ett. I det första fallet svarar modellen direkt eftersom ingen funktion behövs: content innehåller text och tool_calls är None.

# response.choices[0].message.content contains the text response
# response.choices[0].message.tool_calls is None
print(response.choices[0].message.content)
# → "Hello! How can I help you?"

I det andra fallet vill modellen anropa en funktion. Situationen är den omvända: content är tom eller null, och tool_calls bär på datamängden.

# response.choices[0].message.content is None or empty
# response.choices[0].message.tool_calls contains the calls
message = response.choices[0].message

if message.tool_calls:
    for tool_call in message.tool_calls:
        print(f"Function: {tool_call.function.name}")
        print(f"Arguments: {tool_call.function.arguments}")
        print(f"ID: {tool_call.id}")

Typisk utmatning:

Function: retrieve_payment_status
Arguments: {"transaction_id": "T1001"}
ID: call_abc123xyz

Parsa svaret och extrahera tool_calls

Här är den kompletta koden för att rent extrahera information från ett verktygsanrop:

message = response.choices[0].message

if message.tool_calls and len(message.tool_calls) > 0:
    tool_call = message.tool_calls[0]

    # Extract the function name
    function_name = tool_call.function.name

    # Parse JSON arguments into a Python dictionary
    function_params = json.loads(tool_call.function.arguments)

    # Retrieve the unique call identifier
    tool_call_id = tool_call.id

    print(f"The model wants to call: {function_name}")
    print(f"With parameters: {function_params}")
    print(f"Call ID: {tool_call_id}")
else:
    # The model responded directly
    print(f"Response: {message.content}")

Tre delar information kommer ut ur detta block, och den tredje är den som folk glömmer. Funktionsnamnet används för dirigering, de parsade argumenten används för anropet, men tool_call_id är det som låter modellen koppla ditt resultat till rätt anrop när du skickar tillbaka det. Tappar du bort det blir konversationsomgången oåterkallelig.

När modellen begär saknad information

Ibland tillhandahåller användaren inte tillräckligt med information. Modellen har en elegant utväg: anropa inte någon funktion alls, utan ställ istället en förtydligande fråga.

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

response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools
)

message = response.choices[0].message
print(message.content)
# → "I need the transaction ID to check the status.
#     Could you please provide the transaction number?"

Detta beteende är exakt vad du vill ha. Modellen vet att transaction_id listas under required; istället för att hitta på ett trovärdigt ID och utlösa en begäran om icke-existerande data, lämnar den över ordet till användaren. Detta är också den bästa demonstrationen av nyttan med fältet required som behandlades i föregående lektion.

Hantera systemmeddelandet

Systemmeddelandet låter dig rama in detta beteende snarare än att hoppas på det.

messages = [
    {
        "role": "system",
        "content": "You are a payment tracking assistant. "
                   "Respond in English. "
                   "Use the available tools to answer questions "
                   "about transactions. If the user does not provide "
                   "the transaction ID, ask for it politely."
    },
    {
        "role": "user",
        "content": "What is the status of payment T1001?"
    }
]

Läs det rad för rad: den första meningen sätter rollen, den andra sätter tonen och språket för assistenten, den tredje specificerar när funktioner ska användas, och den sista ger en explicit instruktion för ett specialfall – saknad information. Dessa är de tre användningsfall för vilka ett systemmeddelande rekommenderas, och de räcker de flesta gånger.

Kompletterande kod för steg 2–3

Här är den kompletta, återanvändbara koden för att skicka en begäran med verktyg. Den kapslar in allt ovan och normaliserar svaret till en ordlista med två former, vilket sparar dig från att sprida ut if message.tool_calls-kontroller genom hela din applikation.

import os
import json
from mistralai.client import Mistral

def call_mistral_with_tools(
    messages: list,
    tools: list,
    model: str = "mistral-large-latest",
    tool_choice: str = "auto"
) -> dict:
    """Sends a request to Mistral with tools and returns the parsed response."""
    client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

    response = client.chat.complete(
        model=model,
        messages=messages,
        tools=tools,
        tool_choice=tool_choice
    )

    message = response.choices[0].message

    if message.tool_calls and len(message.tool_calls) > 0:
        return {
            "type": "tool_call",
            "message": message,
            "tool_calls": [
                {
                    "id": tc.id,
                    "function_name": tc.function.name,
                    "arguments": json.loads(tc.function.arguments)
                }
                for tc in message.tool_calls
            ]
        }

    return {
        "type": "text",
        "message": message,
        "content": message.content
    }

Observera att listkomprehensionen itererar över alla tool_calls, inte bara det första. Modellen kan producera flera samtidigt; en senare lektion kommer att täcka detta, men din hjälpfunktion är redan redo att hantera dem.

Viktiga punkter

  • Skicka tools och messages till client.chat.complete() för att aktivera funktionsanrop
  • Kontrollera alltid om message.tool_calls finns innan du försöker parsa
  • tool_call_id är obligatoriskt för att skicka resultatet tillbaka till modellen
  • Argument är en JSON-sträng som måste parsas med json.loads()
  • Modellen kan välja att svara direkt om den inte behöver en funktion eller om information saknas