Integrar agentes de IA de núcleo semántico con Bright Data Web MCP.

En este tutorial, verá

Qué es el Semantic Kernel, las características principales que ofrece y cómo funciona.
Por qué ampliarlo con MCP lo hace aún más potente.
Cómo construir un agente de IA con integración Bright Data Web MCP usando Semantic Kernel.

Entremos en materia.

¿Qué es Semantic Kernel?

Semantic Kernel es un SDK de código abierto desarrollado por Microsoft que le ayuda a integrar modelos de IA y LLM en aplicaciones para crear agentes de IA y soluciones GenAI avanzadas. Actúa como middleware listo para la producción, proporcionando conectores a múltiples servicios de IA y permitiendo la ejecución de funciones semánticas (basadas en instrucciones) y nativas (basadas en código).

El SDK está disponible en C#, Python y Java. Es una solución flexible para generar texto, completar chats o conectarse a fuentes de datos y servicios externos. En el momento de escribir estas líneas, el repositorio GitHub del proyecto cuenta con más de 26k estrellas.

Principales funciones

Las principales características que ofrece Semantic Kernel son:

Integración de modelos de IA: Se conecta a servicios como OpenAI y Azure OpenAI con una interfaz unificada para la finalización de chat, generación de texto y más.
Sistema de plugins: Admite plugins con funciones semánticas (prompts) y funciones nativas (C#, Python o Java) para ampliar la funcionalidad de IA.
Agentes de IA: Permite crear agentes que interpretan las peticiones de los usuarios y coordinan varios plugins y servicios para resolver tareas complejas.
Planificación y llamada a funciones: Ayuda a los agentes a desglosar y ejecutar tareas de varios pasos seleccionando los plugins o funciones adecuados.
Generación aumentada por recuperación (RAG): Integra datos reales en las peticiones mediante conectores de búsqueda y datos para obtener respuestas más precisas y actualizadas.

Cómo funciona Semantic Kernel

Para entender cómo funciona la biblioteca, es útil conocer sus componentes principales:

Núcleo central: Orquesta los servicios y plugins de IA.
Conectores de servicios de IA: Vinculan el código de la aplicación a diferentes modelos y servicios de IA a través de una interfaz común.
Plugins: Contienen funciones semánticas y nativas que amplían las capacidades del agente.
Agentes deIA: Construidos sobre el kernel, utilizando plugins para procesar peticiones y ejecutar flujos de trabajo.

Por qué ampliar Semantic Kernel con integración MCP

Semantic Kernel es un SDK agnóstico al modelo que le permite construir, orquestar y desplegar agentes de IA complejos, flujos de trabajo e incluso sistemas multiagente. Independientemente de lo sofisticada que sea su arquitectura, estos flujos de trabajo y agentes siguen necesitando un modelo de IA subyacente para funcionar.

Ya sea OpenAI, Azure OpenAI u otro LLM, todos los modelos comparten la misma limitación fundamental: su conocimiento es estático…

Los LLM se entrenan con datos que representan una instantánea en el tiempo, lo que significa que sus conocimientos pueden quedar obsoletos rápidamente. Y lo que es más importante, no pueden interactuar de forma nativa con sitios web activos o fuentes de datos externas.

Aquí es donde la extensibilidad de Semantic Kernel mediante plugins marca la diferencia. Al integrarlo con el Web MCP de Bright Data, puede ampliar sus agentes de IA más allá del conocimiento estático, permitiéndoles recuperar datos frescos y de alta calidad directamente de la web.

El servidor Web MCP de código abierto proporciona acceso a más de 60 herramientas preparadas para IA, todas ellas impulsadas por la infraestructura de Bright Data para la interacción web y la recopilación de datos.

Incluso en el nivel gratuito, su agente de IA ya puede utilizar dos potentes herramientas:

Herramienta	Descripción
`motor_de_busqueda`	Recupere resultados de búsqueda de Google, Bing o Yandex en JSON o Markdown.
`scrape_as_markdown`	Raspe cualquier página web en formato Markdown limpio, evitando la detección de bots y CAPTCHA.

Además, Web MCP desbloquea docenas de herramientas especializadas para la recopilación de datos estructurados en plataformas como Amazon, LinkedIn, Yahoo Finance, TikTok, etc. Más información en la página oficial de GitHub.

En resumen, la combinación de Semantic Kernel con Web MCP transforma los flujos de trabajo estáticos en agentes de IA dinámicos que pueden interactuar con sitios web activos y acceder a datos web para generar perspectivas basadas en el mundo real.

Cómo crear un agente de IA en Semantic Kernel que se conecte a Web MCP de Bright Data

En esta sección guiada, aprenderá a conectar el MCP web de Bright Data a un agente de IA de Semantic Kernel escrito en C#. En particular, utilizará esta integración para construir un agente de IA analizador de Reddit que:

Utiliza las herramientas Web MCP de Bright Data para recuperar información de las publicaciones de Reddit.
Procese los datos recuperados utilizando un modelo OpenAI GPT-5.
Le devuelve los resultados en un informe Markdown.

Nota: El código que aparece a continuación está escrito en C# utilizando .NET 9. Sin embargo, puedes convertirlo fácilmente a Python o Java, los otros dos lenguajes de programación soportados.

Siga los pasos que se indican a continuación para empezar.

Requisitos previos

Antes de empezar, asegúrate de que tienes

.NET 8.0 o superior instalado localmente (este tutorial se referirá a .NET 9)
Una clave API de OpenAI
Una cuenta de Bright Data con una clave API preparada

No se preocupe por configurar la cuenta de Bright Data, ya que se le guiará a través de ese proceso en un paso posterior.

Paso #1: Configure su proyecto .NET C#

Inicialice un nuevo proyecto de consola .NET llamado SK_MCP_Agent con:

dotnet new console -n SK_MCP_Agent

A continuación, entre en la carpeta del proyecto

cd SK_MCP_Agent

Ahora debería ver la siguiente estructura de archivos

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 detalle, Program.cs contiene actualmente un programa “Hola, mundo” por defecto. Este archivo es donde colocarás la lógica de tu agente de IA del Semantic Kernel.

Ahora, abra la carpeta de su proyecto en un IDE .NET C#, como Visual Studio o Visual Studio Code. En el terminal del IDE, instale las dependencias necesarias con estos comandos:

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

Los paquetes NuGet necesarios son:

Microsoft.Extensions.Configuration.*: Proporciona configuración basada en valores clave para leer ajustes de variables de entorno y secretos de usuario .NET.
Microsoft.SemanticKernel.*: Un SDK ligero para integrar LLMs de IA con lenguajes de programación convencionales, con herramientas para el desarrollo de agentes.
ModelContextProtocol: El cliente C# oficial de MCP, que se utilizará para conectarse a Bright Data Web MCP.
System.Linq.AsyncEnumerable: Expone un conjunto completo de métodos de extensión LINQ para IAsyncEnumerable<T>.

Nota: El indicador --prerelease en dotnet add package indica a .NET CLI que instale las versiones más recientes (pre-release) de un paquete NuGet. Esto es necesario para algunos paquetes porque todavía están en desarrollo o en fase experimental.

Listo. Su entorno de desarrollo .NET está configurado para crear un agente de IA en C# utilizando Semantic Kernel, con integración Bright Data Web MCP.

Paso 2: Configurar la carga secreta

Su agente de IA dependerá de componentes de terceros como los modelos OpenAI y el servidor MCP de Bright Data Web. Ambas integraciones requieren autenticación mediante tokens de clave API. Para evitar exponer estas claves directamente en su código, almacénelas de forma segura utilizando el sistema de almacenamiento de secretos de usuario de .NET o variables de entorno.

Para configurarlo, importe primero el paquete de configuración

usando Microsoft.Extensions.Configuration;

A continuación, cargar los secretos en un objeto config con:

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

Ahora puede acceder a sus secretos en código como este:

config["<nombre_secreto>"]

Inicializa el almacenamiento de secretos de usuario ejecutando el siguiente comando en la carpeta de tu proyecto:

dotnet user-secrets init

Esto creará un almacenamiento local seguro para tus secretos (es decir, las claves API).

¡Listo! Ahora su programa C# puede manejar credenciales confidenciales de forma segura sin exponerlas en su código fuente.

Paso #3: Probar el MCP Web de Bright Data

Antes de conectarse al MCP Web de Bright Data en su agente, compruebe primero que su máquina puede ejecutar el servidor MCP.

Si aún no tiene una cuenta Bright Data, cree una nueva. Si ya la tiene, simplemente inicie sesión. Para una configuración rápida, vaya a la sección “MCP” del panel de control y siga las instrucciones:

The “MCP” section in your Bright Data account

Si no, empiece por generar una clave API de Bright Data. A continuación, guárdela en un lugar seguro, ya que la necesitará pronto. En esta sección, asumiremos que la clave API tiene permisos de administrador, ya que esto simplifica el proceso de integración de Web MCP.

Ejecute el siguiente comando para instalar Web MCP globalmente en su sistema:

npm install -g @brightdata/mcp

A continuación, comprueba que el servidor MCP local funciona ejecutando:

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

O, de forma equivalente, en Linux/macOS

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

Sustituya <YOUR_BRIGHT_DATA_API> por su token real de API de Bright Data. El comando establece la variable de entorno API_TOKEN necesaria e inicia Web MCP a través del paquete @brightdata/mcp.

Si tiene éxito, debería ver registros similares a este:

En el primer inicio, el Web MCP crea automáticamente dos zonas predeterminadas en su cuenta de Bright Data:

mcp_unlocker: Una zona para Web Unlocker.
mcp_browser: Una zona para Browser API.
El servidor MCP se basa en estas dos zonas para alimentar las más de 60 herramientas.

Para confirmar que se han creado las zonas, inicie sesión en su panel de Bright Data. Vaya a la página “Proxies e Infraestructura de scraping” y debería verlas en la tabla de zonas:

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

Si su token de API no tiene permisos de administrador, estas zonas no se crearán para usted. En ese caso, deberá crearlas manualmente en el panel de control y configurar sus nombres mediante variables de entorno(consulte la página de GitHub para obtener más detalles).

Importante: Por defecto, el servidor MCP sólo expone las herramientas search_engine y scrape_as_markdown (y sus versiones por lotes). Estas herramientas están incluidas en el nivel gratuito de Web MCP.

Para desbloquear herramientas avanzadas, como la automatización del navegador y los feeds de datos estructurados, es necesario activar el modo Pro. Para ello, establezca la variable de entorno PRO_MODE="true" antes de iniciar Web MCP:

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

O, en Linux/macOS

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

Elmodo Pro desbloquea las más de 60 herramientas, pero no está incluido en el nivel gratuito e incurrirá en cargos adicionales.

Éxito. Acaba de verificar que el servidor Web MCP se ejecuta en su máquina. Finalice el proceso MCP, ya que está a punto de configurar su agente Semantic Kernel para lanzar el servidor y conectarse a él en los siguientes pasos.

Paso 4: Configurar la integración Web MCP

Ahora que su máquina puede ejecutar Web MCP, comience añadiendo la clave de API de Bright Data que recuperó anteriormente a los secretos de usuario:

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

Sustituya el marcador de posición <YOUR_BRIGHT_DATA_API_KEY> por su clave de API real. Ese comando almacena de forma segura la clave en el almacenamiento de secretos de tu proyecto.

Recuerde que puede obtener el mismo resultado estableciendo la clave de API como una variable de entorno:

$Env:BrightData__ApiKey="<TU_CLAVE_API_BRIGHT_DATA>"

O, en macOS/Linux

export BrightData__ApiKey="<TU_CLAVE_API_BRIGHT_DATA_API_KEY>"

Nota: Microsoft.Extensions.Configuration convertirá BrightData__ApiKey en BrightData:ApiKey por usted.

A continuación, utilice McpClientFactory del paqueteModelContextProtocol para definir un cliente MCP y conectarse al Web MCP:

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

La configuración anterior da como resultado el mismo comando npx visto en los pasos de configuración anteriores, con la variable de entorno requerida. Tenga en cuenta que PRO_MODE es opcional, mientras que API_TOKEN se lee del secreto BrightData:ApiKey definido anteriormente.

A continuación, cargue la lista de todas las herramientas disponibles:

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

El script ejecutará el comando npx para lanzar el Web MCP como un proceso local y conectarse a él, accediendo a las herramientas que expone.

Puedes verificar que la conexión al Web MCP funciona y que tienes acceso a sus herramientas registrándolas todas:

foreach (var tool in tools)
{
    Console.WriteLine($"{herramienta.Nombre}: {herramienta.Descripción}");
}

Si ejecutas tu script ahora, deberías ver una salida similar a esta:

Estas son las 2 herramientas por defecto (+ 2 versiones por lotes) expuestas por el Web MCP en el nivel gratuito. En el modo Pro, tendrá acceso a las más de 60 herramientas.

¡Maravilloso! El resultado anterior confirma que la integración con Web MCP funciona perfectamente.

Paso 5: Crear un núcleo con acceso a las herramientas de MCP

En Semantic Kernel, un kernel actúa como un contenedor de Inyección de Dependencias que gestiona todos los servicios y plugins necesarios para ejecutar tu aplicación IA. Una vez que proporcionas tus servicios y plugins al kernel, éstos pueden ser utilizados por la IA siempre que los necesite.

Ahora, es el momento de crear un kernel para la integración de OpenAI con soporte para la llamada a herramientas a través de MCP. Comienza añadiendo tu clave API de OpenAI a los secretos de usuario:

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

Como se mencionó anteriormente, también puede establecer esto como una variable de entorno llamada OpenAI__ApiKey.

A continuación, define un nuevo kernel que se conecte a OpenAI:

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

En este ejemplo, el kernel se conecta al modelo gpt-5-mini (pero puedes configurar cualquier otro modelo OpenAI) utilizando la clave API almacenada en tus secretos de usuario.

A continuación, añade un plugin al kernel para el uso de la herramienta:

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

Esta línea de código convierte sus herramientas MCP en funciones listas para el kernel que pueden ser llamadas por el modelo de IA especificado.

Las importaciones necesarias para esta sección son

using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.Conectores.OpenAI;

Perfecto. Ya tienes un kernel totalmente configurado, que es el núcleo de tu aplicación de IA del SemanticKernel.

Paso #6: Definir el Agente de IA

Empieza importando la clase Agents de SemanticKernel:

using Microsoft.SemanticKernel.Agents;

A continuación, utiliza el kernel para inicializar un nuevo agente de IA que esté configurado para llamar automáticamente a las herramientas:

var executionSettings = new OpenAIPromptExecutionSettings()
{
    FunctionChoiceBehavior = FunctionChoiceBehavior.Auto() // Habilitar la llamada automática de funciones para el LLM
};

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

Esencialmente, el agente creado aquí puede ejecutar las herramientas expuestas por el MCP de Bright Data Web. Esto ocurre siempre que el modelo de IA determina que una o más herramientas son necesarias para conseguir lo que se describe en el prompt de entrada.

Tenga en cuenta que el agente se ha llamado “RedditAgent” porque este tutorial se centra en la construcción de un agente centrado en Reddit. Adapta el nombre a tu propio proyecto si estás creando un agente de IA del Semantic Kernel para un propósito diferente.

¡Genial! El siguiente paso es simplemente ejecutar un prompt usando el agente.

Paso #7: Ejecutar una Tarea en el Agente

Para probar las capacidades de recuperación de datos web de su agente de IA mejorado con las herramientas proporcionadas por el MCP Bright Data Web, necesita un prompt apropiado. Por ejemplo, puede pedirle al agente de IA que recupere información de un subreddit en particular, como se muestra a continuación:

var prompt = @"
Extraiga páginas del siguiente subreddit:
https://www.reddit.com/r/webscraping/

A partir del contenido raspado, genera un informe Markdown que incluya:
- La descripción oficial del subreddit y estadísticas clave (tipo de comunidad, fecha de creación)
- Una lista de las URL de las 10 publicaciones más recientes
";

Esta es una tarea ideal para probar las capacidades de recuperación web. Los modelos estándar de OpenAI fallan cuando se les pregunta algo así porque no pueden acceder mediante programación a la página de Reddit para recuperar datos en tiempo real:

Nota: El resultado anterior no es fiable, ya que la mayoría del contenido es falso o completamente inventado. Los modelos de OpenAI no pueden obtener datos frescos de la web de forma fiable sin herramientas externas como las que proporciona Bright Data.

Gracias a las herramientas disponibles a través del MCP Web, su agente podrá recuperar los datos Reddit necesarios y presentar un resultado preciso. Ejecute la tarea e imprima el resultado en el terminal con:

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

Esto es suficiente para probar una sola solicitud. En escenarios del mundo real, generalmente querrás mantener tu agente en ejecución y consciente del contexto implementando un bucle REPL con memoria para rastrear interacciones previas.

Y ahí lo tienes. Su agente de IA experto en Reddit, construido con Semantic Kernel e integrado con Bright Data Web MCP, ya es completamente funcional.

Paso #8: Ponerlo todo junto

El código final en Program.cs es

using Microsoft.Extensions.Configuration;
using ModelContextProtocolo.Cliente;
using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.Conectores.OpenAI;
using Microsoft.SemanticKernel.Agents;

// Cargar secretos de usuario y variables de entorno para las claves API
var config = new ConfigurationBuilder()
    .AddUserSecrets<Program>()
    .AddEnvironmentVariables()
    .Build();

// Crear un cliente MCP para el servidor MCP de Bright Data Web
await using var mcpClient = await McpClientFactory.CreateAsync(new StdioClientTransport(new()
{
    Nombre = "BrightDataWebMCP",
    Comando = "npx",
    Argumentos = ["-y", "@brightdata/mcp"],
    VariablesEntorno = new Dictionary<string, string?>
    {
        { "API_TOKEN", config["BrightData:ApiKey"] },
        // { "PRO_MODE", "true" }, // <-- Opcional: activar Modo Pro
    }
}));

// Recuperar la lista de herramientas disponibles en el servidor MCP de Bright Data Web
var tools = await mcpClient.ListToolsAsync().ConfigureAwait(false);

// Construir un Kernel Semántico y registrar las herramientas MCP como funciones del kernel
var builder = Kernel.CreateBuilder();
builder.Services
    AddOpenAIChatCompletion(
        modelId: "gpt-5-mini",
        apiKey: config["OpenAI:ApiKey"]].
    );
Kernel kernel = builder.Build();
// Crea un plugin a partir de las herramientas MCP y añádelo a la colección de plugins del kernel
kernel.Plugins.AddFromFunctions("BrightData", tools.Select(aiFunction => aiFunction.AsKernelFunction());

// Habilitar la llamada automática a funciones para el LLM
var executionSettings = new OpenAIPromptExecutionSettings()
{
    FunctionChoiceBehavior = FunctionChoiceBehavior.Auto()
};

// Definir el agente IA con integración MCP
var agent = new ChatCompletionAgent()
{
    Nombre = "RedditAgent",
    Kernel = kernel,
    Arguments = new KernelArguments(executionSettings), // Pasar configuración para llamadas a herramientas MCP
};

// Probar el agente de IA con un prompt de subreddit scraping
var prompt = @"
Raspe páginas del siguiente subreddit:
https://www.reddit.com/r/webscraping/

A partir del contenido raspado, genera un informe Markdown que incluya:
- La descripción oficial del subreddit y estadísticas clave (tipo de comunidad, fecha de creación)
- Una lista de las URL de las 10 publicaciones más recientes
";

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

¡Vaya! En sólo unas 65 líneas de C#, ha creado un agente de IA de Semantic Kernel con integración Bright Data Web MCP.

Ejecute su agente con

dotnet run

La salida debería ser similar a esta:

Observe cómo el agente ha escaneado la página /about para obtener la información de subreddit, y después las páginas /new para obtener los posts más recientes.

Todos los datos mostrados en la salida son correctos, como puedes comprobar visitando la página /about del subreddit:

The /about page of the r/webscraping subreddit

Los datos en la salida del agente de IA coinciden exactamente con lo que se muestra en esta página. Lo mismo ocurre con los mensajes más recientes, que puedes encontrar en la página /new del subreddit.

La única diferencia es el orden de las entradas, que viene determinado por el frontend de Reddit y no es relevante aquí.

El scraping de Reddit es un reto porque está protegido por sistemas anti-bot que bloquean las peticiones automatizadas. Gracias a las capacidades de Scraping web con bypass anti-bot proporcionadas por el servidor Bright Data Web MCP, su agente de IA tiene acceso a un potente conjunto de herramientas para la recuperación, interacción y búsqueda de datos web.

Este ejemplo muestra sólo uno de los muchos escenarios posibles. Con la amplia gama de herramientas de Bright Data disponibles a través de Semantic Kernel, puede crear agentes más complejos que se adapten a muchos otros casos de uso.

¡Et voilà! Acaba de experimentar la potencia de la integración de Bright Data Web MCP en un agente de IA de Semantic Kernel en C#.

Conclusión

En esta entrada de blog, ha visto cómo conectar un agente de IA construido con Semantic Kernel al Web MCP de Bright Data(¡que ahora viene con un nivel gratuito!). Esta integración proporciona a su agente capacidades mejoradas, incluyendo búsqueda web, extracción de datos e interacción en tiempo real.

Para crear agentes de IA más avanzados, explore el conjunto más amplio de productos y servicios de la infraestructura de IA de Bright Data. Estas herramientas están diseñadas para potenciar diversos flujos de trabajo de IA y casos de uso de agentes.

Regístrese hoy mismo para obtener una cuenta gratuita de Bright Data y empiece a experimentar con soluciones de datos web preparadas para IA.

Contactar Ventas Prueba gratuita