Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Funktionen in Python definieren

Lektion 4 von 14 Aktualisiert am 2. November 2026 Entwickler
Auf dieser Seite
  1. Von der Theorie zum Code
  2. Mistral SDK installieren
  3. Python-Funktionen erstellen
  4. JSON-Spezifikationen schreiben
  5. Funktionen in einem Wörterbuch organisieren
  6. Die Option tool_choice
  7. Kernaussagen

Von der Theorie zum Code

Sie verstehen nun den fünfstufigen Prozess und die Struktur des JSON-Schemas. Es ist Zeit, echten Python-Code zu schreiben. In dieser Lektion erstellen Sie Funktionen, entwerfen deren Spezifikationen und bereiten alles vor, was für den ersten Aufruf der Mistral-API benötigt wird.

Mistral SDK installieren

Beginnen Sie mit der Installation des offiziellen Pakets:

pip install mistralai

Konfigurieren Sie anschließend Ihren API-Schlüssel. Best Practices schreiben vor, dass Sie diesen niemals direkt im Quellcode festlegen. Stattdessen lesen Sie ihn aus einer Umgebungsvariablen, sodass Sie Ihren Code sicher in Versionskontrollsysteme einchecken können.

export MISTRAL_API_KEY="your-api-key"
import os
from mistralai.client import Mistral

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

Python-Funktionen erstellen

Schauen wir uns ein konkretes Beispiel an: Ein Zahlungsnachverfolgungssystem, das auf einem Pandas DataFrame basiert. Dies ist ein klassisches Beispiel aus der Mistral-Dokumentation, das das Konzept perfekt veranschaulicht – hier übernimmt das DataFrame die Rolle einer Datenbank in der Produktion.

import pandas as pd
import json

# Zahlungsinformationen
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)

Nun folgt der Code, der tatsächlich auf diese Daten zugreift. Dies sind Standard-Python-Funktionen; nichts in ihrer Implementierung deutet darauf hin, dass ein LLM sie steuern wird.

def retrieve_payment_status(df: pd.DataFrame, transaction_id: str) -> str:
    """Ruft den Status einer Zahlung anhand ihrer ID ab."""
    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:
    """Ruft das Datum einer Zahlung anhand ihrer ID ab."""
    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"})

Zwei Implementierungsdetails verdienen Ihre Aufmerksamkeit. Erstens geben diese Funktionen immer eine JSON-Zeichenfolge zurück, niemals ein rohes Python-Objekt. Dies ist das Format, das das Modell als Werkzeugergebnis erwartet, daher ist der Aufruf von json.dumps() unerlässlich. Zweitens behandeln sie explizit den Fall, in dem eine Transaktion nicht gefunden wird, anstatt eine Ausnahme zu werfen. Dieser Fehler, als JSON formatiert, kehrt an das Modell zurück wie jedes andere Ergebnis und ermöglicht es ihm, den Benutzer höflich darüber zu informieren, dass die Transaktion T9999 nicht existiert. Sie werden später im Kurs sehen, warum dieses Reflexverhalten essenziell ist.

JSON-Spezifikationen schreiben

Jede Funktion benötigt eine Spezifikation, damit das Modell sie verstehen kann. Hier wenden Sie die Struktur aus der vorherigen Lektion auf die beiden obigen Funktionen an – beachten Sie die strikte Korrespondenz zwischen den name-Feldern und den tatsächlichen Namen der Python-Funktionen.

tools = [
    {
        "type": "function",
        "function": {
            "name": "retrieve_payment_status",
            "description": "Ruft den Status einer Zahlung (paid, pending, failed) "
                           "basierend auf der Transaktions-ID ab.",
            "parameters": {
                "type": "object",
                "properties": {
                    "transaction_id": {
                        "type": "string",
                        "description": "Einzigartige Transaktionskennung (z. B. T1001)"
                    }
                },
                "required": ["transaction_id"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "retrieve_payment_date",
            "description": "Ruft das Datum ab, an dem eine Zahlung getätigt wurde "
                           "basierend auf der Transaktions-ID.",
            "parameters": {
                "type": "object",
                "properties": {
                    "transaction_id": {
                        "type": "string",
                        "description": "Einzigartige Transaktionskennung (z. B. T1001)"
                    }
                },
                "required": ["transaction_id"]
            }
        }
    }
]

Funktionen in einem Wörterbuch organisieren

Das Modell gibt einen Funktionsnamen als Zeichenfolge zurück. Sie benötigen eine Möglichkeit, diese Zeichenfolge auf das entsprechende aufrufbare Objekt abzubilden, ohne auf eval oder eine Kaskade von if-Anweisungen zurückzugreifen. Ein Dispatch-Wörterbuch löst dieses Problem in drei Zeilen.

from functools import partial

# Binden Sie das DataFrame an jede Funktion
available_functions = {
    "retrieve_payment_status": partial(retrieve_payment_status, df),
    "retrieve_payment_date": partial(retrieve_payment_date, df),
}

functools.partial adressiert eine spezifische, reale Schwierigkeit. Ihre Funktionen erwarten zwei Argumente – das DataFrame und die ID –, das Modell liefert jedoch nur eines. Das Modell weiß nichts über df, noch sollte es. partial füllt diesen ersten Parameter einmal und für alle vor. Derselbe Mechanismus gilt für Datenbankverbindungen, HTTP-Clients oder Authentifizierungstoken. Die dynamische Aufrufbarkeit wird dadurch trivial.

function_name = "retrieve_payment_status"
function_params = {"transaction_id": "T1001"}

result = available_functions[function_name](**function_params)
# → '{"status": "paid"}'

Die Option tool_choice

Wenn Sie diese Werkzeuge an die API senden, entscheidet der Parameter tool_choice, wie viel Freiheit Sie dem Modell geben. Drei Werte sind möglich.

# Das Modell entscheidet selbst, ob es ein Werkzeug verwendet oder direkt antwortet (Standard)
response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools,
    tool_choice="auto"
)

# Erzwingen Sie, dass das Modell ein Werkzeug verwendet
response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools,
    tool_choice="any"
)

# Verhindern Sie, dass das Modell Werkzeuge verwendet
response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools,
    tool_choice="none"
)

Der Modus "auto" ist aus gutem Grund in der Produktion am häufigsten: Ein Zahlungsnachverfolgungs-Assistent sollte in der Lage sein, „Hallo” zu sagen, ohne eine Datenbankabfrage auszulösen. Das Modell antwortet direkt auf allgemeine Fragen und verwendet Funktionen nur, wenn diese relevant sind. Eine vollständige Lektion später im Kurs behandelt spezifische Anwendungsfälle für any und none.

Kernaussagen

  • Funktionen müssen JSON-Zeichenfolgen zurückgeben – niemals rohe Python-Objekte
  • Verwenden Sie ein Dispatch-Wörterbuch, um Funktionsnamen auf ihre Implementierungen abzubilden
  • functools.partial ist ideal zum Vorabfüllen von Parametern wie Datenbankverbindungen oder DataFrames
  • tool_choice steuert, ob das Modell Funktionen verwenden kann oder muss (auto, any, none)
  • Behandeln Sie Fehlerfälle in Ihren Funktionen immer (ungültige Parameter, fehlende Daten)