Integration semantischer Kern-KI-Agenten mit Bright Data Web MCP

In diesem Tutorial werden Sie sehen:

Was der Semantic Kernel ist, welche Kernfunktionen er bietet und wie er funktioniert.
Warum die Erweiterung mit MCP ihn noch leistungsfähiger macht.
Wie man einen KI-Agenten mit Bright Data Web MCP-Integration unter Verwendung von Semantic Kernel erstellt.

Tauchen wir ein!

Was ist Semantic Kernel?

Semantic Kernel ist ein von Microsoft entwickeltes Open-Source-SDK, mit dem Sie KI-Modelle und LLMs in Anwendungen integrieren können, um KI-Agenten und fortschrittliche GenAI-Lösungen zu erstellen. Es fungiert als produktionsreife Middleware, die Konnektoren zu mehreren KI-Diensten bereitstellt und sowohl die semantische (prompt-basierte) als auch die native (code-basierte) Funktionsausführung ermöglicht.

Das SDK ist in C#, Python und Java verfügbar. Es ist eine flexible Lösung zur Generierung von Text, zur Durchführung von Chatvervollständigungen oder zur Verbindung mit externen Datenquellen und Diensten. Zum Zeitpunkt der Erstellung dieses Artikels hat das GitHub-Repository des Projekts mehr als 26k Sterne.

Wichtigste Funktionen

Die wichtigsten Funktionen von Semantic Kernel sind:

KI-Modell-Integration: Verbindung zu Diensten wie OpenAI und Azure OpenAI mit einer einheitlichen Schnittstelle für Chatvervollständigung, Texterstellung und mehr.
Plugin-System: Unterstützt Plugins mit semantischen Funktionen (Prompts) und nativen Funktionen (C#, Python oder Java) zur Erweiterung der KI-Funktionalität.
KI-Agenten: Ermöglicht den Aufbau von Agenten, die Benutzeranfragen interpretieren und mehrere Plugins und Dienste koordinieren, um komplexe Aufgaben zu lösen.
Planung und Funktionsaufrufe: Unterstützt Agenten bei der Aufteilung und Ausführung von mehrstufigen Aufgaben durch Auswahl der richtigen Plugins oder Funktionen.
Retrieval-augmented Generation (RAG): Integriert reale Daten in Prompts mithilfe von Such- und Datenkonnektoren für genauere und aktuellere Antworten.

Wie der Semantic Kernel funktioniert

Um zu verstehen, wie die Bibliothek funktioniert, ist es hilfreich, ihre Hauptkomponenten zu kennen:

Kern Kernel: Orchestriert KI-Dienste und Plugins.
KI-Dienst-Konnektoren: Verbinden Anwendungscode mit verschiedenen KI-Modellen und -Diensten über eine gemeinsame Schnittstelle.
Plugins: Enthalten semantische und native Funktionen, die die Fähigkeiten des Agenten erweitern.
KI-Agenten: Sie bauen auf dem Kernel auf und verwenden Plugins, um Anfragen zu verarbeiten und Workflows auszuführen.

Warum den Semantic Kernel mit MCP-Integration erweitern?

Semantic Kernel ist ein modellunabhängiges SDK, mit dem Sie komplexe KI-Agenten, Workflows und sogar Multi-Agentensysteme erstellen, orchestrieren und bereitstellen können. Unabhängig davon, wie ausgefeilt Ihre Architektur ist, benötigen diese Workflows und Agenten immer noch ein zugrunde liegendes KI-Modell, um zu funktionieren.

Egal, ob es sich um OpenAI, Azure OpenAI oder ein anderes LLM handelt, alle Modelle haben dieselbe grundlegende Einschränkung: Ihr Wissen ist statisch…

LLMs werden auf Daten trainiert, die eine Momentaufnahme in der Zeit darstellen, was bedeutet, dass ihr Wissen schnell veraltet sein kann. Noch wichtiger ist, dass sie nicht von Haus aus mit Live-Websites oder externen Datenquellen interagieren können.

Hier macht die Erweiterbarkeit des Semantic Kernel durch Plugins den entscheidenden Unterschied aus. Durch die Integration mit dem Web MCP von Bright Data können Sie Ihre KI-Agenten über statisches Wissen hinaus erweitern und sie in die Lage versetzen, frische, hochwertige Daten direkt aus dem Web abzurufen.

Der Open-Source-Web-MCP-Server bietet Zugriff auf mehr als 60 KI-fähige Tools, die alle auf der Infrastruktur von Bright Data für Webinteraktion und Datenerfassung basieren.

Bereits mit der kostenlosen Version kann Ihr KI-Agent zwei leistungsstarke Tools nutzen:

Tool	Beschreibung
`suche_maschine`	Rufen Sie Suchergebnisse von Google, Bing oder Yandex in JSON oder Markdown ab.
`scrape_as_markdown`	Scrape eine beliebige Webseite in ein sauberes Markdown-Format und umgehe dabei Bot-Erkennung und CAPTCHA.

Darüber hinaus schaltet Web MCP Dutzende von spezialisierten Tools für die strukturierte Datenerfassung auf Plattformen wie Amazon, LinkedIn, Yahoo Finance, TikTok und anderen frei. Erfahren Sie mehr auf der offiziellen GitHub-Seite.

Kurz gesagt, die Kombination von Semantic Kernel mit Web MCP verwandelt statische Workflows in dynamische KI-Agenten, die mit Live-Websites interagieren und auf Webdaten zugreifen können, um Erkenntnisse aus der realen Welt zu gewinnen.

So erstellen Sie einen KI-Agenten in Semantic Kernel, der mit Web MCP von Bright Data verbunden ist

In dieser Anleitung erfahren Sie, wie Sie die Web MCP von Bright Data mit einem in C# geschriebenen KI-Agenten von Semantic Kernel verbinden können. Insbesondere werden Sie diese Integration verwenden, um einen KI-Agenten für Reddit-Analysen zu erstellen, der:

Verwendung der Web MCP-Tools von Bright Data zum Abrufen von Informationen aus Reddit-Beiträgen.
Die abgerufenen Daten mithilfe eines OpenAI GPT-5-Modells verarbeitet.
Die Ergebnisse in einem Markdown-Bericht an Sie zurückgibt.

Hinweis: Der folgende Code wurde in C# unter Verwendung von .NET 9 geschrieben. Sie können ihn jedoch leicht in Python oder Java, die beiden anderen unterstützten Programmiersprachen, konvertieren.

Führen Sie die folgenden Schritte aus, um loszulegen!

Voraussetzungen

Bevor Sie beginnen, stellen Sie sicher, dass Sie:

.NET 8.0 oder höher lokal installiert haben (diese Anleitung bezieht sich auf .NET 9)
Einen OpenAI-API-Schlüssel
Ein Bright Data-Konto mit einem fertigen API-Schlüssel

Machen Sie sich keine Gedanken über die Einrichtung des Bright Data-Kontos, da Sie in einem späteren Schritt durch diesen Prozess geführt werden.

Schritt 1: Einrichten des .NET-C#-Projekts

Initialisieren Sie ein neues .NET-Konsolenprojekt namens SK_MCP_Agent mit:

dotnet new console -n SK_MCP_Agent

Geben Sie dann den Projektordner ein:

cd SK_MCP_Agent

Sie sollten nun die folgende Dateistruktur sehen:

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

Im Einzelnen enthält Program.cs derzeit ein Standardprogramm “Hello, World”. In diese Datei werden Sie die Logik Ihres Semantic Kernel KI Agenten einfügen.

Öffnen Sie nun Ihren Projektordner in einer .NET C# IDE, wie z.B. Visual Studio oder Visual Studio Code. Installieren Sie im Terminal der IDE die erforderlichen Abhängigkeiten mit diesen Befehlen:

dotnet add package Microsoft.Extensions.Configuration
dotnet add package Microsoft.Extensions.Configuration.EnvironmentVariables
dotnet fügt das Paket Microsoft.Extensions.Configuration.UserSecrets hinzu  
dotnet add Paket Microsoft.SemanticKernel --prerelease
dotnet Paket Microsoft.SemanticKernel.Agents.Core --Vorabversion hinzufügen
dotnet-Paket ModelContextProtocol hinzufügen --vorab freigeben
dotnet-Paket System.Linq.AsyncEnumerable hinzufügen --vorab freigeben

Die erforderlichen NuGet-Pakete sind:

Microsoft.Extensions.Configuration.*: Bietet eine schlüsselwertbasierte Konfiguration zum Lesen von Einstellungen aus Umgebungsvariablen und .NET-Benutzergeheimnissen.
Microsoft.SemanticKernel.*: Ein leichtgewichtiges SDK für die Integration von KI LLMs mit herkömmlichen Programmiersprachen, mit Tools für die Agentenentwicklung.
ModelContextProtocol: Der offizielle MCP C#-Client, der für die Verbindung mit Bright Data Web MCP verwendet wird.
System.Linq.AsyncEnumerable: Stellt einen vollständigen Satz von LINQ-Erweiterungsmethoden für IAsyncEnumerable<T> bereit.

Hinweis: Das Flag --prerelease in dotnet add package weist die .NET CLI an, die neuesten (Vorab-)Versionen eines NuGet-Pakets zu installieren. Dies ist für einige Pakete erforderlich, da sie sich noch in der Entwicklung oder im experimentellen Stadium befinden.

Geschafft! Ihre .NET-Entwicklungsumgebung ist nun für die Erstellung eines KI-Agenten in C# mit Semantic Kernel und Bright Data Web MCP-Integration eingerichtet.

Schritt Nr. 2: Konfigurieren des geheimen Ladens

Ihr KI-Agent wird auf Komponenten von Drittanbietern wie OpenAI-Modelle und den Bright Data Web MCP-Server angewiesen sein. Für beide Integrationen ist eine Authentifizierung über API-Schlüssel-Tokens erforderlich. Um zu vermeiden, dass diese Schlüssel direkt in Ihrem Code offengelegt werden, speichern Sie sie sicher mithilfe des Speichersystems für .NET-Benutzergeheimnisse oder Umgebungsvariablen.

Um dies zu konfigurieren, importieren Sie zunächst das Konfigurationspaket:

using Microsoft.Extensions.Configuration;

Dann laden Sie die Geheimnisse in ein Konfigurationsobjekt mit:

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

Sie können nun auf Ihre Geheimnisse im Code wie folgt zugreifen:

config["<secret_name>"]

Initialisieren Sie den Speicher für die Benutzergeheimnisse, indem Sie den folgenden Befehl in Ihrem Projektordner ausführen:

dotnet user-secrets init

Dadurch wird ein sicherer lokaler Speicher für Ihre Geheimnisse (d. h. die API-Schlüssel) erstellt.

Gut gemacht! Ihr C#-Programm kann nun sicher mit vertraulichen Anmeldeinformationen umgehen, ohne sie im Quellcode offenzulegen.

Schritt 3: Testen des Web-MCP von Bright Data

Bevor Sie in Ihrem Agenten eine Verbindung zum Web-MCP von Bright Data herstellen, sollten Sie zunächst überprüfen, ob Ihr Computer den MCP-Server ausführen kann.

Wenn Sie noch kein Bright Data-Konto haben, erstellen Sie ein neues. Wenn Sie eines haben, melden Sie sich einfach an. Für eine schnelle Einrichtung navigieren Sie zum Abschnitt “MCP” im Dashboard, und folgen Sie den Anweisungen:

The “MCP” section in your Bright Data account

Andernfalls erstellen Sie zunächst einen Bright Data-API-Schlüssel. Bewahren Sie ihn dann an einem sicheren Ort auf, da Sie ihn bald benötigen werden. In diesem Abschnitt wird davon ausgegangen, dass der API-Schlüssel über Admin-Berechtigungen verfügt, da dies den Web MCP-Integrationsprozess vereinfacht.

Führen Sie den folgenden Befehl aus, um den Web MCP global in Ihrem System zu installieren:

npm install -g @brightdata/mcp

Überprüfen Sie anschließend, ob der lokale MCP-Server funktioniert, indem Sie den Befehl ausführen:

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

Oder, äquivalent, auf Linux/macOS:

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

Ersetzen Sie <YOUR_BRIGHT_DATA_API> durch Ihr tatsächliches Bright Data-API-Token. Der Befehl setzt die erforderliche Umgebungsvariable API_TOKEN und startet den Web MCP über das Paket @brightdata/mcp.

Bei Erfolg sollten Sie ähnliche Protokolle wie das folgende sehen:

Beim ersten Start erstellt die Web MCP automatisch zwei Standardzonen in Ihrem Bright Data-Konto:

mcp_unlocker: Eine Zone für Web Unlocker.
mcp_browser: Eine Zone für Browser API.
Der MCP-Server stützt sich auf diese beiden Zonen, um alle 60+ Tools zu betreiben.

Um zu überprüfen, ob die Zonen erstellt wurden, melden Sie sich bei Ihrem Bright Data Dashboard an. Gehen Sie zur Seite “Proxies & Scraping-Infrastruktur“, und Sie sollten die Zonen in der Zonentabelle sehen:

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

Wenn Ihr API-Token nicht über Admin-Berechtigungen verfügt, werden diese Zonen nicht für Sie erstellt. In diesem Fall müssen Sie sie manuell im Dashboard erstellen und ihre Namen über Umgebungsvariablen konfigurieren(Details finden Sie auf der GitHub-Seite).

Wichtig: Standardmäßig stellt der MCP-Server nur die Tools search_engine und scrape_as_markdown (und ihre Batch-Versionen) zur Verfügung. Diese Tools sind in der kostenlosen Web MCP-Version enthalten.

Um fortgeschrittene Tools wie die Browser-Automatisierung und strukturierte Daten-Feeds freizuschalten, müssen Sie den Pro-Modus aktivieren. Dazu setzen Sie die Umgebungsvariable PRO_MODE="true", bevor Sie die Web MCP starten:

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

Oder, unter Linux/macOS:

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

DerPro-Modus schaltet alle 60+ Tools frei, ist aber nicht in der kostenlosen Version enthalten und verursacht zusätzliche Kosten.

Erfolgreich! Sie haben soeben sichergestellt, dass der Web-MCP-Server auf Ihrem Rechner läuft. Beenden Sie den MCP-Prozess, da Sie in den nächsten Schritten Ihren Semantic Kernel Agent so konfigurieren werden, dass er den Server startet und eine Verbindung zu ihm herstellt.

Schritt 4: Konfigurieren Sie die Web MCP-Integration

Da Ihr Computer nun die Web MCP ausführen kann, fügen Sie zunächst den API-Schlüssel von Bright Data, den Sie zuvor abgerufen haben, zu den Benutzergeheimnissen hinzu:

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

Ersetzen Sie den Platzhalter <YOUR_BRIGHT_DATA_API_KEY> durch Ihren tatsächlichen API-Schlüssel. Mit diesem Befehl wird der Schlüssel sicher im Geheimhaltungsspeicher Ihres Projekts gespeichert.

Denken Sie daran, dass Sie das gleiche Ergebnis erzielen können, wenn Sie den API-Schlüssel als Umgebungsvariable festlegen:

$Env:BrightData__ApiKey="<YOUR_BRIGHT_DATA_API_KEY>"

Oder, unter macOS/Linux:

export BrightData__ApiKey="<YOUR_BRIGHT_DATA_API_KEY>"

Hinweis: Microsoft.Extensions.Configuration konvertiert BrightData__ApiKey in BrightData:ApiKey für Sie.

Verwenden Sie als Nächstes die McpClientFactory aus dem PaketModelContextProtocol, um einen MCP-Client zu definieren und eine Verbindung mit dem Web-MCP herzustellen:

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

Die obige Konfiguration ergibt den gleichen npx-Befehl wie in den vorherigen Einrichtungsschritten, mit der erforderlichen Umgebungsvariablen. Beachten Sie, dass PRO_MODE optional ist, während API_TOKEN aus dem zuvor definierten BrightData:ApiKey-Geheimnis gelesen wird.

Als Nächstes wird die Liste aller verfügbaren Tools geladen:

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

Das Skript führt den Befehl npx aus, um den Web MCP als lokalen Prozess zu starten und sich mit ihm zu verbinden, um auf die von ihm bereitgestellten Tools zuzugreifen.

Sie können überprüfen, ob die Verbindung zum Web-MCP funktioniert und ob Sie Zugriff auf seine Tools haben, indem Sie alle Tools protokollieren:

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

Wenn Sie Ihr Skript jetzt ausführen, sollten Sie eine ähnliche Ausgabe wie diese sehen:

Dies sind die 2 Standardwerkzeuge (+ 2 Batch-Versionen), die von der Web MCP in der kostenlosen Version zur Verfügung gestellt werden. Im Pro-Modus hätten Sie Zugriff auf alle 60+ Tools.

Wunderbar! Die obige Ausgabe bestätigt, dass die Web MCP-Integration perfekt funktioniert!

Schritt Nr. 5: Erstellen eines Kernels mit Zugriff auf MCP-Tools

Im Semantic Kernel fungiert ein Kernel als Dependency Injection-Container, der alle Dienste und Plugins verwaltet, die für die Ausführung Ihrer KI-Anwendung erforderlich sind. Sobald Sie dem Kernel Ihre Dienste und Plugins zur Verfügung stellen, können diese von der KI bei Bedarf genutzt werden.

Nun ist es an der Zeit, einen Kernel für die OpenAI-Integration mit Unterstützung für Tool-Aufrufe über MCP zu erstellen. Beginnen Sie damit, Ihren OpenAI API-Schlüssel zu den Benutzergeheimnissen hinzuzufügen:

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

Wie bereits erwähnt, können Sie dies auch als Umgebungsvariable namens OpenAI__ApiKey festlegen.

Als nächstes definieren Sie einen neuen Kernel, der sich mit OpenAI verbindet:

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

In diesem Beispiel verbindet sich der Kernel mit dem gpt-5-mini-Modell (Sie können aber auch jedes andere OpenAI-Modell konfigurieren) unter Verwendung des API-Schlüssels, der in Ihren Benutzergeheimnissen gespeichert ist.

Dann fügen Sie dem Kernel ein Plugin für die Verwendung des Werkzeugs hinzu:

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

Diese Codezeile wandelt Ihre MCP-Tools in kernel-ready-Funktionen um, die von dem angegebenen KI-Modell aufgerufen werden können.

Die erforderlichen Importe für diesen Abschnitt sind:

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

Perfekt! Sie haben nun einen vollständig konfigurierten Kernel, der den Kern Ihrer SemanticKernel KI-Anwendung darstellt.

Schritt #6: Definieren Sie den KI-Agenten

Importieren Sie zunächst die Klasse Agents aus SemanticKernel:

using Microsoft.SemanticKernel.Agents;

Als nächstes verwenden Sie den Kernel, um einen neuen KI-Agenten zu initialisieren, der so konfiguriert ist, dass er automatisch Tools aufruft:

var executionSettings = new OpenAIPromptExecutionSettings()
{
    FunctionChoiceBehavior = FunctionChoiceBehavior.Auto() // Aktivieren Sie den automatischen Funktionsaufruf für den LLM
};

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

Im Wesentlichen kann der hier erstellte Agent die von der Bright Data Web MCP bereitgestellten Tools ausführen. Dies geschieht immer dann, wenn das KI-Modell feststellt, dass ein oder mehrere Tools erforderlich sind, um das in der Eingabeaufforderung beschriebene Ziel zu erreichen.

Beachten Sie, dass der Agent “RedditAgent” genannt wurde, da sich dieses Lernprogramm auf die Erstellung eines auf Reddit fokussierten Agenten konzentriert. Passen Sie den Namen an Ihr eigenes Projekt an, wenn Sie einen Semantic Kernel KI-Agenten für einen anderen Zweck erstellen.

Klasse! Der nächste Schritt besteht einfach darin, eine Eingabeaufforderung mit dem Agenten auszuführen.

Schritt #7: Ausführen einer Aufgabe im Agenten

Um die Fähigkeiten Ihres KI-Agenten zum Abrufen von Webdaten zu testen, die mit den von Bright Data Web MCP bereitgestellten Tools erweitert wurden, benötigen Sie eine geeignete Eingabeaufforderung. Sie könnten den KI-Agenten zum Beispiel auffordern, Informationen aus einem bestimmten Subreddit abzurufen, wie folgt:

var prompt = @"
Scrape Seiten aus dem folgenden Subreddit:
https://www.reddit.com/r/webscraping/

Erstellen Sie aus dem gescrapten Inhalt einen Markdown-Bericht, der Folgendes enthält:
- Die offizielle Beschreibung des Subreddits und wichtige Statistiken (Community-Typ, Erstellungsdatum)
- Eine Liste von URLs für die ~10 neuesten Beiträge
";

Dies ist eine ideale Aufgabe, um die Webabfragefähigkeiten zu testen. Standard-OpenAI-Modelle scheitern bei einer solchen Aufforderung, weil sie nicht programmatisch auf die Reddit-Seite zugreifen können, um Echtzeitdaten abzurufen:

Hinweis: Die obige Ausgabe ist unzuverlässig, da der Großteil des Inhalts entweder falsch oder komplett erfunden ist. OpenAI-Modelle können ohne externe Tools, wie sie von Bright Data bereitgestellt werden, keine frischen Webdaten zuverlässig aus dem Internet abrufen.

Dank der über die Web MCP verfügbaren Tools ist Ihr Agent in der Lage, die erforderlichen Reddit-Daten abzurufen und ein genaues Ergebnis zu präsentieren. Führen Sie die Aufgabe aus und geben Sie das Ergebnis im Terminal mit aus:

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

Dies reicht aus, um eine einzelne Eingabeaufforderung zu testen. In realen Szenarien möchten Sie Ihren Agenten in der Regel in Gang halten und kontextbewusst halten, indem Sie eine REPL-Schleife mit Speicher implementieren , um frühere Interaktionen zu verfolgen.

Und da haben Sie ihn! Ihr Reddit-Experte-KI-Agent, der mit Semantic Kernel erstellt und in Bright Data Web MCP integriert wurde, ist nun voll funktionsfähig.

Schritt Nr. 8: Alles zusammenfügen

Der endgültige Code in Program.cs lautet:

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

// Laden von Benutzergeheimnissen und Umgebungsvariablen für API-Schlüssel
var config = new ConfigurationBuilder()
    .AddUserSecrets<Programm>()
    .AddEnvironmentVariables()
    .Build();

// Erstellen eines MCP-Clients für den Bright Data Web MCP-Server
await using var mcpClient = await McpClientFactory.CreateAsync(new StdioClientTransport(new()
{
    Name = "BrightDataWebMCP",
    Befehl = "npx",
    Arguments = ["-y", "@brightdata/mcp"],
    EnvironmentVariables = new Dictionary<string, string?>
    {
        { "API_TOKEN", config["BrightData:ApiKey"] },
        // { "PRO_MODE", "true" }, // <-- Optional: Pro-Modus aktivieren
    }
}));

// Abrufen der Liste der auf dem Bright Data Web MCP-Server verfügbaren Tools
var tools = await mcpClient.ListToolsAsync().ConfigureAwait(false);

// Erstellen Sie einen semantischen Kernel und registrieren Sie die MCP-Tools als Kernel-Funktionen
var builder = Kernel.CreateBuilder();
builder.Services
    .AddOpenAIChatCompletion(
        modelId: "gpt-5-mini",
        apiKey: config["OpenAI:ApiKey"]
    );
Kernel kernel = builder.Build();
// Erstellen Sie ein Plugin aus den MCP-Tools und fügen Sie es der Plugin-Sammlung des Kernels hinzu
kernel.Plugins.AddFromFunctions("BrightData", tools.Select(aiFunction => aiFunction.AsKernelFunction()));

// Aktivieren des automatischen Funktionsaufrufs für den LLM
var executionSettings = new OpenAIPromptExecutionSettings()
{
    FunctionChoiceBehavior = FunctionChoiceBehavior.Auto()
};

// Definieren Sie den KI-Agenten mit MCP-Integration
var agent = new ChatCompletionAgent()
{
    Name = "RedditAgent",
    Kernel = kernel,
    Arguments = new KernelArguments(executionSettings), // Einstellungen für MCP-Werkzeugaufrufe übergeben
};

// Testen Sie den KI-Agenten mit einer Aufforderung zum Scraping von Subreddits
var prompt = @"
Scrape Seiten aus dem folgenden Subreddit:
https://www.reddit.com/r/webscraping/

Erstellen Sie aus den gescrapten Inhalten einen Markdown-Bericht, der Folgendes enthält:
- Die offizielle Beschreibung des Subreddits und wichtige Statistiken (Community-Typ, Erstellungsdatum)
- Eine Liste von URLs für die ~10 neuesten Beiträge
";

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

Wow! In nur etwa 65 Zeilen C# haben Sie einen Semantic Kernel KI-Agenten mit Bright Data Web MCP-Integration erstellt.

Führen Sie Ihren Agenten mit aus:

dotnet run

Die Ausgabe sollte in etwa so aussehen:

Beachten Sie, wie der Agent die Seite /about durchsucht hat, um die Subreddit-Informationen abzurufen, und dann die Seiten /new, um die neuesten Beiträge abzurufen.

Alle in der Ausgabe angezeigten Daten sind korrekt, wie Sie überprüfen können, indem Sie die /about-Seite des Subreddits besuchen:

The /about page of the r/webscraping subreddit

Die Daten in der Ausgabe des KI-Agenten entsprechen genau dem, was auf dieser Seite angezeigt wird. Das Gleiche gilt für die neuesten Beiträge, die Sie auf der /new-Seite des Subreddits finden können.

Der einzige Unterschied ist die Reihenfolge der Beiträge, die vom Reddit-Frontend bestimmt wird und hier nicht relevant ist.

DasScraping von Reddit ist eine Herausforderung, da es durch Anti-Bot-Systeme geschützt ist, die automatische Anfragen blockieren. Dank der Web-Scraping-Funktionen mit Anti-Bot-Umgehung, die der Bright Data Web MCP-Server bietet, hat Ihr KI-Agent Zugriff auf eine Reihe leistungsstarker Tools für den Abruf, die Interaktion und die Suche von Webdaten.

Dieses Beispiel veranschaulicht nur eines der vielen möglichen Szenarien. Mit der breiten Palette an Bright Data-Tools, die über Semantic Kernel verfügbar sind, können Sie komplexere Agenten erstellen , die sich an viele andere Anwendungsfälle anpassen.

Et voilà! Sie haben soeben die Leistungsfähigkeit der Bright Data Web MCP-Integration in einem Semantic Kernel-KI-Agenten in C# erlebt.

Fazit

In diesem Blog-Beitrag haben Sie gesehen, wie Sie einen mit Semantic Kernel erstellten KI-Agenten mit der Web MCP von Bright Data verbinden können(die jetzt mit einer kostenlosen Stufe erhältlich ist!). Durch diese Integration erhält Ihr Agent erweiterte Funktionen, einschließlich Websuche, Datenextraktion und Echtzeitinteraktion.

Für die Entwicklung fortschrittlicherer KI-Agenten sollten Sie sich die breitere Palette an Produkten und Services der KI-Infrastruktur von Bright Data ansehen. Diese Tools wurden entwickelt, um verschiedene KI-Workflows und agentenbasierte Anwendungsfälle zu unterstützen.

Melden Sie sich noch heute für ein kostenloses Bright Data-Konto an und experimentieren Sie mit KI-fähigen Webdatenlösungen!

Vertrieb kontaktieren Gratis testen