Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Der 5-Schritte-Prozess

Lektion 2 von 14 Aktualisiert am 2. November 2026 Entwickler
Auf dieser Seite
  1. Ein klares Protokoll zwischen Ihnen und dem Modell
  2. Der Ablauf im Detail
  3. Ablaufmuster
  4. Kernaussagen

Ein klares Protokoll zwischen Ihnen und dem Modell

Mistral Function Calling folgt einem wohldefinierten 5-Schritte-Prozess. Was dieses Protokoll lesbar macht, ist, dass jeder Schritt einen einzigen Verantwortlichen hat: entweder Sie (der Entwickler), das Modell oder der Nutzer. Kein Schritt wird geteilt, und keiner ist mehrdeutig. Nehmen Sie sich Zeit, diese Aufgabenteilung zu memorieren, bevor Sie eine einzige Zeile Code schreiben: Die meisten Fehler beim Function Calling entstehen, wenn ein Entwickler erwartet, dass das Modell einen Schritt übernimmt, der eigentlich seine Verantwortung ist.

1

Funktionen definieren (Entwickler)

Sie beschreiben jede verfügbare Funktion mit einem JSON-Schema: Name, Beschreibung, Parameter, Typen und erforderliche Felder. Das Modell sieht nur diese Spezifikation, nicht Ihren Code.

2

Nutzer stellt eine Frage (Nutzer)

Der Nutzer stellt seine Frage in natürlicher Sprache. Sie senden diese Anfrage an das Mistral-Modell zusammen mit der Liste der verfügbaren Tools.

3

Argumente generieren (Modell)

Das Modell analysiert die Anfrage, wählt die passende Funktion aus und generiert die Argumente im JSON-Format. Es führt die Funktion nicht aus – es sagt Ihnen lediglich, was aufgerufen werden soll und mit welchen Parametern.

4

Funktion ausführen (Entwickler)

Ihr Code extrahiert den Funktionsnamen und die Argumente aus der Antwort des Modells, führt die entsprechende Funktion aus und ruft das Ergebnis ab.

5

Endantwort formulieren (Modell)

Sie senden das Funktionsergebnis zurück an das Modell. Es integriert das Ergebnis in den Gesprächskontext und formuliert eine natürliche Antwort für den Nutzer.

Der Ablauf im Detail

Diese fünf Schritte entsprechen direkt Code. Lassen Sie uns sie anhand eines einzigen, absichtlich minimalen Beispiels durchgehen: Ein Nutzer möchte den Status der Zahlung T1001 wissen. Wir verwenden dieses gleiche Beispiel als roten Faden bis zum Ende des Blocks „Python-Implementierung”, daher machen Sie sich jetzt mit seinen Identifikatoren vertraut.

Schritt 1: Sie definieren die Tools

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"]
            }
        }
    }
]

Hier ist kein ausführbarer Code: Es ist eine Beschreibung. Das Modell lernt, dass eine Funktion namens get_payment_status existiert, was sie tut und dass sie eine transaction_id vom Typ string benötigt. Es lernt nie, wie die Funktion implementiert ist.

Schritt 2: Der Nutzer stellt seine Frage

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

Schritt 3: Das Modell generiert die Argumente

from mistralai.client import Mistral

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

# Das Modell gibt einen tool_call zurück:
# function.name = "get_payment_status"
# function.arguments = '{"transaction_id": "T1001"}'

Das Modell hat „T1001” aus dem Satz extrahiert und in das richtige Feld platziert. Beachten Sie, dass arguments als String, nicht als Dictionary, ankommt: Sie werden diese Detailfrage im nächsten Schritt behandeln.

Schritt 4: Sie führen die Funktion aus

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"}

Schritt 5: Das Modell formuliert die Antwort

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."

Es werden zwei Nachrichten zur Historie hinzugefügt, niemals nur eine: die Assistant-Nachricht, die den Aufruf anfordert, gefolgt von der Nachricht, die das Ergebnis enthält. Die tool_call_id verknüpft die beiden. Lassen Sie eine davon weg, und die API wird die Anfrage ablehnen, oder das Modell wird eine vom Thema abweichende Antwort geben.

Ablaufmuster

Je nach Komplexität der Anfrage kann dieser Ablauf verschiedene Formen annehmen. Der einfachste Fall ist, wenn keine Funktion beteiligt ist: Der Nutzer stellt eine allgemeine Frage – „Was kannst du?” – und das Modell antwortet direkt, ohne die Tools jemals zu berühren. Als Nächstes kommt der einfache Aufruf, den wir gerade durchgegangen sind: eine Funktion, ein Ergebnis, eine Antwort.

Die beiden folgenden Formen sind interessanter. In einer sequentiellen Kette ruft das Modell eine erste Funktion auf, liest das Ergebnis und nutzt es, um einen zweiten Aufruf zu entscheiden – typischerweise die Abfrage einer Kunden-ID vor dem Abrufen ihrer Rechnungen. Bei einem parallelen Aufruf bittet es um die gleichzeitige Ausführung mehrerer Funktionen, da keine von der anderen abhängt. Wir widmen ganze Lektionen diesen beiden Mustern; denken Sie für jetzt nur daran, dass beide auf genau den fünf Schritten oben basieren, die einfach wiederholt werden.

Kernaussagen

  • Function Calling folgt einem 5-Schritte-Prozess mit klaren Verantwortlichkeiten
  • Das Modell kann eine Funktion niemals direkt ausführen – es generiert nur Argumente
  • Ihr Code ist das Tor: Er entscheidet, ob die Funktion ausgeführt wird oder nicht
  • Das Funktionsergebnis wird zurück an das Modell gesendet, damit es eine natürliche Antwort formulieren kann
  • Der Ablauf kann einfach (ein Aufruf) oder komplex (sequentiell, parallel) sein