Blog / AI
AI

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

Connectez Qwen-Agent au serveur MCP de Bright Data pour alimenter les agents d’intelligence artificielle avec la récupération de données Web en temps réel et l’automatisation.
19 min de lecture
Qwen-Agent with Bright Data's MCP

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 :

Outil Description
moteur_de_recherche Récupère les résultats de recherche de Google, Bing ou Yandex. Renvoie les résultats des SERP au format markdown (URL, titre, description).
scrape_as_markdown Scrape une seule page web et renvoie le contenu extrait au format Markdown. Fonctionne même sur des pages protégées par des robots ou des CAPTCHA.
scrape_as_html Idem que ci-dessus, mais renvoie le contenu en HTML brut.
session_stats Fournit un résumé de l’utilisation de l’outil pendant la session en cours.
web_data_amazon_product Récupère les données structurées des produits Amazon en utilisant une URL /dp/. Plus fiable que le scraping grâce à la mise en cache.
web_data_amazon_product_reviews Récupérer les données structurées des critiques Amazon en utilisant une URL /dp/. Mis en cache et fiable.
web_data_linkedin_person_profile Accédez aux données structurées de votre profil LinkedIn. Mise en cache pour plus de cohérence et de rapidité.
web_data_linkedin_company_profile Accédez aux données structurées de l’entreprise LinkedIn. La version en cache améliore la fiabilité.
web_data_zoominfo_profil_d'entreprise Récupère les données structurées de l’entreprise ZoomInfo. Requiert une URL ZoomInfo valide.
web_data_instagram_profiles Données structurées du profil Instagram. Nécessite une URL Instagram valide.
web_data_instagram_posts Récupérer des données structurées pour les posts Instagram.
web_data_instagram_reels Récupérer des données structurées pour les bobines Instagram.
web_data_instagram_comments Récupérer les commentaires Instagram sous forme de données structurées.
web_data_facebook_posts Accéder aux données structurées pour les posts Facebook.
web_data_facebook_marketplace_listings Récupérer les listes structurées de Facebook Marketplace.
web_data_facebook_company_reviews Récupérer les avis d’entreprises sur Facebook. Nécessite l’URL de l’entreprise et le nombre d’avis.
web_data_x_posts Récupérer des données structurées à partir des messages de X (anciennement Twitter).
web_data_zillow_properties_listing Accès aux données structurées de Zillow.
web_data_booking_hotel_listings Récupérer des listes d’hôtels structurées de Booking.com.
web_data_youtube_videos Données vidéo structurées de YouTube. Nécessite une URL vidéo valide.
scraping_browser_navigate Naviguez dans le navigateur de scraping jusqu’à une nouvelle URL.
scraping_browser_go_back Retourner à la page précédente.
scraping_browser_go_forward Naviguer vers l’avant dans l’historique du navigateur.
scraping_browser_click Cliquer sur un élément spécifique de la page. Nécessite un sélecteur d’éléments.
scraping_browser_links Récupère tous les liens de la page actuelle avec leurs sélecteurs et leur texte.
type_de_navigateur_de_grattage Simuler la saisie d’un texte dans un champ de saisie.
scraping_browser_wait_for Attendre qu’un élément spécifique devienne visible.
scraping_browser_screenshot Faites une capture d’écran de la page en cours.
scraping_browser_get_html Récupère le code HTML complet de la page en cours. À utiliser avec précaution si le contenu de la page n’est pas nécessaire.
scraping_browser_get_text Récupère le contenu textuel visible de la page en cours.

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 :

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 :

La structure des fichiers du projet d'agent MCP Qwen-Agent

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 :

Le fichier .env dans le dossier de l'agent imbriqué

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” :

La page "API Keys" dans la plateforme OpenRouter

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 :

Page Amazon PS5

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

Exécution de la demande d'extraction de données Amazon dans Qwen-Agent

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 :

Voir le résultat de l'outil web_data_amazon_product

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 !

Aucune carte de crédit requise