Integrieren Sie Bright Data’s Web MCP in smolagents

In diesem Blog-Beitrag werden Sie lernen:

• Was smolagents ist und warum es sich so großer Beliebtheit erfreut.
• Wie seine Agenten auf die Ausführung von Tools angewiesen sind und wie man Tools über Bright Data’s Web MCP abruft.
• Wie man Web MCP-Tools in smolagents integriert, um einen KI-Code-Agenten zu erstellen.

Lasst uns eintauchen!

Was ist smolagents?

smolagents ist eine leichtgewichtige Python-Bibliothek, die es ermöglicht, leistungsstarke KI-Agenten mit minimalem Code zu erstellen. Das Besondere an smolagents ist der CodeAgent, der die Aktionen, die zur Ausführung einer Eingabeaufforderung benötigt werden, als ausführbare Python-Code-Schnipsel schreibt (anstatt nur eine textuelle Antwort zurückzugeben).

Dieser Ansatz verbessert die Effizienz, reduziert LLM-Aufrufe und ermöglicht es Agenten, direkt mit Tools und Umgebungen zu interagieren, die durch die Sandbox-Ausführung sicher sind. Die Community hat diesen neuen Ansatz zur Entwicklung von KI-Agenten angenommen, wie die 23.000 Sterne zeigen, die die Bibliothek in nur wenigen Monaten auf GitHub erhalten hat:

Denken Sie daran, dass smolagents ist:

1. Modell-agnostisch, unterstützt OpenAI, Anthropic, lokale Transformatoren, oder jede LLM auf dem Hugging Face Hub.
2. Modalitäts-agnostisch, unterstützt Text, Vision, Audio und Video.
3. Tool-agnostisch, unterstützt Tools von MCP-Servern, LangChain oder Hub Spaces.

Erfahren Sie mehr über die Philosophie hinter dieser Bibliothek in der Ankündigung im Hugging Face Blog.

Warum smolagents auf die Verwendung von Tools drängt

LLMs sind durch die Daten, auf denen sie trainiert wurden, begrenzt . Sie können auf der Grundlage dieses Wissens Antworten, Inhalte, Code oder Multimedia generieren. Das macht sie zwar leistungsfähig, stellt aber auch eine der größten Beschränkungen der aktuellen KI dar.

smolagents setzt hier an, indem es Agenten bereitstellt, die um Werkzeuge herum aufgebaut sind. Das ist so wichtig, dass jede Agenten-Klasse in der Bibliothek eine Liste von Werkzeugen als erforderliches Argument akzeptiert. Dank der Werkzeugaufrufe kann Ihr KI-Modell mit der Umgebung interagieren und Aufgaben ausführen, die über die Generierung von Inhalten hinausgehen.

Denken Sie insbesondere daran, dass smolagents eine Verbindung zu Tools von MCP-Servern, LangChain oder sogar einem Hub Space herstellen kann. Es unterstützt auch standardmäßige JSON/Text-basierte Tool-Aufrufe.

Was fehlt der typischen KI heute noch? Genaue, aktuelle Daten und die Fähigkeit, mit Webseiten wie Menschen zu interagieren. Genau das bieten die Web MCP-Tools von Bright Data!

Der Web MCP ist ein Open-Source-Server mit über 60 KI-fähigen Tools, die alle auf der Infrastruktur von Bright Data für Webinteraktion und Datenerfassung basieren. Schon mit der kostenlosen Version erhalten Sie Zugriff auf zwei bahnbrechende Tools:

Darüber hinaus stellt Web MCP Tools für die Interaktion in einem Cloud-Browser und Dutzende von spezialisierten Tools für die strukturierte Datenerfassung auf Plattformen wie YouTube, Amazon, LinkedIn, TikTok, Yahoo Finance und anderen zur Verfügung. Entdecken Sie mehr auf der offiziellen GitHub-Seite.

Sehen Sie Web MCP in Aktion mit smolagents!

Wie man einen smolagents KI Code Agent mit Web MCP Tools erweitert

In diesem Tutorial lernen Sie, wie Sie einen smolagents-KI-Agenten erstellen, der mit Bright Data Web MCP integriert wird. Insbesondere wird der Agent die vom MCP-Server zur Verfügung gestellten Tools verwenden, um Webdaten im laufenden Betrieb abzurufen und Sentiment-Analysen damit durchzuführen.

Hinweis: Dies ist nur ein Beispiel, und Sie können es leicht an andere Anwendungsfälle anpassen, indem Sie die Eingabeaufforderung ändern.

Befolgen Sie die unten stehenden Anweisungen!

Voraussetzungen

Um diesem Tutorial zu folgen, stellen Sie sicher, dass Sie Folgendes haben

• Python 3.10+ lokal installiert haben.
• Node.js ist auf Ihrem Rechner installiert (wir empfehlen die neueste LTS-Version) für die Ausführung von Web MCP.
• Einen Gemini-API-Schlüssel (oder einen API-Schlüssel für eines der anderen unterstützten Modelle).

Sie benötigen außerdem ein Bright Data-Konto mit einem API-Schlüssel. Machen Sie sich keine Sorgen, wir werden Sie in Kürze dazu anleiten. Ein grundlegendes Verständnis der Funktionsweise von MCP und der von Web MCP bereitgestellten Tools ist ebenfalls von Vorteil.

Schritt 1: Projekt einrichten

Öffnen Sie das Terminal und erstellen Sie einen neuen Ordner für Ihr smolagents-Projekt:

mkdir smolagents-mcp-agent

smolagents-mcp-agent/ enthält den Python-Code für Ihren KI-Agenten, der über die Web-MCP-Tools erweitert wurde.

Betreten Sie dann das Projektverzeichnis und initialisieren Sie darin eine virtuelle Umgebung:

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

Fügen Sie eine neue Datei namens agent.py hinzu. Die Dateistruktur in Ihrem Projekt sollte nun wie folgt aussehen:

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

agent.py ist Ihre Haupt-Python-Datei und enthält die Definition des KI-Agenten.

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

Aktivieren Sie nun die virtuelle Umgebung, die Sie zuvor erstellt haben. In Linux oder macOS, Feuer:

source .venv/bin/activate

Äquivalent dazu führen Sie unter Windows aus:

.venv/Scripts/activate

Wenn die virtuelle Umgebung aktiviert ist, installieren Sie die erforderlichen PyPI-Bibliotheken:

pip install "smolagents[mcp,openai]" python-dotenv

Die Abhängigkeiten sind:

• "smolagents[mcp,openai]": Das smolagent-Paket, erweitert um Abschnitte für die MCP-Integration und die Verbindung zu jedem Anbieter, der OpenAI-ähnliche APIs anbietet.
• python-dotenv: Zum Lesen von Umgebungsvariablen aus einer lokalen .env-Datei.

Geschafft! Sie haben nun eine Python-Umgebung für die Entwicklung von KI-Agenten mit smolagents.

Schritt #2: Konfigurieren Sie das Lesen von Umgebungsvariablen

Ihr Agent wird sich mit Drittanbieterdiensten wie Gemini und Bright Data verbinden. Um diese Verbindungen zu authentifizieren, müssen Sie einige API-Schlüssel festlegen. Wenn Sie diese in Ihrer agent.py-Datei fest kodieren, kann dies zu Sicherheitsproblemen führen. Konfigurieren Sie also Ihr Skript so, dass es Geheimnisse aus Umgebungsvariablen liest.

Genau aus diesem Grund haben wir das Paket python-dotenv installiert. Importieren Sie in Ihrer agent.py-Datei die Bibliothek und rufen Sie load_dotenv() auf, um Ihre Umgebungsvariablen zu laden:

from dotenv import load_dotenv

load_dotenv()

Ihr Skript kann nun auf Umgebungsvariablen aus einer lokalen .env-Datei zugreifen.

Fügen Sie eine .env-Datei zu Ihrem Projektverzeichnis hinzu:

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

Sie können dann in Ihrem Code auf Umgebungsvariablen zugreifen, indem Sie:

import os

os.getenv("ENV_NAME")

Großartig! Ihr Skript lädt nun sicher die Integrationsgeheimnisse von Drittanbietern aus Umgebungsvariablen.

Schritt 3: Lokales Testen des Web MCP von Bright Data

Bevor Sie die Verbindung zum Web-MCP von Bright Data konfigurieren, stellen Sie sicher, dass Ihr Computer den Server ausführen kann. Dies ist erforderlich, da Sie smolagents anweisen werden, den Web MCP lokal zu starten. Ihr Agent stellt dann über STDIO eine Verbindung zum Server her.

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 folgen Sie den Anweisungen im Abschnitt “MCP” Ihres Kontos:

Andernfalls befolgen Sie die nachstehenden Anweisungen, um weitere Informationen zu erhalten.

Generieren Sie zunächst einen Bright Data-API-Schlüssel. Bewahren Sie ihn an einem sicheren Ort auf, da Sie ihn in Kürze benötigen werden. Wir gehen hier davon aus, dass Ihr API-Schlüssel über Admin-Berechtigungen verfügt, da dies den Web MCP-Integrationsprozess vereinfacht.

Installieren Sie Web MCP über das Paket @brightdata/mcp global auf Ihrem Computer:

npm install -g @brightdata/mcp

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

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

Oder, äquivalent, in PowerShell:

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

Ersetzen Sie den Platzhalter <YOUR_BRIGHT_DATA_API> durch Ihr Bright Data-API-Token. Mit diesen Befehlen wird die erforderliche API_TOKEN-Umgebungsvariable festgelegt und der Web MCP lokal durch Ausführen des npm-Pakets gestartet.

Bei Erfolg sollten Sie die folgenden Protokolle 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.

Web MCP nutzt diese beiden Bright Data-Produkte, um seine über 60 Tools zu betreiben.

Wenn Sie überprüfen möchten, ob die Zonen erstellt wurden, melden Sie sich bei Ihrem Bright Data Dashboard an. Rufen Sie die Seite “Proxies & Scraping-Infrastruktur” auf, und Sie sollten die beiden Zonen in der Tabelle sehen:

Hinweis: Wenn Ihr API-Token nicht über Admin-Berechtigungen verfügt, werden die beiden Zonen nicht erstellt. In diesem Fall müssen Sie sie manuell einrichten und ihre Namen über Umgebungsvariablen konfigurieren , wie auf GitHub erklärt.

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 im kostenlosen Web MCP-Tier enthalten, sodass Sie sie kostenlos nutzen können.

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

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

Oder, unter Windows:

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

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

Wunderbar! Sie haben soeben sichergestellt, dass der Web-MCP-Server auf Ihrem System läuft. Beenden Sie den MCP-Prozess, da Sie nun Ihr Skript zum Starten und Verbinden mit dem Server konfigurieren werden.

Schritt Nr. 4: Verbindung mit Web MCP

Weisen Sie Ihr Python-Skript an, eine Verbindung mit dem Web MCP-Server über STDIO herzustellen.

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

BRIGHT_DATA_API_KEY="<IHR_BRIGHT_DATA_API_KEY>"

Ersetzen Sie den Platzhalter <YOUR_BRIGHT_DATA_API_KEY> durch Ihren tatsächlichen Schlüssel.

In agent.py laden Sie den API-Schlüssel mit:

BRIGHT_DATA_API_KEY = os.getenv("BRIGHT_DATA_API_KEY")

Definieren Sie dann ein StdioServerParameters-Objekt, um die STDIO-Verbindung zu konfigurieren:

from mcp import StdioServerParameters

server_parameters = StdioServerParameters(
    command="npx",
    args=["-y", "@brightdata/mcp"],
    env={
      "API_TOKEN": BRIGHT_DATA_API_KEY,
      "PRO_MODE": "true", # Optional
    },
)

Dieses Setup spiegelt den npx-Befehl von vorhin wider, wobei die Umgebungsvariable für das API-Token verwendet wird. Beachten Sie, dass API_TOKEN erforderlich ist, während PRO_MODE optional ist.

Verwenden Sie eine MCPClient-Instanz, um diese Verbindungseinstellungen anzuwenden und die Liste der vom Server bereitgestellten Tools abzurufen:

von smolagents import MCPClient

with MCPClient(server_parameters, structured_output=True) as tools:

Ihr agent.py-Skript wird nun einen Web-MCP-Prozess starten und sich über STDIO verbinden. Das Ergebnis ist ein Array von Werkzeugen, die Sie an jeden smolagents KI-Agenten übergeben können.

Überprüfen Sie die Verbindung, indem Sie die verfügbaren Werkzeuge ausdrucken:

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

Wenn Sie das Skript mit deaktiviertem Pro-Modus ausführen, sollten Sie eine begrenzte Anzahl von Werkzeugen sehen:

Wenn der Pro-Modus aktiviert ist, werden alle 60+ Werkzeuge angezeigt:

Großartig! Dies bestätigt, dass Ihre Web MCP-Integration korrekt funktioniert.

Schritt #5: Definieren Sie die LLM-Integration

Ihr Skript hat nun Zugriff auf die Tools, aber Ihr Agent braucht auch ein Gehirn. Das bedeutet, dass es an der Zeit ist, eine Verbindung zu einem LLM-Dienst zu konfigurieren.

Beginnen Sie, indem Sie Ihren Gemini API-Schlüssel in die .env-Datei einfügen:

GEMINI_API_KEY="<IHR_GEMINI_API_KEY>"

Dann laden Sie ihn in Ihre agent.py-Datei:

GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")

Als nächstes definieren Sie eine OpenAIServerModel-Instanz, um sich mit den Gemini APIs zu verbinden:

from smolagents import OpenAIServerModel

model = OpenAIServerModel(
    model_id="gemini-2.5-flash",
    # Google Gemini OpenAI-kompatible API-Basis-URL
    api_base="https://generativelanguage.googleapis.com/v1beta/openai/",
    api_key=GEMINI_API_KEY,
)

Auch wenn Sie eine Modellklasse für OpenAI verwenden, wird dies funktionieren. Das liegt an der spezifischen api_base, die Sie festgelegt haben und die Ihnen Zugang zu OpenAI-kompatiblen Endpunkten für die Gemini-Integration gibt. Klasse!

Schritt #6: Erstellen Sie den KI-Agenten mit den Web MCP Tools

Sie haben nun alle Bausteine, um einen smolagents code KI-Agenten zu erstellen. Benutzen Sie die Web MCP Tools und die LLM Engine, um einen solchen zu definieren:

from smolagents import CodeAgent

agent = CodeAgent(
  model=model,
  tools=tools,
  stream_outputs=True,
)

CodeAgent ist der wichtigste KI-Agententyp von smolagents. Er generiert Python-Code-Schnipsel, um Aktionen auszuführen und Aufgaben zu lösen. Die Vor- und Nachteile dieses Ansatzes sind:

Vorteile:

• Äußerst ausdrucksstark: Kann mit komplexer Logik und Kontrollfluss umgehen und mehrere Tools kombinieren. Außerdem unterstützt es Schleifen, Transformationen, Schlussfolgerungen usw.
• Flexibel: Es muss nicht jede Aktion vordefiniert werden, da es dynamisch neue Aktionen und Werkzeuge generieren kann.
• Emergente Argumentation: Gut geeignet für mehrstufige Probleme oder dynamische Entscheidungsfindung.

Nachteile:

• Risiko von Fehlern: Kann Python-Syntaxfehler oder Ausnahmen erzeugen, die behandelt werden müssen.
• Weniger vorhersehbar: Die Ausgaben können unerwartet oder unsicher sein.
• Erfordert eine sichere Umgebung: Muss in einem sicheren Ausführungskontext ausgeführt werden.

Jetzt müssen Sie nur noch Ihren Agenten starten und ihn Aufgaben ausführen lassen!

Schritt #7: Führen Sie eine Aufgabe im Agenten aus

Um die Fähigkeiten Ihres Agenten zum Abrufen von Webdaten zu testen, müssen Sie eine geeignete Eingabeaufforderung schreiben. Nehmen wir zum Beispiel an, Sie möchten die Stimmung der Kommentare zu einem YouTube-Video analysieren.

Ein Web MCP-Tool wird die Kommentare abrufen, und ein vom CodeAgent generiertes Python-Skript wird die Stimmungsanalyse durchführen. Schließlich wird der Code ausgeführt. Der generierte Python-Code ist auch nützlich, um den Prozess zu verstehen und zukünftige Erweiterungen zu erleichtern.

Erreichen Sie dies, indem Sie eine Eingabeaufforderung wie die folgende in Ihrem Agenten ausführen:

prompt = """
Rufen Sie die 10 wichtigsten Kommentare aus dem folgenden YouTube-Video ab:

Erstellen Sie einen prägnanten Bericht, der eine Stimmungsanalyse sowie Auszüge aus den Kommentaren enthält
"""

# Führen Sie die Eingabeaufforderung im Agenten aus
agent.run(prompt)

Bei dem Eingabevideo handelt es sich um einen Ankündigungstrailer für Black Ops 7, ein Videospiel, das in der Community nicht gut aufgenommen wurde.

Da die meisten Kommentare recht voreingenommen sind, ist zu erwarten, dass die Stimmungsanalyse Ergebnisse liefert, die hauptsächlich negative Reaktionen hervorheben.

Schritt #8: Alles zusammenfügen

Jetzt sollte Ihre agent.py-Datei Folgendes enthalten:

# pip install "smolagents[mcp,openai]" python-dotenv
from dotenv importieren load_dotenv
os importieren
from smolagents import OpenAIServerModel, MCPClient, CodeAgent, ToolCallingAgent
von mcp importieren StdioServerParameter

# Laden von Umgebungsvariablen aus der .env-Datei
load_dotenv()

# Die API-Schlüssel aus den Umgebungsvariablen lesen
GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
BRIGHT_DATA_API_KEY = os.getenv("BRIGHT_DATA_API_KEY")

server_parameters = StdioServerParameters(
    command="npx",
    args=["-y", "@brightdata/mcp"],
    env={
      "API_TOKEN": BRIGHT_DATA_API_KEY,
      "PRO_MODE": "true", # Optional
    },
)

# Initialisieren der Verbindung zu Gemini
model = OpenAIServerModel(
    model_id="gemini-2.5-flash",
    # Google Gemini OpenAI-kompatible API-Basis-URL
    api_base="https://generativelanguage.googleapis.com/v1beta/openai/",
    api_key=GEMINI_API_KEY,
)

# Initialisieren des MCP-Clients und Abrufen der Tools
with MCPClient(server_parameters, structured_output=True) as tools:
  # Definieren Sie den KI-Agenten, erweitert um die MCP-Tools
  agent = CodeAgent(
    model=model,
    tools=tools,
    stream_outputs=True,
  )

  prompt = """
  Abrufen der 10 wichtigsten Kommentare aus dem folgenden YouTube-Video:
  
  Erstellen Sie einen prägnanten Bericht, der eine Stimmungsanalyse sowie Auszüge aus den Kommentaren enthält
  """

  # Führen Sie die Eingabeaufforderung im Agenten aus
  agent.run(prompt)

Wie versprochen, erfüllt smolagents die Erwartungen und ermöglicht es Ihnen, einen vollständigen KI-Agenten mit MCP-Integration in weniger als 50 Codezeilen zu erstellen.

Testen Sie ihn, indem Sie ihn ausführen:

python agent.py

Nehmen wir an, Sie führen es mit aktiviertem Pro-Modus für den Web-MCP aus. Das Ergebnis wird eine mehrstufige Ausgabe wie die folgende sein:

Anhand der Eingabeaufforderung können Sie erkennen, dass der Agent erfolgreich das Web-MCP-Tool web_data_youtube_comments ausgewählt hat. Er hat es mit den richtigen Argumenten aufgerufen, um das Ziel zu erreichen. Dieses Werkzeug wird beschrieben als: “Schnelles Lesen von strukturierten youtube-Kommentardaten. Erfordert eine gültige youtube-Video-URL. Dies kann ein Cache-Lookup sein, so dass es zuverlässiger sein kann als Scraping.” Das war also eine gute Entscheidung!

Nachdem das Tool die Kommentardaten zurückgegeben hat, beginnt Schritt 2 der Berichtserstellung:

In diesem Schritt wird der endgültige Bericht zur Stimmungsanalyse erstellt. CodeAgent erstellt insbesondere den gesamten Python-Code für die Erstellung des Berichts und führt ihn auf den von web_data_youtube_comments abgerufenen Daten aus.

Mit diesem Ansatz können Sie den Prozess, den die KI zur Erstellung des Ergebnisses verwendet hat, klar nachvollziehen, wodurch ein Großteil des üblichen “Blackbox”-Effekts von LLMs entfällt.

Das Ergebnis sieht dann etwa so aus:

Wie erwartet, ist die Stimmungsanalyse weitgehend negativ.

Beachten Sie, dass die Kommentare, auf die im Bericht verwiesen wird, genau mit dem übereinstimmen, was Sie auf der YouTube-Seite für das Video sehen können:

Wenn Sie schon einmal versucht haben, YouTube zu scrapen, wissen Sie, wie schwierig das aufgrund des Anti-Bot-Schutzes und der erforderlichen Benutzerinteraktionen sein kann. Dies ist etwas, das herkömmliche LLMs nicht bewältigen können, was die Leistungsfähigkeit und Effektivität der Integration von Bright Data’s Web MCP in einen smolagents KI-Agenten demonstriert.

Sie können gerne mit verschiedenen Eingabeaufforderungen experimentieren. Mit der breiten Palette von Bright Data Web MCP-Tools können Sie eine Vielzahl von realen Anwendungsfällen abdecken.

Et voilà! Sie haben soeben gesehen, wie leistungsfähig die Kombination von Bright Data’s Web MCP mit einem smolagents KI-Agenten in Python ist.

Fazit

In diesem Blog-Beitrag haben Sie gelernt, wie man einen codebasierten KI-Agenten mit smolagents erstellt. Sie haben gesehen, wie Sie ihn mit den Tools der Web MCP von Bright Data erweitern können, die sogar ein kostenloses Tier bietet.

Diese Integration ermöglicht Ihrem Agenten die Websuche, die Extraktion strukturierter Daten, den Zugriff auf Live-Webdaten-Feeds, automatische Webinteraktionen und vieles mehr. Um noch ausgefeiltere KI-Agenten zu erstellen, sollten Sie das breitere Angebot an KI-fähigen Produkten und Services im Ökosystem von Bright Data erkunden.

Erstellen Sie noch heute ein Bright Data-Konto und experimentieren Sie mit unseren Webdatentools!