Integração de agentes de IA de núcleo semântico com o MCP da Web de dados brilhantes

Neste tutorial, você verá:

O que é o Semantic Kernel, os principais recursos que ele oferece e como ele funciona.
Por que ampliá-lo com o MCP o torna ainda mais avançado.
Como criar um agente de IA com a integração do Bright Data Web MCP usando o Semantic Kernel.

Vamos nos aprofundar!

O que é o Semantic Kernel?

O Semantic Kernel é um SDK de código aberto desenvolvido pela Microsoft que ajuda você a integrar modelos de IA e LLMs em aplicativos para criar agentes de IA e soluções avançadas de GenAI. Ele atua como um middleware pronto para a produção, fornecendo conectores para vários serviços de IA e permitindo a execução de funções semânticas (baseadas em prompts) e nativas (baseadas em código).

O SDK está disponível em C#, Python e Java. É uma solução flexível para gerar texto, executar conclusões de bate-papo ou conectar-se a fontes e serviços de dados externos. No momento em que este texto foi escrito, o repositório do projeto no GitHub tinha mais de 26 mil estrelas.

Principais recursos

Os principais recursos oferecidos pelo Semantic Kernel são:

Integração de modelos de IA: Conecta-se a serviços como OpenAI e Azure OpenAI com uma interface unificada para preenchimento de bate-papo, geração de texto e muito mais.
Sistema de plugins: Oferece suporte a plug-ins com funções semânticas (prompts) e funções nativas (C#, Python ou Java) para ampliar a funcionalidade de IA.
Agentes de IA: Permite criar agentes que interpretam as solicitações do usuário e coordenam vários plug-ins e serviços para resolver tarefas complexas.
Planejamento e chamada de função: Ajuda os agentes a dividir e executar tarefas de várias etapas, selecionando os plug-ins ou as funções certas.
Geração aumentada por recuperação (RAG): Integra dados reais em prompts usando conectores de pesquisa e dados para obter respostas mais precisas e atualizadas.

Como o Semantic Kernel funciona

Para entender como a biblioteca funciona, é útil conhecer seus principais componentes:

Núcleo principal: Orquestra os serviços e plug-ins de IA.
Conectores de serviços de IA: Vinculam o código do aplicativo a diferentes modelos e serviços de IA por meio de uma interface comum.
Plug-ins: contêm funções semânticas e nativas que ampliam os recursos do agente.
Agentes de IA: Criados sobre o kernel, usando plug-ins para processar solicitações e executar fluxos de trabalho.

Por que estender o Semantic Kernel com a integração do MCP

O Semantic Kernel é um SDK independente de modelo que permite criar, orquestrar e implementar agentes de IA complexos, fluxos de trabalho e até mesmo sistemas multiagentes. Independentemente da sofisticação de sua arquitetura, esses fluxos de trabalho e agentes ainda precisam de um modelo de IA subjacente para funcionar.

Seja o OpenAI, o Azure OpenAI ou outro LLM, todos os modelos compartilham a mesma limitação fundamental: seu conhecimento é estático…

Os LLMs são treinados em dados que representam um instantâneo no tempo, o que significa que seu conhecimento pode ficar desatualizado rapidamente. Mais importante ainda, eles não podem interagir nativamente com sites ativos ou fontes de dados externas.

É nesse ponto que a extensibilidade do Semantic Kernel por meio de plug-ins faz toda a diferença. Ao integrá-lo ao Web MCP da Bright Data, você pode estender seus agentes de IA para além do conhecimento estático, permitindo que eles recuperem dados novos e de alta qualidade diretamente da Web.

O servidor Web MCP de código aberto fornece acesso a mais de 60 ferramentas prontas para IA, todas alimentadas pela infraestrutura da Bright Data para interação com a Web e coleta de dados.

Mesmo na camada gratuita, seu agente de IA já pode usar duas ferramentas poderosas:

Ferramenta	Descrição da ferramenta
`search_engine`	Recuperar resultados de pesquisa do Google, Bing ou Yandex em JSON ou Markdown.
`scrape_as_markdown`	Extraia qualquer página da Web em um formato Markdown limpo, ignorando a detecção de bots e o CAPTCHA.

Além disso, o Web MCP desbloqueia dezenas de ferramentas especializadas para coleta de dados estruturados em plataformas como Amazon, LinkedIn, Yahoo Finance, TikTok e muito mais. Saiba mais na página oficial do GitHub.

Em resumo, a combinação do Semantic Kernel com o Web MCP transforma fluxos de trabalho estáticos em agentes de IA dinâmicos que podem interagir com sites ativos e acessar dados da Web para gerar insights baseados no mundo real.

Como criar um agente de IA no Semantic Kernel que se conecta ao Web MCP da Bright Data

Nesta seção guiada, você aprenderá como conectar o Web MCP da Bright Data a um agente de IA do Semantic Kernel escrito em C#. Em particular, você usará essa integração para criar um agente de IA analisador do Reddit que:

Utiliza as ferramentas do Web MCP da Bright Data para recuperar informações das postagens do Reddit.
Processa os dados recuperados usando um modelo OpenAI GPT-5.
Retorna os resultados para você em um relatório Markdown.

Observação: o código abaixo foi escrito em C# usando o .NET 9. No entanto, você pode convertê-lo facilmente em Python ou Java, as outras duas linguagens de programação compatíveis.

Siga as etapas abaixo para começar!

Pré-requisitos

Antes de começar, certifique-se de que você tenha:

O .NET 8.0 ou superior instalado localmente (este tutorial fará referência ao .NET 9)
Uma chave de API da OpenAI
Uma conta da Bright Data com uma chave de API pronta

Não se preocupe com a configuração da conta da Bright Data, pois você será orientado sobre esse processo em uma etapa posterior.

Etapa 1: Configurar seu projeto .NET C#

Inicialize um novo projeto de console .NET chamado SK_MCP_Agent com:

dotnet new console -n SK_MCP_Agent

Em seguida, entre na pasta do projeto:

cd SK_MCP_Agent

Agora você deve ver a seguinte estrutura de arquivos:

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

Em detalhes, Program.cs contém atualmente um programa padrão “Hello, World”. Esse arquivo é onde você colocará a lógica do agente de IA do Semantic Kernel.

Agora, abra a pasta do projeto em um IDE .NET C#, como o Visual Studio ou o Visual Studio Code. No terminal do IDE, instale as dependências necessárias com estes comandos:

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

Os pacotes NuGet necessários são:

Microsoft.Extensions.Configuration.*: fornece configuração baseada em valores-chave para ler configurações de variáveis de ambiente e segredos de usuário do .NET.
Microsoft.SemanticKernel.*: um SDK leve para integrar IA LLMs com linguagens de programação convencionais, com ferramentas para desenvolvimento de agentes.
ModelContextProtocol: O cliente C# oficial do MCP, que será usado para se conectar ao Bright Data Web MCP.
System.Linq.AsyncEnumerable: Expõe um conjunto completo de métodos de extensão LINQ para IAsyncEnumerable<T>.

Observação: O sinalizador --prerelease no pacote dotnet add informa à CLI do .NET para instalar as versões mais recentes (pré-lançamento) de um pacote NuGet. Isso é necessário para alguns pacotes porque eles ainda estão em desenvolvimento ou em estágios experimentais.

Pronto! Seu ambiente de desenvolvimento .NET está configurado para criar um agente de IA em C# usando o Semantic Kernel, com a integração do Bright Data Web MCP.

Etapa 2: Configurar o carregamento de segredos

Seu agente de IA dependerá de componentes de terceiros, como os modelos OpenAI e o servidor MCP da Web da Bright Data. Ambas as integrações exigem autenticação por meio de tokens de chave API. Para evitar a exposição dessas chaves diretamente no seu código, armazene-as com segurança usando o sistema de armazenamento de segredos de usuário do .NET ou variáveis de ambiente.

Para configurar isso, primeiro importe o pacote de configuração:

using Microsoft.Extensions.Configuration;

Em seguida, carregue os segredos em um objeto de configuração com:

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

Agora você pode acessar seus segredos em um código como este:

config["<secret_name>"]

Inicialize o armazenamento de segredos do usuário executando o seguinte comando na pasta do seu projeto:

dotnet user-secrets init

Isso criará um armazenamento local seguro para seus segredos (ou seja, as chaves da API).

Muito bem! Seu programa C# agora pode lidar com segurança com credenciais confidenciais sem expô-las em seu código-fonte.

Etapa #3: Teste o Web MCP da Bright Data

Antes de se conectar ao Web MCP da Bright Data em seu agente, verifique primeiro se sua máquina pode executar o servidor MCP.

Se você ainda não tiver uma conta da Bright Data, crie uma nova. Se já tiver, basta fazer o login. Para uma configuração rápida, navegue até a seção “MCP” no painel e siga as instruções:

The “MCP” section in your Bright Data account

Caso contrário, comece gerando uma chave de API da Bright Data. Em seguida, guarde-a em um local seguro, pois você precisará dela em breve. Nesta seção, assumiremos que a chave da API tem permissões de administrador porque isso simplifica o processo de integração do Web MCP.

Execute o seguinte comando para instalar o Web MCP globalmente em seu sistema:

npm install -g @brightdata/mcp

Em seguida, verifique se o servidor MCP local funciona executando:

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

Ou, de forma equivalente, no Linux/macOS:

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

Substitua <YOUR_BRIGHT_DATA_API> pelo seu token real da API da Bright Data. O comando define a variável de ambiente API_TOKEN necessária e inicia o Web MCP por meio do pacote @brightdata/mcp.

Se for bem-sucedido, você verá registros semelhantes a este:

Na primeira inicialização, o Web MCP cria automaticamente duas zonas padrão em sua conta da Bright Data:

mcp_unlocker: Uma zona para o Web Unlocker.
mcp_browser: Uma zona para a API do navegador.
O servidor MCP depende dessas duas zonas para alimentar todas as mais de 60 ferramentas.

Para confirmar que as zonas foram criadas, faça login no painel de controle da Bright Data. Vá para a página “Proxies & Scraping Infrastructure” e você deverá vê-las na tabela de zonas:

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

Se o seu token de API não tiver permissões de administrador, essas zonas não serão criadas para você. Nesse caso, você deverá criá-las manualmente no painel e configurar seus nomes por meio de variáveis de ambiente(consulte a página do GitHub para obter detalhes).

Importante: por padrão, o servidor MCP expõe apenas as ferramentas search_engine e scrape_as_markdown (e suas versões em lote). Essas ferramentas estão incluídas na camada gratuita do Web MCP.

Para desbloquear ferramentas avançadas, como automação do navegador e feeds de dados estruturados, você precisa ativar o modo Pro. Para isso, defina a variável de ambiente PRO_MODE="true" antes de iniciar o Web MCP:

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

Ou, no Linux/macOS:

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

O modo Pro desbloqueia todas as mais de 60 ferramentas, mas não está incluído no nível gratuito e incorrerá em cobranças adicionais.

Sucesso! Você acabou de verificar que o servidor Web MCP é executado em seu computador. Encerre o processo do MCP, pois você está prestes a configurar o agente do Semantic Kernel para iniciar o servidor e se conectar a ele nas próximas etapas.

Etapa 4: configurar a integração do Web MCP

Agora que sua máquina pode executar o Web MCP, comece adicionando a chave da API da Bright Data recuperada anteriormente aos segredos do usuário:

dotnet user-secrets set "BrightData:ApiKey" "<YOUR_BRIGHT_DATA_API_KEY>"

Substitua o espaço reservado <YOUR_BRIGHT_DATA_API_KEY> por sua chave de API real. Esse comando armazena com segurança a chave no armazenamento de segredos de seu projeto.

Lembre-se de que você pode obter o mesmo resultado definindo a chave da API como uma variável de ambiente:

$Env:BrightData__ApiKey="<YOUR_BRIGHT_DATA_API_KEY>"

Ou, no macOS/Linux:

export BrightData__ApiKey="<YOUR_BRIGHT_DATA_API_KEY>"

Observação: Microsoft.Extensions.Configuration converterá BrightData__ApiKey em BrightData:ApiKey para você.

Em seguida, use o McpClientFactory do pacoteModelContextProtocol para definir um cliente MCP e conectar-se ao Web MCP:

await using var mcpClient = await McpClientFactory.CreateAsync(new StdioClientTransport(new()
{
    Nome = "BrightDataWebMCP",
    Command = "npx",
    Argumentos = ["-y", "@brightdata/mcp"],
    EnvironmentVariables = new Dictionary<string, string?>
    {
        { "API_TOKEN", config["BrightData:ApiKey"] },
        // { "PRO_MODE", "true" }, // <-- Opcional: ativar o Modo Pro
    }
}));

A configuração acima resulta no mesmo comando npx visto nas etapas de configuração anteriores, com a variável de ambiente necessária. Observe que PRO_MODE é opcional, enquanto API_TOKEN é lido a partir do segredo BrightData:ApiKey definido anteriormente.

Em seguida, carregue a lista de todas as ferramentas disponíveis:

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

O script executará o comando npx para iniciar o Web MCP como um processo local e se conectar a ele, acessando as ferramentas que ele expõe.

É possível verificar se a conexão com o Web MCP funciona e se você tem acesso às suas ferramentas registrando todas elas:

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

Se você executar o script agora, deverá ver uma saída semelhante a esta:

Essas são as duas ferramentas padrão (+ duas versões em lote) expostas pelo Web MCP na camada gratuita. No modo Pro, você teria acesso a todas as mais de 60 ferramentas.

Maravilhoso! A saída acima confirma que a integração do Web MCP está funcionando perfeitamente!

Etapa 5: criar um kernel com acesso às ferramentas do MCP

No Semantic Kernel, um kernel atua como um contêiner de injeção de dependência que gerencia todos os serviços e plug-ins necessários para executar seu aplicativo IA. Depois de fornecer seus serviços e plug-ins ao kernel, eles podem ser usados pela IA sempre que necessário.

Agora, é hora de criar um kernel para a integração do OpenAI com suporte para chamadas de ferramentas via MCP. Comece adicionando sua chave da API do OpenAI aos segredos do usuário:

dotnet user-secrets set "OpenAI:ApiKey" "<YOUR_OPENAI_KEY>"

Conforme mencionado anteriormente, você também pode definir isso como uma variável de ambiente chamada OpenAI__ApiKey.

Em seguida, defina um novo kernel que se conecte ao OpenAI:

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

Neste exemplo, o kernel se conecta ao modelo gpt-5-mini (mas você pode configurar qualquer outro modelo do OpenAI) usando a chave da API armazenada nos segredos do usuário.

Em seguida, adicione um plug-in ao kernel para uso da ferramenta:

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

Essa linha de código converte suas ferramentas MCP em funções prontas para o kernel que podem ser chamadas pelo modelo de IA especificado.

As importações necessárias para esta seção são:

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

Perfeito! Agora você tem um kernel totalmente configurado, que é o núcleo do seu aplicativo de IA do Semantic Kernel.

Etapa 6: definir o agente de IA

Comece importando a classe Agents do SemanticKernel:

using Microsoft.SemanticKernel.Agents;

Em seguida, use o kernel para inicializar um novo agente de IA que esteja configurado para chamar ferramentas automaticamente:

var executionSettings = new OpenAIPromptExecutionSettings()
{
    FunctionChoiceBehavior = FunctionChoiceBehavior.Auto() // Habilita a chamada automática de funções para o LLM
};

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

Essencialmente, o agente criado aqui pode executar as ferramentas expostas pelo Bright Data Web MCP. Isso ocorre sempre que o modelo de IA determina que uma ou mais ferramentas são necessárias para alcançar o que está descrito no prompt de entrada.

Observe que o agente foi nomeado “RedditAgent” porque este tutorial se concentra na criação de um agente voltado para o Reddit. Adapte o nome para se adequar ao seu próprio projeto se estiver criando um agente de IA do Semantic Kernel para uma finalidade diferente.

Legal! A próxima etapa é simplesmente executar um prompt usando o agente.

Etapa nº 7: executar uma tarefa no agente

Para testar os recursos de recuperação de dados da Web do seu agente de IA aprimorado com as ferramentas fornecidas pelo Bright Data Web MCP, você precisa de um prompt adequado. Por exemplo, você pode pedir ao agente de IA para recuperar informações de um subreddit específico, como segue:

var prompt = @"
Extraia páginas do seguinte subreddit:
https://www.reddit.com/r/webscraping/

A partir do conteúdo extraído, gere um relatório Markdown que inclua:
- A descrição oficial do subreddit e as principais estatísticas (tipo de comunidade, data de criação)
- Uma lista de URLs para as cerca de 10 publicações mais recentes
";

Essa é uma tarefa ideal para testar os recursos de recuperação da Web. Os modelos padrão da OpenAI falham quando recebem esse tipo de solicitação porque não podem acessar programaticamente a página do Reddit para recuperar dados em tempo real:

Observação: o resultado acima não é confiável, pois a maior parte do conteúdo é falsa ou completamente fabricada. Os modelos da OpenAI não podem obter de forma confiável dados novos da Web sem ferramentas externas como as fornecidas pela Bright Data.

Graças às ferramentas disponíveis no Web MCP, seu agente poderá recuperar os dados do Reddit necessários e apresentar um resultado preciso. Execute a tarefa e imprima o resultado no terminal com:

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

Isso é suficiente para testar um único prompt. Em cenários do mundo real, você geralmente deseja manter o agente em execução e ciente do contexto implementando um loop REPL com memória para rastrear interações anteriores.

E aí está! Seu agente de IA especialista em Reddit, criado com o Semantic Kernel e integrado ao Bright Data Web MCP, agora está totalmente funcional.

Etapa #8: Juntar tudo

O código final em Program.cs é:

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

// Carregar segredos de usuário e variáveis de ambiente para chaves da API
var config = new ConfigurationBuilder()
    .AddUserSecrets<Program>()
    .AddEnvironmentVariables()
    .Build();

// Criar um cliente MCP para o servidor Bright Data Web MCP
await using var mcpClient = await McpClientFactory.CreateAsync(new StdioClientTransport(new()
{
    Nome = "BrightDataWebMCP",
    Command = "npx",
    Argumentos = ["-y", "@brightdata/mcp"],
    EnvironmentVariables = new Dictionary<string, string?>
    {
        { "API_TOKEN", config["BrightData:ApiKey"] },
        // { "PRO_MODE", "true" }, // <-- Opcional: ativar o Modo Pro
    }
}));

// Recuperar a lista de ferramentas disponíveis no servidor Bright Data Web MCP
var tools = await mcpClient.ListToolsAsync().ConfigureAwait(false);

// Crie um Semantic Kernel e registre as ferramentas MCP como funções do kernel
var builder = Kernel.CreateBuilder();
builder.Services
    .AddOpenAIChatCompletion(
        modelId: "gpt-5-mini",
        apiKey: config["OpenAI:ApiKey"]
    );
Kernel kernel = builder.Build();
// Criar um plug-in das ferramentas MCP e adicioná-lo à coleção de plug-ins do kernel
kernel.Plugins.AddFromFunctions("BrightData", tools.Select(aiFunction => aiFunction.AsKernelFunction()));

// Habilitar a chamada automática de função para o LLM
var executionSettings = new OpenAIPromptExecutionSettings()
{
    FunctionChoiceBehavior = FunctionChoiceBehavior.Auto()
};

// Definir o agente de IA com integração MCP
var agent = new ChatCompletionAgent()
{
    Nome = "RedditAgent",
    Kernel = kernel,
    Arguments = new KernelArguments(executionSettings), // Passar configurações para chamadas de ferramentas MCP
};

// Testar o agente IA com um prompt de raspagem de subreddit
var prompt = @"
Extraia páginas do seguinte subreddit:
https://www.reddit.com/r/webscraping/

A partir do conteúdo extraído, gere um relatório Markdown que inclua:
- A descrição oficial do subreddit e as principais estatísticas (tipo de comunidade, data de criação)
- Uma lista de URLs para as cerca de 10 publicações mais recentes
";

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

Uau! Em apenas cerca de 65 linhas de C#, você criou um agente de IA do Semantic Kernel com a integração do Bright Data Web MCP.

Execute seu agente com:

dotnet run

O resultado deve ser semelhante a este:

Observe como o agente extraiu a página /about para obter as informações do subreddit e, em seguida, as páginas /new para obter as publicações mais recentes.

Todos os dados mostrados na saída estão corretos, como você pode verificar visitando a página /about do subreddit:

The /about page of the r/webscraping subreddit

Os dados na saída do agente de IA correspondem exatamente ao que é mostrado nessa página. O mesmo se aplica às publicações mais recentes, que você pode encontrar na página /new do subreddit.

A única diferença é a ordem das postagens, que é determinada pelo frontend do Reddit e não é relevante aqui.

Raspar o Reddit é um desafio porque ele é protegido por sistemas anti-bot que bloqueiam solicitações automatizadas. Graças aos recursos de scraping de dados da Web com desvio anti-bot fornecido pelo servidor Bright Data Web MCP, seu agente de IA tem acesso a um conjunto poderoso de ferramentas para recuperação, interação e pesquisa de dados da Web.

Este exemplo demonstra apenas um dos muitos cenários possíveis. Com a ampla gama de ferramentas da Bright Data disponíveis por meio do Semantic Kernel, você pode criar agentes mais complexos que se adaptam a muitos outros casos de uso.

E pronto! Você acabou de experimentar o poder da integração do Bright Data Web MCP em um agente de IA do Semantic Kernel em C#.

Conclusão

Nesta postagem do blog, você viu como conectar um agente de IA criado com o Semantic Kernel ao Web MCP da Bright Data(que agora vem com um nível gratuito!). Essa integração oferece ao seu agente recursos aprimorados, incluindo pesquisa na Web, extração de dados e interação em tempo real.

Para criar agentes de IA mais avançados, explore o conjunto mais amplo de produtos e serviços na infraestrutura de IA da Bright Data. Essas ferramentas foram projetadas para potencializar diversos fluxos de trabalho de IA e casos de uso de agentes.

Inscreva-se hoje mesmo em uma conta gratuita da Bright Data e comece a experimentar as soluções de dados da Web prontas para IA!

Contate-nos Teste grátis