--- title: "Bright Data MCP mit AutoGen AgentChat und Studio" slug: autogen-agentchat-with-web-mcp date: 2025-11-26T12:55:00+00:00 modified: 2025-11-26T12:55:02+00:00 permalink: https://brightdata.de/blog/ai/autogen-agentchat-with-web-mcp type: blog --- [ Blog ](https://brightdata.de/blog "Blog") / [AI](https://brightdata.de/blog/ai) [AI](https://brightdata.de/blog/ai) # Bright Data MCP mit AutoGen AgentChat und Studio Entdecken Sie, wie Sie AutoGen-KI-Agenten mit Live-Webdaten mithilfe von Bright Data’s Web MCP verbessern können. Enthält Schritt-für-Schritt-Anleitungen für AgentChat und AutoGen Studio. 6 min lesen [ ![Antonello Zanini](https://media.brightdata.de/2022/12/Antonello-Zanini-2-50x50.jpg) ](https://brightdata.com/blog/authors/antonello-zanini) [Antonello Zanini Technical Writer ](https://brightdata.com/blog/authors/antonello-zanini) ![AutoGen AgentChat × Bright Data MCP](https://media.brightdata.de/2025/10/AutoGen-AgentChat-%C3%97-Bright-Data-MCP.png) 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 Bright Data 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](https://www.microsoft.com/en-us/research/project/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](https://github.com/microsoft/autogen) 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 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](/blog/web-data/llm-training-data), 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 Bright Data MCP**](/ai/mcp-server) 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 Bright Data MCP ein Open-Source-Server, der [mehr als 60 KI-fähige Tools](https://docs.brightdata.com/mcp-server/tools) bereitstellt. Diese basieren alle auf der Infrastruktur von Bright Data für Webinteraktion und Datenerfassung. Selbst in [der kostenlosen Version](/blog/ai/web-mcp-free-tier) 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 Bright Data 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](https://github.com/brightdata/brightdata-mcp). Kurz gesagt: Die Konfiguration von Bright Data 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 Bright Data MCP in AutoGen AgentChat unter Verwendung von Python In diesem Abschnitt erfahren Sie, wie Sie einen Agenten mit [AutoGen AgentChat](https://microsoft.github.io/autogen/stable//user-guide/agentchat-user-guide/index.html) erstellen, der hochentwickelten API zum Erstellen von Multi-Agent-Anwendungen. Der Agent kann alle vom Bright Data 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](https://microsoft.github.io/autogen-for-net/). 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+](https://www.python.org/downloads/) auf Ihrem Computer installiert ist. - Node.js installiert (wir empfehlen die [neueste](https://nodejs.org/en/download)[LTS-Version](https://nodejs.org/en/download)). - Einen [OpenAI-API-Schlüssel](https://platform.openai.com/api-keys) (oder einen API-Schlüssel von einem der [anderen unterstützten LLMs](https://microsoft.github.io/autogen/stable//user-guide/agentchat-user-guide/tutorial/models.html)). 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](https://modelcontextprotocol.io/specification/2025-06-18) und [die von Bright Data MCP bereitgestellten Tools](https://docs.brightdata.com/mcp-server/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: ```none 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](https://docs.python.org/3/library/venv.html) darin [eine virtuelle Umgebung](https://docs.python.org/3/library/venv.html): ```none cd autogen-mcp-agent python -m venv .venv ``` Aktivieren Sie die virtuelle Umgebung. Führen Sie unter Linux oder macOS folgenden Befehl aus: ```none source .venv/bin/activate ``` Unter Windows führen Sie stattdessen folgenden Befehl aus: ```none .venv/Scripts/activate ``` Fügen Sie Ihrem Projekt eine neue Datei namens `agent.py` hinzu, die nun Folgendes enthalten sollte: ```none 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](https://code.visualstudio.com/docs/languages/python) oder [PyCharm Community Edition](https://www.jetbrains.com/pycharm/download/). Installieren Sie bei aktivierter virtueller Umgebung die erforderlichen Abhängigkeiten: ```none pip install autogen-agentchat „autogen-ext[openai]” „autogen-ext[mcp]” python-dotenv ``` Die soeben installierten Bibliotheken sind: - [`autogen-agentchat`](https://pypi.org/project/autogen-agentchat/): Zur Entwicklung von Einzel- oder Mehrfachagent-Anwendungen über eine benutzerfreundliche API, die auf autogen-core aufbaut. - [`„autogen-ext[openai]”`](https://pypi.org/project/autogen-ext/): Erweiterung für AutoGen zum Erstellen von Agenten, die auf OpenAI-Modellen basieren. - [`„autogen-ext[mcp]”`](https://pypi.org/project/autogen-ext/)[:](https://pypi.org/project/autogen-ext/) Erweiterung zum Verbinden von AutoGen-Agenten mit MCP-Servern. - [`python-dotenv`](https://pypi.org/project/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](https://microsoft.github.io/autogen/stable//user-guide/agentchat-user-guide/tutorial/models.html). 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: ```none 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: ```none autogen-mcp-agent/ ├── .venv/ ├── .env # <------ └── agent.py ``` Sie können nun mit folgendem Befehl auf Umgebungsvariablen in Ihrem Code zugreifen: ```none 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 MCP Bevor Sie Ihren Agenten mit dem Bright Data 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 Bright Data MCP lokal zu starten, und der Agent sich dann damit verbinden wird. Wenn Sie noch kein Bright Data-Konto haben, [erstellen Sie eines](/?hs_signup=1). Wenn Sie bereits ein Konto haben, [melden Sie sich einfach an](/cp/start). Für eine schnelle Einrichtung sehen Sie sich den Abschnitt[„MCP”](/cp/mcp)in Ihrem Konto an: ![The “MCP” section in your Bright Data account](https://media.brightdata.com/2025/10/image-11-1024x548.png)Weitere Anleitungen finden Sie in den folgenden Schritten. Beginnen Sie mit [der Generierung eines Bright Data-API-Schlüssels](https://docs.brightdata.com/api-reference/authentication#generating-an-api-key%3A). 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 Bright Data MCP vereinfacht. Fahren Sie fort, indem Sie das Web-MCP über das npm-Paket [`@brightdata/mcp`](https://www.npmjs.com/package/@brightdata/mcp) global auf Ihrem System installieren: ```none npm install -g @brightdata/mcp ``` Überprüfen Sie anschließend, ob der lokale MCP-Server funktioniert, indem Sie ihn starten: ```none $Env:API_TOKEN=""; npx -y @brightdata/mcp ``` Oder, gleichwertig, unter Linux/macOS: ```none API_TOKEN="" npx -y @brightdata/mcp ``` Ersetzen Sie den Platzhalter `` 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: ![Bright Data MCP startup logs](https://media.brightdata.com/2025/10/image-12-1024x157.png)Beim ersten Start erstellt der Web-MCP automatisch zwei Standardzonen in Ihrem Bright Data-Konto: - `mcp_unlocker`: Eine Zone für [Web Unlocker](/products/web-unlocker). - `mcp_browser`: Eine Zone für [die Browser-API](/products/scraping-browser). Bright Data 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“](/cp/zones)auf. Sie sollten die beiden Zonen in der Tabelle sehen: ![The mcp_unlocker and mcp_browser zones created by the Bright Data MCP at startup](https://media.brightdata.com/2025/10/image-13-1024x539.png)**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](https://github.com/brightdata/brightdata-mcp?tab=readme-ov-file#-account-setup)). 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 Bright Data MCP](/blog/ai/web-mcp-free-tier) 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 Bright Data MCP starten: ```none $Env:API_TOKEN=""; $Env:PRO_MODE="true"; npx -y @brightdata/mcp ``` Oder unter Linux/macOS: ```none API_TOKEN="" 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](https://github.com/brightdata/brightdata-mcp?tab=readme-ov-file#-pricing--modes). 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: ```none BRIGHT_DATA_API_KEY="" ``` Ersetzen Sie `` durch Ihren tatsächlichen API-Schlüssel. Laden Sie in `agent.py` den Wert des Bright Data API-Schlüssels mit folgendem Befehl: ```none BRIGHT_DATA_API_KEY = os.getenv("BRIGHT_DATA_API_KEY") ``` Definieren Sie als Nächstes eine [`asynchrone`](https://docs.python.org/3/library/asyncio.html) Funktion und konfigurieren Sie die MCP-Verbindung zu einem lokalen Web-MCP-Prozess: ```none from autogen_ext.tools.mcp import ( StdioServerParams, mcp_server_tools ) async def main(): # Konfigurationen für die Verbindung mit dem Bright Data 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 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](https://modelcontextprotocol.io/specification/2025-06-18/basic/transports#stdio). 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: ```none 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](https://media.brightdata.com/2025/10/image-14-1024x225.png)Andernfalls, wenn der Pro-Modus aktiviert ist, werden Ihnen alle über 60 Tools angezeigt: ![The tool list output with Pro mode enabled](https://media.brightdata.com/2025/10/image-15-1024x525.png)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](https://microsoft.github.io/autogen/stable//user-guide/agentchat-user-guide/tutorial/agents.html) geliefert [,](https://microsoft.github.io/autogen/stable//user-guide/agentchat-user-guide/tutorial/agents.html) die jeweils mit unterschiedlichen Antwortstilen ausgestattet sind. In diesem Fall ist der universell einsetzbare [`AssistantAgent`](https://microsoft.github.io/autogen/stable//user-guide/agentchat-user-guide/tutorial/agents.html#assistant-agent) 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: ```none OPENAI_API_KEY="" ``` Richten Sie dann die OpenAI-Integration in Ihrem Code ein mit: ```none from autogen_ext.models.openai import OpenAIChatCompletionClient model_client = OpenAIChatCompletionClient( model="gpt-4o-mini", ) ``` Der [`OpenAIChatCompletionClient`](https://microsoft.github.io/autogen/stable//reference/python/autogen_ext.models.openai.html#autogen_ext.models.openai.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](https://platform.openai.com/docs/models/gpt-4o) 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: ```none 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](https://microsoft.github.io/autogen/stable//user-guide/agentchat-user-guide/tutorial/teams.html), die gemeinsam auf ein Ziel hinarbeiten. In Ihrem Fall wird das Team nur einen Agenten haben ([was eine gültige Konfiguration ist](https://microsoft.github.io/autogen/stable//user-guide/agentchat-user-guide/tutorial/teams.html#single-agent-team)). 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`](https://microsoft.github.io/autogen/stable//reference/python/autogen_agentchat.teams.html#autogen_agentchat.teams.RoundRobinGroupChat), 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`](https://microsoft.github.io/autogen/stable//reference/python/autogen_agentchat.conditions.html#autogen_agentchat.conditions.TextMentionTermination), das so konfiguriert ist, dass der Prozess beendet wird, wenn das Wort „TERMINATE” in der Antwort des Agenten erscheint: ```none 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: ```none 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: ```none 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 Bright Data 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: ```none await model_client.close() ``` ### Schritt 8: Alles zusammenfügen Ihre Datei `agent.py` sollte Folgendes enthalten: ```none # 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 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 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: ```none python agent.py ``` Das sollten Sie im Terminal sehen: ![Note the tool execution from the agent](https://media.brightdata.com/2025/10/image-16-1024x224.png)Wie Sie sehen können, hat der Agent korrekt erkannt, dass `web_data_apple_app_store` von Bright Data 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](https://media.brightdata.com/2025/10/image-17-1024x190.png)Diese strukturierte Ausgabe wird dann vom LLM analysiert und verarbeitet, der einen Markdown-Bericht generiert: ![The report produced by the AI model](https://media.brightdata.com/2025/10/image-18-1024x804.png)Beachten Sie die detaillierten Informationen am Anfang des generierten Berichts. Diese stimmen genau mit den Angaben auf der [Zielseite des App Stores](https://apps.apple.com/us/app/brave-browser-search-engine/id1052879175) überein: ![The target page](https://media.brightdata.com/2025/10/image-19-1024x604.png)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 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](/ai/web-access) zugeschnitten sind. Et voilà! Sie haben gerade die Leistungsfähigkeit der Integration von Bright Data MCP in einen AutoGen AgentChat KI-Agenten in Python gesehen. ## Testen Sie den mit Bright Data MCP erweiterten Agenten visuell in Agent Studio AutoGen bietet auch [Studio](https://microsoft.github.io/autogen/stable/user-guide/autogenstudio-user-guide/index.html), 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: ```none 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: ```none 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: ```none 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: ![The default team in AutoGen Studio](https://media.brightdata.com/2025/10/image-20-1024x551.png)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: ![Enabling the “View JSON” mode](https://media.brightdata.com/2025/10/image-21-1024x783.png)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): ![Pressing the “Save Changes” button](https://media.brightdata.com/2025/10/image-22-1024x749.png)Ihr aktualisiertes „RoundRobin Team“ sollte nun wie folgt aussehen: ![The updated team](https://media.brightdata.com/2025/10/image-23-1024x784.png)Beachten Sie, dass der Agentenname nun web\_agent lautet, genau wie Sie ihn im Code definiert haben. Sie können Ihren mit Bright Data 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: ![Note the chat section on the right](https://media.brightdata.com/2025/10/image-24-1024x550.png)Fügen Sie dieselbe Aufgabenaufforderung wie zuvor ein und starten Sie sie: ![Executing the same task as before](https://media.brightdata.com/2025/10/Executing-the-same-task-as-before-1024x548.gif)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](https://media.brightdata.com/2025/10/image-25-1024x1006.png)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 Bright Data MCP ([das auch eine kostenlose Stufe bietet!](/blog/ai/web-mcp-free-tier)) 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](/ai). Registrieren Sie sich noch heute für ein kostenloses Bright Data-Konto und probieren Sie die KI-fähigen Webdaten-Tools aus! Vertrieb kontaktierenGratis testen![google social icon](/wp-content/themes/brightdata/assets/images/ic_google.svg) Inhaltsverzeichnis Data for AI Supercharge your AI with instant and reliable access to web data. No blockers. No hassle. Talk to an expert Bright Data MCP Get started with Bright Data’s Web MCP Server today with 5000 free monthly requests and unlock your AI’s full potential. Start free now [ ](https://news.ycombinator.com/submitlink?t=Bright+Data+MCP+mit+AutoGen+AgentChat+und+Studio&u=https://brightdata.de/blog/ai/autogen-agentchat-with-web-mcp) [ ](https://www.linkedin.com/shareArticle?mini=true&title=Bright+Data+MCP+mit+AutoGen+AgentChat+und+Studio&url=https://brightdata.de/blog/ai/autogen-agentchat-with-web-mcp) [ ](http://www.reddit.com/submit?title=Bright+Data+MCP+mit+AutoGen+AgentChat+und+Studio&url=https://brightdata.de/blog/ai/autogen-agentchat-with-web-mcp) ## Das könnte Sie auch interessieren [ ![OpenHuman with Bright Data](https://media.brightdata.de/2026/09/OpenHuman-with-Bright-Data.png) ](https://brightdata.de/blog/ai/openhuman-with-bright-data "Produktionsreifer Web-Zugriff in OpenHuman über die Bright Data CLI") [AI ![Antonello Zanini](https://media.brightdata.de/2022/12/Antonello-Zanini-2-50x50.jpg) Antonello Zanini Technical Writer ### Produktionsreifer Web-Zugriff in OpenHuman über die Bright Data CLI Integrieren Sie die Bright Data CLI mit OpenHuman, um produktionsreifen Web-Zugriff und Datenerhebung für KI-Agenten zu ermöglichen. 09-Sep-2026 12 min lesen ](https://brightdata.de/blog/ai/openhuman-with-bright-data) [ ![Multimodal Web Scraping with MiniMax](https://media.brightdata.de/2026/09/Multimodal-Web-Scraping-with-MiniMax.png) ](https://brightdata.de/blog/web-data-de/multimodal-web-scraping-with-minimax "Multimodales Web-Scraping mit MiniMax") [Web Data ![Antonello Zanini](https://media.brightdata.de/2022/12/Antonello-Zanini-2-50x50.jpg) Antonello Zanini Technical Writer ### Multimodales Web-Scraping mit MiniMax Kombinieren Sie Bright Data Web Unlocker mit MiniMax M3 Vision, um strukturierte Daten aus Bildern und Webseiten-Screenshots zu extrahieren. 09-Sep-2026 4 min lesen ](https://brightdata.de/blog/web-data-de/multimodal-web-scraping-with-minimax) [ ![The 10 Best CLI Tools for Codex in 2026](https://media.brightdata.de/2026/08/The-10-Best-CLI-Tools-for-Codex-in-2026.png) ](https://brightdata.de/blog/ai/best-cli-tools-for-codex "Die 10 besten CLI-Tools für Codex im Jahr 2026 – Getestet & Bewertet") [AI ![Daniel Shashko](https://media.brightdata.de/2022/04/Daniel-Shashko-2-50x50.png) Daniel Shashko Web Data & AI Expert ### Die 10 besten CLI-Tools für Codex im Jahr 2026 – Getestet & Bewertet Die 10 CLI-Tools, die Codex schneller und leistungsfähiger machen, beginnend mit dem Bright Data CLI für echten Web-Zugriff aus der Sandbox heraus. 06-Sep-2026 20 min lesen ](https://brightdata.de/blog/ai/best-cli-tools-for-codex)