--- title: "Pydantic AI mit Bright Data MCP für Agenten mit Datenzugang" slug: pydantic-ai-with-web-mcp date: 2025-08-24T14:04:59+00:00 modified: 2025-11-04T08:46:12+00:00 permalink: https://brightdata.de/blog/ai/pydantic-ai-with-web-mcp type: blog --- [ Blog ](https://brightdata.de/blog "Blog") / [AI](https://brightdata.de/blog/ai) [AI](https://brightdata.de/blog/ai) # Pydantic AI mit Bright Data MCP für Agenten mit Datenzugang Erfahren Sie, wie Sie Pydantic AI mit Bright Data MCP kombinieren können, um Python-KI-Agenten zu erstellen, die in Echtzeit auf Webdaten zugreifen und diese extrahieren. 7 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) ![Pydantic AI × Bright Data's Bright Data MCP](https://media.brightdata.de/2025/08/Pydantic-AI%E2%80%AF%C3%97%E2%80%AFBright%E2%80%AFDatas-Web-MCP.png) In diesem Leitfaden erfahren Sie mehr: - Was Pydantic AI ist und was es als Rahmen für die Entwicklung von KI-Agenten einzigartig macht. - Warum sich Pydantic AI gut mit dem Bright Data MCP-Server von Bright Data kombinieren lässt, um Agenten zu erstellen, die auf das Internet zugreifen können. - Wie man Pydantic mit Bright Data MCP integriert, um einen KI-Agenten zu erstellen, der auf echten Daten basiert. Lasst uns eintauchen! ## Was ist Pydantic AI? [Pydantic AI](//ai.pydantic.dev/) ist ein Python-Agenten-Framework, das von den Schöpfern von [Pydantic](https://docs.pydantic.dev/latest/), der am weitesten verbreiteten Datenvalidierungsbibliothek für Python, entwickelt wurde. Im Vergleich zu anderen [KI-Agenten-Frameworks](/blog/ai/best-ai-agent-frameworks) legt Pydantic AI den Schwerpunkt auf Typsicherheit, strukturierte Ausgaben und die Integration mit realen Daten und Tools. Im Einzelnen sind einige der wichtigsten Merkmale: - Unterstützung für OpenAI, Anthropic, Gemini, Cohere, Mistral, Groq, HuggingFace, Deepseek, Ollama und andere LLM-Anbieter. - Strukturierte Output-Validierung über pydantische Modelle. - Debugging und Überwachung über [Pydantic Logfire](https://pydantic.dev/logfire). - Optionale Injektion von Abhängigkeiten für Tools, Prompts und Validatoren. - Gestreamte LLM-Antworten mit fließender Datenvalidierung. - Unterstützung von Multi-Agenten und Graphen für komplexe Arbeitsabläufe. - Tool-Integration über MCP und einschließlich HTTP-Aufrufe. - Vertrauter Python-Flow, um KI-Agenten wie Standard-Python-Anwendungen zu erstellen. - Integrierte Unterstützung für Unit-Tests und iterative Entwicklung. Die Bibliothek ist quelloffen und hat bereits [über 11k Sterne auf GitHub](https://github.com/pydantic/pydantic-ai) erreicht. ## Warum sollte man Pydantic AI mit einem MCP-Server für die Abfrage von Webdaten kombinieren? KI-Agenten, die mit Pydantic AI entwickelt werden, erben die Einschränkungen des zugrunde liegenden LLM. Dazu gehört der fehlende Zugang zu Echtzeitinformationen, was zu ungenauen Antworten führen kann. Glücklicherweise kann dieses Problem leicht behoben werden, indem der Agent mit aktuellen Daten ausgestattet wird und die Möglichkeit erhält, das Internet live zu erkunden. An dieser Stelle kommt der [**Web-MCP von Bright Data**](/ai/mcp-server) ins Spiel. Dieser MCP-Server basiert auf Node.js und ist mit der Bright Data-Suite von KI-fähigen Datenabfragetools integriert. Diese Tools ermöglichen es Ihrem Agenten, auf Webinhalte zuzugreifen, strukturierte Datensätze abzufragen, das Web zu durchsuchen und mit Webseiten on the fly zu interagieren. Zu den [MCP-Tools auf dem Server](https://github.com/brightdata/brightdata-mcp/blob/main/assets/Tools.md) gehören derzeit: **Werkzeug****Beschreibung**`scrape_as_markdown`Scrapen Sie Inhalte von einer einzelnen URL mit erweiterten Extraktionsoptionen und geben Sie die Ergebnisse als Markdown zurück. Kann die Bot-Erkennung und CAPTCHA umgehen.`Suchmaschine`Extrahiert Suchergebnisse von Google, Bing oder Yandex und gibt SERP-Daten im Markdown-Format (URL, Titel, Snippet) zurück.`scrape_as_html`Abrufen von Webseiteninhalten aus einer URL mit erweiterten Extraktionsoptionen, die den vollständigen HTML-Code zurückgeben. Kann die Bot-Erkennung und CAPTCHA umgehen.`session_stats`Bereitstellung von Statistiken über die Nutzung des Tools während der aktuellen Sitzung.`scraping_browser_go_back`Navigieren Sie zurück zur vorherigen Seite in der Scraping-Browser-Sitzung.`scraping_browser_go_forward`Navigieren Sie in der Scraping-Browser-Sitzung zur nächsten Seite.`scraping_browser_click`Ausführen einer Klick-Aktion auf ein bestimmtes Element per Selektor.`scraping_browser_links`Ruft alle Links, einschließlich Text und Selektoren, auf der aktuellen Seite ab.`scraping_browser_type`Eingabe von Text in ein bestimmtes Element innerhalb des Scraping-Browsers.`scraping_browser_wait_for`Warten Sie, bis ein bestimmtes Element auf der Seite sichtbar wird, bevor Sie fortfahren.`scrapen_browser_bildschirmfoto`Erfassen Sie einen Screenshot der aktuellen Browserseite.`scraping_browser_get_html`Ruft den HTML-Inhalt der aktuellen Seite im Browser ab.`scraping_browser_get_text`Extrahiert den sichtbaren Textinhalt aus der aktuellen Seite.Darüber hinaus gibt es über 40 spezialisierte Tools zum Sammeln strukturierter Daten von einer Vielzahl von Websites (z. B. Amazon, Yahoo Finance, TikTok, LinkedIn und mehr) unter Verwendung von [Web Scraper APIs](/products/web-scraper). Das Tool `web_data_amazon_product` beispielsweise sammelt detaillierte, strukturierte Produktinformationen von Amazon, indem es eine gültige Produkt-URL als Eingabe akzeptiert. Sehen Sie sich jetzt an, wie Sie diese MCP-Tools in Pydantic AI verwenden können! ## Integration von Pydantic AI mit dem Bright MCP Server in Python In diesem Abschnitt lernen Sie, wie Sie mit Pydantic AI einen KI-Agenten erstellen. Der Agent wird mit Live-Daten-Scraping-, Abruf- und Interaktionsfunktionen vom Web-MCP-Server ausgestattet. Als Beispiel werden wir demonstrieren, wie der Agent Produktdaten von Amazon abrufen kann. Denken Sie daran, dass dies nur einer von [vielen möglichen Anwendungsfällen](/ai/data-for-ai-agents) ist. Der KI-Agent kann auf jedes der über 50 Tools zugreifen, die über den MCP-Server verfügbar sind, um eine Vielzahl von Aufgaben auszuführen. Folgen Sie dieser Anleitung, um Ihren Gemini + Bright Data MCP-gesteuerten KI-Agenten mit Pydantic AI zu erstellen! ### Voraussetzungen Um das Code-Beispiel nachzubilden, stellen Sie sicher, dass Sie das Folgende lokal installiert haben: - [Python 3.10 oder höher](https://www.python.org/downloads/). - [Node.js](https://nodejs.org/en/download) (wir empfehlen die neueste LTS-Version). Sie benötigen außerdem: - Ein Bright Data-Konto. - Ein Gemini-API-Schlüssel (oder ein API-Schlüssel für einen anderen unterstützten LLM-Anbieter, wie OpenAI, Anthropic, Deepseek, Ollama, Groq, Cohere und Mistral). Kümmern Sie sich jetzt noch nicht um die Einrichtung der API-Schlüssel. Die folgenden Schritte führen Sie durch die Konfiguration der Bright Data- und Gemini-Anmeldeinformationen, wenn es so weit ist. Dieses Hintergrundwissen ist zwar nicht unbedingt erforderlich, aber es wird Ihnen helfen, dem Lernprogramm zu folgen: - Ein allgemeines Verständnis der Funktionsweise von MCP. - Grundlegende Vertrautheit mit der [Funktionsweise von KI-Agenten](/blog/ai/ai-agent-tech-stack). - Gewisse Kenntnisse des Web-MCP-Servers und seiner verfügbaren Tools. - Grundkenntnisse in [asynchroner Programmierung in Python](https://docs.python.org/3/library/asyncio.html). ### Schritt #1: Erstellen Sie Ihr Python-Projekt Öffnen Sie Ihr Terminal und erstellen Sie einen neuen Ordner für Ihr Projekt: ```none mkdir pydantic-ai-mcp-agent ``` Der Ordner `pydantic-ai-mcp-agent` enthält den gesamten Code für Ihren Python-KI-Agenten. Navigieren Sie zu dem neu erstellten Ordner und richten Sie darin eine [virtuelle Umgebung](https://docs.python.org/3/library/venv.html) ein: ```none cd pydantic-ai-mcp-agent python -m venv venv ``` Öffnen Sie nun den Projektordner in Ihrer bevorzugten Python-IDE. Wir empfehlen [Visual Studio Code mit der Python-Erweiterung](https://code.visualstudio.com/docs/languages/python) oder [PyCharm Community Edition](https://www.jetbrains.com/pycharm/download/#section=windows). Erstellen Sie eine Datei namens `agent.py` im Stammverzeichnis Ihres Projekts. Zu diesem Zeitpunkt sollte Ihre Ordnerstruktur wie folgt aussehen: ```none pydantic-ai-mcp-agent/ ├── venv/ └── agent.py ``` Die Datei `agent.py` ist derzeit noch leer, wird aber bald die Logik für die Integration von Pydantic AI 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: ```none source venv/bin/activate ``` Starten Sie unter Windows die entsprechende Funktion: ```none venv/Scripts/activate ``` Sie sind bereit! Sie haben jetzt eine Python-Umgebung, um einen KI-Agenten mit Webdatenzugriff zu erstellen. ### Schritt #2: Pydantic AI installieren Installieren Sie in Ihrer aktivierten virtuellen Umgebung alle erforderlichen Pydantic AI-Pakete mit: ```none pip install "pydantic-ai-slim[google,mcp]" ``` Dies installiert [`pydantic-ai-slim`](https://ai.pydantic.dev/install/#slim-install), eine abgespeckte Version des vollständigen [`pydantic-ai-Pakets`](https://pypi.org/project/pydantic-ai/), das keine unnötigen Abhängigkeiten mit sich bringt. Da Sie in diesem Fall planen, Ihren Agenten in den Bright Data MCP Server zu integrieren, benötigen Sie die `mcp-Erweiterung`. Und da wir Gemini als LLM-Anbieter integrieren werden, benötigen Sie auch die `google-Erweiterung`. **Hinweis**: Bei anderen Modellen oder Anbietern ist in der [Modelldokumentation](https://ai.pydantic.dev/models/) nachzulesen, welche optionalen Abhängigkeiten erforderlich sind. Als nächstes fügen Sie diese Importe in Ihre `agent.py-Datei` ein: ```none from pydantic_ai import Agent from pydantic_ai.mcp import MCPServerStdio from pydantic_ai.models.google import GoogleModel from pydantic_ai.providers.google import GoogleProvider ``` Super! Sie können jetzt Pydantic AI für den Aufbau von Agenten verwenden. ### Schritt #3: Einrichten von Umgebungsvariablen Lesen Ihr KI-Agent interagiert mit Diensten von Drittanbietern wie Bright Data und Gemini über eine API. Programmieren Sie Ihre API-Schlüssel nicht fest in Ihren Python-Code ein. Laden Sie sie stattdessen aus Umgebungsvariablen, um die Sicherheit und Wartungsfreundlichkeit zu erhöhen. Um den Prozess zu vereinfachen, nutzen Sie die [`python-dotenv-Bibliothek`](https://pypi.org/project/python-dotenv/). Wenn Ihre virtuelle Umgebung aktiviert ist, installieren Sie sie, indem Sie sie ausführen: ```none pip install python-dotenv ``` Dann importieren Sie in Ihrer `agent.py-Datei` die Bibliothek und laden die Umgebungsvariablen mit `load_dotenv()`: ```none from dotenv import load_dotenv load_dotenv() ``` Dies ermöglicht es dem Skript, Umgebungsvariablen aus einer lokalen `.env-Datei` zu lesen. Legen Sie also eine `.env-Datei` in Ihrem Projektordner an: ```none pydantic-ai-mcp-agent/ ├── venv/ ├── agent.py └── .env # <--------------- ``` Sie können nun wie folgt auf Umgebungsvariablen zugreifen: ```none env_value = os.getenv("") ``` Vergessen Sie nicht, das Modul [`os`](https://docs.python.org/3/library/os.html) aus der Python-Standardbibliothek zu importieren: ```none import os ``` So geht’s! Sie sind nun in der Lage, Api-Schlüssel sicher aus der `.env-Datei` zu laden. ### Schritt Nr. 4: Erste Schritte mit dem Bright Data MCP-Server Falls Sie dies noch nicht getan haben, [erstellen Sie ein Bright Data-Konto](/?hs_signup=1). Wenn Sie bereits eines haben, melden Sie sich einfach an. [Folgen Sie](https://docs.brightdata.com/api-reference/authentication#generating-an-api-key%3A) dann [den offiziellen Anweisungen](https://docs.brightdata.com/api-reference/authentication#generating-an-api-key%3A), um Ihren Bright Data-API-Schlüssel einzurichten. Der Einfachheit halber gehen wir davon aus, dass Sie in diesem Abschnitt ein Token mit Admin-Berechtigungen verwenden. Installieren Sie den [Bright Data MCP von Bright Data](https://github.com/brightdata/brightdata-mcp) global über `npm`: ```none npm install -g @brightdata/mcp ``` Testen Sie dann mit dem folgenden Bash-Befehl, ob alles funktioniert: ```none API_TOKEN="" npx -y @brightdata/mcp ``` Oder unter Windows lautet der entsprechende PowerShell-Befehl: ```none $env:API_TOKEN=""; npx -y @brightdata/mcp ``` Ersetzen Sie im obigen Befehl den `` Platzhalter durch die tatsächliche Bright Data-API, die Sie zuvor abgerufen haben. Beide Befehle setzen die erforderliche Umgebungsvariable `API_TOKEN` und starten den MCP-Server über das npm-Paket [`@brightdata/mcp`](https://www.npmjs.com/package/@brightdata/mcp). Wenn alles richtig funktioniert, zeigt Ihr Terminal ähnliche Protokolle an wie dieses: ![Die Startprotokolle des Bright Data MCP-Servers](https://media.brightdata.com/2025/08/image-31-1024x157.png)Wenn Sie den MCP-Server zum ersten Mal starten, werden automatisch zwei Standardzonen in Ihrem Bright Data-Konto erstellt: - `mcp_unlocker`: Eine Zone für [Web Unlocker](/products/web-unlocker). - `mcp_browser`: Eine Zone für die [Browser-API](/products/scraping-browser). Diese beiden Zonen ermöglichen es dem MCP-Server, alle Tools auszuführen, die er zur Verfügung stellt. Um dies zu überprüfen, melden Sie sich bei Ihrem Bright Data-Dashboard an und navigieren Sie zur Seite[“Proxies & Scraping-Infrastruktur](/cp/zones)“. Sie sehen, dass die folgenden Zonen automatisch erstellt wurden: ![Die vom MCP-Server beim Start erstellten Zonen mcp_unlocker und mcp_browser](https://media.brightdata.com/2025/08/image-32-1024x539.png)**Hinweis**: Wenn Sie kein API-Token mit Admin-Rechten verwenden, müssen Sie die Zonen manuell erstellen. In jedem Fall können Sie die Zonennamen in den Umgebungsvariablen angeben, wie in der [offiziellen Dokumentation](https://github.com/brightdata/brightdata-mcp?tab=readme-ov-file#-account-setup) beschrieben. Standardmäßig stellt die Bright Data MCP nur die Werkzeuge `search_engine` und `scrape_as_markdown` zur Verfügung. Um erweiterte Funktionen wie Browser-Automatisierung und Extraktion strukturierter Daten freizuschalten, müssen Sie den Pro-Modus aktivieren, indem Sie die Umgebungsvariable `PRO_MODE=true` setzen. Großartig! Das Bright Data MCP funktioniert wie ein Zauber. ### Schritt Nr. 5: Verbindung zum Bright Data MCP Nachdem Sie nun bestätigt haben, dass Ihr Rechner den Bright Data MCP ausführen kann, stellen Sie eine Verbindung her! Fügen Sie zunächst Ihren Bright Data-API-Schlüssel in die `.env-Datei` ein: ```none BRIGHT_DATA_API_KEY="" ``` Ersetzen Sie den `` Platzhalter durch den tatsächlichen Bright Data-API-Schlüssel, den Sie zuvor erhalten haben. Dann lesen Sie es in der Datei `agent.py` mit: ```none BRIGHT_DATA_API_KEY = os.getenv("BRIGHT_DATA_API_KEY") ``` Beachten Sie, dass Pydantic AI [drei Methoden zur Verbindung mit einem MCP-Server](https://ai.pydantic.dev/mcp/client/#usage) unterstützt: 1. Verwendung des Streamable HTTP-Transports. 2. Verwendung des HTTP SSE-Transports. 3. Ausführen des Servers als Unterprozess und Verbindung über [`stdio`](https://modelcontextprotocol.io/specification/2025-03-26/basic/transports#stdio). Wenn Sie mit den ersten beiden Methoden nicht vertraut sind, lesen Sie unseren Leitfaden zu [SSE vs. Streamable HTTP](/blog/ai/sse-vs-streamable-http), um eine genauere Erklärung zu erhalten. In diesem Fall möchten Sie den Server als Unterprozess laufen lassen (dritte Methode). Zu diesem Zweck initialisieren Sie eine [`MCPServerStdio-Instanz`](https://ai.pydantic.dev/api/mcp/#pydantic_ai.mcp.MCPServerStdio) wie unten gezeigt: ```none server = MCPServerStdio( "npx", args=[ "-y", "@brightdata/mcp", ], env={ "API_TOKEN": BRIGHT_DATA_API_KEY, "PRO_MODE": "true" # Enable the Pro Mode to access all Bright Data tools }, ) ``` Diese Codezeilen bewirken im Wesentlichen, dass Bright Data MCP mit demselben `npx-Befehl` gestartet wird, den Sie zuvor ausgeführt haben. Er setzt die Umgebungsvariable `API_TOKEN` mit Ihrem Bright Data-API-Schlüssel zur Authentifizierung. Außerdem wird der `PRO_MODE` aktiviert, so dass Sie Zugriff auf alle verfügbaren Tools haben, auch auf die erweiterten Tools. Sehr gut! Sie haben nun erfolgreich die Verbindung zu Ihrem lokalen Bright Data MCP im Code konfiguriert. ### Schritt #6: Konfigurieren Sie das LLM **Hinweis**: Dieser Abschnitt bezieht sich auf Gemini, den für das Tutorial gewählten LLM. Sie können ihn jedoch leicht an [OpenAI](https://ai.pydantic.dev/models/openai/) oder jeden anderen unterstützten LLM anpassen, indem Sie [der offiziellen Dokumentation folgen](https://ai.pydantic.dev/models/). Beginnen Sie damit, [Ihren Gemini-API-Schlüssel abzurufen](https://aistudio.google.com/app/apikey) und fügen Sie ihn wie folgt zu Ihrer `.env-Datei` hinzu: ```none GOOGLE_API_KEY="" ``` Ersetzen Sie den `` Platzhalter durch Ihren tatsächlichen API-Schlüssel. Als Nächstes importieren Sie die erforderlichen Pydantic AI-Bibliotheken für die Integration in Gemini: ```none from pydantic_ai.models.google import GoogleModel from pydantic_ai.providers.google import GoogleProvider ``` Diese Importe ermöglichen es Ihnen, sich mit den Google-APIs zu verbinden und ein Gemini-Modell zu konfigurieren. Beachten Sie, dass Sie den `GOOGLE_API_KEY` nicht manuell aus der `.env-Datei` lesen müssen. Der Grund dafür ist, dass `GoogleProvider` unter der Haube [`google-genai`](https://pypi.org/project/google-genai/) verwendet, das automatisch den API-Schlüssel aus der `GOOGLE_API_KEY` env-Datei liest. Initialisieren Sie nun die Anbieter- und Modellinstanzen: ```none provider = GoogleProvider() model = GoogleModel("gemini-2.5-flash", provider=provider) ``` Erstaunlich! Dadurch kann der Pydantic-KI-Agent über die kostenlos nutzbare Google-API eine Verbindung zum [`gemini-2.5-Flash-Modell`](https://cloud.google.com/vertex-ai/generative-ai/docs/models/gemini/2-5-flash) herstellen. ### Schritt #7: Definieren Sie den Pydantic AI Agent Definieren Sie einen Pydantic AI Agent, der das zuvor konfigurierte LLM verwendet und eine Verbindung zum Bright Data MCP Server herstellt: ```none agent = Agent(model, toolsets=[server]) ``` Perfekt! Mit nur einer einzigen Codezeile haben Sie gerade ein [`Agent-Objekt`](https://ai.pydantic.dev/api/agent/#pydantic_ai.agent.Agent) instanziiert. Dieses stellt einen KI-Agenten dar, der Ihre Aufgaben mithilfe der vom Web-MCP-Server bereitgestellten Tools erledigen kann. ### Schritt #8: Starten Sie Ihren Agenten Um Ihren KI-Agenten zu testen, müssen Sie eine Eingabeaufforderung schreiben, die eine Aufgabe zur Extraktion von Webdaten (bei Interaktion) beinhaltet. So können Sie überprüfen, ob der Agent die Bright Data-Tools wie erwartet verwendet. Ein guter Ausgangspunkt ist die Aufforderung, Produktdaten von einer Amazon-Seite abzurufen, etwa so: > “Geben Sie mir Produktdaten von https://www.amazon.com/AmazonBasics-Pound-Neoprene-Dumbbells-Weights/dp/B01LR5S6HK/” Wenn Sie eine solche Anfrage direkt an Gemini senden, würde normalerweise eines von zwei Dingen passieren: 1. Die Anfrage würde an Amazons Anti-Bot-Systemen (z. B. dem [Amazon CAPTCHA](/blog/web-data-de/bypass-amazon-captcha)) scheitern, die Gemini daran hindern, auf den Seiteninhalt zuzugreifen. 2. Sie würde halluzinierte oder erfundene Produktinformationen zurückgeben, da sie nicht auf die Live-Seite zugreifen kann. Versuchen Sie die Eingabeaufforderung direkt in Gemini. Wahrscheinlich erhalten Sie die Meldung, dass kein Zugriff auf die Amazon-Seite möglich war, gefolgt von gefälschten Produktdetails, wie unten dargestellt: ![Die erfolglose Antwort von Gemini](https://media.brightdata.com/2025/08/image-33-1024x538.png)Dank der Integration mit dem Bright Data MCP-Server sollte dies in Ihrem Setup nicht passieren. Anstatt zu scheitern oder zu raten, sollte Ihr Agent das `web_data_amazon_product-Tool` verwenden, um strukturierte Produktdaten in Echtzeit von der Amazon-Seite abzurufen und sie dann in einem sauberen, lesbaren Format zurückzugeben. Da die Methode zur Abfrage des Pydantic AI-Agenten asynchron ist, verpacken Sie die Ausführungslogik wie folgt in eine `asynchrone` Funktion: ```none async def main(): async with agent: result = await agent.run("Give me product data from https://www.amazon.com/AmazonBasics-Pound-Neoprene-Dumbbells-Weights/dp/B01LR5S6HK/") output = result.output print(output) if __name__ == "__main__": asyncio.run(main()) ``` Vergessen Sie nicht, [`asyncio`](https://docs.python.org/3/library/asyncio.html) aus der Python-Standardbibliothek zu importieren: ```none import asyncio ``` Auftrag erfüllt! Jetzt müssen wir nur noch den vollständigen Code ausführen und sehen, ob der Agent die Erwartungen erfüllt. ### Schritt #9: Alles zusammenfügen Dies ist der endgültige Code in `agent.py`: ```none from pydantic_ai import Agent from pydantic_ai.mcp import MCPServerStdio from pydantic_ai.models.google import GoogleModel from pydantic_ai.providers.google import GoogleProvider from dotenv import load_dotenv import os import asyncio # Load the environment variables from the .env file load_dotenv() # Read the API key from the envs for integration with the Bright Data MCP server BRIGHT_DATA_API_KEY = os.getenv("BRIGHT_DATA_API_KEY") # Connect to the Bright Data MCP server server = MCPServerStdio( "npx", args=[ "-y", "@brightdata/mcp", ], env={ "API_TOKEN": BRIGHT_DATA_API_KEY, "PRO_MODE": "true" # Enable the Pro Mode to access all Bright Data tools }, ) # Configure the Google LLM model provider = GoogleProvider() model = GoogleModel("gemini-2.5-flash", provider=provider) # Initialize the AI agent with Gemini and Bright Data MCP server integration agent = Agent(model, toolsets=[server]) async def main(): async with agent: # Ask the AI Agent to perform a scraping task result = await agent.run("Give me product data from https://www.amazon.com/AmazonBasics-Pound-Neoprene-Dumbbells-Weights/dp/B01LR5S6HK/") # Get the result produced by the agent and print it output = result.output print(output) if __name__ == "__main__": asyncio.run(main()) ``` Wow! Dank Pydantic AI und Bright Data haben Sie soeben in etwa 50 Zeilen Code einen leistungsstarken MCP-gestützten KI-Agenten erstellt. Führen Sie den KI-Agenten mit aus: ```none python agent.py ``` Im Terminal sollten Sie eine Ausgabe wie folgt sehen: ![Die von dem KI-Agenten Pydantic erzeugte Ausgabe](https://media.brightdata.com/2025/08/image-34-1024x647.png)Wie Sie anhand der [in der Aufforderung genannten Amazon-Produktseite](https://www.amazon.com/AmazonBasics-Pound-Neoprene-Dumbbells-Weights/dp/B01LR5S6HK/) sehen können, sind die vom KI-Agenten zurückgegebenen Informationen korrekt: ![Das in der Aufforderung erwähnte Amazon-Produkt](https://media.brightdata.com/2025/08/The-Amazon-product-mentioned-in-the-prompt-1-1024x553.png)Das liegt daran, dass der Agent das vom Web-MCP-Server bereitgestellte Tool `web_data_amazon_product` verwendet, um frische, strukturierte Produktdaten von Amazon im JSON-Format abzurufen. Et voilà! Die Erwartungen wurden erfüllt, und die KI- und MCP-Integration von Pydantic funktionierte genau wie vorgesehen. ### Nächste Schritte Der hier erstellte KI-Agent ist funktionsfähig, aber er dient nur als Ausgangspunkt. Erwägen Sie, ihn auf die nächste Stufe zu heben, indem Sie: - Implementierung einer REPL-Schleife zum Chatten mit dem Agenten in der CLI oder [Integration mit GUI-Chat-Tools wie Gradio](https://www.gradio.app/guides/creating-a-chatbot-fast). - Erweiterung der Bright Data MCP-Tools durch die [Definition eigener benutzerdefinierter Tools](https://ai.pydantic.dev/tools/). - Hinzufügen von Debugging und Überwachung [mit Pydantic Logfire](https://ai.pydantic.dev/logfire/). - Umwandlung Ihres Agenten in einen [autonomen RAG-Agenten](/blog/ai/agentic-rag) innerhalb eines Multi-Agenten-Workflows. - Definition von [benutzerdefinierten Funktionsvalidatoren](https://ai.pydantic.dev/output/#output-validator-functions) für die Integrität der Ausgabedaten. ## Schlussfolgerung In diesem Artikel haben Sie gelernt, wie Sie Pydantic AI mit [dem Bright Data MCP-Server von Bright Data](/ai/mcp-server) integrieren, um einen AI-Agenten zu erstellen, der auf das Internet zugreifen kann. Diese Integration wird durch die in Pydantic AI integrierte Unterstützung für MCP ermöglicht. Um anspruchsvollere Agenten zu erstellen, können Sie die gesamte Palette der in der [Bright Data AI-Infrastruktur](/ai) verfügbaren Services nutzen. Diese Lösungen können eine Vielzahl von [Agentenszenarien](/ai/web-access) unterstützen. Erstellen Sie ein kostenloses Bright Data-Konto und experimentieren Sie mit unseren KI-fähigen Webdatentools! 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=Pydantic+AI+mit+Bright+Data+MCP+f%C3%BCr+Agenten+mit+Datenzugang&u=https://brightdata.de/blog/ai/pydantic-ai-with-web-mcp) [ ](https://www.linkedin.com/shareArticle?mini=true&title=Pydantic+AI+mit+Bright+Data+MCP+f%C3%BCr+Agenten+mit+Datenzugang&url=https://brightdata.de/blog/ai/pydantic-ai-with-web-mcp) [ ](http://www.reddit.com/submit?title=Pydantic+AI+mit+Bright+Data+MCP+f%C3%BCr+Agenten+mit+Datenzugang&url=https://brightdata.de/blog/ai/pydantic-ai-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)