Intégrer Qwen-Agent à MCP pour créer des agents avec un accès direct aux données

Dans ce guide, vous apprendrez :

• Ce qu’est la bibliothèque Qwen-Agent et comment elle vous aide à construire des agents d’intelligence artificielle.
• Pourquoi l’utilisation de Qwen3 avec le serveur MCP de Bright Data est idéale pour créer des agents d’IA de nouvelle génération.
• Comment intégrer Qwen-Agent avec le MCP de Bright Data pour construire un agent compétent alimenté par Qwen3.

Plongeons dans l’aventure !

Qu’est-ce que Qwen-Agent ?

Qwen-Agent est un cadre open-source développé par Alibaba Cloud pour construire des applications avancées alimentées par LLM. Il exploite les capacités des modèles Qwen pour créer des agents d’intelligence artificielle capables de suivre des instructions, d’utiliser des outils, de planifier et de gérer la mémoire.

Cette bibliothèque sert notamment de backend pour Qwen Chat. Elle offre des composants de base pour la construction d’agents d’intelligence artificielle, avec un support natif pour l’appel de fonctions et d’outils, même via MCP(Model Context Protocol).

Qwen-Agent permet un déploiement flexible des modèles, que ce soit par le biais du service DashScope d’Alibaba Cloud ou des modèles Qwen auto-hébergés. Il comprend également une interface Web basée sur Gradio pour déployer et tester rapidement vos agents dans le navigateur.

Pourquoi combiner Qwen3 avec un serveur MCP dans Qwen-Agent ?

Qwen3 est le dernier modèle développé par Alibaba Cloud. Il offre d’excellentes performances et, comme il s’agit d’un logiciel libre, il est disponible gratuitement auprès de nombreux fournisseurs en ligne (et vous pouvez même l’héberger vous-même !). Il s’agit donc d’un choix idéal pour créer des agents d’intelligence artificielle rentables mais puissants.

Aujourd’hui, les agents d’IA alimentés par Qwen3 et construits avec Qwen-Agent sont déjà capables. Cependant, ils héritent des limitations du LLM sous-jacent. Ces limites, telles que le manque d’accès aux informations en temps réel, peuvent être surmontées en fournissant à l’agent des données précises et en lui permettant d’explorer le web en direct.

C’est là que le serveur MCP de Bright Data entre en jeu. Construit sur Node.js, le serveur MCP s’intègre à la suite d’outils d’extraction de données d’IA de Bright Data. Grâce à ces outils, votre agent est en mesure d’accéder au contenu Web en temps réel, d’interroger des ensembles de données structurées et d’effectuer des recherches en direct sur le Web.

À l’heure actuelle, les outils MCP pris en charge sont les suivants :

Pour découvrir des exemples concrets, lisez notre guide sur le scraping avec le serveur MCP ou voyez comment il s’intègre à des outils tels que le SDK de Google.

Remarque: Bright Data développe continuellement l’ensemble des outils MCP, et s’attend donc à ce qu’il y ait de plus en plus de possibilités au fil du temps.

Maintenant, regardez comment vous pouvez utiliser ces outils MCP à travers Qwen3 avec Qwen-Agent !

Comment intégrer Qwen-Agent au serveur Bright MCP en Python ?

Dans cette section, vous apprendrez à utiliser Qwen-Agent pour construire un puissant agent d’IA Python alimenté par Qwen3. L’agent sera équipé de capacités de récupération, d’extraction et de transformation de données en direct via le serveur MCP de Bright Data.

À titre d’exemple, nous montrerons comment l’agent d’IA peut récupérer des données de produits en direct sur Amazon, qui estconnu pour ses défis en matière de scraping. Il s’agit là d’un cas d’utilisation parmi d’autres. L’agent d’intelligence artificielle peut utiliser n’importe lequel des plus de 20 outils disponibles via le serveur MCP pour gérer une grande variété de tâches.

Remarque: il suffit de donner à l’agent d’intelligence artificielle des invites différentes pour réaliser n’importe quel autre scénario ou cas d’utilisation.

Suivez les étapes ci-dessous pour créer votre agent d’IA alimenté par le MCP de Bright Data à l’aide de Qwen-Agent et de Qwen 3 !

Conditions préalables

Pour suivre ce tutoriel, vous devez avoir :

• Python 3.10 ou supérieur installé localement.
• Node.js installé localement.

Vous aurez également besoin de :

• Un compte Bright Data.
• Une clé API OpenRouter.

Les étapes ci-dessous vous guideront dans la configuration des informations d’identification de Bright Data et d’OpenRouter lorsque cela sera nécessaire. Ne vous en préoccupez donc pas pour l’instant.

Bien qu’elles ne soient pas obligatoires, les connaissances suivantes vous aideront à tirer le meilleur parti de ce didacticiel :

• Une compréhension générale du fonctionnement du programme MCP.
• Connaissance de base du fonctionnement de l’agent Qwen.
• Une certaine connaissance du serveur MCP de Bright Data et des outils disponibles.
• Une certaine expérience de la programmation asynchrone en Python.

Étape 1 : Configuration du projet

Ouvrez le terminal et créez un nouveau dossier pour votre agent IA alimenté par MCP :

mkdir qwen-agent-mcp

Le dossier qwen-agent-mcp contiendra tout le code de votre agent IA Python.

Ensuite, naviguez dans le dossier du projet et créez un environnement virtuel à l’intérieur de celui-ci :

cd qwen-agent-mcp
python -m venv venv

Ouvrez le dossier du projet dans votre IDE Python préféré. Nous recommandons d’utiliser Visual Studio Code avec l’extension Python ou PyCharm Community Edition.

Créez un fichier nommé agent.py dans le dossier du projet, qui devrait maintenant ressembler à ceci :

Le fichier agent.py est actuellement vide, mais il contiendra bientôt la logique d’intégration de Qwen3 avec le serveur MCP de Bright Data.

Activez l’environnement virtuel en utilisant le terminal de votre IDE. Sous Linux ou macOS, exécutez cette commande :

source venv/bin/activate

De manière équivalente, sous Windows, lancez :

venv/Scripts/activate

Vous êtes prêt ! Vous disposez maintenant d’un environnement Python pour créer un agent d’intelligence artificielle à l’aide de Qwen-Agent et du serveur MCP de Bright Data.

Étape 2 : Configurer les variables d’environnement Lecture

Votre projet interagira avec des services tiers tels que OpenRouter et Bright Data. Évitez de coder en dur les clés d’API dans votre code Python. Chargez-les plutôt à partir de variables d’environnement pour plus de sécurité et de facilité de maintenance.

Pour simplifier ce processus, nous allons utiliser la bibliothèque python-dotenv. Avec votre environnement virtuel activé, installez-la en exécutant :

pip install python-dotenv

Ensuite, dans votre fichier agent.py, importez la bibliothèque et chargez les variables d’environnement avec load_dotenv() :

from dotenv import load_dotenv

load_dotenv()

Cela permet à votre script de lire les variables d’environnement à partir d’un fichier .env local. Créez donc un fichier .env dans le dossier de votre projet :

Vous pouvez maintenant accéder aux variables d’environnement dans votre code comme suit :

env_value = os.getenv("<ENV_NAME>")

N’oubliez pas d’importer le module os de la bibliothèque standard de Python :

import os

C’est très bien ! Vous êtes maintenant prêt à charger en toute sécurité des secrets à partir des variables d’environnement.

Étape 3 : Démarrer avec Google ADK

Dans votre environnement virtuel activé, installez la bibliothèque Qwen-Agent en exécutant :

pip install "qwen-agent[gui,mcp]"

Notez que qwen-agent supporte quelques sous-modules optionnels. Pour ce tutoriel, ces deux-là suffisent :

• [gui] pour une interface utilisateur basée sur Gradio.
• [mcp] pour l’intégration avec n’importe quel serveur MCP.

Ensuite, ouvrez votre fichier agent.py et incluez les importations suivantes :

from qwen_agent.agents import Assistant
from qwen_agent.gui import WebUI

Ceux-ci seront utilisés dans les étapes suivantes pour connecter Qwen-Agent au serveur MCP et mettre en œuvre votre agent AI.

Par défaut, Qwen-Agent attend une clé API DashScope dans votre environnement pour accéder aux modèles Qwen. Cependant, dans ce tutoriel, nous utiliserons Qwen3 via la plateforme gratuite OpenRouter.

⚠️ Avertissement: Vous vous demandez peut-être pourquoi nous n’utilisons pas DashScope d’Alibaba Cloud pour accéder directement à Qwen3. La raison en est que, à l’heure où nous écrivons ces lignes, il existe des restrictions pour les utilisateurs internationaux (c’est-à-dire les utilisateurs en dehors de la Chine). Ces restrictions conduisent actuellement au message d’erreur suivant (quelque peu trompeur) :

Error code: InvalidApiKey. Error message: Invalid API-key provided.

Pour éviter ce problème, vous pouvez utiliser OpenRouter ou toute autre plateforme qui fournit un accès à Qwen3 sans restrictions régionales.

Voyons maintenant comment configurer votre clé API OpenRouter pour l’intégration de Qwen3 !

Étape 4 : Récupérer votre clé API OpenRouter

Si vous ne l’avez pas encore fait, créez un compte OpenRouter. Si vous en avez déjà un, il vous suffit de vous connecter.

Ensuite, accédez à la page “Clés API” en survolant l’image de votre profil dans le coin supérieur droit et en sélectionnant l’option “Clés” :

Cliquez sur le bouton “Create API Key” et suivez les instructions pour générer votre clé. Copiez ensuite la clé et ajoutez-la à votre fichier .env comme suit :

OPEN_ROUTER_API_KEY="<YOUR_OPEN_ROUTER_API_KEY>"

Remplacez le par votre clé API OpenRouter.

Ensuite, dans votre fichier agent.py, chargez la clé en utilisant :

OPEN_ROUTER_API_KEY = os.getenv("OPEN_ROUTER_API_KEY")

Génial ! Vous êtes maintenant prêt à utiliser Qwen3 avec Qwen-Agent via OpenRouter.

Étape 5 : configuration du serveur MCP de Bright Data

Commencez par [créer un nouveau compte Bright Data]() ou connectez-vous simplement à votre compte existant.

Ensuite, suivez les instructions officielles pour :

1. Récupérez votre clé API Bright Data.
2. Configurer Web Unlocker et Scraping Browser pour l’intégration MCP.

Une fois cela fait, vous devriez avoir

• Un jeton d’API Bright Data.
• Une zone Web Unlocker (ici, nous supposerons que le nom de la zone est le nom par défaut “mcp_unlocker”).
• Récupération des informations d’identification du navigateur au format <BRIGHT_DATA_SB_USERNAME>:<BRIGHT_DATA_SB_PASSWORD>.

Maintenant, installez le serveur MCP de Bright Data globalement dans votre environnement Node.js avec :

npm install -g @brightdata/mcp

Ensuite, assurez-vous de spécifier deux environnements dans votre terminal :

API_TOKEN="<YOUR_BRIGHT_DATA_API_TOKEN>"
BROWSER_AUTH="<BRIGHT_DATA_SB_USERNAME>:<BRIGHT_DATA_SB_PASSWORD>"

Suivez la procédure correcte pour la définition des variables d’environnement en fonction du système d’exploitation.

Vous pouvez maintenant démarrer le serveur MCP via le paquet @brightdata/mcp npm avec :

npx -y @brightdata/mcp

Cette commande lance le serveur MCP localement, en lisant les variables d’environnement requises(API_TOKEN et BROWSER_AUTH). Si tout est configuré correctement, vous devriez obtenir une sortie comme celle-ci :

Checking for required zones...
Required zone "mcp_unlocker" already exists
Starting server...

Bon travail ! Le serveur MCP de Bright Data fonctionne à merveille.

Ensuite, ajoutez ces deux variables d’environnement à votre fichier .env :

BRIGHT_DATA_API_TOKEN="<YOUR_BRIGHT_DATA_API_TOKEN>"
BRIGHT_DATA_BROWSER_AUTH="<BRIGHT_DATA_SB_USERNAME>:<BRIGHT_DATA_SB_PASSWORD>"

Remplacer les espaces réservés par les valeurs réelles.

Dans votre agent.py, chargez ces variables avec :

BRIGHT_DATA_API_TOKEN = os.getenv("BRIGHT_DATA_API_TOKEN")
BRIGHT_DATA_BROWSER_AUTH = os.getenv("BRIGHT_DATA_BROWSER_AUTH")

C’est parfait ! Vous avez maintenant tout ce qu’il faut pour intégrer le serveur MCP de Bright Data à Qwen-Agent.

Étape 6 : Définir l’agent Qwen3 alimenté par MCP

Créez une fonction pour initialiser votre agent AI avec le support Qwen3 et MCP :

def initialize_mcp_agent():
    # To connect to Qwen3 via OpenRouter
    llm_cfg = {
        "model": "qwen/qwen3-32b:free",
        "model_server": "https://openrouter.ai/api/v1",
        "api_key": OPEN_ROUTER_API_KEY,
    }

    # To connect to the Bright Data MCP server
    tools = [{
        "mcpServers": {
            "brightdata": {
                "command": "npx",
                "args": ["-y", "@brightdata/mcp"],
                "env": {
                    "API_TOKEN": BRIGHT_DATA_API_TOKEN,
                    "BROWSER_AUTH": BRIGHT_DATA_BROWSER_AUTH,
                }
            }
        }
    }]


    # Define the Qwen-Agent assistant with MCP integration
    agent = Assistant(
        llm=llm_cfg,
        function_list=tools,
        name="MCP-Powered Assistant with Access to Live Data",
        description="This agent can answer questions by retrieving up-to-date information from the Internet using configured MCP tools"
    )

    return agent

Comme vous pouvez le voir, dans le code ci-dessus :

• Le dictionnaire llm_cfg permet d’accéder à la version gratuite de Qwen3 via l’API OpenRouter.
• Le tableau des outils définit comment se connecter au serveur MCP de Bright Data, ce qui permet à l’agent AI d’appeler des outils de recherche de données externes.
• Enfin, la classe Assistant() fournie par Qwen-Agent est utilisée pour définir l’agent d’IA avec les intégrations LLM et outils.

C’est ici que ça se passe ! Grâce à Qwen-Agent, l’intégration de MCP dans votre agent IA ne nécessite que quelques lignes de code.

Étape 7 : Lancer l’agent MCP Qwen3

Ajoutez le code suivant à agent.py pour exécuter l’agent IA défini dans une interface Gradio :

if __name__ == "__main__":
    # Initialize the MCP-powered agent
    mcp_agent = initialize_mcp_agent()

    # Launch the Gradio-based web UI to interact with the AI agent in the browser
    WebUI(mcp_agent).run()

Mission accomplie ! Il ne reste plus qu’à tester le code et à voir ce dont l’agent IA est capable.

Étape n° 8 : Assembler le tout

C’est le code final de agent.py :

from dotenv import load_dotenv
import os
from qwen_agent.agents import Assistant
from qwen_agent.gui import WebUI

# Load the environment variables from the .env file
load_dotenv()

# Read the API key from OpenRouter to use Qwen3
OPEN_ROUTER_API_KEY = os.getenv("OPEN_ROUTER_API_KEY")

# Read the envs for integration with the Bright Data MCP server
BRIGHT_DATA_API_TOKEN = os.getenv("BRIGHT_DATA_API_TOKEN")
BRIGHT_DATA_BROWSER_AUTH = os.getenv("BRIGHT_DATA_BROWSER_AUTH")

# Define the agent with Qwen 3 and MCP configuration
def initialize_mcp_agent():
    # To connect to Qwen3 via OpenRouter
    llm_cfg = {
        "model": "qwen/qwen3-32b:free",
        "model_server": "https://openrouter.ai/api/v1",
        "api_key": OPEN_ROUTER_API_KEY,
    }

    # To connect to the Bright Data MCP server
    tools = [{
        "mcpServers": {
            "brightdata": {
                "command": "npx",
                "args": ["-y", "@brightdata/mcp"],
                "env": {
                    "API_TOKEN": BRIGHT_DATA_API_TOKEN,
                    "BROWSER_AUTH": BRIGHT_DATA_BROWSER_AUTH,
                }
            }
        }
    }]


    # Define the Qwen-Agent assistant with MCP integration
    agent = Assistant(
        llm=llm_cfg,
        function_list=tools,
        name="MCP-Powered Assistant with Access to Live Data",
        description="This agent can answer questions by retrieving up-to-date information from the Internet using configured MCP tools"
    )

    return agent

if __name__ == "__main__":
    # Initialize the MCP-powered agent
    mcp_agent = initialize_mcp_agent()

    # Launch the Gradio-based web UI to interact with the AI agent in the browser
    WebUI(mcp_agent).run()

Ouah ! Avec seulement une cinquantaine de lignes de code, vous pouvez créer un puissant agent d’intelligence artificielle alimenté par MCP, grâce à Qwen-Agent et OpenRouter.

Exécuter l’agent AI avec :

python agent.py

Dans le terminal, vous devriez voir une sortie comme suit :

2025-05-27 15:40:58,783 - mcp_manager.py - 122 - INFO - Initializing MCP tools from mcp servers: ['brightdata']
2025-05-27 15:40:58,800 - mcp_manager.py - 340 - INFO - Initializing a MCP stdio_client, if this takes forever, please check the config of this mcp server: brightdata
2025-05-27 15:41:01,098 - mcp_manager.py - 350 - INFO - No list resources: Method not found
* Running on local URL:  http://127.0.0.1:7860

Cela vous indique que le serveur MCP est opérationnel et que votre agent AI est connecté et accessible à l’adresse http://127.0.0.1:7860. Visitez cette URL dans votre navigateur pour interagir avec l’agent via l’interface web de Gradio.

Par exemple, essayez de lui poser une question comme celle-ci :

From the Amazon product page "https://www.amazon.com/PlayStation%C2%AE5-console-slim-PlayStation-5/dp/B0CL61F39H/", extract the main info and return it in JSON format

Il s’agit d’un excellent test pour vérifier si l’agent d’intelligence artificielle peut récupérer (et donc utiliser/apprendre) des données en temps réel à partir de la page du produit Amazon PS5 :

Lorsque vous lancez cette invite dans l’interface utilisateur, voici ce qui devrait se passer :

Tout d’abord, notez que le panneau de droite contient une liste de tous les outils disponibles sur le serveur MCP de Bright Data. Voyez également comment l’agent Qwen utilise l’outil web_data_amazon_product du serveur MCP de Bright Data pour répondre à la demande.

Vous pouvez le vérifier en consultant la liste des puces dans l’interface, qui montre le résultat de l’exécution de l’outil :

Au final, la sortie JSON doit ressembler à ceci :

{
  "title": "PlayStation®5 console (slim)",
  "url": "https://www.amazon.com/PlayStation%C2%AE5-console-slim-PlayStation-5/dp/B0CL61F39H",
  "brand": "Sony",
  "model_number": "CFI-2015",
  "price": {
    "currency": "USD",
    "final_price": 499
  },
  "availability": "In Stock",
  "rating": 4.7,
  "reviews_count": 6824,
  "description": "The PS5 console unleashes new gaming possibilities that you never anticipated. Experience lightning fast loading with an ultra-high speed SSD, deeper immersion with support for haptic feedback, adaptive triggers, and 3D Audio*, and an all-new generation of incredible PlayStation games...",
  "key_features": [
    "Custom CPU, GPU, and SSD with Integrated I/O",
    "Support for haptic feedback, adaptive triggers, and 3D Audio",
    "Backward compatibility with PS4 games",
    "1TB SSD and 10.6 lb console weight",
    "Includes DualSense Wireless Controller"
  ],
  "delivery_info": "FREE delivery Sunday, June 1. Or Prime members get FREE Same-Day delivery Today 10 AM - 3 PM.",
  "images": [
    "https://m.media-amazon.com/images/I/41ECK5cY-2L.SL1000.jpg",
    "https://m.media-amazon.com/images/I/41srF-iY93L.SL1000.jpg"
    // more image URLs...
  ],
  "product_details": {
    "ASIN": "B0CL61F39H",
    "Release Date": "December 10, 2023",
    "Dimensions": "14 x 17 x 7 inches",
    "Weight": "10.6 pounds",
    "Best Seller Rank": "#18 in Video Games",
    "Manufacturer": "Sony"
  },
  // omitted for brevity...
}

Ce simple exemple montre à quel point votre agent d’intelligence artificielle est puissant. Il peut extraire à la volée des données structurées en direct de n’importe quel site. C’est parfait pour la recherche en direct, la RAG(Retrieval-Augmented Generation) et la prise de décision actualisée.

Mieux encore, l’agent peut également utiliser l’Agent Browser (anciennement Scraping Browser) pour interagir directement avec les pages web, ce qui permet une automatisation de haut niveau et des flux de travail complexes.

Et voilà ! C’est la puissance de Qwen3 + l’intégration de MCP avec Qwen-Agent pour construire des agents d’IA de nouvelle génération.

Conclusion

Dans cet article de blog, vous avez appris à construire un puissant agent d’IA en Python en utilisant la bibliothèque Qwen-Agent en combinaison avec Qwen3 et Bright Data MCP.

Comme le montre l’exemple, l’intégration d’un serveur MCP riche en fonctionnalités avec Qwen-Agent permet à votre agent d’IA de récupérer des données en temps réel sur le Web et d’effectuer des tâches avancées de manière autonome. Ce n’est qu’un exemple de la façon dont les outils de Bright Data peuvent alimenter des flux de travail d’IA intelligents et automatisés.

Explorez les solutions de notre infrastructure d’IA :

• Agents d’intelligence artificielle autonomes: Recherchez, accédez et interagissez avec n’importe quel site web en temps réel à l’aide d’un puissant ensemble d’API.
• Apps d’IA verticales: créez des pipelines de données fiables et personnalisés pour extraire des données web à partir de sources spécifiques à votre secteur d’activité.
• Modèles de base: Accédez à des ensembles de données conformes à l’échelle du web pour faciliter le pré-entraînement, l’évaluation et la mise au point.
• IA multimodale: exploitez le plus grand référentiel d’images, de vidéos et d’audios au monde, optimisé pour l’IA.
• Fournisseurs de données: Connectez-vous avec des fournisseurs de confiance pour obtenir des ensembles de données de haute qualité, prêts pour l’IA, à grande échelle.
• Paquets de données: Obtenez des ensembles de données curatées, prêtes à l’emploi, structurées, enrichies et annotées.

Pour plus d’informations, consultez notre centre d’information sur l’IA.

Créez un compte Bright Data et essayez tous nos produits et services pour le développement d’agents d’IA !