Mistral Agents API : Un guide avec un projet de démonstration

Mistral a publié l'API Agents, un cadre qui facilite le développement d'agents intelligents et autonomes capables d'exécuter des tâches complexes à plusieurs étapes. Il va au-delà des modèles linguistiques traditionnels en intégrant l'utilisation d'outils, la mémoire persistante et les capacités d'orchestration.

Dans ce tutoriel, je vous explique comment utiliser l'API Mistral Agents pour créer des assistants intelligents capables de.. :

• Utilisation d'outils tels que la recherche sur le web, l'exécution de code et la génération d'images
• Conserver la mémoire au cours de longues conversations pour préserver le contexte
• Déléguer des tâches à plusieurs agents

Vous apprendrez les concepts fondamentaux du cadre agentique de Mistral, explorerez les connecteurs intégrés et les fonctions d'orchestration, et construirez un assistant multi-agents fonctionnel.

Nous tenons nos lecteurs informés des dernières nouveautés en matière d'IA en leur envoyant The Median, notre lettre d'information gratuite du vendredi qui analyse les principaux sujets de la semaine. Abonnez-vous et restez à la pointe de la technologie en quelques minutes par semaine :

Qu'est-ce que l'API des agents de Mistral ?

L'API des agents Mistral est un cadre qui permet aux grands modèles linguistiques d'effectuer des actions en plusieurs étapes, d'utiliser des outils externes et de conserver la mémoire au fil des interactions. Contrairement aux simples API de chat, il permet aux agents d'IA de :

• Accéder au web, exécuter du code, générer des images ou récupérer des documents
• Coordonner avec d'autres agents via l'orchestration
• Maintenir des conversations persistantes avec la mémoire à long terme

Actuellement, seuls mistral-medium-latest (également connu sous le nom de mistral-medium-2505) et mistral-large-latest sont pris en charge, mais d'autres modèles pourraient bientôt l'être.

Explication des concepts fondamentaux

Avant de passer à la partie pratique, je pense qu'il est utile de clarifier les concepts fondamentaux de l'API Agents.

Source : Mistral AI

Agents

Dans Mistral, les agents sont des personas alimentés par des modèles et dotés d'instructions prédéfinies, d'un accès aux outils et d'un état de la conversation :

• Les instructions guident le comportement de l'agent (par exemple, "Vous êtes un coach nutritionnel qui enregistre les repas").
• Des outils tels que web_search ou image_generation permettent aux agents de prendre des mesures concrètes.
• Le cursus permet aux agents de suivre les messages antérieurs et les résultats des outils au fil des tours, ce qui favorise le raisonnement contextuel.

Cette abstraction transforme un modèle de chat de base en un assistant multifonctionnel capable de s'engager dans des flux de travail complexes.

Conversations 

Chaque interaction entre un utilisateur et un agent fait partie d'une conversation, qui est enregistrée :

• Messages antérieurs et réponses des assistants
• Appels d'offres et résultats
• Métadonnées en continu pour la visibilité au niveau du jeton (facultatif)

Ces conversations persistantes permettent aux agents d'effectuer des tâches à plusieurs tours comme la planification, la révision ou l'apprentissage à partir de données antérieures.

Connecteurs et outils personnalisés

Mistral permet une intégration facile des outils grâce à :

• Connecteurs: Il s'agit d'outils pré-intégrés tels que web_search, code_execution, image_generation, document_library qui fonctionnent prêts à l'emploi.
• Outils MCP: Ceux-ci permettent des API personnalisées hébergées par des développeurs qui peuvent être invoquées en tant qu'outils dans le flux de travail de l'agent.

Considérez les connecteurs comme des applications intégrées et les outils MCP comme des plugins que vous créez. Ensemble, ils permettent aux agents d'accéder à la fois aux capacités intégrées et aux points de terminaison définis par les développeurs pour une logique personnalisée.

Source : Mistral AI

Entrées et sorties

Le cursus Mistral retrace toutes les actions d'une conversation sous forme d'"entrées" structurées, ce qui permet d'assurer la traçabilité et le contrôle des échanges de messages et de l'exécution des outils.

Les transferts d' agents sont ceux où un agent délègue le contrôle à un autre afin de modulariser les flux de travail.

Source : Mistral AI

Cette architecture d'orchestration facilite la composition et la gestion de systèmes multi-agents complexes sans perte de transparence ou de contrôle.

Configuration de l'API Mistral

Commençons par configurer Mistral. Nous commencerons par créer une clé API pour le projet. Voici les étapes à suivre :

1. Pour commencer, créez un compte Mistral ou connectez-vous à console.mistral.ai.

2. Ensuite, naviguez vers Paramètres de l'espace de travail (flèche déroulante près de votre nom - coin supérieur gauche) et cliquez sur Facturation pour ajouter vos informations de paiement et activer les paiements sur votre compte.

3. Cliquez sur Ajouter des crédits et indiquez vos coordonnées de facturation dans le formulaire. Ensuite, indiquez le nombre de crédits que vous souhaitez. Note : Vous devez ajouter au moins 10 crédits.

4. Ensuite, dans l'onglet de gauche, cliquez sur Clés API et créez une nouvelle clé API en cliquant sur Créer une nouvelle clé. Veillez à copier la clé API, à l'enregistrer en toute sécurité et à ne la communiquer à personne.

Vous disposez maintenant d'une clé API valide pour interagir avec les modèles Mistral et construire des agents intelligents.

Aperçu du projet : Coach en nutrition avec Mistral Agents

Dans ce projet, nous construirons un coach nutritionnel alimenté par l'IA en utilisant l'API Agents de Mistral. Voici le cheminement de l'utilisateur :

1. L'utilisateur soumet un repas qu'il vient de manger (par exemple, "salade de poulet avec vinaigrette à l'huile d'olive").
2. Un agent de recherche sur le web utilise le connecteur intégré pour estimer les calories du repas.
3. Un agent logger enregistre cette entrée sous le nom de l'utilisateur et l'horodatage.
4. Enfin, un agent de génération d'images suggère un repas de suivi sain, renvoyant à la fois une image, une description et une recette.

Pour fournir une interface web où les utilisateurs peuvent interagir avec le nutritionniste, nous utiliserons Gradio.

Étape 1 : Conditions préalables

Avant de commencer, assurez-vous que les éléments suivants sont installés :

• Python 3.8+.
• Tous les paquets requis énumérés dans requirements.txt

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

Créez également un fichier .env contenant votre clé API Mistral. Cette approche garantit la sécurité de vos clés API et permet à différents membres de l'équipe ou environnements de déploiement d'utiliser des informations d'identification différentes sans modifier le code source.

MISTRAL_API_KEY=YOUR_API_KEY

Note : Il est recommandé d'installer ces dépendances dans un environnement isolé comme conda, venv, ou uv pour éviter les conflits de version avec d'autres projets Python.

Voici les commandes permettant de mettre en place différents environnements :

Utilisation de venv

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

Utiliser Conda

conda create -n mistral_env python=3.10
conda activate mistral_env

En utilisant uv

Si vous n'avez pas encore d'UV :

pip install uv

Ensuite :

uv venv mistral_env
source mistral_env/bin/activate

Pour installer toutes les dépendances mentionnées ci-dessus, exécutez le code suivant dans votre terminal :

pip install -r requirements.txt

Note : Si vous rencontrez des erreurs liées à mistralai lors de l'utilisation d'un agent ou d'un connecteur, exécutez le code suivant :

pip install –upgrade mistralai

Cette opération permet de mettre à jour la bibliothèque mistralai avec sa dernière version.

Étape 2 : Mise en place des outils Mistral

Dans cette section, nous allons préparer nos outils et la configuration du client pour l'interaction avec l'API des agents Mistral.  Nous allons définir des schémas d'outils, initialiser le client et vérifier l'authentification. Ces outils seront ensuite référencés lors de la mise en place d'agents spécifiques tels que les estimateurs de calories ou les générateurs d'images.

Étape 2.1 : Registre et initialisation de l'outil

Tout d'abord, nous définissons les schémas de notre outil, la sélection du modèle et l'instanciation du client. Ensuite, nous construisons des méthodes d'aide comme create_chat_completion() et check_client(). Le code suivant est inséré dans le fichier configs.py à l'intérieur du dossier tools :

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

Nous commençons par importer dotenv pour charger les variables sensibles comme la clé d'API de Mistral depuis un fichier local .env dans l'environnement de Python. Les informations d'identification sont ainsi sécurisées et ne figurent pas dans le code source. Ensuite, nous sélectionnons le modèle par défaut mistral-large-latest et instançons un client Mistral à l'aide de la clé API.

Ensuite, nous définissons les spécifications internes de l'outil (schémas) en utilisant le format de schéma JSON. Ils vous aident dans les domaines suivants :

• Simuler le comportement des outils MCP (bien qu'ils ne soient pas enregistrés via la bibliothèque McpTool)
• Décrivez les entrées attendues telles que "nom d'utilisateur", "repas" et "calories".
• Contribuer à assurer un formatage cohérent des entrées dans les différents modules

Ajoutons maintenant nos méthodes d'aide qui créent des complétions de chat, enregistrent des outils, des agents et initialisent le client.

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()

La fonction create_chat_completion() intègre un appel à la méthode client.chat.complete(), qui fait partie du SDK du client Mistral, pour envoyer des messages au modèle.

• Il reformate les messages bruts de type dict en objets UserMessage et SystemMessage requis par le SDK Mistral.
• Il est également utile pour les compléments standardisés dans l'application.

Les fonctions register_tools() et register_agents() facilitent le développement local en enregistrant les outils et les agents actifs dans le système. Entre-temps, les fonctions check_client() et is_client_initialized() garantissent que le client Mistral a été correctement instancié et que la clé API est disponible, ce qui permet d'éviter les erreurs d'exécution lors de l'exécution de l'agent.

Étape 2.2 : Estimation des calories avec l'agent de recherche web

Maintenant que nous avons initialisé les outils de base et le client, construisons un agent de recherche Web dédié à la nutrition. Cet agent utilise le connecteur web_search de Mistral pour rechercher des estimations de calories pour les repas en temps réel. Ce code se trouve dans le fichier web_search.py à l'intérieur du dossier 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

Dans le code ci-dessus, la fonction search_calories() utilise l'outil de connexion intégré pour la recherche sur le web de l'API des agents Mistral, qui permet aux agents d'effectuer des requêtes sur le web en direct, comme l'estimation des calories, en surmontant les limites de l'apprentissage statique du modèle. Voici comment cela fonctionne :

1. Création d'un agent: Il crée d'abord un "agent de recherche nutritionnelle" à l'aide du modèle mistral-medium-latest, qui est équipé de l'outil web_search et a pour instruction de ne renvoyer que descalories .
2. Exécution de la requête: L'agent est ensuite utilisé pour entamer une conversation au cours de laquelle il est interrogé sur le nombre total de calories contenues dans la description du repas fourni.
3. Analyse des réponses: La réponse de l'agent est analysée à l'aide d'expressions régulières pour extraire la première valeur numérique (qui devrait être le nombre de calories).
4. Retombées: Si aucun numéro valide n'est trouvé ou si une erreur se produit, la fonction enregistre le problème et renvoie zéro comme solution de repli.

Sans web_search, la plupart des modèles ne peuvent pas répondre à des questions sur des événements récents ou des repas spécifiques à un domaine qui n'ont pas été vus dans leurs données d'apprentissage. Grâce à elle, nous pouvons consulter des informations nutritionnelles, des menus de restaurants ou des articles d'actualité en temps réel.

Il existe deux variantes de la recherche sur le web :

• web_search: Un connecteur de moteur de recherche léger et polyvalent (utilisé dans notre projet).
• web_search_premium: Une version améliorée qui comprend la vérification des fournisseurs d'informations et une collecte de données contextuelles plus large.

Ensuite, nous explorerons l'estimation de calories de secours en utilisant la logique de l'invite seulement.

Étape 2.3 : Estimation, enregistrement et suggestion de repas

Dans cette section, nous mettons en œuvre trois fonctions essentielles qui servent de repli ou d'amélioration. Le code suivant se trouve dans le fichier next.py du dossier 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."

Ce script définit les fonctions principales du backend qui alimentent notre flux de travail en matière de nutrition (de l'estimation des calories à la planification des repas de suivi). Ces fonctions utilisent les modèles légers de Mistral et la complétion standard du chat, sans nécessiter la création d'un agent ou de connecteurs à utiliser lorsque la recherche sur le web n'est pas disponible, ou pour éviter les erreurs de limite de taux. Voici ce que fait chaque fonction :

1. estimate_calories(): Cette fonction est utilisée comme solution de repli si le connecteur web_search tombe en panne ou n'est pas disponible.
1. Il envoie un message système indiquant le rôle de l'assistant en tant qu'expert en nutrition, ainsi que l'invite de l'utilisateur, qui comprend le repas que l'utilisateur souhaite enregistrer.
2. Le modèle est utilisé avec une faible temperature=0.1 pour un résultat déterministe. Cela signifie que le modèle produira des réponses cohérentes et reproductibles pour les mêmes données d'entrée - des tâches telles que l'estimation et l'enregistrement des calories, pour lesquelles des résultats stables et factuels sont préférables à des variations créatives.
3. Il analyse le premier numéro (à l'aide d'une expression rationnelle) de la réponse du modèle.
2. log_meal(): Cette fonction enregistre le repas d'un utilisateur, y compris un horodatage.
1. Il utilise un chat pour compléter l'instruction et renvoie le message de confirmation formaté de l'assistant.
2. Cela permet une journalisation interne légère sans avoir besoin d'une base de données dédiée.
3. suggest_next_meal(): Cette fonction recommande le prochain repas de l'utilisateur en fonction de son apport calorique antérieur et de son profil alimentaire.
1. Le modèle est invoqué à l'adresse temperature=0.7 pour encourager des suggestions plus créatives.
2. La réponse est ensuite dépouillée et renvoyée en tant qu'idée de repas suivante.

Ensemble, ces fonctions permettent d'estimer les calories, de confirmer le journal et de recommander des aliments sains sans avoir recours à des API externes. Dans l'étape suivante, nous visualiserons les suggestions alimentaires à l'aide du connecteur de génération d'images de Mistral.

Étape 2.4 : Générer des visuels avec le connecteur de génération d'images

Ajoutons maintenant une couche visuelle à notre assistant. Dans cette étape, nous utiliserons le connecteur image_generation intégré à Mistral pour générer une image appétissante du prochain repas suggéré.

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

La fonction generate_food_image() génère une représentation visuelle d'un repas à l'aide de l'outil image_generation intégré à Mistral. Voici ce que fait chaque partie :

• Création d'un agent: Un nouvel agent est chargé de créer des visuels de nourriture réalistes et appétissants.
• Début de la conversation: Une invite est envoyée à l'agent pour qu'il génère une image du site meal_description qui sera générée par l'agent du repas suivant.
• Traitement des réponses: La fonction vérifie si la réponse contient des morceaux d'image. Si oui, il télécharge chaque image via la méthode files.download() du client Mistral. Les images sont enregistrées localement dans un dossier generated_images/ avec des noms de fichiers horodatés.
• Sortie: Elle renvoie le chemin vers la première image enregistrée avec succès, ou un message d'erreur en cas d'échec de la génération.

Cet outil ajoute une couche visuelle à notre coach nutritionnel, rendant les suggestions de repas plus attrayantes et réalistes.

Étape 3 : Pipeline complet de nutritionniste

Maintenant que nous avons développé les outils individuels et les capacités des agents, il est temps de les intégrer dans un pipeline unique. Cette étape permet de coller tous les éléments pour en faire un assistant fonctionnel qui se manipule :

• Recherche de calories (via le web ou l'estimation)
• Enregistrement (utilisateur, repas, calories, horodatage)
• Proposer un repas de suivi
• Visualiser le repas à l'aide d'une image

Toutes ces étapes sont gérées en appelant chaque fonction de nos fichiers précédents dans le bon ordre. Le code de ce pipeline se trouve à l'extérieur du dossier tools, dans le fichier 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))
    }

Le code ci-dessus coordonne l'ensemble du flux de travail de l'assistant nutritionnel en enchaînant plusieurs outils d'agent dans un seul pipeline. Décortiquons le code ci-dessus plus en détail :

• La fonction run_nutritionist_pipeline() accepte les entrées username, meal_desc et dietary_preference pour piloter le processus de recommandation.
• Tout d'abord, il tente de déterminer la teneur en calories du repas à l'aide de la fonction search_calories() alimentée par le connecteur de recherche web de Mistral. En cas d'échec, il revient à une estimation utilisant un modèle léger via estimate_calories().
• La valeur calorique obtenue est ensuite enregistrée à l'aide de la fonction log_meal(), qui marque l'entrée avec un horodatage et l'associe à l'utilisateur.
• Sur la base des calories consommées et des préférences alimentaires, la fonction suggest_next_meal() suggère un repas de suivi à l'aide d'un raisonnement basé sur l'invite.
• Enfin, la fonction generate_food_image() utilise le connecteur de génération d'images de Mistral pour produire une représentation visuelle du plat recommandé.
• Tout au long du processus, time.sleep(1) est utilisé pour introduire de brèves pauses entre les demandes afin d'éviter de déclencher des limites de taux pendant les appels API.
• La fonction renvoie un dictionnaire contenant la confirmation de l'enregistrement du repas, le texte de suggestion du prochain repas, le chemin d'accès à l'image générée et une liste des outils utilisés dans cette interaction.

Ce pipeline combine de multiples fonctionnalités telles que la recherche, l'estimation, l'enregistrement, la suggestion et la visualisation dans une expérience nutritionnelle alimentée par l'IA.

Étape 4 : Créer une interface conviviale avec Gradio

Maintenant que la logique du backend est terminée, nous allons l'intégrer dans un frontend propre et convivial à l'aide de Gradio.

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

Dans l'extrait de code ci-dessus, nous avons mis en place une interface utilisateur Gradio complète pour interagir avec le pipeline de l'agent nutritionniste. Voici comment cela fonctionne :

• Nous commençons par importer la fonction run_nutritionist_pipeline() de agent.py, qui pilote la logique centrale de l'agent.
• Ensuite, la fonction process_meal() agit comme une enveloppe autour du pipeline d'agents, qui accepte username, meal_desc, et dietary_preference comme entrées utilisateur et déclenche la logique multi-agents définie précédemment.
• Dans la fonction process_meal(), le dictionnaire de résultats est analysé pour extraire le résumé du repas, les calories, le prochain repas suggéré et les connecteurs utilisés.
• La fonction vérifie également si le chemin d'accès à l'image générée est valide avant de la renvoyer pour affichage. Si l'image n'est pas trouvée, seul le résultat textuel est renvoyé.
• L'application Gradio est construite à l'aide de gr.Blocks() et la présentation comprend deux côtés, l'un avec des champs de saisie et l'autre avec un bouton Process Meal. L'autre côté contient une zone de sortie pour les résultats de l'analyse des repas et une image de prévisualisation du prochain repas.
• Le callback submit_btn.click() connecte le bouton du frontend pour déclencher la fonction process_meal(), en passant par les entrées et en recevant en sortie du markdown et de l'image formatés.
• Enfin, l'application est lancée via demo.launch() si le script est exécuté en tant que module principal. Vous pouvez définir debug = True pour activer le mode de débogage de l'application.

Pour exécuter cette démo, ouvrez un terminal dans votre répertoire racine et tapez la commande suivante :

python app.py

La structure générale de ce projet serait la suivante :

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 

Vous pouvez trouver le code complet de ce projet sur ce dépôt GitHub.

Conclusion

Dans ce tutoriel, nous avons construit un coach nutritionnel IA entièrement fonctionnel en utilisant l'API des agents Mistral. En chemin, nous avons exploré :

• Les différences entre les agents Mistral et les modèles LLM bruts
• Le rôle des connecteurs tels que web_search et image_generation
• Orchestration de plusieurs agents dans un seul pipeline
• Construire un frontend convivial avec Gradio

Ce projet montre la puissance des flux de travail agentiques où les LLM ne sont pas seulement des répondeurs passifs, mais des entités interactives qui raisonnent, agissent et coordonnent les tâches. De l'enregistrement des repas à la suggestion d'alternatives saines, en passant par la génération d'images, nous avons montré comment combiner des outils simples pour créer des expériences d'IA puissantes.

Pour en savoir plus sur l'utilisation des agents d'intelligence artificielle, je vous recommande ces tutoriels pratiques :

• Codex de l'OpenAI : Un guide avec 3 exemples pratiques
• Google Jules : Un guide avec 3 exemples pratiques
• Laboratoire de perplexité : Un guide avec 5 exemples pratiques
• n8n : Un guide avec des exemples pratiques
• Dify AI : Un guide avec un projet de démonstration