AutoGen AgentChat-Integration mit Bright Data's Web MCP

In diesem Artikel erfahren Sie:

Was AutoGen ist und was es so einzigartig macht.
Warum Sie Ihre Agenten mit Funktionen zum Abrufen von Webdaten und zur Interaktion über MCP erweitern sollten.
Wie Sie einen AutoGen AgentChat-Agenten erstellen, der sich in Bright Datas Web MCP integrieren lässt.
Wie Sie denselben Agenten in der visuellen Webanwendung AutoGen Studio testen können.

Lassen Sie uns loslegen!

Was ist AutoGen?

AutoGen ist ein von Microsoft entwickeltes Open-Source-Framework zum Aufbau von Multi-Agent-KI-Systemen. Es ermöglicht mehreren KI-Agenten, zusammenzuarbeiten und miteinander zu kommunizieren, um komplexe Aufgaben entweder autonom oder unter menschlicher Anleitung zu erledigen.

Die Bibliothek hat mit über 50.000 Sternen auf GitHub große Popularität erlangt und ist sowohl für Python als auch für C# (.NET) verfügbar.

Hauptmerkmale

Zu den Kernfunktionen von AutoGen gehören:

Anpassbare und dialogfähige Agenten: Integriert KI-Agenten mit LLMs, menschlichen Eingaben und verschiedenen Tools. Sie können benutzerdefinierte Verhaltensweisen und Konversationsmuster mithilfe einer High-Level-API oder sogar in JSON definieren.
Human-in-the-Loop-Workflows: Unterstützt die Einbindung von menschlichem Feedback an mehreren Punkten im Workflow. Beispielsweise kann der UserProxyAgent als Proxy für einen Menschen fungieren und so die Überwachung und Intervention ermöglichen.
Tool-Integration: Agenten können mit einer Vielzahl von Tools ausgestattet werden, z. B. mit Funktionen für die Websuche, die Codeausführung oder die Dateiverwaltung. Dazu gehört auch die Unterstützung für die MCP-Integration.
Integrierte Agententypen: AutoGen bietet mehrere vorgefertigte Agententypen, darunter:
- UserProxyAgent: Repräsentiert einen menschlichen Benutzer und kann Code ausführen.
- AssistantAgent: Ein universeller LLM-basierter Assistent, der Aufgaben ausführen und Tools verwenden kann.
- CodeExecutorAgent: Spezialisiert auf die Ausführung und das Testen von Code.
Beobachtbarkeit und Debugging: Bietet integrierte Tools zum Verfolgen und Debuggen von Agenteninteraktionen und Workflows, mit Unterstützung für Standards wie OpenTelemetry.
AutoGen Studio: Eine grafische, Low-Code-Webschnittstelle für die schnelle Prototypenerstellung, das Testen und die Bereitstellung von Multi-Agent-Systemen.

Warum AutoGen-Agenten mit Bright Data’s Web MCP erweitern

AutoGen unterstützt mehrere Anbieter von KI-Modellen. Unabhängig davon, für welches LLM Sie sich entscheiden – ob OpenAI, Anthropic, Ollama oder ein anderer Anbieter – alle Modelle haben dieselbe grundlegende Einschränkung: Ihr Wissen ist statisch.

LLMs werden mit Daten trainiert, die eine Momentaufnahme darstellen, was bedeutet, dass ihr Wissen schnell veralten kann. Noch wichtiger ist, dass sie nicht von Haus aus mit Live-Websites interagieren oder selbstständig auf Datenquellen zugreifen können.

Glücklicherweise unterstützt AutoGen MCP. Das bedeutet, dass Sie Ihre Agenten mit Bright Datas Web MCP kombinieren können. Dadurch werden LLMs erweitert und erhalten Tools, um aktuelle, hochwertige Daten direkt aus dem Web abzurufen, sowie weitere Funktionen.

Genauer gesagt ist Web MCP ein Open-Source-Server, der mehr als 60 KI-fähige Tools bereitstellt. Diese basieren alle auf der Infrastruktur von Bright Data für Webinteraktion und Datenerfassung.

Selbst in der kostenlosen Version haben Sie Zugriff auf diese beiden bahnbrechenden Tools:

Tool	Beschreibung
`search_engine`	Rufen Sie Suchergebnisse von Google, Bing oder Yandex in JSON oder Markdown ab.
`scrape_as_markdown`	Scrapen Sie beliebige Webseiten in ein sauberes Markdown-Format und umgehen Sie dabei Bot-Erkennung und CAPTCHA.

Darüber hinaus bietet Web MCP Dutzende von Spezialtools für die strukturierte Datenerfassung auf beliebten Plattformen wie Amazon, LinkedIn, TikTok, Google Play, App Store, Yahoo Finance und vielen mehr. Weitere Informationen finden Sie auf der offiziellen GitHub-Seite.

Kurz gesagt: Die Konfiguration von Web MCP in AutoGen hilft Ihnen beim Aufbau komplexer KI-Agenten, die mit Live-Websites interagieren und auf aktuelle Webdaten zugreifen können, um Erkenntnisse zu generieren, die auf der realen Welt basieren.

So erstellen Sie einen KI-Agenten mit Tools aus Web MCP in AutoGen AgentChat unter Verwendung von Python

In diesem Abschnitt erfahren Sie, wie Sie einen Agenten mit AutoGen AgentChat erstellen, der hochentwickelten API zum Erstellen von Multi-Agent-Anwendungen. Der Agent kann alle vom Web MCP-Server bereitgestellten Tools nutzen und so die Fähigkeiten des zugrunde liegenden LLM erweitern.

Hinweis: Der folgende Agent wird in Python geschrieben, kann aber leicht an .NET angepasst werden.

Befolgen Sie die folgenden Schritte, um einen Agenten in Python mit AutoGen- und MCP-Integration zu erstellen!

Voraussetzungen

Um dieses Tutorial durcharbeiten zu können, stellen Sie sicher, dass Sie über Folgendes verfügen:

Python 3.10+ auf Ihrem Computer installiert ist.
Node.js installiert (wir empfehlen die neueste LTS-Version).
Einen OpenAI-API-Schlüssel (oder einen API-Schlüssel von einem der anderen unterstützten LLMs).

Sie benötigen außerdem ein Bright Data-Konto mit einem API-Schlüssel, aber keine Sorge, Sie werden in Kürze durch diesen Vorgang geführt. Grundlegende Kenntnisse über die Funktionsweise von MCP und die von Web MCP bereitgestellten Tools sind ebenfalls hilfreich.

Schritt 1: AutoGen-Projekt einrichten

Öffnen Sie ein Terminal und erstellen Sie ein neues Verzeichnis für Ihr AutoGen-KI-Projekt:

mkdir autogen-mcp-agent

Der Ordner „autogen-mcp-agent/“ enthält den Python-Code für Ihren MCP-integrierten Agenten.

Navigieren Sie anschließend in das Projektverzeichnis und initialisieren Sie darin eine virtuelle Umgebung:

cd autogen-mcp-agent
python -m venv .venv

Aktivieren Sie die virtuelle Umgebung. Führen Sie unter Linux oder macOS folgenden Befehl aus:

source .venv/bin/activate

Unter Windows führen Sie stattdessen folgenden Befehl aus:

.venv/Scripts/activate

Fügen Sie Ihrem Projekt eine neue Datei namens agent.py hinzu, die nun Folgendes enthalten sollte:

autogen-mcp-agent/
├── .venv/
└── agent.py

agent.py dient als Ihre Haupt-Python-Datei und enthält die Logik des KI-Agenten.

Laden Sie den Projektordner in Ihre bevorzugte Python-IDE, z. B. Visual Studio Code mit der Python-Erweiterung oder PyCharm Community Edition.

Installieren Sie bei aktivierter virtueller Umgebung die erforderlichen Abhängigkeiten:

pip install autogen-agentchat „autogen-ext[openai]” „autogen-ext[mcp]” python-dotenv

Die soeben installierten Bibliotheken sind:

autogen-agentchat: Zur Entwicklung von Einzel- oder Mehrfachagent-Anwendungen über eine benutzerfreundliche API, die auf autogen-core aufbaut.
„autogen-ext[openai]”: Erweiterung für AutoGen zum Erstellen von Agenten, die auf OpenAI-Modellen basieren.
„autogen-ext[mcp]”: Erweiterung zum Verbinden von AutoGen-Agenten mit MCP-Servern.
python-dotenv: Zum Laden von Umgebungsvariablen aus einer lokalen .env -Datei.

Hinweis: Wenn Sie keine OpenAI-Modelle verwenden möchten, installieren Sie das entsprechende Paket für Ihren bevorzugten LLM-Anbieter, wie in der Dokumentation erläutert.

Fertig! Ihre Python-Umgebung ist nun bereit für die Entwicklung von KI-Agenten mit AutoGen.

Schritt 2: Konfigurieren des Lesens von Umgebungsvariablen

Ihr Agent ist auf Verbindungen zu Drittanbieterdiensten wie OpenAI und Bright Data angewiesen. Um diese Verbindungen zu authentifizieren, müssen Sie Ihre API-Schlüssel angeben. Anstatt diese in Ihrer agent.py-Datei fest zu codieren, was eine schlechte Praxis ist und Sicherheitsprobleme verursachen kann, konfigurieren Sie Ihr Skript so, dass es Geheimnisse aus Umgebungsvariablen liest.

Aus diesem Grund wurde das Python-Dotenv-Paket überhaupt erst installiert. Importieren Sie in Ihrer Datei „agent.py” die Bibliothek und rufen Sie „load_dotenv()” auf, um Ihre Umgebungsvariablen zu laden:

from dotenv import load_dotenv

load_dotenv()

Ihr Assistent kann nun Variablen aus einer lokalen .env -Datei lesen.

Fügen Sie daher eine .env -Datei zum Stammverzeichnis Ihres Projektverzeichnisses hinzu:

autogen-mcp-agent/
├── .venv/
├── .env         # <------
└── agent.py

Sie können nun mit folgendem Befehl auf Umgebungsvariablen in Ihrem Code zugreifen:

import os

os.getenv("ENV_NAME")

Großartig! Ihr Skript lädt Integrationsgeheimnisse von Drittanbietern mithilfe von Umgebungsvariablen.

Schritt 3: Erste Schritte mit Bright Data’s Web MCP

Bevor Sie Ihren Agenten mit dem Web MCP von Bright Data verbinden, müssen Sie zunächst sicherstellen, dass Ihr Rechner den Server ausführen kann. Dies ist erforderlich, da Sie AutoGen anweisen werden, den Web MCP lokal zu starten, und der Agent sich dann damit verbinden wird.

Wenn Sie noch kein Bright Data-Konto haben, erstellen Sie eines. Wenn Sie bereits ein Konto haben, melden Sie sich einfach an. Für eine schnelle Einrichtung sehen Sie sich den Abschnitt„MCP”in Ihrem Konto an:

The “MCP” section in your Bright Data account

Weitere Anleitungen finden Sie in den folgenden Schritten.

Beginnen Sie mit der Generierung eines Bright Data-API-Schlüssels. Bewahren Sie diesen an einem sicheren Ort auf, da Sie ihn in Kürze benötigen werden. Wir gehen davon aus, dass der API-Schlüssel über Administratorrechte verfügt, da dies den Integrationsprozess von Web MCP vereinfacht.

Fahren Sie fort, indem Sie das Web-MCP über das npm-Paket @brightdata/mcp global auf Ihrem System installieren:

npm install -g @brightdata/mcp

Überprüfen Sie anschließend, ob der lokale MCP-Server funktioniert, indem Sie ihn starten:

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

Oder, gleichwertig, unter Linux/macOS:

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

Ersetzen Sie den Platzhalter <YOUR_BRIGHT_DATA_API> durch Ihren tatsächlichen Bright Data API-Token. Beide Befehle legen die erforderliche Umgebungsvariable API_TOKEN fest und starten den Web-MCP lokal.

Wenn dies erfolgreich ist, sollte eine Ausgabe wie diese angezeigt werden:

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

mcp_unlocker: Eine Zone für Web Unlocker.
mcp_browser: Eine Zone für die Browser-API.

Web MCP stützt sich auf diese beiden Bright Data-Produkte, um seine über 60 Tools zu betreiben.

Um zu überprüfen, ob die Zonen erstellt wurden, melden Sie sich bei Ihrem Bright Data-Dashboard an und rufen Sie die Seite„Proxy & Scraping-Infrastruktur“auf. Sie sollten die beiden Zonen in der Tabelle sehen:

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

Hinweis: Wenn Ihr API-Token keine Administratorrechte hat, werden diese Zonen nicht erstellt. In diesem Fall müssen Sie sie manuell im Dashboard definieren und ihre Namen im Befehl über Umgebungsvariablen konfigurieren (weitere Informationen finden Sie auf der GitHub-Seite).

Beachten Sie, dass der MCP-Server standardmäßig nur die Tools search_engine und scrape_as_markdown (und deren Batch-Versionen) bereitstellt. Diese Tools sind in der kostenlosen Version von Web MCP enthalten, sodass Sie sie kostenlos nutzen können.

Um erweiterte Tools wie Browser-Automatisierung und strukturierte Datenfeeds freizuschalten, müssen Sie den Pro-Modus aktivieren. Setzen Sie dazu die Umgebungsvariable PRO_MODE="true", bevor Sie Web MCP starten:

$Env:API_TOKEN="<YOUR_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

Der Pro-Modus schaltet alle über 60 Tools frei, ist jedoch nicht in der kostenlosen Version enthalten und verursacht zusätzliche Kosten.

Perfekt! Sie haben gerade überprüft, dass der Web-MCP-Server auf Ihrem Rechner läuft. Beenden Sie den MCP-Prozess, da Sie im nächsten Schritt Ihren AutoGen AgentChat-Agenten so konfigurieren werden, dass er gestartet wird und sich damit verbindet.

Schritt 4: Konfigurieren der Web-MCP-Verbindung

Nachdem Ihr Computer nun den Web-MCP ausführen kann, müssen Sie Ihr Skript anweisen, eine Verbindung zum Server herzustellen.

Fügen Sie zunächst den zuvor abgerufenen Bright Data API-Schlüssel zu Ihrer .env -Datei hinzu:

BRIGHT_DATA_API_KEY="<YOUR_BRIGHT_DATA_API_KEY>"

Ersetzen Sie <YOUR_BRIGHT_DATA_API_KEY> durch Ihren tatsächlichen API-Schlüssel.

Laden Sie in agent.py den Wert des Bright Data API-Schlüssels mit folgendem Befehl:

BRIGHT_DATA_API_KEY = os.getenv("BRIGHT_DATA_API_KEY")

Definieren Sie als Nächstes eine asynchrone Funktion und konfigurieren Sie die MCP-Verbindung zu einem lokalen Web-MCP-Prozess:

from autogen_ext.tools.mcp import (
    StdioServerParams,
    mcp_server_tools
)

async def main():
    # Konfigurationen für die Verbindung mit dem Bright Data Web MCP
    bright_data_mcp_server = StdioServerParams(
        command="npx",
        args=[
            "-y",
            "@brightdata/mcp"
        ],
        env={
            "API_TOKEN": BRIGHT_DATA_API_KEY,
            "PRO_MODE": "true" # Optional
        }
    )

    # Laden der vom Bright Data Web MCP-Server bereitgestellten Tools
    bright_data_tools = await mcp_server_tools(bright_data_mcp_server)

    # Agentendefinition...

Diese Konfiguration spiegelt den npx-Befehl aus dem vorherigen Schritt wider, wobei die Umgebungsvariable für den API-Token verwendet wird. Beachten Sie, dass PRO_MODE optional ist, während API_TOKEN erforderlich ist.

Im Wesentlichen startet Ihr Skript agent.py nun einen Web-MCP-Prozess und verbindet sich über STDIO damit. Das Ergebnis ist eine Reihe von Tools, die Sie an Ihre AutoGen-Agenten übergeben können.

Überprüfen Sie die Verbindung, indem Sie die verfügbaren Tools auflisten:

for bright_data_tool in bright_data_tools:

print(f"TOOL: {bright_data_tool.name} - {bright_data_tool.description}n")

Wenn Sie Ihr Skript mit deaktiviertem Pro-Modus ausführen, sollte die Ausgabe in etwa so aussehen:

The tool list output with Pro mode disabled

Andernfalls, wenn der Pro-Modus aktiviert ist, werden Ihnen alle über 60 Tools angezeigt:

The tool list output with Pro mode enabled

Das war’s schon! Die Ausgabe bestätigt, dass Ihre Web-MCP-Integration einwandfrei funktioniert.

Schritt 5: Definieren Sie Ihren AutoGen-Agenten

AutoGen AgentChat wird mit einer Reihe voreingestellter Agenten geliefert , die jeweils mit unterschiedlichen Antwortstilen ausgestattet sind. In diesem Fall ist der universell einsetzbare AssistantAgent am besten geeignet.

Bevor Sie den Agenten definieren, müssen Sie eine LLM-Integration konfigurieren, da ein Agent ohne ein zugrunde liegendes KI-Modell nicht funktionieren kann.

Fügen Sie zunächst Ihren OpenAI-API-Schlüssel zur .env -Datei hinzu:

OPENAI_API_KEY="<IHR_OPENAI_API_SCHLÜSSEL>"

Richten Sie dann die OpenAI-Integration in Ihrem Code ein mit:

from autogen_ext.models.openai import OpenAIChatCompletionClient

model_client = OpenAIChatCompletionClient(
    model="gpt-4o-mini",
)

Der OpenAIChatCompletionClient liest automatisch die Umgebungsvariable OPENAI_API_KEY, sodass Sie diese nicht in Ihren Code laden müssen. Diese Umgebung wird zur Authentifizierung der zugrunde liegenden API-Aufrufe an OpenAI verwendet.

Beachten Sie, dass das obige Beispiel Ihren Agenten mit dem GPT-4o-Modell von OpenAI verbindet. Wenn Sie ein anderes Modell oder einen anderen LLM-Anbieter verwenden möchten, lesen Sie deren Dokumentation und nehmen Sie entsprechende Anpassungen vor.

Hinweis: Zum Zeitpunkt der Erstellung dieses Artikels werden GPT-5-Modelle in autogen-ext[openai] noch nicht unterstützt.

Kombinieren Sie nun das Modell mit den zuvor geladenen MCP-Tools, um einen Assistenz-Agenten zu erstellen:

from autogen_agentchat.agents import AssistantAgent

agent = AssistantAgent(
    name="web_agent",
    model_client=model_client,
    tools=bright_data_tools,
)

Großartig! Sie haben gerade Ihren ersten AutoGen AgentChat-Agenten erstellt, der auf OpenAI basiert und in die MCP-Tools von Bright Data integriert ist.

Schritt 6: Erstellen Sie Ihr AutoGen-Team

Sie können eine Aufgabe direkt an Ihren Agenten übergeben und ausführen. Dies ist jedoch nicht die beste Vorgehensweise, da der Agent nach der Ausführung eines einzigen Tools stoppt. Sie könnten dieses Verhalten zwar mit dem Argument max_tool_iterations anpassen, aber in der Regel ist es besser, ein Team zu definieren.

In AutoGen ist ein Team eine Gruppe von Agenten, die gemeinsam auf ein Ziel hinarbeiten. In Ihrem Fall wird das Team nur einen Agenten haben (was eine gültige Konfiguration ist). Dennoch erleichtert die Definition eines Teams jetzt die spätere Erweiterung, wenn Sie weitere Agenten hinzufügen und einen Multi-Agent-Workflow aufbauen möchten.

Eine gängige Konfiguration ist das RoundRobinGroupChat-Team, bei dem sich die Agenten im Round-Robin-Stil abwechseln. Sie benötigen außerdem eine Beendigungsbedingung, um zu entscheiden, wann die Schleife beendet werden soll. Hier verwenden wir TextMentionTermination, das so konfiguriert ist, dass der Prozess beendet wird, wenn das Wort „TERMINATE” in der Antwort des Agenten erscheint:

from autogen_agentchat.conditions import TextMentionTermination
from autogen_agentchat.teams import RoundRobinGroupChat

# Definieren Sie eine Beendigungsbedingung für die Schleife.
text_termination = TextMentionTermination("TERMINATE")

# Erstellen Sie ein Team mit dem einzigen Agenten.
team = RoundRobinGroupChat([agent], termination_condition=text_termination)

Beachten Sie, dass dies eine Standardkonfiguration ist, die in den meisten AutoGen-Beispielen gezeigt wird.

Selbst mit nur einem Agenten ruft das Team diesen so lange wiederholt auf, bis die Aufgabe abgeschlossen ist. Dies ist besonders nützlich für komplexe Aufgaben, die möglicherweise mehrere Tool-Aufrufe – und damit mehrere Interaktionsrunden – erfordern, bevor sie abgeschlossen sind.

Gut! Jetzt muss nur noch das Team ausgeführt und das Ergebnis erfasst werden.

Schritt 7: Ausführen der Aufgabe

Um Ihre AutoGen AgentChat-Anwendung auszuführen, übergeben Sie eine Aufgabe an das Team, zu dem Ihr Agent gehört. Um die erweiterten Funktionen zum Abrufen von Webdaten zu testen, führen Sie eine Eingabeaufforderung wie diese aus:

task = """
Rufen Sie Informationen aus der folgenden App im App Store ab:
„https://apps.apple.com/us/app/brave-browser-search-engine/id1052879175“

Sagen Sie mir anhand von Nutzerbewertungen, Preisen und allen verfügbaren Informationen, ob Sie diese App für installierenswert und vertrauenswürdig halten.
"""

Natürlich können OpenAI-Modelle diese Aufgabe nicht alleine bewältigen, da sie nicht alle Daten aus dem App Store abrufen können. Hier kommt Ihre Integration mit den Tools von Bright Data ins Spiel. Mit dieser Konfiguration kann Ihr Agent die App-Seite scrapen, Bewertungen und Preisdetails analysieren und dann die Informationen vom LLM zu einem klaren, für Menschen lesbaren Bericht verarbeiten lassen.

Dies ist ein praktisches Beispiel dafür, wie Sie einen Agenten erstellen können, der Apps vor der Installation bewertet und potenzielle Probleme oder Bedenken der Benutzer hervorhebt. Schließlich kann die Installation von Apps ohne sorgfältige Prüfung aus Sicherheitsgründen riskant sein.

Führen Sie nun die Aufgabe aus und streamen Sie die Antwort direkt in Ihrem Terminal mit:

from autogen_agentchat.ui import Console

await Console(team.run_stream(task=task))

Cool! An dieser Stelle startet das Team und die Aufgabe wird an Ihren konfigurierten Agenten übergeben. Der Agent führt möglicherweise mehrere Iterationen durch, um das Ziel zu erreichen. Das erwartete Ergebnis ist, dass der Agent die Tools von Bright Data aus Web MCP verwendet, um Daten aus dem App Store zu scrapen, und dass das LLM diese Daten dann zu einer Bewertung zusammenfasst, ob die ausgewählte App eine Installation wert ist.

Vergessen Sie nicht, als letzten Schritt die Verbindung zu Ihrem ausgewählten Modell am Ende Ihres Skripts zu schließen:

await model_client.close()

Schritt 8: Alles zusammenfügen

Ihre Datei agent.py sollte Folgendes enthalten:

# pip install autogen-agentchat "autogen-ext[openai]" "autogen-ext[mcp]" python-dotenv
import asyncio
from dotenv import load_dotenv
import os
from autogen_ext.tools.mcp import (
    StdioServerParams,
    mcp_server_tools
)
from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_agentchat.agents import AssistantAgent
from autogen_agentchat.conditions import TextMentionTermination
from autogen_agentchat.teams import RoundRobinGroupChat
from autogen_agentchat.ui import Console

# Lade die Umgebungsvariablen aus der .env-Datei
load_dotenv()

# Lade deinen Bright Data API-Schlüssel aus den Umgebungsvariablen
BRIGHT_DATA_API_KEY = os.getenv("BRIGHT_DATA_API_KEY")

async def main():
    # Konfigurationen für die Verbindung mit dem Bright Data Web MCP
    bright_data_mcp_server = StdioServerParams(
        command="npx",
        args=[
            "-y",
            "@brightdata/mcp"
        ],
        env={
            "API_TOKEN": BRIGHT_DATA_API_KEY,
            "PRO_MODE": "true" # Optional
        }
    )

    # Laden Sie die vom Bright Data Web MCP-Server bereitgestellten Tools.
    bright_data_tools = await mcp_server_tools(bright_data_mcp_server)

    # LLM-Integration
    model_client = OpenAIChatCompletionClient(
        model="gpt-4o-mini",
    )

    # Definieren Sie Ihren KI-Assistenten, der von den Web-MCP-Tools unterstützt wird.
    agent = AssistantAgent(
        name="web_agent",
        model_client=model_client,
        tools=bright_data_tools,
    )

    # Definieren Sie eine Beendigungsbedingung für die Schleife.
    text_termination = TextMentionTermination("TERMINATE")

    # Erstellen Sie ein Team mit dem einzigen Agenten.
    team = RoundRobinGroupChat([agent], termination_condition=text_termination)

    # Die vom Team auszuführende Aufgabe.
    task = """
    Rufe Informationen aus der folgenden App im App Store ab:
    „https://apps.apple.com/us/app/brave-browser-search-engine/id1052879175“

    Sag mir anhand von Nutzerbewertungen, Preisen und allen verfügbaren Informationen, ob diese App deiner Meinung nach eine Installation wert und vertrauenswürdig ist.
    """

    # Die Antwort des Teams an das Terminal streamen
await Console(team.run_stream(task=task))

# Die KI-Verbindung schließen
await model_client.close()

if __name__ == "__main__":
asyncio.run(main())

Wow! Mit nur etwa 70 Zeilen Code haben Sie gerade ein Single-Agent-Team erstellt, das Apps für die Installation im App Store analysiert.

Führen Sie den Agenten aus mit:

python agent.py

Das sollten Sie im Terminal sehen:

Wie Sie sehen können, hat der Agent korrekt erkannt, dass web_data_apple_app_store von Web MCP das richtige Tool für diese Aufgabe ist. Dies ist ein Pro-Tool zum „schnellen Abrufen strukturierter Apple App Store-Daten”. Es war also definitiv eine gute Wahl. Wenn Sie den Pro-Modus nicht aktiviert hätten, würde der Agent stattdessen das Tool scrape_as_markdown verwenden.

Die Ausführung des Tools kann etwas Zeit in Anspruch nehmen. Das Ergebnis sind strukturierte Daten (im JSON-Format), die wie erwartet aus der App Store-Seite extrahiert wurden:

Note the JSON result returned by the tool

Diese strukturierte Ausgabe wird dann vom LLM analysiert und verarbeitet, der einen Markdown-Bericht generiert:

Beachten Sie die detaillierten Informationen am Anfang des generierten Berichts. Diese stimmen genau mit den Angaben auf der Zielseite des App Stores überein:

Mission erfüllt! Ihr Agent kann nun Daten aus dem Internet abrufen und verarbeiten, um sinnvolle Aufgaben auszuführen.

Beachten Sie, dass dies nur ein einfaches Beispiel war. Mit der breiten Palette an Bright Data Web MCP-Tools, die in AutoGen AgentChat verfügbar sind, können Sie viel fortschrittlichere Agenten entwerfen, die auf eine Vielzahl von Anwendungsfällen in der Praxis zugeschnitten sind.

Et voilà! Sie haben gerade die Leistungsfähigkeit der Integration von Bright Data Web MCP in einen AutoGen AgentChat KI-Agenten in Python gesehen.

Testen Sie den mit Web MCP erweiterten Agenten visuell in Agent Studio

AutoGen bietet auch Studio, ein browserbasiertes Low-Code-Tool, mit dem Sie Agenten visuell erstellen und testen können. Damit können Sie den Agenten mit MCP-Integration auf vereinfachte Weise testen. Sehen Sie selbst!

Voraussetzungen

Die einzige Voraussetzung für diesen optionalen Abschnitt des Tutorials ist die Installation von AutoGen Studio. Installieren Sie es aus Ihrer aktivierten virtuellen Umgebung im Projektverzeichnis mit:

pip install -U autogenstudio

AutoGen Studio liest den OPENAI_API_KEY automatisch aus Ihrer .env-Datei, sodass Sie ihn nicht manuell im Tool konfigurieren müssen.

Schritt 1: JSON-Konfigurationsdatei des Teams abrufen

In AutoGen kann jede Komponente in einer Teamkonfiguration als JSON-Datei dargestellt werden. Da AutoGen Studio auf AgentChat aufbaut, können Sie AgentChat-Komponenten in JSON exportieren und dann in AutoGen Studio laden. Genau das werden wir hier tun!

Beginnen Sie damit, die zuvor erstellte Teamdefinition in eine lokale JSON-Datei zu exportieren:

config = team.dump_component()
with open("bd_mcp_team.json", "w", encoding="utf-8") as f:
    f.write(config.model_dump_json())

Dadurch wird eine Datei namens bd_mcp_team.json in Ihrem Projektordner erstellt. Öffnen Sie diese Datei.

Die Datei enthält eine JSON-Darstellung Ihres Agenten, einschließlich aller notwendigen Details für die Verbindung mit den Web-MCP-Tools von Bright Data.

Schritt 2: Laden Sie die JSON-Datei in AutoGen Studio

Starten Sie AutoGen Studio lokal mit:

autogenstudio ui --port 8080

Die Anwendung ist in Ihrem Browser unter http://127.0.0.1:8080 verfügbar. Öffnen Sie sie, und Sie sollten die folgende Web-App sehen:

Standardmäßig enthält die Lösung ein Team namens „RoundRobin Team”. Um es als Ihren MCP-erweiterten Agenten zu konfigurieren, schalten Sie den „Visual Builder”-Schalter um und rufen Sie den Modus „View JSON” auf:

Fügen Sie im JSON-Editor den Inhalt Ihrer Datei bd_mcp_team.json ein und klicken Sie auf die Schaltfläche „Save Changes“ (Änderungen speichern):

Ihr aktualisiertes „RoundRobin Team“ sollte nun wie folgt aussehen:

Beachten Sie, dass der Agentenname nun web_agent lautet, genau wie Sie ihn im Code definiert haben. Sie können Ihren mit Web MCP integrierten Agenten nun direkt in AutoGen Studio testen.

Schritt 3: Visuelles Testen des Agenten

Klicken Sie auf die Schaltfläche „Ausführen“ in der oberen rechten Ecke. Der Chat-Bereich zum Testen Ihres Teams wird angezeigt:

Fügen Sie dieselbe Aufgabenaufforderung wie zuvor ein und starten Sie sie:

Wie zuvor wählt der Agent das Tool „web_data_apple_app_store“ aus und führt es aus. Die endgültige Ausgabe lautet:

The final, visual result produced by the agent in AutoGen Studio

Auf der linken Seite enthält die vorletzte Nachricht die vom Agenten generierte Antwort. Dieses Mal können Sie auch sehen, dass der Agent mit einer automatisch gesendeten „TERMINATE“-Nachricht beendet wird. Auf der rechten Seite finden Sie eine visuelle Darstellung der Ausführung, die Ihnen hilft, Schritt für Schritt zu verstehen, was passiert.

Auch wenn der Agent beendet wurde, wird sein Kontext weiterhin mit dem Team geteilt. Das bedeutet, dass Sie die Unterhaltung nahtlos fortsetzen können, indem Sie eine weitere Aufgabe übergeben – genau wie in ChatGPT oder jeder anderen chatähnlichen KI-Schnittstelle.

Dies zeigt einen der echten Vorteile des Testens Ihrer Agenten in AutoGen Studio. Sie können die Aktionen des Agenten visuell verfolgen, die Ergebnisse überprüfen und den Kontext über mehrere Interaktionen hinweg beibehalten. Fantastisch!

Fazit

In diesem Blogbeitrag haben Sie gesehen, wie Sie mit AutoGen AgentChat einen KI-Agenten erstellen und ihn mit Tools aus Bright Datas Web MCP (das auch eine kostenlose Stufe bietet!) optimieren können. Außerdem haben Sie Ihren Agenten visuell getestet und ihn in einer chatähnlichen Umgebung über AutoGen Studio ausgeführt.

Diese Integration erweitert Ihren Agenten um Websuche, strukturierte Datenextraktion, Zugriff auf Webdaten-Feeds, Webinteraktionsfunktionen und vieles mehr. Um noch fortschrittlichere KI-Agenten zu erstellen, entdecken Sie die breitere Palette an Produkten und Dienstleistungen innerhalb der KI-Infrastruktur von Bright Data.

Registrieren Sie sich noch heute für ein kostenloses Bright Data-Konto und probieren Sie die KI-fähigen Webdaten-Tools aus!

Vertrieb kontaktieren Gratis testen