Intégrer des agents IA à noyau sémantique avec Bright Data Web MCP

Dans ce tutoriel, vous verrez :

Ce qu’est le Semantic Kernel, les fonctionnalités de base qu’il offre et comment il fonctionne.
Pourquoi le fait de l’étendre avec MCP le rend encore plus puissant.
Comment construire un agent IA avec l’intégration de Bright Data Web MCP en utilisant Semantic Kernel.

Entrons dans le vif du sujet !

Qu’est-ce que Semantic Kernel ?

Semantic K ernel est un SDK open-source développé par Microsoft qui vous aide à intégrer des modèles d’IA et des LLM dans des applications pour construire des agents IA et des solutions GenAI avancées. Il agit comme un middleware prêt à la production, fournissant des connecteurs à de multiples services IA et permettant l’exécution de fonctions sémantiques (basées sur l’invite) et natives (basées sur le code).

Le SDK est disponible en C#, Python et Java. Il s’agit d’une solution flexible pour générer du texte, exécuter des compléments de chat ou se connecter à des sources de données et des services externes. À l’heure où nous écrivons ces lignes, le dépôt GitHub du projet compte plus de 26 000 étoiles.

Principales fonctionnalités

Les principales fonctionnalités offertes par Semantic Kernel sont les suivantes :

Intégration de modèles IA: Se connecte à des services comme OpenAI et Azure OpenAI avec une interface unifiée pour la complétion de chat, la génération de texte, et plus encore.
Système de plugins: Prend en charge les plugins avec des fonctions sémantiques (invites) et des fonctions natives (C#, Python ou Java) pour étendre les fonctionnalités de l’IA.
Agents IA: Permet de créer des agents qui interprètent les demandes des utilisateurs et coordonnent plusieurs plugins et services pour résoudre des tâches complexes.
Planification et appel de fonctions: Aide les agents à décomposer et à exécuter des tâches en plusieurs étapes en sélectionnant les plugins ou les fonctions appropriés.
Génération augmentée par récupération (RAG): Intègre des données réelles dans les invites à l’aide de connecteurs de recherche et de données pour des réponses plus précises et actualisées.

Fonctionnement du noyau sémantique

Pour comprendre le fonctionnement de la bibliothèque, il est utile de connaître ses principaux composants :

Lenoyau central: Orchestre les services d’IA et les plugins.
Connecteurs de services IA: Lient le code de l’application à différents modèles et services d’IA par le biais d’une interface commune.
Plugins: Ils contiennent des fonctions sémantiques et natives qui étendent les capacités de l’agent.
Agents IA: Construits au-dessus du noyau, ils utilisent des plugins pour traiter les demandes et exécuter les flux de travail.

Pourquoi étendre le noyau sémantique avec l’intégration MCP ?

Semantic Kernel est un SDK agnostique qui vous permet de construire, d’orchestrer et de déployer des agents IA complexes, des workflows et même des systèmes multi-agents. Quelle que soit la sophistication de votre architecture, ces workflows et agents ont toujours besoin d’un modèle d’IA sous-jacent pour fonctionner.

Qu’il s’agisse d’OpenAI, d’Azure OpenAI ou d’un autre LLM, tous les modèles partagent la même limitation fondamentale : leurs connaissances sont statiques…

Les LLM sont formés sur des données qui représentent un instantané dans le temps, ce qui signifie que leurs connaissances peuvent rapidement devenir obsolètes. Plus important encore, ils ne peuvent pas interagir de manière native avec des sites web en direct ou des sources de données externes.

C’est là que l’extensibilité de Semantic Kernel par le biais de plugins fait toute la différence. En l’intégrant au Web MCP de Bright Data, vous pouvez étendre vos agents IA au-delà des connaissances statiques, en leur permettant de récupérer des données fraîches et de haute qualité directement sur le web.

Le serveur Web MCP open-source donne accès à plus de 60 outils prêts pour l’IA, tous alimentés par l’infrastructure de Bright Data pour l’interaction web et la collecte de données.

Même avec le niveau gratuit, votre agent IA peut déjà utiliser deux outils puissants :

Outil	Description de l’outil
`moteur_de_recherche`	Récupère les résultats de recherche de Google, Bing ou Yandex en JSON ou Markdown.
`scrape_as_markdown`	Récupère n’importe quelle page web dans un format Markdown propre, en contournant la détection des robots et les CAPTCHA.

Au-delà de cela, Web MCP débloque des dizaines d’outils spécialisés pour la collecte de données structurées sur des plateformes telles qu’Amazon, LinkedIn, Yahoo Finance, TikTok, et plus encore. Pour en savoir plus, consultez la page officielle de GitHub.

En bref, la combinaison de Semantic Kernel et de Web MCP transforme les flux de travail statiques en agents IA dynamiques qui peuvent interagir avec des sites web en direct et accéder aux données web pour générer des perspectives ancrées dans le monde réel.

Comment créer un agent IA dans Semantic Kernel qui se connecte au Web MCP de Bright Data ?

Dans cette section guidée, vous apprendrez à connecter le MCP Web de Bright Data à un agent IA Semantic Kernel écrit en C#. En particulier, vous utiliserez cette intégration pour construire un agent IA d’analyse de Reddit qui :

Utilise les outils Web MCP de Bright Data pour récupérer les informations des messages Reddit.
Traite les données récupérées à l’aide d’un modèle OpenAI GPT-5.
vous renvoie les résultats dans un rapport Markdown.

Remarque: le code ci-dessous est écrit en C# à l’aide de .NET 9. Cependant, vous pouvez facilement le convertir en Python ou en Java, les deux autres langages de programmation pris en charge.

Suivez les étapes ci-dessous pour commencer !

Conditions préalables

Avant de commencer, assurez-vous d’avoir

.NET 8.0 ou supérieur installé localement (ce tutoriel se réfère à .NET 9)
Une clé API OpenAI
Un compte Bright Data avec une clé API prête à l’emploi.

Ne vous préoccupez pas de la configuration du compte Bright Data, car vous serez guidé à travers ce processus dans une étape ultérieure.

Étape 1 : Configurer votre projet .NET C#

Initialisez un nouveau projet de console .NET appelé SK_MCP_Agent avec :

dotnet new console -n SK_MCP_Agent

Ensuite, entrez dans le dossier du projet :

cd SK_MCP_Agent

Vous devriez maintenant voir la structure de fichier suivante :

SK_MCP_Agent/
├── Program.cs
├── SK_MCP_Agent.csproj
└── obj/
    ├── project.assets.json
    ├── project.nuget.cache
    ├── SK_MCP_Agent.csproj.nuget.dgspec.json
    ├── SK_MCP_Agent.csproj.nuget.g.props
    └── SK_MCP_Agent.csproj.nuget.g.targets

En détail, Program.cs contient actuellement un programme par défaut “Hello, World”. C’est dans ce fichier que vous placerez la logique de votre agent Semantic Kernel IA.

Ouvrez maintenant votre dossier de projet dans un IDE .NET C#, tel que Visual Studio ou Visual Studio Code. Dans le terminal de l’IDE, installez les dépendances requises à l’aide de ces commandes :

dotnet add package Microsoft.Extensions.Configuration
dotnet add package Microsoft.Extensions.Configuration.EnvironmentVariables
dotnet add package Microsoft.Extensions.Configuration.UserSecrets  
dotnet add package Microsoft.SemanticKernel --prerelease
dotnet ajoute le paquet Microsoft.SemanticKernel.Agents.Core --prerelease
dotnet add package ModelContextProtocol --prerelease
dotnet add package System.Linq.AsyncEnumerable --prerelease

Les paquets NuGet requis sont :

Microsoft.Extensions.Configuration.*: Fournit une configuration basée sur des valeurs clés pour lire les paramètres des variables d’environnement et des secrets d’utilisateur .NET.
Microsoft.SemanticKernel.*: Un SDK léger pour l’intégration des LLMs IA avec les langages de programmation conventionnels, avec des outils pour le développement d’agents.
ModelContextProtocol: Le client C# officiel du MCP, qui sera utilisé pour se connecter au MCP de Bright Data Web.
System.Linq.AsyncEnumerable: Expose un ensemble complet de méthodes d’extension LINQ pour IAsyncEnumerable<T>.

Remarque: l’option --prerelease de dotnet add package indique à l’interface CLI .NET d’installer les dernières versions (pre-release) d’un package NuGet. Cela est nécessaire pour certains paquets car ils sont encore en phase de développement ou d’expérimentation.

C’est fait ! Votre environnement de développement .NET est configuré pour construire un agent IA en C# à l’aide de Semantic Kernel, avec l’intégration MCP de Bright Data Web.

Étape 2 : Configuration du chargement des secrets

Votre agent IA s’appuiera sur des composants tiers tels que les modèles OpenAI et le serveur MCP de Bright Data Web. Ces deux intégrations nécessitent une authentification via des jetons de clés API. Pour éviter d’exposer ces clés directement dans votre code, stockez-les de manière sécurisée à l’aide du système de stockage des secrets d’utilisateur .NET ou des variables d’environnement.

Pour configurer cela, importez d’abord le paquetage de configuration :

using Microsoft.Extensions.Configuration ;

Ensuite, chargez les secrets dans un objet config avec :

var config = new ConfigurationBuilder()
    .AddUserSecrets<Program>()
    .AddEnvironmentVariables()
    .Build() ;

Vous pouvez maintenant accéder à vos secrets dans un code comme celui-ci :

config["<nom_du_secret>"]

Initialisez le stockage des secrets d’utilisateur en exécutant la commande suivante dans le dossier de votre projet :

dotnet user-secrets init

Cela créera un stockage local sûr pour vos secrets (c’est-à-dire les clés d’API).

Voilà qui est fait ! Votre programme C# peut désormais gérer en toute sécurité des informations d’identification sensibles sans les exposer dans votre code source.

Étape 3 : tester le MCP Web de Bright Data

Avant de vous connecter au MCP Web de Bright Data dans votre agent, vérifiez d’abord que votre machine peut exécuter le serveur MCP.

Si vous n’avez pas encore de compte Bright Data, créez-en un. Si c’est le cas, il vous suffit de vous connecter. Pour une installation rapide, accédez à la section “MCP” du tableau de bord et suivez les instructions :

The “MCP” section in your Bright Data account

Sinon, commencez par générer une clé API Bright Data. Conservez-la ensuite en lieu sûr, car vous en aurez bientôt besoin. Dans cette section, nous supposerons que la clé API dispose d’autorisations Admin, car cela simplifie le processus d’intégration de Web MCP.

Exécutez la commande suivante pour installer globalement le Web MCP dans votre système :

npm install -g @brightdata/mcp

Ensuite, vérifiez que le serveur MCP local fonctionne en exécutant :

$Env:API_TOKEN="<Votre_BRIGHT_DATA_API>" ; npx -y @brightdata/mcp

Ou, de manière équivalente, sous Linux/macOS :

API_TOKEN="<Votre_BRIGHT_DATA_API>" npx -y @brightdata/mcp

Remplacez <Votre_BRIGHT_DATA_API> par votre clé d’API Bright Data. La commande définit la variable d’environnement API_TOKEN requise et lance le Web MCP via le paquet @brightdata/mcp.

En cas de succès, vous devriez voir des journaux similaires à celui-ci :

Lors du premier lancement, le MCP Web crée automatiquement deux zones par défaut dans votre compte Bright Data :

mcp_unlocker: Une zone pour Web Unlocker.
mcp_browser: Une zone pour Browser API.
Le serveur MCP s’appuie sur ces deux zones pour alimenter les plus de 60 outils.

Pour confirmer la création des zones, connectez-vous à votre tableau de bord Bright Data. Allez à la page “Proxy & Scraping Infrastructure“, et vous devriez les voir dans le tableau des zones :

The mcp_unlocker and mcp_browser zones created by the Web MCP at startup

Si votre jeton API ne dispose pas des autorisations Admin, ces zones ne seront pas créées pour vous. Dans ce cas, vous devez les créer manuellement dans le tableau de bord et configurer leurs noms via des variables d’environnement(consultez la page GitHub pour plus de détails).

Important: Par défaut, le serveur MCP n’expose que les outils search_engine et scrape_as_markdown (et leurs versions batch). Ces outils sont inclus dans le niveau gratuit de Web MCP.

Pour débloquer les outils avancés, tels que l’automatisation du navigateur et les flux de données structurées, vous devez activer le mode Pro. Pour ce faire, définissez la variable d’environnement PRO_MODE="true" avant de lancer le MCP Web :

$Env:API_TOKEN="<Votre_BRIGHT_DATA_API>" ; $Env:PRO_MODE="true" ; npx -y @brightdata/mcp

Ou, sous Linux/macOS :

API_TOKEN="<Votre_BRIGHT_DATA_API>" PRO_MODE="true" npx -y @brightdata/mcp

Lemode Pro débloque les 60+ outils, mais il n’est pas inclus dans la version gratuite et entraînera des frais supplémentaires.

Vous venez de vérifier que le Web MCP est bien un outil de travail. Vous venez de vérifier que le serveur Web MCP fonctionne sur votre machine. Arrêtez le processus MCP, car vous êtes sur le point de configurer votre agent Semantic Kernel pour lancer le serveur et vous y connecter dans les étapes suivantes.

Étape 4 : Configurer l’intégration Web MCP

Maintenant que votre machine peut exécuter le MCP Web, commencez par ajouter la clé API de Bright Data que vous avez récupérée plus tôt aux secrets de l’utilisateur :

dotnet user-secrets set "BrightData:ApiKey" "<Votre_clé_API_BRIGHT_DATA>"

Remplacez le caractère générique <YOUR_BRIGHT_DATA_API_KEY> par votre clé d’API réelle. Cette commande stocke la clé de manière sécurisée dans le stockage des secrets de votre projet.

N’oubliez pas que vous pouvez obtenir le même résultat en définissant la clé d’API en tant que variable d’environnement :

$Env:BrightData__ApiKey="<YOUR_BRIGHT_DATA_API_KEY>"

Ou, sous macOS/Linux :

export BrightData__ApiKey="<Votre_BRIGHT_DATA_API_KEY>"

Remarque: Microsoft.Extensions.Configuration convertira BrightData__ApiKey en BrightData:ApiKey pour vous.

Ensuite, utilisez McpClientFactory du packageModelContextProtocol pour définir un client MCP et vous connecter au Web MCP :

await using var mcpClient = await McpClientFactory.CreateAsync(new StdioClientTransport(new()
{
    Name = "BrightDataWebMCP",
    Commande = "npx",
    Arguments = ["-y", "@brightdata/mcp"],
    EnvironmentVariables = new Dictionary<string, string?>
    {
        { "API_TOKEN", config["BrightData:ApiKey"] },
        // { "PRO_MODE", "true" }, // <-- Facultatif : activer le mode Pro
    }
})) ;

La configuration ci-dessus donne lieu à la même commande npx que dans les étapes d’installation précédentes, avec la variable d’environnement requise. Notez que PRO_MODE est facultatif, tandis que API_TOKEN est lu à partir du secret BrightData:ApiKey défini précédemment.

Ensuite, chargez la liste de tous les outils disponibles :

var tools = await mcpClient.ListToolsAsync().ConfigureAwait(false) ;

Le script exécutera la commande npx pour lancer le Web MCP en tant que processus local et s’y connecter, en accédant aux outils qu’il expose.

Vous pouvez vérifier que la connexion au MCP Web fonctionne et que vous avez accès à ses outils en les enregistrant tous :

foreach (var tool in tools)
{
    Console.WriteLine($"{tool.Name} : {tool.Description}") ;
}

Si vous exécutez votre script maintenant, vous devriez obtenir une sortie similaire à celle-ci :

Il s’agit des 2 outils par défaut (+ 2 versions batch) exposés par le Web MCP en mode gratuit. En mode Pro, vous auriez accès à l’ensemble des 60+ outils.

Merveilleux ! Le résultat ci-dessus confirme que l’intégration de Web MCP fonctionne parfaitement !

Etape #5 : Construire un Kernel avec accès aux outils MCP

Dans Semantic Kernel, un noyau agit comme un conteneur d’injection de dépendance qui gère tous les services et plugins nécessaires pour exécuter votre application IA. Une fois que vous avez fourni vos services et plugins au noyau, ceux-ci peuvent être utilisés par l’IA à chaque fois que cela est nécessaire.

Il est maintenant temps de créer un noyau pour l’intégration OpenAI avec un support pour l’appel d’outils via MCP. Commencez par ajouter votre clé API OpenAI aux secrets d’utilisateur :

dotnet user-secrets set "OpenAI:ApiKey" "<Votre_clé_OPENAI>"

Comme mentionné précédemment, vous pouvez également définir cette clé comme une variable d’environnement appelée OpenAI__ApiKey.

Ensuite, définissez un nouveau noyau qui se connecte à OpenAI :

var builder = Kernel.CreateBuilder() ;
builder.Services
    .AddOpenAIChatCompletion(
        modelId : "gpt-5-mini",
        apiKey : config["OpenAI:ApiKey"]
    ) ;
Kernel kernel = builder.Build() ;

Dans cet exemple, le noyau se connecte au modèle gpt-5-mini (mais vous pouvez configurer n’importe quel autre modèle OpenAI) en utilisant la clé API stockée dans vos secrets d’utilisateur.

Ensuite, ajoutez un plugin au noyau pour l’utilisation de l’outil :

kernel.Plugins.AddFromFunctions("BrightData", tools.Select(aiFunction => aiFunction.AsKernelFunction())) ;

Cette ligne de code convertit vos outils MCP en fonctions prêtes pour le noyau qui peuvent être appelées par le modèle IA spécifié.

Les importations requises pour cette section sont les suivantes

using Microsoft.SemanticKernel ;
using Microsoft.SemanticKernel.Connectors.OpenAI ;

C’est parfait ! Vous disposez maintenant d’un noyau entièrement configuré, qui constitue le cœur de votre application d’IA Semantic Kernel.

Étape 6 : Définir l’agent IA

Commencez par importer la classe Agents de SemanticKernel:

using Microsoft.SemanticKernel.Agents ;

Ensuite, utilisez le noyau pour initialiser un nouvel agent IA configuré pour appeler automatiquement des outils :

var executionSettings = new OpenAIPromptExecutionSettings()
{
    FunctionChoiceBehavior = FunctionChoiceBehavior.Auto() // Active l'appel automatique de fonctions pour le LLM
} ;

var agent = new ChatCompletionAgent()
{
    Name = "RedditAgent",
    Kernel = kernel,
    Arguments = new KernelArguments(executionSettings),
} ;

Essentiellement, l’agent créé ici peut exécuter les outils exposés par le MCP Web de Bright Data. Cela se produit chaque fois que le modèle IA détermine qu’un ou plusieurs outils sont nécessaires pour réaliser ce qui est décrit dans l’invite d’entrée.

Notez que l’agent a été nommé “RedditAgent” parce que ce tutoriel se concentre sur la construction d’un agent centré sur Reddit. Adaptez le nom à votre propre projet si vous créez un agent IA du Semantic Kernel dans un but différent.

Cool ! L’étape suivante consiste simplement à exécuter une invite à l’aide de l’agent.

Étape 7 : Exécuter une tâche dans l’agent

Pour tester les capacités de récupération de données Web de votre agent IA amélioré avec les outils fournis par le MCP Bright Data Web, vous avez besoin d’une invite appropriée. Par exemple, vous pouvez demander à l’agent IA d’extraire des informations d’un subreddit particulier, comme suit :

var prompt = @"
Récupérer les pages du subreddit suivant :
https://www.reddit.com/r/webscraping/

À partir du contenu récupéré, générez un rapport Markdown qui comprend :
- La description officielle du subreddit et des statistiques clés (type de communauté, date de création)
- Une liste d'URL pour les ~10 messages les plus récents
" ;

Il s’agit d’une tâche idéale pour tester les capacités de recherche sur le web. Les modèles OpenAI standard échouent lorsqu’on leur demande une telle requête parce qu’ils ne peuvent pas accéder de manière programmatique à la page Reddit pour récupérer des données en temps réel :

Note : Le résultat ci-dessus n’est pas fiable, car la majorité du contenu est soit faux, soit complètement fabriqué. Les modèles OpenAI ne peuvent pas récupérer de manière fiable des données fraîches sur le web sans outils externes tels que ceux fournis par Bright Data.

Grâce aux outils disponibles via le MCP Web, votre agent sera en mesure de récupérer les données Reddit requises et de présenter un résultat précis. Exécutez la tâche et imprimez le résultat dans le terminal avec :

ChatMessageContent response = await agent.InvokeAsync(prompt).FirstAsync() ;
Console.WriteLine($"NResponse:N{response.Content}") ;

Cela suffit pour tester une seule invite. Dans le monde réel, vous souhaitez généralement maintenir votre agent en activité et conscient du contexte en implémentant une boucle REPL avec une mémoire pour suivre les interactions précédentes.

Et voilà ! Votre agent IA expert de Reddit, construit avec Semantic Kernel et intégré à Bright Data Web MCP, est maintenant entièrement fonctionnel.

Étape n° 8 : Assembler le tout

Le code final dans Program.cs est le suivant :

using Microsoft.Extensions.Configuration ;
using ModelContextProtocol.Client ;
using Microsoft.SemanticKernel ;
using Microsoft.SemanticKernel.Connectors.OpenAI ;
using Microsoft.SemanticKernel.Agents ;

// Chargement des secrets d'utilisateur et des variables d'environnement pour les clés d'API
var config = new ConfigurationBuilder()
    .AddUserSecrets<Program>()
    .AddEnvironmentVariables()
    .Build() ;

// Création d'un client MCP pour le serveur MCP de Bright Data Web
await using var mcpClient = await McpClientFactory.CreateAsync(new StdioClientTransport(new()
{
    Name = "BrightDataWebMCP",
    Commande = "npx",
    Arguments = ["-y", "@brightdata/mcp"],
    EnvironmentVariables = new Dictionary<string, string?>
    {
        { "API_TOKEN", config["BrightData:ApiKey"] },
        // { "PRO_MODE", "true" }, // <-- Facultatif : activer le mode Pro
    }
})) ;

// Récupérer la liste des outils disponibles sur le serveur MCP de Bright Data Web
var tools = await mcpClient.ListToolsAsync().ConfigureAwait(false) ;

// Construire un noyau sémantique et enregistrer les outils MCP en tant que fonctions du noyau
var builder = Kernel.CreateBuilder() ;
builder.Services
    .AddOpenAIChatCompletion(
        modelId : "gpt-5-mini",
        apiKey : config["OpenAI:ApiKey"]
    ) ;
Kernel kernel = builder.Build() ;
// Créer un plugin à partir des outils MCP et l'ajouter à la collection de plugins du noyau
kernel.Plugins.AddFromFunctions("BrightData", tools.Select(aiFunction => aiFunction.AsKernelFunction())) ;

// Activer l'appel automatique de fonctions pour le LLM
var executionSettings = new OpenAIPromptExecutionSettings()
{
    FunctionChoiceBehavior = FunctionChoiceBehavior.Auto()
} ;

// Définir l'agent IA avec l'intégration MCP
var agent = new ChatCompletionAgent()
{
    Name = "RedditAgent",
    Kernel = kernel,
    Arguments = new KernelArguments(executionSettings), // Passer les paramètres pour les appels d'outils MCP
} ;

// Tester l'agent IA avec une invite de raclage de subreddit
var prompt = @"
Scraper les pages du subreddit suivant :
https://www.reddit.com/r/webscraping/

À partir du contenu scrapé, générez un rapport Markdown qui comprend :
- La description officielle du subreddit et des statistiques clés (type de communauté, date de création)
- Une liste d'URL pour les ~10 messages les plus récents
" ;

ChatMessageContent response = await agent.InvokeAsync(prompt).FirstAsync() ;
Console.WriteLine($"nResponse:n{response.Content}") ;

Ouah ! En seulement 65 lignes de C#, vous avez construit un agent IA Semantic Kernel avec l’intégration MCP de Bright Data Web.

Exécutez votre agent avec :

dotnet run

La sortie devrait ressembler à ceci :

Remarquez que l’agent a récupéré la page /about pour obtenir les informations sur le subreddit, puis les pages /new pour récupérer les messages les plus récents.

Toutes les données affichées dans le résultat sont correctes, comme vous pouvez le vérifier en visitant la page /about du subreddit :

The /about page of the r/webscraping subreddit

Les Données pour l’IA correspondent exactement à ce qui est affiché sur cette page. Il en va de même pour les messages les plus récents, que vous trouverez sur la page /new du subreddit.

La seule différence est l’ordre des messages, qui est déterminé par le frontend de Reddit et n’est pas pertinent ici.

Lescraping de Reddit est un défi car il est protégé par des systèmes anti-bots qui bloquent les requêtes automatisées. Grâce aux capacités de Scraping web avec contournement anti-bot fournies par le serveur Bright Data Web MCP, votre agent IA a accès à un ensemble puissant d’outils pour l’extraction, l’interaction et la recherche de données web.

Cet exemple illustre l’un des nombreux scénarios possibles. Grâce à la large gamme d’outils Bright Data disponibles via Semantic Kernel, vous pouvez créer des agents plus complexes qui s’adaptent à de nombreux autres cas d’utilisation.

Et voilà ! Vous venez d’expérimenter la puissance de l’intégration de Bright Data Web MCP au sein d’un agent IA de Semantic Kernel en C#.

Conclusion

Dans cet article de blog, vous avez vu comment connecter un agent IA construit avec Semantic Kernel au Web MCP de Bright Data(qui est désormais proposé avec un niveau gratuit !). Cette intégration donne à votre agent des capacités améliorées, y compris la recherche sur le Web, l’extraction de données et l’interaction en temps réel.

Pour créer des agents IA plus avancés, explorez la suite plus large de produits et de services de l’infrastructure IA de Bright Data. Ces outils sont conçus pour alimenter divers flux de travail d’IA et cas d’utilisation d’agents.

Créez un compte Bright Data gratuit dès aujourd’hui et commencez à expérimenter des solutions de données web prêtes pour l’IA !

Contacter Ventes Essai gratuit