Mistral Agents API: Ein Leitfaden mit Demo-Projekt

Mistral hat die Agents APIveröffentlicht , ein Framework, das die Entwicklung von intelligenten, autonomen KI-Agenten erleichtert, die komplexe, mehrstufige Aufgaben ausführen können. Es geht über die traditionellen Sprachmodelle hinaus, indem es die Nutzung von Werkzeugen, persistentem Speicher und Orchestrierungsfunktionen integriert.

In diesem Tutorial zeige ich dir, wie du die Mistral Agents API nutzt, um intelligente Assistenten zu bauen, die in der Lage sind:

• Mit Tools wie Websuche, Codeausführung und Bilderzeugung
• Lange Gespräche im Gedächtnis behalten, um den Kontext zu bewahren
• Aufgaben an mehrere Agenten delegieren

Du lernst die Kernkonzepte des Mistral-Agenten-Frameworks kennen, erkundest die eingebauten Konnektoren und Orchestrierungsfunktionen und baust einen funktionierenden Multi-Agenten-Assistenten.

Wir halten unsere Leserinnen und Leser mit The Median auf dem Laufenden, unserem kostenlosen Freitags-Newsletter, der die wichtigsten Meldungen der Woche aufschlüsselt. Melde dich an und bleibe in nur ein paar Minuten pro Woche auf dem Laufenden:

Was ist die Agenten-API von Mistral?

Die Mistral Agents API ist ein Framework, das es großen Sprachmodellen ermöglicht, mehrstufige Aktionen durchzuführen, externe Tools zu nutzen und den Speicher über Interaktionen hinweg zu erhalten. Anders als einfache Chat-APIs befähigt sie KI-Agenten dazu:

• Auf das Internet zugreifen, Code ausführen, Bilder erzeugen oder Dokumente abrufen
• Koordiniere dich mit anderen Agenten über Orchestrierung
• Führen Sie ausdauernde Gespräche mit dem Langzeitgedächtnis

Zurzeit werden nur mistral-medium-latest (auch bekannt als mistral-medium-2505) und mistral-large-latest unterstützt, aber bald könnten weitere Modelle unterstützt werden.

Kernkonzepte erklärt

Bevor wir zum praktischen Teil übergehen, ist es sinnvoll, die Kernkonzepte der Agenten-API zu erläutern.

Quelle: Mistral KI

Agenten

Agenten in Mistral sind modellgestützte Personas, die mit vordefinierten Anweisungen, Werkzeugzugriff und Gesprächsstatus ausgestattet sind:

• Anweisungen leiten das Verhalten des Agenten (z. B. "Du bist ein Ernährungscoach, der Mahlzeiten aufzeichnet").
• Mit Tools wie web_search oder image_generation können Agenten echte Aktionen durchführen.
• Der Lernpfad ermöglicht es den Agenten, frühere Nachrichten und die Ergebnisse der Werkzeuge über mehrere Runden hinweg zu verfolgen und so kontextbezogene Schlussfolgerungen zu ziehen.

Diese Abstraktion verwandelt ein einfaches Chat-Modell in einen multifunktionalen Assistenten, der in komplexe Arbeitsabläufe eingreifen kann.

Konversationen 

Jede Interaktion zwischen einem Nutzer und einem Agenten ist Teil einer Konversation, die gespeichert wird:

• Vergangene Nachrichten und Antworten der Assistenten
• Tool-Aufrufe und Ergebnisse
• Streaming-Metadaten für Sichtbarkeit auf Token-Ebene (optional)

Diese dauerhaften Unterhaltungen ermöglichen es den Agenten, Aufgaben in mehreren Runden auszuführen, z.B. zu planen, zu überarbeiten oder aus früheren Eingaben zu lernen.

Konnektoren und Unterstützung für benutzerdefinierte Werkzeuge

Mistral ermöglicht eine einfache Tool-Integration durch:

• Verbinder: Es handelt sich um vorintegrierte Tools wie web_search, code_execution, image_generation, document_library, die sofort einsatzbereit sind.
• MCP-Tools: Diese ermöglichen benutzerdefinierte APIs, die von Entwicklern gehostet werden und als Tools innerhalb des Agenten-Workflows aufgerufen werden können.

Betrachte die Konnektoren als integrierte Anwendungen und die MCP Tools als Plugins, die du schreibst. So können Agenten sowohl auf integrierte Funktionen als auch auf vom Entwickler definierte Endpunkte für personalisierte Logik zugreifen.

Quelle: Mistral KI

Eingänge und Übergaben

Mistral verfolgt alle Aktionen in einer Konversation als strukturierte "Einträge" und ermöglicht so die Nachvollziehbarkeit und Kontrolle des Nachrichtenaustauschs und der Ausführung von Tools.

Agentenübergaben sind solche, bei denen ein Agent die Kontrolle an einen anderen delegiert, um Arbeitsabläufe zu modularisieren.

Quelle: Mistral KI

Diese Orchestrierungsarchitektur macht es einfach, komplexe Multiagentensysteme zusammenzustellen und zu verwalten, ohne die Transparenz oder Kontrolle zu verlieren.

Mistral API einrichten

Lass uns mit der Einrichtung von Mistral beginnen. Wir beginnen damit, einen API-Schlüssel für das Projekt zu erstellen. Hier sind die Schritte, die du befolgen solltest:

1. Um loszulegen, erstelle ein Mistral-Konto oder melde dich unter console.mistral.ai an.

2. Dann navigierst du zu den Arbeitsbereichseinstellungen (Dropdown-Pfeil neben deinem Namen - oben links) und klickst auf Abrechnung, um deine Zahlungsinformationen hinzuzufügen und Zahlungen für dein Konto zu aktivieren.

3. Klicke auf Guthaben hinzufügen und trage deine Rechnungsdaten in das Formular ein. Gib dann die Anzahl der Credits ein, die du haben möchtest. Hinweis: Du musst mindestens 10 Credits hinzufügen.

4. Dann klickst du auf der linken Seite auf API-Schlüssel und erstellst einen neuen API-Schlüssel, indem du auf Neuen Schlüssel erstellen klickst. Achte darauf, dass du den API-Schlüssel kopierst, sicher aufbewahrst und nicht mit anderen teilst.

Du hast jetzt einen gültigen API-Schlüssel, um mit Mistral-Modellen zu interagieren und intelligente Agenten zu bauen.

Projektübersicht: Ernährungscoach bei Mistral Agents

In diesem Projekt bauen wir einen KI-gesteuerten Ernährungscoach mit der Agenten-API von Mistral. Hier ist der Benutzerfluss:

1. Der Nutzer gibt eine Mahlzeit ein, die er gerade gegessen hat (z.B. "Hähnchensalat mit Olivenöl-Dressing").
2. Ein Web-Suchagent nutzt den eingebauten Konnektor, um die Kalorien für die Mahlzeit zu schätzen.
3. Ein Logger-Agent zeichnet diesen Eintrag unter dem Namen und dem Zeitstempel des Nutzers auf.
4. Schließlich schlägt ein Bildgenerator ein gesundes Nachfolgegericht vor und liefert sowohl ein Bild als auch eine Beschreibung und ein Rezept.

Um eine Weboberfläche bereitzustellen, über die die Nutzer mit dem Ernährungsberater interagieren können, werden wir Gradio verwenden.

Schritt 1: Voraussetzungen

Bevor wir beginnen, solltest du sicherstellen, dass du Folgendes installiert hast:

• Python 3.8+
• Alle erforderlichen Pakete, die in requirements.txt

python-dotenv==1.1.0
mistralai==0.0.7
typing-extensions==4.12.2
requests==2.31.0
gradio==4.34.0

Richte außerdem eine .env Datei ein, die deinen Mistral-API-Schlüssel enthält. Dieser Ansatz sorgt für die Sicherheit deiner API-Schlüssel und ermöglicht es verschiedenen Teammitgliedern oder Einsatzumgebungen, unterschiedliche Anmeldeinformationen zu verwenden, ohne den Quellcode zu ändern.

MISTRAL_API_KEY=YOUR_API_KEY

Hinweis: Es wird empfohlen, diese Abhängigkeiten in einer isolierten Umgebung wie conda, venv oder uv zu installieren, um Versionskonflikte mit anderen Python-Projekten zu vermeiden.

Hier sind die Befehle, um verschiedene Umgebungen einzurichten:

Mit venv

python -m venv mistral_env
source mistral_env/bin/activate   # On Windows: mistral_env\Scripts\activate

Conda verwenden

conda create -n mistral_env python=3.10
conda activate mistral_env

Mit uv

Wenn du noch kein uv hast:

pip install uv

Dann:

uv venv mistral_env
source mistral_env/bin/activate

Um alle oben genannten Abhängigkeiten zu installieren, führe den folgenden Code in deinem Terminal aus:

pip install -r requirements.txt

Hinweis: Wenn du bei der Verwendung eines Agenten oder Connectors Fehler im Zusammenhang mit mistralai feststellst, führe den folgenden Code aus:

pip install –upgrade mistralai

Dadurch wird die Bibliothek mistralai auf die neueste Version aktualisiert.

Schritt 2: Mistral Tools einrichten

In diesem Abschnitt bereiten wir unsere Tools und unser Client-Setup für die Interaktion mit der Mistral Agents API vor.  Wir definieren Werkzeugschemata, initialisieren den Client und verifizieren die Authentifizierung. Auf diese Tools wird später bei der Einrichtung von speziellen Agenten wie Kalorienschätzern oder Bildgeneratoren Bezug genommen.

Schritt 2.1: Werkzeugregistrierung und Initialisierung

Zunächst definieren wir die Schemata unseres Tools, die Modellauswahl und die Client-Instanziierung. Dann bauen wir Hilfsmethoden wie create_chat_completion() und check_client(). Der folgende Code wird in der Datei configs.py im Ordner "Tools" gespeichert:

#Configuration file
from mistralai import Mistral, UserMessage, SystemMessage
from dotenv import load_dotenv
import os
load_dotenv()
# Mistral model 
mistral_model = "mistral-large-latest"
client = Mistral(api_key=os.environ.get("MISTRAL_API_KEY"))
# Agent IDs
web_search_id = "web_search_agent"
food_logger_id = "food_logger_agent"
user_assistant_id = "user_assistant_agent"
image_generator_id = "image_generator_agent"
# Tool definitions
tools = {
    "log_meal": {
        "name": "log_meal",
        "description": "Log a user's meal with calorie count",
        "input_schema": {
            "type": "object",
            "properties": {
                "username": {"type": "string"},
                "meal": {"type": "string"},
                "calories": {"type": "number"},
                "timestamp": {"type": "string", "format": "date-time"}
            },
            "required": ["username", "meal", "calories", "timestamp"]
        }
    },
    "web_search": {
        "name": "web_search",
        "description": "Search the web for information about a meal",
        "input_schema": {
            "type": "object",
            "properties": {
                "query": {"type": "string"}
            },
            "required": ["query"]
        }
    }
}

Wir beginnen mit dem Import von dotenv, um sensible Variablen wie den Mistral-API-Schlüssel aus einer lokalen .env Datei in die Python-Umgebung zu laden. So bleiben die Anmeldedaten sicher und werden nicht in den Quellcode übernommen. Dann wählen wir das Standardmodell mistral-large-latest und richten mit dem API-Schlüssel einen Mistral-Client ein.

Als Nächstes definieren wir interne Tool-Spezifikationen (Schemata) im JSON-Schema-Format. Sie helfen bei Folgendem:

• Simuliere das Verhalten von MCP-Werkzeugen (obwohl sie nicht über die McpTool-Bibliothek registriert sind)
• Beschreibe erwartete Eingaben wie "Benutzername", "Mahlzeit" und "Kalorien"
• Sicherstellung einer einheitlichen Eingabeformatierung in allen Modulen

Jetzt fügen wir unsere Hilfsmethoden ein, die Chatvervollständigungen erstellen, Tools und Agenten registrieren und den Client initialisieren.

def create_chat_completion(messages, model=mistral_model):  
    # Convert messages to new format
    formatted_messages = []
    for msg in messages:
        if msg["role"] == "system":
            formatted_messages.append(SystemMessage(content=msg["content"]))
        else:
            formatted_messages.append(UserMessage(content=msg["content"]))
    return client.chat.complete(
        model=model,
        messages=formatted_messages
    )
# Register tools
def register_tools():
    for tool_name, tool in tools.items():
        print(f"Registered tool: {tool_name}")
# Register agents
def register_agents():
    print("Registered User Assistant Agent")
    print("Registered Web Search Agent")
    print("Registered Food Logger Agent")
# Initialize everything
def initialize():
    register_tools()
    register_agents()
    check_client()
# Check if the client is initialized
def is_client_initialized():
    return client is not None and os.environ.get("MISTRAL_API_KEY") is not None
def check_client():
    if not is_client_initialized():
        print("Mistral client is not initialized. Please check your API key.")
        return False
    print("Mistral client is initialized.")
    return True
initialize()

Die Funktion create_chat_completion() umhüllt einen Aufruf der Methode client.chat.complete(), die Teil des Mistral Client SDK ist, um Nachrichten an das Modell zu senden.

• Es formatiert rohe Diktat-Nachrichten in UserMessage und SystemMessage Objekte um, die vom Mistral SDK benötigt werden.
• Sie ist auch nützlich für standardisierte Vervollständigungen in der App.

Die Funktionen register_tools() und register_agents() helfen bei der lokalen Entwicklung, indem sie protokollieren, welche Werkzeuge und Agenten im System aktiv sind. Die Funktionen check_client() und is_client_initialized() stellen sicher, dass der Mistral-Client ordnungsgemäß instanziiert wurde und der API-Schlüssel verfügbar ist, um Laufzeitfehler bei der Ausführung des Agenten zu vermeiden.

Schritt 2.2: Kalorien mit dem Web-Suchagenten abschätzen

Nachdem wir nun die Basis-Tools und den Client initialisiert haben, wollen wir einen speziellen Nutrition Web Search Agent erstellen. Dieser Agent nutzt den web_search Connector von Mistral, um Kalorienschätzungen für Mahlzeiten in Echtzeit abzurufen. Dieser Code befindet sich in der Datei web_search.py im Ordner tools.

# Web search tool
import re
from mistralai import Mistral, UserMessage, SystemMessage
from tools.configs import client
def search_calories(meal_desc):
    try:
        # Web search agent
        websearch_agent = client.beta.agents.create(
            model="mistral-medium-latest",
            description="Agent able to search for nutritional information and calorie content of meals",
            name="Nutrition Search Agent",
            instructions="You have the ability to perform web searches with web_search to find accurate calorie information. Return ONLY a single number representing total calories.",
            tools=[{"type": "web_search"}],
            completion_args={
                "temperature": 0.3,
                "top_p": 0.95,
            }
        )
        response = client.beta.conversations.start(
            agent_id=websearch_agent.id,
            inputs=f"What are the total calories in {meal_desc}?"
        )
        print("Raw response:", response)
        # Extract the number from the response
        if hasattr(response, 'outputs'):
            for output in response.outputs:
                if hasattr(output, 'content'):
                    if isinstance(output.content, str):
                        numbers = re.findall(r'\d+', output.content)
                        if numbers:
                            return int(numbers[0])
                    elif isinstance(output.content, list):
                        for chunk in output.content:
                            if hasattr(chunk, 'text'):
                                numbers = re.findall(r'\d+', chunk.text)
                                if numbers:
                                    return int(numbers[0])
        print("No calorie information found in web search response")
        return 0     
    except Exception as e:
        print(f"Error during web search: {str(e)}")
        return 0

Im obigen Code verwendet die Funktion search_calories() das eingebaute Konnektor-Tool für die Websuche von Mistral Agents API, das es den Agenten ermöglicht, Live-Webabfragen wie die Kalorienschätzung durchzuführen und so die Einschränkungen des statischen Modelltrainings zu überwinden. So funktioniert es:

1. Agentenerstellung: Er erstellt zunächst einen "Ernährungssuchagenten" mit dem Modell mistral-medium-latest, der mit dem Tool web_search ausgestattet ist und angewiesen wird, nur Kalorien zu liefern.
2. Abfrageausführung: Der Agent wird dann benutzt, um ein Gespräch zu beginnen, in dem er nach den Gesamtkalorien in der angegebenen Essensbeschreibung gefragt wird.
3. Antwort-Parsing: Die Antwort des Agenten wird mit regulären Ausdrücken geparst, um den ersten numerischen Wert zu extrahieren (das sollte die Kalorienzahl sein).
4. Fallbacks: Wenn keine gültige Nummer gefunden wird oder ein Fehler auftritt, protokolliert die Funktion das Problem und gibt als Rückfall null zurück.

Ohne web_search können die meisten Modelle keine Fragen zu aktuellen Ereignissen oder domänenspezifischen Mahlzeiten beantworten, die nicht in ihren Trainingsdaten vorkommen. Damit können wir Nährwertangaben, Restaurantmenüs oder Nachrichtenartikel in Echtzeit abfragen.

Es gibt zwei Varianten der Websuche:

• web_search: Ein leichtgewichtiger, universell einsetzbarer Suchmaschinen-Connector (wird in unserem Projekt verwendet).
• web_search_premium: Eine erweiterte Version, die die Überprüfung von Nachrichtenanbietern und die Erfassung von mehr Kontext beinhaltet.

Als Nächstes erforschen wir die Ersatzkalorienschätzung mit einer reinen Abfragelogik.

Schritt 2.3: Schätzung, Protokollierung und Essensvorschlag

In diesem Abschnitt implementieren wir drei wichtige Funktionen, die als Ausweich- oder Erweiterungsmöglichkeiten dienen. Der folgende Code befindet sich in der Datei next.py im Ordner tools.

#Meal suggestions
from datetime import datetime
from tools.configs import client, create_chat_completion
from mistralai import SystemMessage, UserMessage
import re
def estimate_calories(meal_desc):   
    try:
        # Messages for calorie estimation
        messages = [
            SystemMessage(content="You are a nutrition expert. Estimate calories in meals. Return ONLY a single number representing total calories."),
            UserMessage(content=f"Estimate calories in: {meal_desc}")
        ]
        response = client.chat.complete(
            model="mistral-small-latest",  # Using smaller model to avoid rate limits
            messages=messages,
            temperature=0.1,
            max_tokens=50
        )
        content = response.choices[0].message.content
        numbers = re.findall(r'\d+', content)    
        if numbers:
            return int(numbers[0])
        return 0     
    except Exception as e:
        print(f"Error during calorie estimation: {str(e)}")
        return 0
def log_meal(username, meal, calories):  
    try:
        # Messages for meal logging
        messages = [
            SystemMessage(content="You are a meal logging assistant. Log the user's meal with calories."),
            UserMessage(content=f"Log this meal: {meal} with {calories} calories for user {username} at {datetime.utcnow().isoformat()}")
        ]
        response = client.chat.complete(
            model="mistral-small-latest",  # Using smaller model to avoid rate limits
            messages=messages,
            temperature=0.1,
            max_tokens=100
        )
        return response.choices[0].message.content.strip()
    except Exception as e:
        print(f"Error during meal logging: {str(e)}")
        return f"Logged {meal} ({calories} calories) for {username}"
def suggest_next_meal(calories, dietary_preference):   
    try:
        # Messages for meal suggestion
        messages = [
            SystemMessage(content="You are a nutrition expert. Suggest healthy meals based on calorie intake and dietary preferences."),
            UserMessage(content=f"Suggest a {dietary_preference} meal that would be a good next meal after consuming {calories} calories. Make it specific and appetizing.")
        ]
        response = client.chat.complete(
            model="mistral-small-latest",  
            messages=messages,
            temperature=0.7
        )
        return response.choices[0].message.content.strip()        
    except Exception as e:
        print(f"Error during meal suggestion: {str(e)}")
        return "Unable to suggest next meal at this time."

Dieses Skript definiert die wichtigsten Backend-Funktionen, die unseren Ernährungs-Workflow steuern (von der Kalorienschätzung bis zur Planung der nächsten Mahlzeit). Diese Funktionen nutzen leichtgewichtige Mistral-Modelle und die Standard-Chatvervollständigung, ohne dass Agenten erstellt oder Konnektoren verwendet werden müssen, wenn die Websuche nicht verfügbar ist oder um Ratenbegrenzungsfehler zu vermeiden. Hier ist, was jede Funktion macht:

1. estimate_calories(): Diese Funktion wird als Fallback verwendet, wenn der web_search Anschluss ausfällt oder nicht verfügbar ist.
1. Es sendet eine Systemnachricht, die die Rolle des Assistenten als Ernährungsexperte enthält, zusammen mit der Benutzeraufforderung, die die Mahlzeit enthält, die der Benutzer protokollieren möchte.
2. Das Modell wird unter temperature=0.1 für deterministische Ergebnisse verwendet. Das bedeutet, dass das Modell konsistente, wiederholbare Antworten für dieselben Eingaben liefert, wie z. B. bei der Kalorienschätzung und der Protokollierung, wo stabile und sachliche Ergebnisse gegenüber kreativen Variationen bevorzugt werden.
3. Sie analysiert die erste Zahl (mithilfe von Regex) aus der Antwort des Modells.
2. log_meal(): Diese Funktion protokolliert die Mahlzeit eines Benutzers, einschließlich eines Zeitstempels.
1. Er verwendet einen Chatabschluss mit der Anweisung und gibt die formatierte Bestätigungsnachricht des Assistenten zurück.
2. Dies ermöglicht eine leichtgewichtige interne Protokollierung, ohne dass eine eigene Backend-Datenbank erforderlich ist.
3. suggest_next_meal(): Diese Funktion empfiehlt der Nutzerin/dem Nutzer die nächste Mahlzeit auf der Grundlage ihrer/seiner vorherigen Kalorienaufnahme und ihres/seines Ernährungsprofils.
1. Das Modell wird mit temperature=0.7 aufgerufen, um zu kreativen Vorschlägen anzuregen.
2. Die Antwort wird dann gestrippt und als nächste Essensidee zurückgegeben.

Zusammen ermöglichen diese Funktionen Kalorienschätzungen, Protokollbestätigungen und gesunde Empfehlungen, ohne dass externe APIs benötigt werden. Im nächsten Schritt visualisieren wir die Essensvorschläge mit dem Mistral-Konnektor zur Bilderzeugung.

Schritt 2.4: Erzeugen von Bildmaterial mit dem Bilderzeugungs-Connector

Jetzt fügen wir unserem Assistenten eine visuelle Ebene hinzu. In diesem Schritt verwenden wir den in Mistral eingebauten image_generation Connector, um ein appetitliches Bild der nächsten vorgeschlagenen Mahlzeit zu erzeugen.

#Image generation tool
import os
import re
from mistralai import Mistral, UserMessage, SystemMessage
from mistralai.models import ToolFileChunk
from tools.configs import client
from datetime import datetime
def generate_food_image(meal_description):  
    try:
        print(f"Starting image generation for: {meal_description}")        
        # Image generation agent
        image_agent = client.beta.agents.create(
            model="mistral-medium-latest",
            name="Food Image Generation Agent",
            description="Agent used to generate food images.",
            instructions="Use the image generation tool to create appetizing food images. Generate realistic and appetizing images of meals.",
            tools=[{"type": "image_generation"}],
            completion_args={
                "temperature": 0.3,
                "top_p": 0.95,
            }
        )
        print("Created image generation agent")
        response = client.beta.conversations.start(
            agent_id=image_agent.id,
            inputs=f"Generate an appetizing image of: {meal_description}",
            stream=False  
        )
        print("Got response from image generation")
        os.makedirs("generated_images", exist_ok=True)
        # Process the response and save images
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        image_paths = []
        if hasattr(response, 'outputs'):
            print(f"Processing {len(response.outputs)} outputs")
            for output in response.outputs:
                if hasattr(output, 'content'):
                    print(f"Processing content of type: {type(output.content)}")
                    if isinstance(output.content, list):
                        for i, chunk in enumerate(output.content):
                            print(f"Processing chunk {i} of type: {type(chunk)}")
                            if isinstance(chunk, ToolFileChunk):
                                print(f"Found ToolFileChunk with file_id: {chunk.file_id}")
                                try:
                                    # Download the image
                                    file_bytes = client.files.download(file_id=chunk.file_id).read()       
                                    # Save the image
                                    image_path = f"generated_images/meal_{timestamp}_{i}.png"
                                    with open(image_path, "wb") as file:
                                        file.write(file_bytes)
                                    image_paths.append(image_path)
                                    print(f"Successfully saved image to: {image_path}")
                                except Exception as e:
                                    print(f"Error processing image chunk: {str(e)}")
                    else:
                        print(f"Content is not a list: {output.content}")
        if image_paths:
            print(f"Successfully generated {len(image_paths)} images")
            return image_paths[0]  # Return the first image path
        else:
            print("No images were generated")
            return "No image was generated”
    except Exception as e:
        print(f"Error during image generation: {str(e)}")
        if hasattr(e, '__dict__'):
            print(f"Error details: {e.__dict__}")
        return f"Error generating image: {str(e)}" 

Die Funktion generate_food_image() erzeugt eine visuelle Darstellung einer Mahlzeit mit dem in Mistral eingebauten Tool image_generation. Hier erfährst du, was jedes Teil macht:

• Agentenerstellung: Ein neuer Agent erhält den Auftrag, realistische und appetitliche Bilder von Lebensmitteln zu erstellen.
• Gesprächsbeginn: Es wird eine Aufforderung gesendet, die den Agenten auffordert, ein Bild der angegebenen meal_description zu erstellen, das vom nächsten Essensagenten erstellt wird.
• Antwortbearbeitung: Die Funktion prüft, ob die Antwort Bildchunks enthält. Wenn ja, lädt er jedes Bild über die files.download() Methode des Mistral-Clients herunter. Die Bilder werden lokal in einem Ordner generated_images/ mit zeitgestempelten Dateinamen gespeichert.
• Ausgabe: Sie gibt den Pfad zum ersten erfolgreich gespeicherten Bild oder eine Fehlermeldung zurück, wenn die Erzeugung fehlschlägt.

Dieses Tool ergänzt unseren Ernährungscoach um eine visuelle Ebene, die die Essensvorschläge ansprechender und realistischer macht.

Schritt 3: Vollständige Ernährungsberater-Pipeline

Jetzt, wo wir die einzelnen Tools und Agentenfähigkeiten entwickelt haben, ist es an der Zeit, sie in einer einzigen Pipeline zusammenzufassen. In diesem Schritt wird alles zu einem funktionierenden Assistenten zusammengeklebt, der funktioniert:

• Nachschlagen von Kalorien (über das Internet oder durch Schätzung)
• Protokollierung (Benutzer, Mahlzeit, Kalorien, Zeitstempel)
• Ein Folgeessen vorschlagen
• Visualisierung der Mahlzeit mit einem Bild

All diese Schritte werden durch den Aufruf der einzelnen Funktionen aus den vorherigen Dateien in der richtigen Reihenfolge durchgeführt. Der Code für diese Pipeline befindet sich außerhalb des Tools-Ordners in der Datei agent.py.

# Pipeline logic file
from tools import estimate_calories, log_meal, suggest_next_meal, search_calories
from tools.image_gen import generate_food_image
from datetime import datetime
import time
def run_nutritionist_pipeline(username, meal_desc, dietary_preference):
    tools_used = set()    
    print(f"Searching for calories for: {meal_desc}")
    calories_text = search_calories(meal_desc)
    tools_used.add("Web Search")    
    # If web search fails, fall back to estimation
    if calories_text == 0:
        print("Web search failed, falling back to estimation...")
        time.sleep(1)  # Add delay to avoid rate limits
        calories_text = estimate_calories(meal_desc)
        tools_used.add("Calorie Estimation")   
    estimated_calories = calories_text
    print(f"Estimated calories: {estimated_calories}")   
    print(f"Logging meal for {username}...")
    time.sleep(1)  # Add delay to avoid rate limits
    log_response = log_meal(username, meal_desc, estimated_calories)
    tools_used.add("Meal Logging")    
    print("Generating next meal suggestion...")
    time.sleep(1)  
    suggestion = suggest_next_meal(estimated_calories, dietary_preference)
    tools_used.add("Next Meal Suggestion")    
    print("Generating image description for suggested meal...")
    time.sleep(1)  
    meal_image = generate_food_image(suggestion)
    tools_used.add("Image Description Generation")
    return {
        "logged": log_response,
        "next_meal_suggestion": suggestion,
        "meal_image": meal_image,
        "tools_used": sorted(list(tools_used))
    }

Der obige Code koordiniert den gesamten Arbeitsablauf des Ernährungsassistenten, indem er mehrere Agententools zu einer einzigen Pipeline zusammenfasst. Schauen wir uns den obigen Code genauer an:

• Die Funktion run_nutritionist_pipeline() akzeptiert die username, meal_desc und dietary_preference als Eingaben, um den Empfehlungsprozess zu steuern.
• Zuerst wird versucht, den Kaloriengehalt der Mahlzeit mit der Funktion search_calories() zu ermitteln, die von Mistrals Websuche unterstützt wird. Wenn dies fehlschlägt, greift es auf eine Schätzung mit einem leichtgewichtigen Modell über estimate_calories() zurück.
• Der ermittelte Kalorienwert wird dann mit der Funktion log_meal() protokolliert, die den Eintrag mit einem Zeitstempel versieht und ihn mit dem Nutzer verknüpft.
• Auf der Grundlage der verbrauchten Kalorien und der Ernährungspräferenz schlägt die Funktion suggest_next_meal() mit Hilfe von Prompt Based Reasoning eine Folgemahlzeit vor.
• Schließlich verwendet die Funktion generate_food_image() den Mistral-Konnektor zur Bilderzeugung, um eine visuelle Darstellung des empfohlenen Gerichts zu erzeugen.
• Während des gesamten Prozesses wird time.sleep(1) verwendet, um kurze Pausen zwischen den Anfragen einzulegen, damit die Ratenbegrenzungen bei API-Aufrufen nicht ausgelöst werden.
• Die Funktion gibt ein Wörterbuch zurück, das die Bestätigung der Essensprotokollierung, den Text des nächsten Essensvorschlags, den generierten Bildpfad und eine Liste der Werkzeuge enthält, die bei dieser Interaktion verwendet wurden.

Diese Pipeline kombiniert verschiedene Funktionen wie Suche, Schätzung, Protokollierung, Vorschläge und Visualisierung zu einem KI-gestützten Ernährungserlebnis.

Schritt 4: Erstellen einer benutzerfreundlichen Oberfläche mit Gradio

Jetzt, da die Backend-Logik fertig ist, können wir sie mit Gradio in ein sauberes, benutzerfreundliches Frontend verpacken.

# Main files
import gradio as gr
from agent import run_nutritionist_pipeline
import os
import re
def process_meal(username, meal_desc, dietary_preference):
    # Run the pipeline
    result = run_nutritionist_pipeline(username, meal_desc, dietary_preference)    
    # Extract calories from the logged meal response
    calories = "Not available"
    if result['logged']:
        calorie_match = re.search(r'(\d+)\s*calories', result['logged'], re.IGNORECASE)
        if calorie_match:
            calories = calorie_match.group(1)
        else:
            paren_match = re.search(r'\((\d+)\)', result['logged'])
            if paren_match:
                calories = paren_match.group(1)
            else:
                number_match = re.search(r'\b(\d+)\b', result['logged'])
                if number_match:
                    calories = number_match.group(1)    
    # Map tool names to Mistral connectors
    connector_map = {
        "Web Search": "Web Search",
        "Image Description Generation": "Image Generation",
        "Meal Logging": "Chat Completion",
        "Next Meal Suggestion": "Chat Completion"
    }   
    connectors_used = set()
    for tool in result['tools_used']:
        if tool in connector_map:
            connectors_used.add(connector_map[tool])    
    output = f"""
# Meal Analysis Results
## Meal Details
- **Meal Description:** {meal_desc}
- **Estimated Calories:** {calories}
## Next Meal Suggestion
{result['next_meal_suggestion']}

## Tools Used
{', '.join(result['tools_used'])}
## Mistral Connectors Used
{', '.join(sorted(connectors_used))}
""
    # Get the image path and check if it is valid
    image_path = result['meal_image']    
    if os.path.exists(image_path) and image_path.endswith('.png'):
        return output, image_path
    else:
        return output, None
# Create the Gradio interface
with gr.Blocks(theme=gr.themes.Soft()) as demo:
    gr.Markdown("# 🍽️ Nutritionist Assistant")    
    with gr.Row():
        with gr.Column():
            username = gr.Textbox(label="Username", placeholder="Enter your name")
            meal_desc = gr.Textbox(label="Meal Description", placeholder="Describe your meal (e.g., 'Chicken salad with olive oil dressing')")
            dietary_preference = gr.Dropdown(
                choices=["vegetarian", "vegan", "Non-vegetarian", "gluten-free"],
                label="Dietary Preference",
                value="omnivore"
            )
            submit_btn = gr.Button("Process Meal", variant="primary")        
        with gr.Column():
            output = gr.Markdown(label="Results")
            image_output = gr.Image(label="Generated Meal Image", type="filepath")    
    submit_btn.click(
        fn=process_meal,
        inputs=[username, meal_desc, dietary_preference],
        outputs=[output, image_output]
    )
# Launch the app
if __name__ == "__main__":
    demo.launch() 

Im obigen Codeschnipsel haben wir eine komplette Gradio-Benutzeroberfläche für die Interaktion mit der Nutritionist Agent Pipeline eingerichtet. So funktioniert es:

• Wir beginnen mit dem Import der Funktion run_nutritionist_pipeline() von agent.py, die die Kernlogik des Agenten steuert.
• Dann fungiert die Funktion process_meal() als Wrapper um die Agenten-Pipeline, die username, meal_desc und dietary_preference als Benutzereingaben akzeptiert und die zuvor definierte Multi-Agenten-Logik auslöst.
• In der Funktion process_meal() wird das Ergebniswörterbuch geparst, um die Zusammenfassung der Mahlzeit, die Kalorien, die vorgeschlagene nächste Mahlzeit und die verwendeten Stecker zu extrahieren.
• Die Funktion prüft auch, ob der erzeugte Bildpfad gültig ist, bevor sie ihn zur Anzeige zurückgibt. Wenn das Bild nicht gefunden wird, wird nur das Textergebnis zurückgegeben.
• Die Gradio-App ist mit gr.Blocks() aufgebaut und das Layout umfasst zwei Seiten, eine mit Eingabefeldern und eine Schaltfläche "Mahlzeit verarbeiten". Die andere Seite enthält einen Ausgabebereich für die Ergebnisse der Mahlzeitenanalyse und eine Bildvorschau der nächsten Mahlzeit.
• Der submit_btn.click() Callback verdrahtet den Frontend-Button, um die Funktion process_meal() auszulösen, die Eingaben zu übergeben und formatiertes Markdown und Bild als Ausgaben zu erhalten.
• Schließlich wird die App über demo.launch() gestartet, wenn das Skript als Hauptmodul ausgeführt wird. Du kannst debug = True einstellen, um den Debugging-Modus der App zu aktivieren.

Um diese Demo auszuführen, öffne ein Terminal in deinem Stammverzeichnis und gib den folgenden Befehl ein:

python app.py

Die Gesamtstruktur dieses Projekts würde folgendermaßen aussehen:

Mistral_Agent_API/
├── generated_images/ # Stores generated meal images
├── tools/
│   ├── configs.py              # API setup, tool schema, environment config
│   ├── image_gen.py            # Generates meal image  
│   ├── next.py                 # Calorie estimator, logger, and next meal 
│   └── web_search.py           # Mistral web_search connector to find calorie 
├── agent.py                    # Main pipeline connecting all tools
├── app.py                      # Gradio UI 
├── requirements.txt            # Project dependencies
├── .env                        # Environment variables 

Den kompletten Code für dieses Projekt findest du auf diesem GitHub-Repositorium.

Fazit

In diesem Tutorial haben wir einen voll funktionsfähigen KI-Ernährungscoach mithilfe der Mistral Agents API gebaut. Auf dem Weg dorthin haben wir alles erkundet:

• Wie sich Mistral-Agenten von einfachen LLM-Modellen unterscheiden
• Die Rolle von Verbindungselementen wie web_search und image_generation
• Orchestrierung über mehrere Agenten in einer einzigen Pipeline
• Ein benutzerfreundliches Frontend mit Gradio erstellen

Dieses Projekt zeigt die Leistungsfähigkeit von agentenbasierten Arbeitsabläufen, bei denen LLMs nicht nur passiv reagieren, sondern interaktiv handeln und Aufgaben koordinieren. Von der Aufzeichnung von Mahlzeiten über Vorschläge für gesunde Alternativen bis hin zur Erstellung von Bildern haben wir gezeigt, wie man einfache Tools zu leistungsstarken KI-Erlebnissen kombinieren kann.

Um mehr über den Einsatz von KI-Agenten zu erfahren, empfehle ich diese praktischen Tutorials:

• Der Codex von OpenAI: Ein Leitfaden mit 3 praktischen Beispielen
• Google Jules: Ein Leitfaden mit 3 praktischen Beispielen
• Perplexity Labs: Ein Leitfaden mit 5 praktischen Beispielen
• n8n: Ein Leitfaden mit praktischen Beispielen
• Dify AI: Ein Leitfaden mit Demo-Projekt