Blog
Point de vue

Utilisation de l'API Mistral Agents avec MCP : Quelle est sa performance ?

L'IA évolue : actions, résolution de problèmes, interactions. Mistral AI franchit un cap avec son API Agents, un outil puissant pour développeurs.

Louis Dupont

Louis Dupont

5 June 2025

Utilisation de l'API Mistral Agents avec MCP : Quelle est sa performance ?

```html

L'Intelligence Artificielle (IA) dépasse rapidement la simple génération de texte ou la reconnaissance d'images. La prochaine frontière concerne l'IA capable d'agir, de résoudre des problèmes et d'interagir avec le monde de manière significative. Mistral AI, un nom de premier plan dans ce domaine, a franchi une étape importante dans cette direction avec son Mistral Agents API. Cette boîte à outils puissante permet aux développeurs de créer des agents d'IA sophistiqués qui peuvent faire bien plus que les modèles de langage traditionnels.

À la base, l'API Agents est conçue pour surmonter les limites des modèles d'IA standard, qui excellent souvent dans la compréhension et la génération de langage, mais ont du mal à effectuer des actions, à se souvenir des interactions passées de manière cohérente ou à utiliser efficacement des outils externes. Le Mistral Agents API relève ces défis en équipant ses puissants modèles de langage de fonctionnalités telles que des connecteurs intégrés à divers outils, une mémoire persistante sur les conversations et la capacité de coordonner des tâches complexes.

Pensez à cela comme une mise à niveau d'un bibliothécaire très compétent qui ne peut que parler de livres vers une équipe de chercheurs experts qui peuvent non seulement accéder à l'information, mais aussi mener des expériences, rédiger des rapports et collaborer entre eux. Cette nouvelle API sert de base à la création d'applications d'IA de qualité entreprise qui peuvent automatiser les flux de travail, aider à la prise de décision complexe et offrir des expériences véritablement interactives.

💡
Vous voulez un excellent outil de test d'API qui génère une belle documentation API ?

Vous voulez une plateforme intégrée, tout-en-un, pour que votre équipe de développeurs travaille ensemble avec une productivité maximale ?

Apidog répond à toutes vos demandes et remplace Postman à un prix beaucoup plus abordable !
button

Qu'est-ce qui rend les agents Mistral si performants ?

Les modèles de langage traditionnels, bien qu'efficaces pour la génération de texte, sont souvent insuffisants lorsqu'il s'agit d'exécuter des actions ou de se souvenir d'informations lors d'interactions prolongées. Le Mistral Agents API répond directement à ces limites en synergie les modèles de langage de pointe de Mistral avec une suite de fonctionnalités puissantes conçues pour les flux de travail agentiques.

Fonctionnalités principales :

Au cœur de l'API Agents, on trouve :

Cette API n'est pas simplement une extension de leur API de complétion de chat ; c'est un cadre dédié spécialement conçu pour simplifier la mise en œuvre des cas d'utilisation agentiques. Elle est conçue pour être l'épine dorsale des plateformes agentiques de qualité entreprise, permettant aux entreprises de déployer l'IA de manière plus pratique, percutante et axée sur l'action.

Mistral Agents en action : applications concrètes

La polyvalence de l'API Agents est mise en évidence à travers diverses applications innovantes :

Mémoire, contexte et conversations avec état

Une pierre angulaire de l'API Agents est son système robuste de gestion des conversations. Il garantit que les interactions sont avec état, ce qui signifie que le contexte est conservé au fil du temps. Les développeurs peuvent initier des conversations de deux manières principales :

  1. Avec un agent : En spécifiant un agent_id, vous tirez parti des capacités, des outils et des instructions préconfigurés d'un agent spécifique.
  2. Accès direct : Vous pouvez démarrer une conversation en spécifiant directement le modèle et les paramètres de complétion, ce qui permet un accès rapide aux connecteurs intégrés sans agent prédéfini.

Chaque conversation conserve un historique structuré grâce à des "entrées de conversation", garantissant que le contexte est méticuleusement préservé. Cet état permet aux développeurs de consulter les conversations passées, de poursuivre toute interaction de manière transparente, ou même de se séparer pour initier de nouveaux chemins conversationnels à partir de n'importe quel point de l'historique. De plus, l'API prend en charge les sorties en streaming, permettant des mises à jour en temps réel et des interactions dynamiques.

Orchestration d'agents : la puissance de la collaboration

La véritable puissance de différenciation de l'API Agents apparaît dans sa capacité à orchestrer plusieurs agents. Il ne s'agit pas d'une seule IA monolithique ; il s'agit d'une symphonie d'agents spécialisés travaillant de concert. Grâce à l'orchestration dynamique, des agents peuvent être ajoutés ou supprimés d'une conversation selon les besoins, chacun contribuant à ses compétences uniques pour s'attaquer à différentes facettes d'un problème complexe.

Pour créer un flux de travail agentique avec des transferts :

  1. Créer des agents : Définissez et créez tous les agents nécessaires, chacun étant équipé d'outils, de modèles et d'instructions spécifiques adaptés à son rôle.
  2. Définir les transferts : Spécifiez quels agents peuvent déléguer des tâches à d'autres. Par exemple, un agent de service client principal peut transférer une requête technique à un agent de dépannage spécialisé ou une demande de facturation à un agent financier.

Ces transferts permettent une chaîne d'actions transparente. Une seule demande utilisateur peut déclencher une cascade de tâches sur plusieurs agents, chacun gérant de manière autonome sa partie désignée. Cette approche collaborative débloque une efficacité et une efficacité sans précédent dans la résolution de problèmes pour des applications réelles sophistiquées.

Utilisation de base de l'API Mistral Agents

Après avoir compris les capacités de l'API Mistral Agents, explorons comment interagir avec elle. L'API introduit trois nouveaux objets principaux :

Notamment, vous pouvez tirer parti de nombreuses fonctionnalités, telles que les conversations avec état et les connecteurs intégrés, sans créer et référencer explicitement un objet "Agent" formel en premier. Cela offre une flexibilité pour les cas d'utilisation plus simples.

Création d'un agent

Pour définir un agent spécialisé, vous faites une requête à l'API en spécifiant plusieurs paramètres :

Voici un exemple de requête cURL pour créer un agent simple :

curl --location "https://api.mistral.ai/v1/agents" \
     --header 'Content-Type: application/json' \
     --header 'Accept: application/json' \
     --header "Authorization: Bearer $MISTRAL_API_KEY" \
     --data '{
         "model": "mistral-medium-latest",
         "name": "Simple Agent",
         "description": "A simple Agent with persistent state."
     }'

Mise à jour d'un agent

Les agents peuvent être mis à jour après la création. Les arguments sont les mêmes que ceux de la création. Cette opération se traduit par un nouvel objet agent avec les paramètres mis à jour, ce qui permet effectivement le versionnement de vos agents.

curl --location "https://api.mistral.ai/v1/agents/<agent_id>" \
     --header 'Content-Type: application/json' \
     --header 'Accept: application/json' \
     --header "Authorization: Bearer $MISTRAL_API_KEY" \
     --data '{
         "completion_args": {
           "temperature": 0.3,
           "top_p": 0.95
         },
         "description": "An edited simple agent."
     }'

Gestion des conversations

Une fois qu'un agent est créé (ou si vous utilisez un accès direct), vous pouvez initier des conversations.

Démarrage d'une conversation :
Vous devez fournir :

Exemple (entrée de chaîne simple) :

curl --location "https://api.mistral.ai/v1/conversations" \
     --header 'Content-Type: application/json' \
     --header 'Accept: application/json' \
     --header "Authorization: Bearer $MISTRAL_API_KEY" \
     --data '{
         "inputs": "Who is Albert Einstein?",
         "stream": false,
         "agent_id": "<agent_id>"
     }'

Poursuite d'une conversation :
Pour ajouter à une conversation existante :

Exemple :

curl --location "https://api.mistral.ai/v1/conversations/<conv_id>" \
     --header 'Content-Type: application/json' \
     --header 'Accept: application/json' \
     --header "Authorization: Bearer $MISTRAL_API_KEY" \
     --data '{
         "inputs": "Translate to French.",
         "stream": false,
         "store": true,
         "handoff_execution": "server"
     }'

Sortie en streaming

Pour les interactions en temps réel, le démarrage et la poursuite des conversations peuvent être diffusés en continu en définissant stream: true et en s'assurant que l'en-tête Accept est text/event-stream.

curl --location "https://api.mistral.ai/v1/conversations" \
     --header 'Content-Type: application/json' \
     --header 'Accept: text/event-stream' \
     --header "Authorization: Bearer $MISTRAL_API_KEY" \
     --data '{
         "inputs": "Who is Albert Einstein?",
         "stream": true,
         "agent_id": "ag_06811008e6e07cb48000fd3f133e1771"
     }'

Lors du streaming, vous recevrez différents types d'événements indiquant la progression et le contenu de la réponse, tels que :

Ces opérations de base constituent le fondement de la création d'applications dynamiques et interactives avec les agents Mistral.

Intégration de l'API Mistral Agents avec le Model Context Protocol (MCP)

Bien que les connecteurs intégrés offrent une puissance significative, la véritable extensibilité de Mistral Agents brille lorsqu'elle est combinée avec le Model Context Protocol (MCP).

Qu'est-ce que le MCP ?

Le Model Context Protocol (MCP) est une norme ouverte conçue pour rationaliser l'intégration des modèles d'IA avec diverses sources de données, outils et API externes. Il fournit une interface standardisée et sécurisée qui permet aux systèmes d'IA d'accéder et d'utiliser efficacement des informations contextuelles du monde réel. Au lieu de construire et de maintenir de nombreuses intégrations sur mesure, le MCP offre un moyen unifié pour les modèles d'IA de se connecter à des données et des systèmes en direct, ce qui conduit à des réponses plus pertinentes, précises et puissantes. Pour des informations détaillées, consultez la documentation officielle du Model Context Protocol.

Le SDK Python de Mistral fournit des mécanismes d'intégration transparente pour connecter les agents aux clients MCP. Cela permet à vos agents d'interagir avec tout service ou source de données qui expose une interface MCP, qu'il s'agisse d'un outil local, d'une API tierce ou d'un système d'entreprise propriétaire.

Nous allons explorer trois scénarios courants pour l'utilisation du MCP avec Mistral Agents : un serveur MCP local, un serveur MCP distant sans authentification et un serveur MCP distant avec authentification. Tous les exemples utiliseront du code Python asynchrone.

Scénario 1 : Utilisation d'un serveur MCP local

Imaginez que vous disposez d'un script ou d'un service local (par exemple, un fournisseur d'informations météorologiques personnalisé) avec lequel vous souhaitez que votre agent Mistral interagisse.

Étape 1 : Initialiser le client Mistral et la configuration
Importez les modules nécessaires de mistralai et mcp. Cela inclut Mistral, RunContext, StdioServerParameters (pour les serveurs MCP locaux basés sur les processus) et MCPClientSTDIO.

import asyncio
import os
from pathlib import Path
from mistralai import Mistral
from mistralai.extra.run.context import RunContext
from mcp import StdioServerParameters
from mistralai.extra.mcp.stdio import MCPClientSTDIO
from mistralai.types import BaseModel

cwd = Path(__file__).parent
MODEL = "mistral-medium-latest" # Or your preferred model

async def main_local_mcp():
    api_key = os.environ["MISTRAL_API_KEY"]
    client = Mistral(api_key=api_key)

    # Define parameters for the local MCP server (e.g., running a Python script)
    server_params = StdioServerParameters(
        command="python",
        args=[str((cwd / "mcp_servers/stdio_server.py").resolve())], # Path to your MCP server script
        env=None,
    )

    # Create an agent
    weather_agent = client.beta.agents.create(
        model=MODEL,
        name="Local Weather Teller",
        instructions="You can tell the weather using a local MCP tool.",
        description="Fetches weather from a local source.",
    )

    # Define expected output format (optional, but good for structured data)
    class WeatherResult(BaseModel):
        user: str
        location: str
        temperature: float

    # Create a Run Context
    async with RunContext(
        agent_id=weather_agent.id,
        output_format=WeatherResult, # Optional: For structured output
        continue_on_fn_error=True,
    ) as run_ctx:
        # Create and register MCP client
        mcp_client = MCPClientSTDIO(stdio_params=server_params)
        await run_ctx.register_mcp_client(mcp_client=mcp_client)

        # Example of registering a local Python function as a tool
        import random
        @run_ctx.register_func
        def get_location(name: str) -> str:
            """Function to get a random location for a user."""
            return random.choice(["New York", "London", "Paris"])

        # Run the agent
        run_result = await client.beta.conversations.run_async(
            run_ctx=run_ctx,
            inputs="Tell me the weather in John's location currently.",
        )

        print("Local MCP - All run entries:")
        for entry in run_result.output_entries:
            print(f"{entry}\n")
        if run_result.output_as_model:
            print(f"Local MCP - Final model output: {run_result.output_as_model}")
        else:
            print(f"Local MCP - Final text output: {run_result.output_as_text}")

# if __name__ == "__main__":
#     asyncio.run(main_local_mcp())

Dans cette configuration, stdio_server.py serait votre script mettant en œuvre la logique du serveur MCP, communiquant via stdin/stdout. Le RunContext gère l'interaction, et register_mcp_client rend le serveur MCP local disponible en tant qu'outil pour l'agent. Vous pouvez également enregistrer des fonctions Python locales directement en utilisant @run_ctx.register_func.

Streaming avec un serveur MCP local :
Pour diffuser en continu, utilisez client.beta.conversations.run_stream_async et traitez les événements au fur et à mesure qu'ils arrivent :

    # Inside RunContext, after MCP client registration
    # events = await client.beta.conversations.run_stream_async(
    #     run_ctx=run_ctx,
    #     inputs="Tell me the weather in John's location currently, stream style.",
    # )
    # streamed_run_result = None
    # async for event in events:
    #     if isinstance(event, RunResult): # Assuming RunResult is defined or imported
    #         streamed_run_result = event
    #     else:
    #         print(f"Stream event: {event}")
    # if streamed_run_result:
    #     # Process streamed_run_result
    #     pass

Scénario 2 : Utilisation d'un serveur MCP distant sans authentification

De nombreux services publics ou internes peuvent exposer une interface MCP via HTTP/SSE sans nécessiter d'authentification.

from mistralai.extra.mcp.sse import MCPClientSSE, SSEServerParams

async def main_remote_no_auth_mcp():
    api_key = os.environ["MISTRAL_API_KEY"]
    client = Mistral(api_key=api_key)

    # Define the URL for the remote MCP server (e.g., Semgrep's public MCP)
    server_url = "https://mcp.semgrep.ai/sse"
    mcp_client = MCPClientSSE(sse_params=SSEServerParams(url=server_url, timeout=100))

    async with RunContext(
        model=MODEL, # Can use agent_id too if an agent is pre-created
    ) as run_ctx:
        await run_ctx.register_mcp_client(mcp_client=mcp_client)

        run_result = await client.beta.conversations.run_async(
            run_ctx=run_ctx,
            inputs="Can you write a hello_world.py file and then check it for security vulnerabilities using available tools?",
        )

        print("Remote No-Auth MCP - All run entries:")
        for entry in run_result.output_entries:
            print(f"{entry}\n")
        print(f"Remote No-Auth MCP - Final Response: {run_result.output_as_text}")

# if __name__ == "__main__":
#     asyncio.run(main_remote_no_auth_mcp())

Ici, MCPClientSSE est utilisé avec SSEServerParams pointant vers l'URL distante. L'agent peut ensuite exploiter les outils fournis par ce serveur MCP distant. Le streaming suit le même modèle que l'exemple MCP local, en utilisant run_stream_async.

Scénario 3 : Utilisation d'un serveur MCP distant avec authentification (OAuth)

Pour les services nécessitant une authentification OAuth2 (comme Linear, Jira, etc.), le processus implique quelques étapes supplémentaires pour gérer le flux d'autorisation.

from http.server import BaseHTTPRequestHandler, HTTPServer
import threading
import webbrowser
from mistralai.extra.mcp.auth import build_oauth_params

CALLBACK_PORT = 16010 # Ensure this port is free

# Callback server setup (simplified from source)
def run_callback_server_util(callback_func, auth_response_dict):
    class OAuthCallbackHandler(BaseHTTPRequestHandler):
        def do_GET(self):
            if "/callback" in self.path or "/oauth/callback" in self.path: # More robust check
                auth_response_dict["url"] = self.path
                self.send_response(200)
                self.send_header("Content-type", "text/html")
                self.end_headers()
                self.wfile.write(b"<html><body>Authentication successful. You may close this window.</body></html>")
                callback_func() # Signal completion
                threading.Thread(target=self.server.shutdown).start()
            else:
                self.send_response(404)
                self.end_headers()

    server_address = ("localhost", CALLBACK_PORT)
    httpd = HTTPServer(server_address, OAuthCallbackHandler)
    threading.Thread(target=httpd.serve_forever, daemon=True).start() # Use daemon thread
    redirect_url = f"http://localhost:{CALLBACK_PORT}/oauth/callback"
    return httpd, redirect_url

async def main_remote_auth_mcp():
    api_key = os.environ["MISTRAL_API_KEY"]
    client = Mistral(api_key=api_key)

    server_url = "https://mcp.linear.app/sse" # Example: Linear MCP
    mcp_client_auth = MCPClientSSE(sse_params=SSEServerParams(url=server_url))

    callback_event = asyncio.Event()
    event_loop = asyncio.get_event_loop()
    auth_response_holder = {"url": ""}

    if await mcp_client_auth.requires_auth():
        httpd, redirect_url = run_callback_server_util(
            lambda: event_loop.call_soon_threadsafe(callback_event.set),
            auth_response_holder
        )
        try:
            oauth_params = await build_oauth_params(mcp_client_auth.base_url, redirect_url=redirect_url)
            mcp_client_auth.set_oauth_params(oauth_params=oauth_params)
            login_url, state = await mcp_client_auth.get_auth_url_and_state(redirect_url)

            print(f"Please go to this URL and authorize: {login_url}")
            webbrowser.open(login_url, new=2)
            await callback_event.wait() # Wait for OAuth callback

            token = await mcp_client_auth.get_token_from_auth_response(
                auth_response_holder["url"], redirect_url=redirect_url, state=state
            )
            mcp_client_auth.set_auth_token(token)
            print("Authentication successful.")
        except Exception as e:
            print(f"Error during authentication: {e}")
            return # Exit if auth fails
        finally:
            if 'httpd' in locals() and httpd:
                httpd.shutdown()
                httpd.server_close()
    
    async with RunContext(model=MODEL) as run_ctx: # Or agent_id
        await run_ctx.register_mcp_client(mcp_client=mcp_client_auth)

        run_result = await client.beta.conversations.run_async(
            run_ctx=run_ctx,
            inputs="Tell me which projects do I have in my Linear workspace?",
        )
        print(f"Remote Auth MCP - Final Response: {run_result.output_as_text}")

# if __name__ == "__main__":
#     asyncio.run(main_remote_auth_mcp())

Cela implique de configurer un serveur HTTP local pour intercepter la redirection OAuth, de guider l'utilisateur à travers la page d'autorisation du fournisseur, d'échanger le code reçu contre un jeton d'accès, puis de configurer le MCPClientSSE avec ce jeton. Une fois authentifié, l'agent peut interagir avec le service MCP protégé. Le streaming suit à nouveau le modèle établi.

Conclusion : L'avenir est agentique et interconnecté

L'API Mistral Agents, en particulier lorsqu'elle est augmentée par le Model Context Protocol, offre une plateforme robuste et flexible pour la création d'applications d'IA de nouvelle génération. En permettant aux agents non seulement de raisonner et de communiquer, mais aussi d'interagir avec un vaste écosystème d'outils, de sources de données et de services, les développeurs peuvent créer des systèmes véritablement intelligents capables de s'attaquer à des problèmes complexes du monde réel. Que vous automatisiez des flux de travail complexes, que vous fournissiez une assistance profondément contextualisée ou que vous soyez pionnier de nouvelles formes de collaboration homme-IA, la combinaison de Mistral Agents et de MCP fournit la boîte à outils fondamentale pour cet avenir passionnant. Au fur et à mesure que la norme MCP gagnera en adoption, le potentiel de création d'agents d'IA interconnectés et très performants ne fera que croître.

💡
Vous voulez un excellent outil de test d'API qui génère une belle documentation API ?

Vous voulez une plateforme intégrée, tout-en-un, pour que votre équipe de développeurs travaille ensemble avec une productivité maximale ?

Apidog répond à toutes vos demandes et remplace Postman à un prix beaucoup plus abordable !
button

```

Explore more

Fathom-R1-14B : Modèle de raisonnement IA avancé d'Inde

Fathom-R1-14B : Modèle de raisonnement IA avancé d'Inde

L'IA en expansion rapide. Fathom-R1-14B (14,8 milliards de paramètres) excelle en raisonnement mathématique et général, conçu par Fractal AI Research.

5 June 2025

Mistral Code : L'assistant de codage le plus personnalisable basé sur l'IA pour les entreprises

Mistral Code : L'assistant de codage le plus personnalisable basé sur l'IA pour les entreprises

Découvrez Mistral Code, l'IA d'aide au code la plus personnalisable pour les entreprises.

5 June 2025

Comment Claude Code transforme le codage de l'IA en 2025

Comment Claude Code transforme le codage de l'IA en 2025

Découvrez Claude Code en 2025 : codage IA révolutionné. Fonctionnalités, démo, et pourquoi il gagne du terrain après Windsurf d'Anthropic. Indispensable !

5 June 2025

Pratiquez le Design-first d'API dans Apidog

Découvrez une manière plus simple de créer et utiliser des API

S'inscrire gratuitementTélécharger