Outil code_interpreter : exécuter du Python

Exécuter du code dans le cloud Mistral

L’outil code_interpreter permet à votre agent d’écrire et d’exécuter du code Python dans un conteneur sandboxé. C’est l’outil idéal pour les calculs, l’analyse de données, la génération de graphiques et la validation de code. L’enjeu dépasse le confort : un LLM qui « calcule » de tête produit un résultat plausible, pas un résultat juste. En déportant l’opération vers un interpréteur réel, vous remplacez une prédiction de tokens par une exécution vérifiable, dont vous pouvez relire le code.

Créer un agent avec code interpreter

Les instructions de cet agent lui imposent de montrer le code avant de l’exécuter, ce qui vous laisse un point de contrôle sur ce qui tourne réellement.

from mistralai import Mistral
import os

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

agent = client.beta.agents.create(
    model="mistral-medium-latest",
    name="Agent Code",
    instructions="""Vous êtes un assistant de programmation Python.
- Utilisez le code interpreter pour exécuter du code quand nécessaire
- Montrez toujours le code avant de l'exécuter
- Expliquez les résultats de manière claire""",
    tools=[{"type": "code_interpreter"}],
    completion_args={"temperature": 0.3, "top_p": 0.95}
)

Lancer une exécution

Une demande de calcul suffit à déclencher l’outil, sans instruction particulière de votre part.

response = client.beta.conversations.start(
    agent_id=agent.id,
    inputs="Calcule les 20 premiers nombres de Fibonacci."
)

L’agent écrit alors un script Python pour calculer la suite, l’exécute dans le sandbox, puis vous présente les résultats accompagnés d’explications. Les vingt valeurs que vous recevez sortent d’une exécution réelle : elles seront exactes même au-delà du rang où un modèle commence habituellement à se tromper.

Structure de la réponse

Cette mécanique se lit directement dans les entries retournées, et votre code doit distinguer le texte du résultat d’exécution.

for entry in response.outputs:
    if entry.type == "message.output":
        # Première réponse : "Je vais calculer..." ou résultat final
        print(f"Message : {entry.content}")

    elif entry.type == "tool.execution":
        # Code exécuté et résultat
        print(f"Code : {entry.info.code}")
        print(f"Sortie : {entry.info.code_output}")

L’agent ouvre par un message.output dans lequel il annonce ce qu’il va faire. Vient ensuite le tool.execution où le code tourne : info.code contient le script, info.code_output sa sortie. Un second message.output clôt la séquence, dans lequel l’agent interprète et explique les résultats. Ces deux champs info.code et info.code_output sont votre trace d’audit — conservez-les dans vos journaux applicatifs, car ils permettent de rejouer et de contester n’importe quel chiffre produit par l’agent.

Ce que l’outil change en pratique

L’analyse de données est l’usage le plus immédiat. Fournissez une série de valeurs et demandez les statistiques : la moyenne, la médiane et l’écart-type sont calculés, pas estimés.

response = client.beta.conversations.start(
    agent_id=agent.id,
    inputs="""Voici les ventes mensuelles (en K€) : 
    Jan: 120, Fév: 135, Mar: 142, Avr: 128, Mai: 155, Juin: 168
    Calcule la moyenne, la médiane, l'écart-type et la tendance."""
)

La génération de graphiques prolonge naturellement cette capacité, puisque l’environnement dispose des bibliothèques de tracé.

response = client.beta.conversations.start(
    agent_id=agent.id,
    inputs="Crée un graphique en barres des parts de marché cloud en Europe : AWS 31%, Azure 25%, GCP 11%, OVH 8%, Autres 25%"
)

L’agent utilise matplotlib pour générer le graphique. Le résultat est un fichier image accessible dans la réponse — pensez donc à traiter ce cas dans votre code de lecture, sous peine de n’afficher que le commentaire textuel qui l’accompagne.

La validation de code constitue un troisième usage, moins évident mais précieux. Soumettez une fonction et les cas à couvrir : l’agent ne se contente pas de raisonner sur le code, il le fait tourner. Dans l’exemple ci-dessous, l’entrée "Madam" révèle un défaut que la relecture seule laisse volontiers passer.

response = client.beta.conversations.start(
    agent_id=agent.id,
    inputs="""Vérifie si cette fonction est correcte :
    
def is_palindrome(s):
    return s == s[::-1]

Teste-la avec : "radar", "hello", "kayak", "Madam"
"""
)

Les mathématiques appliquées ferment la liste : résolution de systèmes, algèbre linéaire, optimisation. Là encore, la réponse s’appuie sur un solveur et non sur une intuition.

response = client.beta.conversations.start(
    agent_id=agent.id,
    inputs="Résous le système d'équations : 2x + 3y = 12, 4x - y = 5"
)

Combiner avec d’autres outils

Un agent peut avoir plusieurs outils activés simultanément, et c’est souvent là que la valeur apparaît : la recherche apporte des données fraîches que le code transforme en analyse.

agent = client.beta.agents.create(
    model="mistral-large-latest",
    name="Analyste Complet",
    description="Recherche + Calcul",
    instructions="Recherchez des données récentes puis analysez-les avec du code.",
    tools=[
        {"type": "web_search"},
        {"type": "code_interpreter"}
    ]
)

response = client.beta.conversations.start(
    agent_id=agent.id,
    inputs="Cherche le cours actuel du Bitcoin et calcule son évolution en pourcentage sur les 30 derniers jours."
)

L’agent choisit automatiquement quel outil utiliser à chaque étape. Dans cette requête, il enchaîne les deux : impossible de calculer une évolution sans avoir d’abord obtenu les valeurs, et impossible d’obtenir ces valeurs sans accès au web.

Limitations du sandbox

Cet environnement isolé impose des contraintes qu’il vaut mieux connaître avant de concevoir votre application. Les bibliothèques sont limitées : les packages standards Python sont disponibles — numpy, pandas, matplotlib, entre autres — mais pas tous les packages tiers, ce qui exclut vos dépendances internes. Le code n’a pas d’accès réseau, si bien qu’une donnée doit lui parvenir par le contexte ou par un autre outil, jamais par un appel HTTP écrit dans le script. Le temps d’exécution est borné, donc les traitements longs sont interrompus : découpez les gros volumes plutôt que d’espérer une passe unique. Enfin, il n’y a pas de persistance entre les appels, et un fichier créé lors d’une exécution ne sera pas retrouvé à la suivante.

Points clés à retenir

• code_interpreter exécute du Python dans un sandbox sécurisé côté Mistral
• La réponse contient le code exécuté (info.code) et sa sortie (info.code_output)
• Idéal pour les calculs, l’analyse de données et la génération de graphiques
• Peut être combiné avec d’autres outils (web_search, etc.)
• Le sandbox a des limitations : pas d’accès réseau, bibliothèques limitées, pas de persistance