Integration von Qwen-Agent mit MCP zur Erstellung von Agenten mit Live-Datenzugriff

In diesem Leitfaden erfahren Sie mehr:

• Was die Qwen-Agent-Bibliothek ist und wie sie Ihnen hilft, KI-Agenten zu erstellen.
• Warum die Verwendung von Qwen3 mit dem Bright Data MCP-Server ideal für die Erstellung von KI-Agenten der nächsten Generation ist.
• Wie man Qwen-Agent mit Bright Data’s MCP integriert, um einen kompetenten Agenten auf Basis von Qwen3 aufzubauen.

Lasst uns eintauchen!

Was ist Qwen-Agent?

Qwen-Agent ist ein von Alibaba Cloud entwickeltes Open-Source-Framework für die Entwicklung fortschrittlicher LLM-gestützter Anwendungen. Es nutzt die Fähigkeiten von Qwen-Modellen zur Erstellung von KI-Agenten mit Unterstützung für Befehlsverfolgung, Werkzeugnutzung, Planung und Speicherverwaltung.

Diese Bibliothek dient vor allem als Backend für Qwen Chat. Sie bietet Kernkomponenten für den Aufbau von KI-Agenten, mit nativer Unterstützung für Funktions- und Toolaufrufe – auch über MCP(Model Context Protocol).

Qwen-Agent ermöglicht eine flexible Modellbereitstellung, sei es über den DashScope-Service von Alibaba Cloud oder selbst gehostete Qwen-Modelle. Es enthält auch eine Gradio-basierte Web-UI für die schnelle Bereitstellung und das Testen Ihrer Agenten im Browser.

Warum Qwen3 mit einem MCP-Server in Qwen-Agent kombinieren?

Qwen3 ist das neueste Modell, das von Alibaba Cloud entwickelt wurde. Es bietet eine starke Leistung und ist als Open-Source-Software bei mehreren Online-Anbietern kostenlos erhältlich (und Sie können es sogar selbst hosten!). Das macht es zu einer idealen Wahl für den Aufbau kostengünstiger und dennoch leistungsstarker KI-Agenten.

KI-Agenten, die auf Qwen3 basieren und mit Qwen-Agent entwickelt wurden, sind bereits leistungsfähig. Dennoch erben sie die Einschränkungen des zugrunde liegenden LLM. Diese Einschränkungen – wie der fehlende Zugang zu Echtzeit-Informationen – können überwunden werden, indem man den Agenten mit genauen Daten versorgt und ihm die Möglichkeit gibt, das Web live zu erkunden.

An dieser Stelle kommt der Bright Data MCP-Server ins Spiel. Der auf Node.js basierende MCP-Server ist mit den KI-Datenabfragetools von Bright Data integriert. Mit diesen Tools kann Ihr Agent in Echtzeit auf Webinhalte zugreifen, strukturierte Datensätze abfragen und Live-Web-Scraping durchführen.

Derzeit werden die folgenden MCP-Tools unterstützt:

Um einige Beispiele aus der Praxis kennenzulernen, lesen Sie unseren Leitfaden zum Scraping mit dem MCP-Server oder sehen Sie sich an, wie er mit Tools wie dem Google SDK integriert werden kann.

Hinweis: Bright Data erweitert das MCP-Toolset kontinuierlich, so dass Sie im Laufe der Zeit mit noch mehr Funktionen rechnen können.

Schauen Sie sich jetzt an, wie Sie diese MCP-Tools über Qwen3 mit Qwen-Agent nutzen können!

Integration von Qwen-Agent mit dem Bright MCP Server in Python

In diesem Abschnitt lernen Sie, wie Sie mit Qwen-Agent einen leistungsstarken Python-KI-Agenten auf Basis von Qwen3 erstellen. Der Agent wird mit Live-Datenabfrage-, Abruf- und Umwandlungsfunktionen über den Bright Data MCP-Server ausgestattet.

Als Beispiel werden wir zeigen, wie der KI-Agent Live-Produktdaten von Amazon abrufen kann, dasfür seine Scraping-Herausforderungen bekannt ist. Beachten Sie, dass dies nur ein möglicher Anwendungsfall ist. Der KI-Agent kann jedes der über 20 Tools nutzen, die über den MCP-Server verfügbar sind, um eine Vielzahl von Aufgaben zu bewältigen.

Hinweis: Indem Sie dem KI-Agenten einfach andere Aufforderungen geben, können Sie jedes andere Szenario oder jeden anderen Anwendungsfall erfüllen.

Führen Sie die folgenden Schritte aus, um mit Qwen-Agent und Qwen 3 einen KI-Agenten mit MCP-Unterstützung von Bright Data zu erstellen!

Voraussetzungen

Um diesem Tutorial folgen zu können, müssen Sie über Folgendes verfügen:

• Python 3.10 oder höher lokal installiert.
• Node.js lokal installiert.

Sie benötigen außerdem:

• Ein Bright Data-Konto.
• Ein OpenRouter-API-Schlüssel.

Die folgenden Schritte führen Sie durch die Einrichtung der Bright Data- und OpenRouter-Anmeldeinformationen, falls erforderlich. Machen Sie sich also im Moment keine Gedanken darüber.

Die folgenden Kenntnisse sind zwar nicht erforderlich, werden Ihnen aber helfen, den größtmöglichen Nutzen aus diesem Lernprogramm zu ziehen:

• Ein allgemeines Verständnis der Funktionsweise von MCP.
• Grundlegende Vertrautheit mit der Funktionsweise von Qwen Agent.
• Gewisse Kenntnisse des Bright Data MCP-Servers und seiner verfügbaren Tools.
• Einige Erfahrung mit asynchroner Programmierung in Python.

Schritt 1: Projekt einrichten

Öffnen Sie das Terminal und erstellen Sie einen neuen Ordner für Ihren MCP-gesteuerten KI-Agenten:

mkdir qwen-agent-mcp

Der Ordner qwen-agent-mcp enthält den gesamten Code für Ihren Python-KI-Agenten.

Navigieren Sie dann in den Projektordner und erstellen Sie darin eine virtuelle Umgebung:

cd qwen-agent-mcp
python -m venv venv

Öffnen Sie den Projektordner in Ihrer bevorzugten Python-IDE. Wir empfehlen die Verwendung von Visual Studio Code mit der Python-Erweiterung oder PyCharm Community Edition.

Erstellen Sie eine Datei mit dem Namen agent.py im Projektordner, die nun wie folgt aussehen sollte:

Die Datei agent.py ist derzeit leer, wird aber bald die Logik für die Integration von Qwen3 mit dem Bright Data MCP-Server enthalten.

Aktivieren Sie die virtuelle Umgebung über das Terminal in Ihrer IDE. Unter Linux oder macOS führen Sie diesen Befehl aus:

source venv/bin/activate

Starten Sie unter Windows die entsprechende Funktion:

venv/Scripts/activate

Sie sind bereit! Sie verfügen nun über eine Python-Umgebung zur Erstellung eines KI-Agenten unter Verwendung des Qwen-Agenten und des Bright Data MCP-Servers.

Schritt #2: Einrichten von Umgebungsvariablen Lesen

Ihr Projekt wird mit Drittanbieterdiensten wie OpenRouter und Bright Data interagieren. Vermeiden Sie die Festcodierung von API-Schlüsseln in Ihrem Python-Code. Laden Sie sie stattdessen aus Umgebungsvariablen, um die Sicherheit und Wartungsfreundlichkeit zu erhöhen.

Um diesen Prozess zu vereinfachen, werden wir die python-dotenv-Bibliothek nutzen. Installieren Sie sie bei aktivierter virtueller Umgebung, indem Sie sie ausführen:

pip install python-dotenv

Als nächstes importieren Sie in Ihrer agent.py-Datei die Bibliothek und laden die Umgebungsvariablen mit load_dotenv():

from dotenv import load_dotenv

load_dotenv()

Dies ermöglicht es Ihrem Skript, Umgebungsvariablen aus einer lokalen .env-Datei zu lesen. Legen Sie also eine .env-Datei in Ihrem Projektordner an:

Sie können nun auf Umgebungsvariablen in Ihrem Code wie folgt zugreifen:

env_value = os.getenv("<ENV_NAME>")

Vergessen Sie nicht, das Modul os aus der Python-Standardbibliothek zu importieren:

import os

Großartig! Sie sind nun in der Lage, Geheimnisse sicher aus den Umgebungsvariablen zu laden.

Schritt #3: Starten Sie mit Google ADK

Installieren Sie in Ihrer aktivierten virtuellen Umgebung die Qwen-Agent Bibliothek, indem Sie diese ausführen:

pip install "qwen-agent[gui,mcp]"

Beachten Sie, dass qwen-agent einige optionale Untermodule unterstützt. Für dieses Tutorial sind diese beiden ausreichend:

• [gui] für eine Gradio-basierte Benutzeroberfläche.
• [mcp] für die Integration mit einem beliebigen MCP-Server.

Öffnen Sie dann Ihre Datei agent.py und fügen Sie die folgenden Importe ein:

from qwen_agent.agents import Assistant
from qwen_agent.gui import WebUI

Diese werden in den nächsten Schritten verwendet, um Qwen-Agent mit dem MCP-Server zu verbinden und Ihren KI-Agenten zu implementieren.

Standardmäßig erwartet Qwen-Agent einen DashScope API-Schlüssel in Ihrer Umgebung, um auf Qwen-Modelle zuzugreifen. In diesem Tutorial werden wir jedoch Qwen3 über die kostenlose OpenRouter-Plattform verwenden.

⚠️ Warnung: Sie fragen sich vielleicht, warum wir DashScope von Alibaba Cloud nicht für den direkten Zugriff auf Qwen3 verwenden. Der Grund dafür ist, dass es zum Zeitpunkt dieses Schreibens Einschränkungen für internationale Nutzer (d.h. Nutzer außerhalb Chinas) gibt. Diese Einschränkungen führen derzeit zu der folgenden (etwas irreführenden) Fehlermeldung:

Error code: InvalidApiKey. Error message: Invalid API-key provided.

Um dieses Problem zu vermeiden, können Sie auf OpenRouter oder eine andere Plattform zurückgreifen, die den Zugang zu Qwen3 ohne regionale Einschränkungen ermöglicht.

Lassen Sie uns jetzt durchgehen, wie Sie Ihren OpenRouter API-Schlüssel für die Qwen3-Integration einrichten!

Schritt #4: Abrufen des OpenRouter API-Schlüssels

Falls Sie dies noch nicht getan haben, melden Sie sich für ein OpenRouter-Konto an. Wenn Sie bereits eines haben, melden Sie sich einfach an.

Navigieren Sie anschließend zur Seite “API-Schlüssel”, indem Sie mit dem Mauszeiger über Ihr Profilbild in der oberen rechten Ecke fahren und die Option “Schlüssel” auswählen:

Klicken Sie auf die Schaltfläche “API-Schlüssel erstellen” und folgen Sie den Anweisungen, um Ihren Schlüssel zu generieren. Kopieren Sie dann den Schlüssel und fügen Sie ihn wie folgt zu Ihrer .env-Datei hinzu:

OPEN_ROUTER_API_KEY="<YOUR_OPEN_ROUTER_API_KEY>"

Ersetzen Sie den Platzhalter durch Ihren tatsächlichen OpenRouter-API-Schlüssel.

Als nächstes laden Sie in Ihrer agent.py-Datei den Schlüssel mit:

OPEN_ROUTER_API_KEY = os.getenv("OPEN_ROUTER_API_KEY")

Großartig! Sie sind nun bereit, Qwen3 mit Qwen-Agent über OpenRouter zu verwenden.

Schritt Nr. 5: Einrichten des Bright Data MCP-Servers

Beginnen Sie mit der [Erstellung eines neuen Bright Data-Kontos]() oder melden Sie sich einfach bei Ihrem bestehenden Konto an.

Folgen Sie dann den offiziellen Anweisungen:

1. Rufen Sie Ihr Bright Data-API-Token ab.
2. Konfigurieren Sie Web Unlocker und Scraping Browser für die MCP-Integration.

Sobald dies geschehen ist, sollten Sie es haben:

• Ein Bright Data-API-Token.
• Eine Web Unlocker-Zone (wir gehen hier davon aus, dass der Zonenname der Standardname “mcp_unlocker” ist).
• Scraping Browser-Anmeldeinformationen im Format <BRIGHT_DATA_SB_USERNAME>:<BRIGHT_DATA_SB_PASSWORD>.

Installieren Sie nun den Bright Data MCP-Server global in Ihrer Node.js-Umgebung mit:

npm install -g @brightdata/mcp

Stellen Sie dann sicher, dass Sie zwei Umgebungen in Ihrem Terminal angeben:

API_TOKEN="<YOUR_BRIGHT_DATA_API_TOKEN>"
BROWSER_AUTH="<BRIGHT_DATA_SB_USERNAME>:<BRIGHT_DATA_SB_PASSWORD>"

Befolgen Sie die korrekte Vorgehensweise für die Definition von Umgebungsvariablen je nach Betriebssystem.

Sie können nun den MCP-Server über das npm-Paket @brightdata/mcp mit starten:

npx -y @brightdata/mcp

Dieser Befehl startet den MCP-Server lokal und liest die erforderlichen Umgebungsvariablen(API_TOKEN und BROWSER_AUTH). Wenn alles korrekt konfiguriert ist, sollten Sie eine Ausgabe wie diese sehen:

Checking for required zones...
Required zone "mcp_unlocker" already exists
Starting server...

Gute Arbeit! Der Bright Data MCP-Server funktioniert wie ein Zauber.

Als Nächstes fügen Sie diese beiden Umgebungsvariablen zu Ihrer .env-Datei hinzu:

BRIGHT_DATA_API_TOKEN="<YOUR_BRIGHT_DATA_API_TOKEN>"
BRIGHT_DATA_BROWSER_AUTH="<BRIGHT_DATA_SB_USERNAME>:<BRIGHT_DATA_SB_PASSWORD>"

Ersetzen Sie die Platzhalter durch die tatsächlichen Werte.

In Ihrer agent.py laden Sie diese Variablen mit:

BRIGHT_DATA_API_TOKEN = os.getenv("BRIGHT_DATA_API_TOKEN")
BRIGHT_DATA_BROWSER_AUTH = os.getenv("BRIGHT_DATA_BROWSER_AUTH")

Perfekt! Sie haben nun alles für die Integration des Bright Data MCP-Servers mit Qwen-Agent vorbereitet.

Schritt #6: Definieren Sie den Qwen3 MCP-gesteuerten Agenten

Erstellen Sie eine Funktion zur Initialisierung Ihres KI-Agenten mit Qwen3 und MCP-Unterstützung:

def initialize_mcp_agent():
    # To connect to Qwen3 via OpenRouter
    llm_cfg = {
        "model": "qwen/qwen3-32b:free",
        "model_server": "https://openrouter.ai/api/v1",
        "api_key": OPEN_ROUTER_API_KEY,
    }

    # To connect to the Bright Data MCP server
    tools = [{
        "mcpServers": {
            "brightdata": {
                "command": "npx",
                "args": ["-y", "@brightdata/mcp"],
                "env": {
                    "API_TOKEN": BRIGHT_DATA_API_TOKEN,
                    "BROWSER_AUTH": BRIGHT_DATA_BROWSER_AUTH,
                }
            }
        }
    }]


    # Define the Qwen-Agent assistant with MCP integration
    agent = Assistant(
        llm=llm_cfg,
        function_list=tools,
        name="MCP-Powered Assistant with Access to Live Data",
        description="This agent can answer questions by retrieving up-to-date information from the Internet using configured MCP tools"
    )

    return agent

Wie Sie sehen können, ist im obigen Code:

• Das llm_cfg-Wörterbuch richtet den Zugriff auf die freie Version von Qwen3 über die OpenRouter-API ein.
• Das Tool-Array legt fest, wie eine Verbindung zum Bright Data MCP-Server hergestellt werden kann, damit der KI-Agent externe Datenabfragetools aufrufen kann.
• Schließlich wird die von Qwen-Agent zur Verfügung gestellte Assistant()-K lasse verwendet, um den KI-Agenten sowohl mit dem LLM als auch mit der Tool-Integration zu definieren.

Das ist es! Dank Qwen-Agent sind für die Integration von MCP in Ihren KI-Agenten nur ein paar Zeilen Code erforderlich.

Schritt #7: Starten Sie Ihren Qwen3 MCP Agent

Fügen Sie den folgenden Code zu agent.py hinzu, um den definierten KI-Agenten in einer Gradio-Schnittstelle auszuführen:

if __name__ == "__main__":
    # Initialize the MCP-powered agent
    mcp_agent = initialize_mcp_agent()

    # Launch the Gradio-based web UI to interact with the AI agent in the browser
    WebUI(mcp_agent).run()

Auftrag erfüllt! Es bleibt nur noch, den Code zu testen und zu sehen, wozu der KI-Agent fähig ist.

Schritt #8: Alles zusammenfügen

Dies ist der endgültige Code in agent.py:

from dotenv import load_dotenv
import os
from qwen_agent.agents import Assistant
from qwen_agent.gui import WebUI

# Load the environment variables from the .env file
load_dotenv()

# Read the API key from OpenRouter to use Qwen3
OPEN_ROUTER_API_KEY = os.getenv("OPEN_ROUTER_API_KEY")

# Read the envs for integration with the Bright Data MCP server
BRIGHT_DATA_API_TOKEN = os.getenv("BRIGHT_DATA_API_TOKEN")
BRIGHT_DATA_BROWSER_AUTH = os.getenv("BRIGHT_DATA_BROWSER_AUTH")

# Define the agent with Qwen 3 and MCP configuration
def initialize_mcp_agent():
    # To connect to Qwen3 via OpenRouter
    llm_cfg = {
        "model": "qwen/qwen3-32b:free",
        "model_server": "https://openrouter.ai/api/v1",
        "api_key": OPEN_ROUTER_API_KEY,
    }

    # To connect to the Bright Data MCP server
    tools = [{
        "mcpServers": {
            "brightdata": {
                "command": "npx",
                "args": ["-y", "@brightdata/mcp"],
                "env": {
                    "API_TOKEN": BRIGHT_DATA_API_TOKEN,
                    "BROWSER_AUTH": BRIGHT_DATA_BROWSER_AUTH,
                }
            }
        }
    }]


    # Define the Qwen-Agent assistant with MCP integration
    agent = Assistant(
        llm=llm_cfg,
        function_list=tools,
        name="MCP-Powered Assistant with Access to Live Data",
        description="This agent can answer questions by retrieving up-to-date information from the Internet using configured MCP tools"
    )

    return agent

if __name__ == "__main__":
    # Initialize the MCP-powered agent
    mcp_agent = initialize_mcp_agent()

    # Launch the Gradio-based web UI to interact with the AI agent in the browser
    WebUI(mcp_agent).run()

Wahnsinn! Mit nur etwa 50 Zeilen Code können Sie einen leistungsstarken MCP-gestützten KI-Agenten erstellen – dank Qwen-Agent und OpenRouter.

Führen Sie den KI-Agenten mit aus:

python agent.py

Im Terminal sollten Sie eine Ausgabe wie folgt sehen:

2025-05-27 15:40:58,783 - mcp_manager.py - 122 - INFO - Initializing MCP tools from mcp servers: ['brightdata']
2025-05-27 15:40:58,800 - mcp_manager.py - 340 - INFO - Initializing a MCP stdio_client, if this takes forever, please check the config of this mcp server: brightdata
2025-05-27 15:41:01,098 - mcp_manager.py - 350 - INFO - No list resources: Method not found
* Running on local URL:  http://127.0.0.1:7860

Dies zeigt Ihnen, dass der MCP-Server in Betrieb ist und Ihr KI-Agent verbunden und unter http://127.0.0.1:7860 erreichbar ist . Besuchen Sie diese URL in Ihrem Browser, um mit dem Agenten über die Gradio-Web-UI zu interagieren.

Versuchen Sie es zum Beispiel mit einer Aufforderung wie dieser:

From the Amazon product page "https://www.amazon.com/PlayStation%C2%AE5-console-slim-PlayStation-5/dp/B0CL61F39H/", extract the main info and return it in JSON format

Dies ist ein hervorragender Test, um zu überprüfen, ob der KI-Agent Echtzeitdaten von der Amazon PS5-Produktseite abrufen (und somit nutzen/lernen) kann:

Wenn Sie diese Eingabeaufforderung in der Benutzeroberfläche aufrufen, sollte folgendes passieren:

Beachten Sie zunächst, dass auf der rechten Seite eine Liste aller verfügbaren Bright Data MCP-Server-Tools angezeigt wird. Sehen Sie auch, wie der Qwen-Agent das Tool web_data_amazon_product vom Bright Data MCP-Server verwendet, um die Anforderung zu erfüllen.

Sie können dies anhand der Aufzählungsliste in der Schnittstelle überprüfen, die das Ergebnis der Werkzeugausführung anzeigt:

Am Ende sollte die endgültige JSON-Ausgabe wie folgt aussehen:

{
  "title": "PlayStation®5 console (slim)",
  "url": "https://www.amazon.com/PlayStation%C2%AE5-console-slim-PlayStation-5/dp/B0CL61F39H",
  "brand": "Sony",
  "model_number": "CFI-2015",
  "price": {
    "currency": "USD",
    "final_price": 499
  },
  "availability": "In Stock",
  "rating": 4.7,
  "reviews_count": 6824,
  "description": "The PS5 console unleashes new gaming possibilities that you never anticipated. Experience lightning fast loading with an ultra-high speed SSD, deeper immersion with support for haptic feedback, adaptive triggers, and 3D Audio*, and an all-new generation of incredible PlayStation games...",
  "key_features": [
    "Custom CPU, GPU, and SSD with Integrated I/O",
    "Support for haptic feedback, adaptive triggers, and 3D Audio",
    "Backward compatibility with PS4 games",
    "1TB SSD and 10.6 lb console weight",
    "Includes DualSense Wireless Controller"
  ],
  "delivery_info": "FREE delivery Sunday, June 1. Or Prime members get FREE Same-Day delivery Today 10 AM - 3 PM.",
  "images": [
    "https://m.media-amazon.com/images/I/41ECK5cY-2L.SL1000.jpg",
    "https://m.media-amazon.com/images/I/41srF-iY93L.SL1000.jpg"
    // more image URLs...
  ],
  "product_details": {
    "ASIN": "B0CL61F39H",
    "Release Date": "December 10, 2023",
    "Dimensions": "14 x 17 x 7 inches",
    "Weight": "10.6 pounds",
    "Best Seller Rank": "#18 in Video Games",
    "Manufacturer": "Sony"
  },
  // omitted for brevity...
}

Dieses einfache Beispiel zeigt, wie leistungsfähig Ihr KI-Agent ist. Er kann in Echtzeit strukturierte Daten von jeder beliebigen Website extrahieren. Das ist perfekt für die Live-Suche, RAG(Retrieval-Augmented Generation) und aktuelle Entscheidungen.

Noch besser: Der Agent kann auch den Agent Browser (früher Scraping Browser) verwenden, um direkt mit Webseiten zu interagieren, was eine Automatisierung auf hohem Niveau und komplexe Workflows ermöglicht.

Et voilà! Das ist die Leistung von Qwen3 + MCP-Integration mit Qwen-Agent für den Aufbau von KI-Agenten der nächsten Generation.

Schlussfolgerung

In diesem Blog-Beitrag haben Sie gelernt, wie Sie mit der Qwen-Agent-Bibliothek in Kombination mit Qwen3 und Bright Data MCP einen leistungsstarken KI-Agenten in Python erstellen können.

Wie gezeigt, ermöglicht die Integration eines funktionsreichen MCP-Servers mit Qwen-Agent Ihrem KI-Agenten, Echtzeitdaten aus dem Internet abzurufen und fortgeschrittene Aufgaben selbstständig durchzuführen. Dies ist nur ein Beispiel dafür, wie die Tools von Bright Data intelligente, automatisierte KI-Workflows unterstützen können.

Erkunden Sie die Lösungen in unserer KI-Infrastruktur:

• Autonome KI-Agenten: Suche, Zugriff und Interaktion mit jeder Website in Echtzeit über eine Reihe leistungsstarker APIs.
• Vertikale KI-Anwendungen: Erstellen Sie zuverlässige, benutzerdefinierte Datenpipelines zur Extraktion von Webdaten aus branchenspezifischen Quellen.
• Grundlegende Modelle: Greifen Sie auf konforme, webbasierte Datensätze zu, um Pre-Training, Bewertung und Feinabstimmung zu unterstützen.
• Multimodale KI: Nutzen Sie den weltweit größten Fundus an Bildern, Videos und Audiodateien, die für KI optimiert sind.
• Datenanbieter: Verbinden Sie sich mit vertrauenswürdigen Anbietern, um hochwertige, KI-fähige Datensätze in großem Umfang zu beziehen.
• Datenpakete: Erhalten Sie kuratierte, gebrauchsfertige, strukturierte, angereicherte und kommentierte Datensätze.

Weitere Informationen finden Sie in unserem KI-Hub.

Erstellen Sie ein Bright Data-Konto und testen Sie alle unsere Produkte und Services für die Entwicklung von KI-Agenten!