Best Practices und Produktion
Auf dieser Seite
Vom Prototyp zur Produktion
Sie verfügen nun über alle Bausteine, um Funktion-Aufruf-Systeme mit Mistral zu konstruieren. Was Ihren Prototypen von einem produktionsreifen Service unterscheidet, sind nicht fehlende Funktionen, sondern eine Reihe von Prüf- und Abstimmungsschritten, die Sie typischerweise während eines Vorfalls entdecken. Diese letzte Lektion bündelt Best Practices, häufige Fallstricke und eine Checkliste, um mit Zuversicht in die Produktion zu gehen.
Bereitstellungs-Checkliste
Dies ist der einzige Ort in diesem Kurs, an dem ein Listenformat zwingend erforderlich ist: Bevor Sie live gehen, setzen Sie Haken. Vier Domänen müssen abgedeckt sein, wobei jede eine andere Frage beantwortet.
Architektur stellt sicher, dass die Mechanismen standhalten. Das Rückgeben von JSON-Strings in der Kette und ein vollständiges Dispatch-Dict sind die beiden häufigsten Ursachen für Abstürze beim ersten echten Aufruf.
- Alle Funktionen geben JSON-Strings zurück (niemals rohe Python-Objekte)
- Das Dispatch-Dict ist vollständig und aktuell
- Funktionen behandeln Fehlerfälle und geben verwertbare Nachrichten zurück
- Die Systemnachricht ist klar, präzise und getestet
- Der Gesprächsloop behandelt sequenzielle und parallele Aufrufe
Sicherheit geht davon aus, dass Argumente von einem Nutzer stammen, niemals von Ihrer Anwendung.
- Argumente werden vor der Ausführung validiert (Format, Typ, Werte)
- SQL-Abfragen verwenden Parameter (keine Verkettung)
- Eine Whitelist begrenzt verfügbare Funktionen
- Zerstörende Aktionen erfordern Bestätigung
- Rate Limiting ist pro Funktion und pro Nutzer vorhanden
- Ergebnisse werden bereinigt (keine sensiblen Daten werden an das Modell zurückgegeben)
Zuverlässigkeit behandelt das, was fehlschlägt, ohne dass jemand schuld ist.
- Fehler werden dem Modell in einem strukturierten Format zurückgegeben
- Retry mit Backoff ist für vorübergehende Fehler implementiert
- Timeouts sind für jede externe Funktion konfiguriert
- Die Historiengröße ist begrenzt, um Token-Überläufe zu vermeiden
Überwachung schließlich ist das, was es Ihnen ermöglicht, zu diagnostizieren, ohne zu raten.
- Jeder Funktionsaufruf wird protokolliert (Name, Argumente, Ergebnis, Dauer)
- Fehler lösen Alarme aus (Slack, PagerDuty usw.)
- Metriken werden gesammelt (Erfolgsquote, Latenz, API-Kosten)
Beschreibungen schreiben, die das Modell funktionieren lassen
Die Qualität der Beschreibung hat einen direkten Einfluss auf die Genauigkeit, und es ist oft der günstigste Hebel, den man ziehen kann. Drei Muster wiederholen sich bei Teams mit hohen Raten korrekter Aufrufe. Das erste verankert die Beschreibung im Geschäftskontext: Statt den Funktionsnamen umzudeuten, werden mögliche Rückgabewerte aufgelistet und es wird explizit angegeben, wann sie aufgerufen werden sollen. Das zweite gleitet Formatbeispiele in die Parameterbeschreibung ein, was die meisten ID-Extraktionsfehler behebt. Das dritte ersetzt eine natürliche Sprachanweisung durch ein enum, die einzige Möglichkeit, einen Wert außerhalb der Liste wirklich zu verbieten.
# Muster 1: Beschreibung mit Geschäftskontext
{
"description": "Holt den Zahlungstatus. "
"Mögliche Status: paid, pending, failed, refunded. "
"Verwenden Sie diese Funktion, wenn der Nutzer "
"nach dem Status einer Zahlung oder ob sie empfangen wurde, fragt."
}
# Muster 2: Parameter mit Beispielen
{
"transaction_id": {
"type": "string",
"description": "Einzigartige ID im Format T gefolgt von 4 Ziffern (z. B. T1001, T2345)"
}
}
# Muster 3: Enum für begrenzte Werte
{
"status": {
"type": "string",
"enum": ["paid", "pending", "failed", "refunded"],
"description": "Filtern nach Zahlungstatus"
}
}
Das richtige Modell wählen
Die Modellwahl ist ein Abwägen zwischen Genauigkeit und Kosten, und es gibt keine universelle Antwort: Es hängt von der Anzahl der exponierten Funktionen und der Komplexität ihrer Schemata ab. Ein komplexer Fall mit vielen Funktionen und verschachtelten Parametern rechtfertigt Mistral Large 3, das bei der Funktionsauswahl zuverlässiger ist, aber teurer. Ein Standardfall mit wenigen einfachen Funktionen läuft in Hochdurchsatz-Produktionen sehr gut auf Mistral Small 4, das schnell und wirtschaftlich ist. Für Prototyping und Tests bietet Mistral Medium 3.5 einen guten Kompromiss.
# Komplexe Fälle: viele Funktionen, verschachtelte Parameter
# -> Mistral Large 3 (zuverlässiger, teurer)
model = "mistral-large-latest"
# Standardfälle: wenige einfache Funktionen, Hochdurchsatz-Produktion
# -> Mistral Small 4 (schnell, wirtschaftlich)
model = "mistral-small-latest"
# Entwicklungsfälle: Prototyping, Tests
# -> Mistral Medium 3.5 (guter Kompromiss)
model = "mistral-medium-latest"
Die Methode ist so wichtig wie das Ergebnis: In der Produktion beginnen Sie mit dem leistungsfähigsten Modell, messen Ihre korrekte Aufrufquote und gehen dann schrittweise nach unten, um das beste Kosten-/Leistungsverhältnis zu finden. Das Gegenteil – mit dem günstigsten Modell zu beginnen – beraubt Sie der Basis, um zu wissen, ob eine Verschlechterung vom Modell oder von Ihren Beschreibungen stammt.
Das System-Message strukturieren
Ein gutes System-Message macht den Unterschied zwischen einem mittelmäßigen Assistenten und einem exzellenten. Dieses illustriert eine bewährte Struktur: eine Rollenbestimmung, ein Block imperativer Regeln und dann eine Erinnerung an verfügbare Werkzeuge. Die beiden kosteneffektivsten Regeln hier sind “Wenn der Nutzer keine erforderliche ID bereitstellt, bitten Sie höflich” und “Raten Sie niemals eine Transaktions-ID” – zusammen eliminieren sie das schädlichste Verhalten überhaupt, nämlich den Aufruf einer Funktion mit einer erfundenen ID.
system_message = {
"role": "system",
"content": """Sie sind ein Zahlungshilfsassistent für die Acme Corporation.
Regeln:
- Antworten Sie immer auf Englisch
- Formatieren Sie Beträge in Euro mit Symbol und 2 Dezimalstellen
- Wenn der Nutzer keine erforderliche ID bereitstellt, bitten Sie höflich
- Raten Sie niemals eine Transaktions-ID
- Wenn eine Transaktion fehlschlägt, bieten Sie an, die Details zu prüfen
Verfügbare Werkzeuge:
- retrieve_payment_status: um den Status einer Zahlung zu prüfen
- retrieve_payment_date: um das Datum einer Zahlung zu prüfen
- retrieve_payment_details: um alle Details einer Transaktion zu erhalten
- list_customer_transactions: um alle Transaktionen eines Kunden anzuzeigen"""
}
Kosten in der Produktion managen
Jeder Funktion-Aufruf verbraucht Tokens, und die Rechnung steigt durch zwei unterschätzte Kanäle: Tool-Definitionen werden mit jeder Anfrage gesendet, und die Historie wächst mit jeder Runde. Das Filtern von Funktionen nach Kontext löst den ersten Punkt – kein Bedarf, alle zwölf Tools zu senden, wenn die Frage eindeutig nach Zahlungen fragt. Das Truncieren der Historie über einen Schwellenwert hinaus löst den zweiten. Und wenn alle notwendigen Daten bereits im Kontext sind, vermeidet tool_choice="none" eine zusätzliche Hin-und-Her-Reise.
# 1. Die Anzahl der Funktionen pro Anfrage begrenzen
# Übergeben Sie nur Funktionen, die für den Kontext relevant sind
def get_relevant_tools(user_input: str, all_tools: list) -> list:
"""Filtert Tools basierend auf dem Kontext."""
if "payment" in user_input.lower() or "transaction" in user_input.lower():
return [t for t in all_tools if "payment" in t["function"]["name"]]
if "contact" in user_input.lower() or "customer" in user_input.lower():
return [t for t in all_tools if "contact" in t["function"]["name"]]
return all_tools
# 2. Die Historiengröße begrenzen
MAX_HISTORY = 20 # Nachrichten
# 3. tool_choice="none" verwenden, wenn Daten bereits verfügbar sind
Funktion-Aufrufe testen
Tests sind unerlässlich, um Regressionen zu vermeiden, und hier zielen sie auf ein ungewöhnliches Objekt ab: Sie prüfen nicht den Rückgabewert Ihrer Funktion, sondern die Entscheidung des Modells. Zwei Testfamilien decken das Wesentliche ab. Die erste verifiziert, dass eine geschäftliche Frage die richtige Funktion mit den richtigen extrahierten Argumenten auslöst. Die zweite, ebenso wichtige und oft vergessene, verifiziert, dass eine Begrüßung keinen Aufruf auslöst – dieser Test fängt zu breite Beschreibungen ab, die das Modell dazu drängen, in jeder Situation eine Funktion aufzurufen.
def test_payment_status():
"""Testet, dass das Modell die richtige Funktion aufruft."""
messages = [{"role": "user", "content": "Status of payment T1001?"}]
response = client.chat.complete(
model=model, messages=messages, tools=tools
)
message = response.choices[0].message
assert message.tool_calls is not None
assert len(message.tool_calls) == 1
assert message.tool_calls[0].function.name == "retrieve_payment_status"
args = json.loads(message.tool_calls[0].function.arguments)
assert args["transaction_id"] == "T1001"
def test_no_function_for_greeting():
"""Testet, dass das Modell für eine Begrüßung keine Funktion aufruft."""
messages = [{"role": "user", "content": "Hello!"}]
response = client.chat.complete(
model=model, messages=messages, tools=tools
)
message = response.choices[0].message
assert message.tool_calls is None or len(message.tool_calls) == 0
assert message.content is not None
Überwachung in der Produktion
Jetzt müssen Sie wissen, was Ihr System tut, sobald es in die Wildnis entlassen wurde. Die Klasse unten aggregiert drei Signale, die zusammen fast die ganze Geschichte erzählen: die allgemeine Erfolgsquote, die durchschnittliche Latenz und die Aufschlüsselung nach Funktion. Letztere ist in der Praxis am aussagekräftigsten – eine Funktion, deren Fehlerzähler isoliert driftet, weist auf ein spezifisches Problem hin, während eine verschlechterte Gesamtquote Ihnen nichts darüber sagt, wo man suchen soll.
import time
import logging
logger = logging.getLogger("fc_monitor")
class FunctionCallingMonitor:
def __init__(self):
self.metrics = {
"total_calls": 0,
"successful_calls": 0,
"failed_calls": 0,
"total_latency_ms": 0,
"calls_by_function": {}
}
def record(self, function_name: str, success: bool, latency_ms: float):
self.metrics["total_calls"] += 1
self.metrics["total_latency_ms"] += latency_ms
if success:
self.metrics["successful_calls"] += 1
else:
self.metrics["failed_calls"] += 1
if function_name not in self.metrics["calls_by_function"]:
self.metrics["calls_by_function"][function_name] = {
"count": 0, "errors": 0
}
self.metrics["calls_by_function"][function_name]["count"] += 1
if not success:
self.metrics["calls_by_function"][function_name]["errors"] += 1
def get_success_rate(self) -> float:
if self.metrics["total_calls"] == 0:
return 0.0
return self.metrics["successful_calls"] / self.metrics["total_calls"]
def get_avg_latency(self) -> float:
if self.metrics["total_calls"] == 0:
return 0.0
return self.metrics["total_latency_ms"] / self.metrics["total_calls"]
monitor = FunctionCallingMonitor()
Nächste Schritte
Jetzt, da Sie Funktion-Aufrufe mit Mistral gemeistert haben, öffnen sich mehrere Richtungen. Die natürlichste ist der Aufbau autonomer Agenten, die Funktion-Aufrufe mit einem Agenten-Loop kombinieren, der komplexe Aufgaben plant und ausführt; die Mistral Agents API und ihr client.beta.agents.create() gehen weiter, indem sie persistente Agenten mit Zustand anbieten. Eine andere Achse kombiniert RAG und Funktion-Aufrufe: Das Modell entscheidet selbst, wann es eine Vektordatenbank abfragt, anstatt dass die Suche systematisch im Vorfeld ausgelöst wird. Auf der Seite der Benutzererfahrung ermöglicht Streaming, dass Sie Antworten in Echtzeit anzeigen, während Funktionen ausgeführt werden, was die Wahrnehmung der Latenz bei langen Aufrufketten verändert. Schließlich öffnet multimodal Funktion-Aufrufe für die Vision zur Dokumentenanalyse.
Kernaussagen
- Die Bereitstellungs-Checkliste deckt Architektur, Sicherheit, Zuverlässigkeit und Überwachung ab
- Präzise Beschreibungen mit Beispielen und Enums verbessern die Modellgenauigkeit
- Wählen Sie das richtige Modell basierend auf Komplexität und Budget (Large für Zuverlässigkeit, Small für Durchsatz)
- Das System-Message ist ein mächtiger Hebel, um das Verhalten zu lenken
- Testen Sie Funktion-Aufrufe und das Verhalten ohne Funktion systematisch
- Überwachen Sie Erfolgsquote, Latenz und Kosten in der Produktion
Wissen prüfen
End-to-End-Funktion-Aufrufe: fünf Kontrollen.
1. Was sind die fünf Schritte des Funktion-Aufrufs?
Antwort: Funktionen (Schemata) definieren, sie der API bereitstellen, das Modell bittet um einen Aufruf mit seinen Argumenten, Ihr Code führt aus und gibt das Ergebnis zurück, das Modell produziert die finale Antwort.
2. Was macht ein gutes Funktionsschema aus?
Antwort: Strenge Typen und operative Beschreibungen – klarer Name, wann es zu verwenden ist, Format jedes Parameters: das ist der Text, den das Modell liest, um zu entscheiden und auszufüllen.
3. Was ermöglichen parallele Aufrufe?
Antwort: Das Modell bittet in einer einzigen Antwort um mehrere Funktionen, wenn sie unabhängig sind – weniger Hin-und-Her-Reisen, sofern Sie jedes Ergebnis seinem Aufruf zuordnen.
4. Wozu dient tool_choice?
Antwort: Um die Freiheit des Modells festzulegen: auto (es entscheidet), any (es muss ein Tool verwenden) oder ein erzwungenes Tool – letzteres ist entscheidend für zuverlässige strukturierte Extraktion.
5. Welche Sicherheitsregeln für exponierte Funktionen?
Antwort: Empfangene Argumente validieren, den Umfang jeder Funktion begrenzen, Aufrufe protokollieren und menschliche Validierung beim Festlegen von Aktionen beibehalten – das Modell schlägt vor, Ihr Code entscheidet.
Die beiden durchgeführten Beispiele in diesem Kurs (Zahlungstracker, CRM) wenden genau diese Regeln an – Ihre eigenen Integrationen werden demselben Muster folgen.