Definiera funktioner i Python
På denna sida
Från teori till kod
Nu har du förstått femstegsprocessen och strukturen för JSON Schema. Det är dags att skriva riktig Python-kod. I den här lektionen ska du skapa funktioner, utforma deras specifikationer och förbereda allt för Mistral API – allt som måste finnas på plats innan du gör ditt första nätverksanrop.
Installera Mistral SDK
Börja med att installera det officiella paketet:
pip install mistralai
Konfigurera sedan din API-nyckel. Bästa praxis säger att du aldrig ska hårdkoda den i dina källfiler. Läs den istället från en miljövariabel så att du säkert kan checka in din kod i versionshantering.
export MISTRAL_API_KEY="your-api-key"
import os
from mistralai.client import Mistral
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
Skapa Python-funktioner
Låt oss titta på ett genomgående exempel: ett system för betalningsövervakning backed av en Pandas DataFrame. Detta är ett klassiskt exempel från Mistral-dokumentationen som perfekt illustrerar konceptet – här spelar DataFrame:t den roll en databas skulle ha i produktion.
import pandas as pd
import json
# Betalningsdata
data = {
"transaction_id": ["T1001", "T1002", "T1003", "T1004", "T1005"],
"customer_id": ["C001", "C002", "C003", "C002", "C001"],
"payment_amount": [125.50, 89.99, 350.00, 45.00, 210.75],
"payment_date": ["2026-03-15", "2026-03-16", "2026-03-17", "2026-03-17", "2026-03-18"],
"payment_status": ["paid", "paid", "pending", "paid", "failed"]
}
df = pd.DataFrame(data)
Därefter kommer koden som faktiskt använder denna data. Detta är vanliga Python-funktioner; inget i deras implementation antyder att en LLM kommer att styra dem.
def retrieve_payment_status(df: pd.DataFrame, transaction_id: str) -> str:
"""Hämtar status för en betalning baserat på dess ID."""
if transaction_id in df["transaction_id"].values:
status = df[df["transaction_id"] == transaction_id]["payment_status"].values[0]
return json.dumps({"status": status})
return json.dumps({"error": f"Transaction {transaction_id} not found"})
def retrieve_payment_date(df: pd.DataFrame, transaction_id: str) -> str:
"""Hämtar datumet för en betalning baserat på dess ID."""
if transaction_id in df["transaction_id"].values:
date = df[df["transaction_id"] == transaction_id]["payment_date"].values[0]
return json.dumps({"date": date})
return json.dumps({"error": f"Transaction {transaction_id} not found"})
Två implementationsdetaljer förtjänar din uppmärksamhet. För det första returnerar dessa funktioner alltid en JSON-sträng, aldrig ett rått Python-objekt. Detta är formatet som modellen förväntar sig som verktygsresultat, så json.dumps() är ett måste. För det andra hanterar de explicit fallet där en transaktion inte hittas istället för att kasta ett undantag. Detta fel, formaterat som JSON, returneras till modellen precis som vilket annat resultat som helst, vilket gör att den kan informera användaren artigt om att transaktion T9999 inte finns. Du kommer senare i kursen att se varför detta reflex är avgörande.
Skriv JSON-specifikationer
Varje funktion behöver en specifikation så att modellen kan förstå den. Här tillämpar du strukturen från föregående lektion på de två funktionerna ovan – notera den strikta överensstämmelsen mellan fälten name och de faktiska Python-funktionsnamnen.
tools = [
{
"type": "function",
"function": {
"name": "retrieve_payment_status",
"description": "Retrieves the status of a payment (paid, pending, failed) "
"based on the transaction ID.",
"parameters": {
"type": "object",
"properties": {
"transaction_id": {
"type": "string",
"description": "Unique transaction identifier (e.g., T1001)"
}
},
"required": ["transaction_id"]
}
}
},
{
"type": "function",
"function": {
"name": "retrieve_payment_date",
"description": "Retrieves the date a payment was made "
"based on the transaction ID.",
"parameters": {
"type": "object",
"properties": {
"transaction_id": {
"type": "string",
"description": "Unique transaction identifier (e.g., T1001)"
}
},
"required": ["transaction_id"]
}
}
}
]
Organisera funktioner i en ordlista
Modellen returnerar ett funktionsnamn som en sträng. Du behöver ett sätt att mappa den strängen till motsvarande anropbara objekt utan att tillgripa eval eller en kaskad av if-satser. En dispatch-ordlista löser detta problem på tre rader.
from functools import partial
# Bind DataFrame:t till varje funktion
available_functions = {
"retrieve_payment_status": partial(retrieve_payment_status, df),
"retrieve_payment_date": partial(retrieve_payment_date, df),
}
functools.partial adresserar en specifik, verklig svårighet. Dina funktioner förväntar sig två argument – DataFrame:t och ID:t – men modellen tillhandahåller bara ett. Modellen vet ingenting om df, och det ska den inte heller. partial fyller i den första parametern en gång för alla. Samma mekanism gäller för databasanslutningar, HTTP-klienter eller autentiseringstokens. Dynamisk anrop blir då trivialt.
function_name = "retrieve_payment_status"
function_params = {"transaction_id": "T1001"}
result = available_functions[function_name](**function_params)
# → '{"status": "paid"}'
Alternativet tool_choice
När du skickar dessa verktyg till API:t bestämmer parametern tool_choice hur mycket frihet du ger modellen. Tre värden är möjliga.
# Modellen avgör själv om den ska använda ett verktyg eller svara direkt (standard)
response = client.chat.complete(
model="mistral-large-latest",
messages=messages,
tools=tools,
tool_choice="auto"
)
# Tvinga modellen att använda ett verktyg
response = client.chat.complete(
model="mistral-large-latest",
messages=messages,
tools=tools,
tool_choice="any"
)
# Förhindra modellen från att använda verktyg
response = client.chat.complete(
model="mistral-large-latest",
messages=messages,
tools=tools,
tool_choice="none"
)
Läget "auto" är vanligast i produktion av goda skäl: en assistent för betalningsövervakning bör kunna säga “hej” utan att utlösa en databasfråga. Modellen svarar direkt på generella frågor och använder funktioner endast när det är relevant. En hel lektion senare i kursen täcker specifika användningsfall för any och none.
Viktiga punkter
- Funktioner måste returnera JSON-strängar – aldrig råa Python-objekt
- Använd en dispatch-ordlista för att mappa funktionsnamn till deras implementationer
functools.partialär idealiskt för att fylla i parametrar i förväg, som DB-anslutningar eller DataFramestool_choicestyr om modellen kan eller måste använda funktioner (auto,any,none)- Hantera alltid felcase i dina funktioner (ogiltiga parametrar, saknad data)