Mistral Medium 3 Tutoriel : Construire des applications agentiques

Mistral Medium 3 offre des performances élevées à un prix nettement inférieur à celui de nombreuses autres solutions. Elle est actuellement disponible via l'API Mistral AI, au prix de 0,40 dollar par million de jetons d'entrée et de 2 dollars par million de jetons de sortie. Cette tarification surpasse celle des principaux concurrents tels que DeepSeek v3qu'il s'agisse d'API ou de systèmes auto-déployés. En résumé, vous pouvez atteindre jusqu'à 90% de la performance de Claude Sonnet 3.7 sur différents benchmarks, tout en réalisant des économies considérables.

Dans ce tutoriel, nous allons apprendre à configurer l'API Mistral et à utiliser le client Python pour accéder au modèle. Ensuite, nous utiliserons LangGraph pour construire une application agentique qui utilise la recherche sur le web et l'outil Python REPL pour générer des réponses.

Image par l'auteur

Démarrer avec Mistral Medium 3

Dans cette section, nous allons apprendre à générer la clé API, à l'enregistrer en tant que variable d'environnement, puis à utiliser le client Python pour accéder à Mistral Medium 3 pour la génération de texte et la compréhension d'images.

1. Générer la clé de l'API Mistral AI

Inscrivez-vous à La Plateforme : Mistral AI et allez ensuite dans la rubrique Facturation et chargez le crédit de 5 $ en utilisant la carte de crédit/débit. Vous n'avez besoin que de quelques centimes pour ce projet. Ensuite, allez dans la section Clés API pour générer la nouvelle clé API.

2. Mise en place de l'environnement

La configuration d'une variable d'environnement dans DataLab est simple. Allez simplement dans l'onglet "Environnement", sélectionnez l'option "Variables d'environnement", et ajoutez une nouvelle variable nommée "MISTRAL_API_KEY" avec votre clé API. Après avoir enregistré les modifications, veillez à le connecter.

Dans DataLab, créez la nouvelle cellule Python et installez le paquet python Mistral AI. 

!pip install -U mistralai 

3. Génération de texte

Avant d'écrire le moindre code, il est essentiel de localiser les noms des points de terminaison de la clé API de Mistral Medium 3 en visitant la page Aperçu des modèles. D'après la documentation, le point de terminaison semble s'appeler mistral-medium-latest.

Source : Aperçu des modèles | Mistral AI Large Language Models

Ensuite, nous allons créer un client Mistral AI à l'aide de la clé API et générer une réponse en continu à une requête de l'utilisateur. 

import osfrom mistralai import Mistralapi_key = os.environ["MISTRAL_API_KEY"]model = "mistral-medium-latest"client = Mistral(api_key=api_key)stream_response = client.chat.stream(    model = model,    messages = [        {            "role": "user",            "content": "What is the best course to take from DataCamp?",        },    ])for chunk in stream_response:    print(chunk.data.choices[0].delta.content, end="" )

La réponse est très précise et ne nous a rien coûté. 

4. Compréhension de l'image

Pour tester les capacités multimodales du modèle, nous prendrons une capture d'écran de la page d'accueil du blog de DataCamp et la fournirons au modèle avec une invite de l'utilisateur.

Source : Blog | Articles sur la science des données | DataCamp

Comme le modèle ne peut pas accéder directement au fichier image, nous devons d'abord charger l'image et la convertir en une chaîne encodée en Base64.

import base64import requestsdef encode_image(image_path):    """Encode the image to base64."""    try:        with open(image_path, "rb") as image_file:            return base64.b64encode(image_file.read()).decode('utf-8')    except FileNotFoundError:        print(f"Error: The file {image_path} was not found.")        return None    except Exception as e:  # Added general exception handling        print(f"Error: {e}")        return None# Path to your imageimage_path = "datacamp_fp.png"# Getting the base64 stringbase64_image = encode_image(image_path)

Nous allons maintenant envoyer l'image codée en Base64, accompagnée d'une requête de l'utilisateur, au client de complétion de chat de Mistral AI.

# Define the messages for the chatmessages = [    {        "role": "user",        "content": [            {                "type": "text",                "text": "Explain the image in a Donald Trump style."            },            {                "type": "image_url",                "image_url": f"data:image/png;base64,{base64_image}"             }        ]    }]stream_response = client.chat.stream(    model = model,    messages = messages)for chunk in stream_response:    print(chunk.data.choices[0].delta.content, end="" )

Le modèle interprète avec succès l'image et génère une réponse dans le style de Donald Trump, démontrant ainsi ses capacités de compréhension multimodale. 

Construire une application agentique avec Mistral Medium 3

Dans ce projet, nous utiliserons Mistral Medium 3 avec LangGraph pour construire une application agentique. Cette application utilisera l'API Python pour la recherche sur le web et la REPL Python pour l'exécution du code en fonction des invites de l'utilisateur.

Vous êtes nouveau sur LangGraph ? Pas de problème ! Suivez notre tutoriel LangGraph et apprenez tout ce que vous devez savoir sur le framework.

1. Mise en place de l'API Tavily

Avant de plonger dans l'implémentation, nous devons configurer Tavily AI en créant un compte et en générant une clé API. La procédure est simple et vous n'avez pas besoin de fournir des informations de paiement ou une carte de crédit.

Une fois que vous avez la clé API, enregistrez-la en tant que variable d'environnement nommée TAVILY_API_KEY, soit localement, soit dans votre configuration DataLab, comme indiqué dans la section précédente.

2. Installation des paquets Python

Ensuite, nous installerons les paquets Python nécessaires à la création d'outils et d'agents utilisant l'écosystème LangChain.

%%capture!pip install -U \    mistralai \    langchain langchain-mistralai \    langchain-experimental \    langgraph  \    tavily-python

3. Création d'un client LLM

Nous allons créer le client LangChain ChatMistralAI pour les grands modèles de langage (LLM) en spécifiant le nom du modèle, la température et en activant les réponses en continu.

from langchain_mistralai import ChatMistralAIllm = ChatMistralAI(    model="mistral-medium-latest",       temperature=0.2,                     streaming=True          )

4. Initialisation des outils

Nous allons maintenant mettre en place les outils pour l'agent. Au lieu de créer manuellement des outils, nous pouvons utiliser des outils préconstruits comme Tavily Search et Python REPL de l'écosystème LangChain. 

from langchain_community.tools import TavilySearchResultsfrom langchain_experimental.tools.python.tool import PythonREPLToolsearch_tool = TavilySearchResults(max_results=5, include_answer=True)code_tool   = PythonREPLTool()tools = [search_tool, code_tool]

5. Mise en place d'un agent

Le client et les outils LLM étant prêts, nous pouvons maintenant créer l'agent React à l'aide de LangGraph.

from langgraph.prebuilt import create_react_agentagent = create_react_agent(    model=llm,           tools=tools,      )    ```                 6. Extracting tool namesBefore executing the agent, we will define a Python function to extract the names of the tools used during the agent’s response generation. This function will help us identify which tools were invoked.```pythondef extract_tool_names(conversation: dict) -> list[str]:    """    Given a conversation dict with a 'messages' list (where each message    may be a dict or a Pydantic model), extract all unique tool names    used in any tool call.    """    tool_names = set()    for msg in conversation.get('messages', []):        # 1) Try direct attribute access (for Pydantic models)        calls = []        if hasattr(msg, 'tool_calls'):            calls = getattr(msg, 'tool_calls') or []        # 2) If that fails, the message might be a dict        elif isinstance(msg, dict):            calls = msg.get('tool_calls')            # also check nested in additional_kwargs            if not calls and isinstance(msg.get('additional_kwargs'), dict):                calls = msg['additional_kwargs'].get('tool_calls')        # 3) Finally, check additional_kwargs on objects        else:            ak = getattr(msg, 'additional_kwargs', None)            if isinstance(ak, dict):                calls = ak.get('tool_calls', [])        # Normalize to list        calls = calls or []        # Extract names        for call in calls:            # dict-style tool call            if isinstance(call, dict):                # top-level 'name'                if 'name' in call:                    tool_names.add(call['name'])                # nested under 'function'                elif 'function' in call and isinstance(call['function'], dict):                    fn = call['function']                    if 'name' in fn:                        tool_names.add(fn['name'])    return sorted(tool_names)

LangGraph Studio est un environnement de développement visuel pour le cadre LangGraph ; suivez le guide LangGraph Studio à l'adresse: Installation, paramétrage, cas d'utilisation pour en savoir plus.

7. Test de l'agent 

Testons l'agent en lui posant une question sur les dernières nouvelles. 

question = "What are the top 5 breaking news stories?"def run_agent(question):    result = agent.invoke(        {            "messages": [                {"role": "user", "content": question}            ]        }    )    tool_name = extract_tool_names(result)    # The LLM’s final answer is always in the last message    raw_answer = result["messages"][-1].content    clean_text = "".join(part for part in raw_answer if isinstance(part, str))    return tool_name, clean_texttool_name, clean_text = run_agent(question)print("Tool used ⫸", tool_name, "\n")print(clean_text)

L'agent a utilisé l'outil de recherche Tavily pour générer une réponse sur les dernières nouvelles.

Ensuite, testons l'outil Python REPL en demandant à l'agent de générer et d'exécuter du code Python.

question = "Write a code to display the stars in a triangle. Please execute the code too."tool_name, clean_text = run_agent(question)print("Tool used ⫸", tool_name, "\n")print(clean_text)

L'agent a utilisé Mistral Medium 3 pour la génération de code et Python REPL pour l'exécution du code.

Enfin, testons une requête qui demande à l'agent d'utiliser les deux outils l'un après l'autre.

question = "Get the latest gold price data for the past 7 days and use it to generate a line plot"tool_name, clean_text = run_agent(question)print("Tool used ⫸", tool_name, "\n")print(clean_text)

L'agent utilisera Tavily Search pour obtenir des données sur le cours de l'or, Mistral Medium 3 pour générer du code pour la visualisation des données, et Python REPL pour exécuter ce code. Le résultat comprendra un tableau très précis ainsi qu'un résumé des outils utilisés.

Tool used ⫸ ['Python_REPL', 'tavily_search_results_json'] The code generates a line plot showing the gold price per gram in USD over the last 7 days, with the x-axis representing dates and the y-axis representing the gold price. The plot includes markers for each data point, a title, labeled axes, a grid, and rotated x-axis labels for better readability.

Si vous rencontrez des problèmes lors de l'exécution du code, reportez-vous à la section Mistral Medium 3 - DataLab pour obtenir des conseils supplémentaires.

Vous pouvez utiliser l'écosystème Haystack pour créer une application d'agent plus puissante et plus facile à mettre en œuvre. Suivez les tutoriels pour en savoir plus : Tutoriel Haystack AI : Construire des flux de travail agentiques.

Conclusion

Après avoir expérimenté l'API Mistral AI et créé des agents pour tester diverses applications, l'un des aspects les plus remarquables est qu'elle ne m'a pas coûté un seul dollar, même après avoir utilisé 161 075 jetons. Le modèle est abordable, rapide, précis et incroyablement facile à mettre en place. Il s'agit d'une excellente alternative à d'autres API coûteuses, telles que DeepSeek, tout en offrant des fonctionnalités comparables.

Le paysage de l'IA évolue clairement vers des modèles plus petits, plus rapides, plus précis et plus rentables, ce qui constitue une tendance prometteuse, en particulier pour les startups et les petites et moyennes entreprises (PME). Ces organisations dépendent souvent fortement des fournisseurs de LLM et, à mesure que ces modèles deviendront plus abordables, elles bénéficieront de marges bénéficiaires plus importantes.

Prenez le Développer de grands modèles de langage le cursus de compétences pour construire vos propres LLM en utilisant PyTorch et Hugging Face et les dernières techniques d'apprentissage profond et de NLP.