--- title: "Integration von Bright Data in BabyAGI über benutzerdefinierte Funktionen" slug: babyagi-with-bright-data date: 2026-01-27T13:04:54+00:00 modified: 2026-01-27T13:04:57+00:00 permalink: https://brightdata.de/blog/ai/babyagi-with-bright-data type: blog --- [ Blog ](https://brightdata.de/blog "Blog") / [AI](https://brightdata.de/blog/ai) [AI](https://brightdata.de/blog/ai) # Integration von Bright Data in BabyAGI über benutzerdefinierte Funktionen Befolgen Sie diese Schritt-für-Schritt-Anleitung, um die SERP-API und die Web Unlocker-API von Bright Data zu BabyAGI hinzuzufügen und so intelligentere, selbstlernende KI-Agenten zu ermöglichen. 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) ![BabyAGI with Bright Data](https://media.brightdata.de/2025/12/BabyAGI-with-Bright-Data.png) In diesem Tutorial lernen Sie: - Was BabyAGI ist und was es zu einem wirklich einzigartigen Framework für die Erstellung von KI-Agenten macht. - Warum die Erweiterung von BabyAGI um Bright Data-Dienste die Tür zu einer Vielzahl interessanter Szenarien öffnet. - Wie Sie Bright Data über benutzerdefinierte Funktionen in BabyAGI integrieren können. Lassen Sie uns loslegen! ## Was ist BabyAGI? [BabyAGI](https://babyagi.org/) ist ein experimentelles Python-Framework, das entwickelt wurde, um selbstkonfigurierende autonome KI-Agenten zu erstellen, die in der Lage sind, Aufgaben zu generieren, zu priorisieren und auszuführen, um benutzerdefinierte Ziele zu erreichen. Es funktioniert wie ein minimalistischer, sich selbst verbessernder Task-Manager, der LLMs wie die Modelle von OpenAI für das Schlussfolgern und [Vektordatenbanken für den Speicher](/blog/ai/vector-databases) nutzt. Im Allgemeinen arbeitet es in einer intelligenten Schleife, um komplexe Arbeitsabläufe zu automatisieren. Im Kern führt BabyAGI ein funktionsbasiertes Framework namens `functionz` ein, um Funktionen aus einer Datenbank zu speichern, zu verwalten und auszuführen. Diese Funktionen unterstützen auch die Codegenerierung, sodass der KI-Agent neue Funktionen registrieren, aufrufen und sich autonom weiterentwickeln kann. Über ein integriertes Dashboard können Sie dann Funktionen verwalten, die Ausführung überwachen und Geheimnisse registrieren. Es verfügt über eine graphbasierte Struktur zur Verfolgung von Importen, abhängigen Funktionen und Authentifizierungsgeheimnissen mit automatischem Laden und detaillierter Protokollierung. Was BabyAGI besonders interessant macht, ist seine Einfachheit, seine Fähigkeit zur Selbstkonstruktion und sein benutzerfreundliches Web-Dashboard. Die Kernidee ist, dass die effektivsten autonomen Agenten diejenigen sind, die sich mit minimaler Struktur selbst erweitern können. BabyAGI ist Open Source und wird aktiv gepflegt, mit [über 22.000 Sternen auf GitHub](https://github.com/yoheinakajima/babyagi). ## Bessere selbstaufbauende KI-Agenten durch Zugriff auf Webdaten LLMs sind von Natur aus durch die [statischen Daten](/blog/web-data/llm-training-data) begrenzt, [mit denen sie trainiert wurden](/blog/web-data/llm-training-data), was häufig zu Halluzinationen und anderen häufigen LLM-Problemen führt. BabyAGI überwindet diese Einschränkungen durch sein selbstkonstruierendes Funktionsframework. Es verwendet ein LLM, um benutzerdefinierte Funktionen zu schreiben, die dann als Werkzeuge zur Erweiterung seiner Fähigkeiten an den Agenten zurückgegeben werden. Die Logik zur Generierung dieser Funktionen ist jedoch nach wie vor durch das veraltete Wissen des LLM eingeschränkt. Um diese große Einschränkung zu beheben, muss BabyAGI in der Lage sein, das Web zu durchsuchen und genaue, aktuelle Informationen abzurufen, damit es zuverlässigere Funktionen erstellen kann. Dies wird durch die Verbindung mit Bright Data-Diensten ermöglicht, wie zum Beispiel: - [**SERP-API**](/products/serp-api): Sammeln Sie Suchmaschinenergebnisse von Google, Bing und anderen in großem Umfang, ohne blockiert zu werden. - [**Web Unlocker API**](/products/web-unlocker): Greifen Sie mit einer einzigen Anfrage auf jede Website zu und erhalten Sie sauberes HTML oder Markdown, mit automatischer Verarbeitung von Proxys, Headern und CAPTCHAs. - [**Web-Scraping-APIs**](/products/web-scraper): Rufen Sie strukturierte, geparste Daten von beliebten Plattformen wie Amazon, LinkedIn, Instagram, Yahoo Finance und anderen ab. - Und [weitere Lösungen…](/products) Mit diesen Integrationen in Kombination mit der selbstaufbauenden Architektur von BabyAGI kann sich die KI autonom weiterentwickeln, neue Funktionen hinzufügen und komplexe Arbeitsabläufe bewältigen, die weit über das hinausgehen, was ein Standard-LLM allein leisten könnte. ## So erweitern Sie BabyAGI mit Bright Data um Funktionen zum Abrufen von Webdaten In diesem Schritt-für-Schritt-Abschnitt werden Sie durch die Integration von Bright Data in BabyAGI über benutzerdefinierte Funktionen geführt. Diese verbinden sich mit zwei Bright Data-Produkten: der SERP-API und der Web Unlocker-API. Befolgen Sie die nachstehenden Anweisungen, um loszulegen! ### Voraussetzungen Um diesem Tutorial folgen zu können, benötigen Sie: - [Python 3.10+](https://www.python.org/downloads/) lokal installiert. - Einen [OpenAI-API-Schlüssel](https://platform.openai.com/api-keys). - Ein [Bright Data-Konto](/), das mit einer SERP-API-Zone, einer Web Unlocker-API-Zone und einem aktiven API-Schlüssel konfiguriert ist. Machen Sie sich keine Sorgen, wenn Ihr Bright Data-Konto noch nicht eingerichtet ist, da Sie in einem speziellen Schritt durch diesen Vorgang geführt werden. ### Schritt 1: Einrichten eines BabyAGI-Projekts Öffnen Sie das Terminal und erstellen Sie einen neuen Ordner für Ihr BabyAGI-Projekt. Nennen Sie ihn beispielsweise `babyagi-bright-data-app`: ```none mkdir babyagi-bright-data-app ``` `babyagi-bright-data-app/` enthält den Python-Code zum Starten des BabyAGI-Dashboards und zum Definieren der Bright Data-Integrationsfunktionen. Wechseln Sie als Nächstes 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 babyagi-bright-data-app python -m venv .venv ``` Fügen Sie eine neue Datei namens `main.py` im Projektstammverzeichnis hinzu, die nun Folgendes enthalten sollte: ```none babyagi-bright-data-app/ ├── .venv/ └── main.py ``` `main.py` enthält die Start- und Erweiterungslogik von BabyAGI. 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/). Aktivieren Sie nun die zuvor erstellte 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 ``` Installieren Sie nach Aktivierung der virtuellen Umgebung die erforderlichen PyPI-Bibliotheken: ```none pip install babyagi requests ``` Die Abhängigkeiten für diese Anwendung sind: - [`babyagi`](https://pypi.org/project/babyagi/0.0.8/): Installieren Sie BabyAGI und alle erforderlichen Komponenten, damit Sie das Dashboard starten können. - [`requests`](https://pypi.org/project/requests/): Hilft Ihnen bei der Erstellung von HTTP-Anfragen, um eine Verbindung zu Bright Data-Diensten herzustellen. Fertig! Sie verfügen nun über eine Python-Umgebung für die Entwicklung eigener Agenten in BabyAGI. ### Schritt 2: Starten Sie das BabyAGI-Dashboard Fügen Sie in Ihrer Datei `main.py` den folgenden Code hinzu, um [das BabyAGI-Dashboard](https://babyagi.org/#dashboard) zu initialisieren und zu starten: ```none import babyagi if __name__ == "__main__": app = babyagi.create_app("/dashboard") app.run(host="0.0.0.0", port=8080) ``` Dadurch wird BabyAGI angewiesen, die Dashboard-Anwendung unter folgender Adresse bereitzustellen: ```none http://localhost:8080/dashboard ``` Überprüfen Sie, ob die Anwendung funktioniert, indem Sie Folgendes ausführen: ```none python main.py ``` Im Terminal sollten Sie Protokolle sehen, die anzeigen, dass das Dashboard unter `http://localhost:8080/dashboard` empfangsbereit ist: ![The logs produced by BabyAGI at startup](https://media.brightdata.com/2025/12/s_8EA673771F087AE2E9F7D72FCEC4F9277F20824890852EDABBC9CCBB30F80213_1766050132595_image.png) Rufen Sie diese URL in Ihrem Browser auf, um auf das Dashboard zuzugreifen: ![The BabyAGI dashboard](https://media.brightdata.com/2025/12/s_8EA673771F087AE2E9F7D72FCEC4F9277F20824890852EDABBC9CCBB30F80213_1765993660117_image.png) Auf der Startseite des BabyAGI-Dashboards werden alle verfügbaren Funktionen aufgelistet. Standardmäßig enthält die Bibliothek zwei vorinstallierte Funktionspakete: 1. **Standardfunktionen**: - **Funktionsausführung**: Ausführen, Hinzufügen, Aktualisieren und Abrufen von Funktionen und deren Versionen. - **Schlüsselverwaltung**: Hinzufügen und Abrufen von geheimen Schlüsseln. - **Trigger**: Konfigurieren Sie Trigger, um Funktionen basierend auf anderen Funktionen auszuführen. - **Protokolle**: Abrufen von Ausführungsprotokollen mit optionalen Filtern. 2. **KI-Funktionen**: - **KI-Beschreibungen und Einbettungen**: Automatische Generierung von Funktionsbeschreibungen und Einbettungen. - **Funktionsauswahl**: Finden oder empfehlen Sie ähnliche Funktionen basierend auf einer Eingabeaufforderung. Das BabyAGI-Dashboard bietet eine benutzerfreundliche Oberfläche zum Verwalten von Funktionen, Überwachen von Ausführungen, Verwalten von Geheimnissen, Konfigurieren von Triggern und Visualisieren von Abhängigkeiten. Entdecken Sie die verfügbaren Seiten, um sich mit ihren Funktionen und Optionen vertraut zu machen! ### Schritt 3: Konfigurieren Sie die Geheimnisverwaltung Ihr BabyAGI-Agent stellt eine Verbindung zu Drittanbieterdiensten wie OpenAI und Bright Data her. Diese Verbindungen werden mit externen API-Schlüsseln authentifiziert. Das direkte Festcodieren von API-Schlüsseln in Ihrer `main.py-Datei` ist keine bewährte Vorgehensweise, da dies zu Sicherheitsproblemen führen kann. Stattdessen sollten Sie sie aus Umgebungsvariablen laden. BabyAGI verfügt über einen integrierten Mechanismus zum Lesen von Geheimnissen aus Umgebungsvariablen oder aus einer lokalen `.env-Datei`, ohne dass zusätzliche Abhängigkeiten erforderlich sind. Um diese Funktion zu nutzen, fügen Sie eine `.env-Datei` zu Ihrem Projektverzeichnis hinzu: ```none babyagi-bright-data-app/ ├── .venv/ ├── .env # <---- └── main.py ``` Nachdem Sie Ihre Variablen zur `.env-Datei` hinzugefügt haben, können Sie in Ihrem Code wie folgt darauf zugreifen: ```none import os ENV_VALUE = os.getenv("ENV_NAME") ``` Das war’s schon! Ihr Skript lädt nun sicher Integrationsgeheimnisse von Drittanbietern aus Umgebungsvariablen statt aus fest codierten Werten. Alternativ können Sie diese Geheimnisse auch direkt über das Dashboard festlegen. Zunächst müssen Sie einen OpenAI-API-Schlüssel konfigurieren (dies wird im nächsten Schritt behandelt). Sobald dies erledigt ist, rufen Sie die Seite „Chat” im Dashboard auf. Wählen Sie aus der Funktionsauswahl die Funktion `add_key_wrapper` und fordern Sie sie auf, Ihr Geheimnis mit einer Nachricht wie der folgenden zu definieren: ```none Definieren Sie einen ENV_NAME-Geheimcode, dessen Wert ENV_VALUE ist. ``` Nach dem Absenden der Eingabeaufforderung sollte ein Ergebnis ähnlich dem folgenden angezeigt werden: ![Defining a secret through the dashboard](https://media.brightdata.com/2025/12/s_8EA673771F087AE2E9F7D72FCEC4F9277F20824890852EDABBC9CCBB30F80213_1766050391989_image.png) Wie gezeigt, wurde das Geheimnis erfolgreich erstellt. Überprüfen Sie, ob das Geheimnis vorhanden ist, indem Sie die Funktion `„get_all_secrets_keys“` hinzufügen und aufrufen. ### Schritt 4: Verbinden Sie BabyAGI mit einem OpenAI-Modell Auf der Seite „Chat“ im BabyAGI-Dashboard können Sie Funktionen auswählen und über eine Konversationsschnittstelle aufrufen: ![The “Chat” page in the BabyAGI dashboard](https://media.brightdata.com/2025/12/s_8EA673771F087AE2E9F7D72FCEC4F9277F20824890852EDABBC9CCBB30F80213_1766051488455_image.png) Hinter den Kulissen wird diese Schnittstelle durch eine OpenAI-Integration von [LiteLLM](https://www.litellm.ai/) unterstützt. Aus diesem Grund müssen Sie einen OpenAI-API-Schlüssel in Ihren Geheimnissen konfigurieren. Wenn das Geheimnis `OPENAI_API_KEY` fehlt, schlägt jede über die Chat-Seite gesendete Nachricht mit einer Fehlermeldung ähnlich der folgenden fehl: ```none {"error":"litellm.AuthenticationError: AuthenticationError: OpenAIException – Die api_key-Client-Option muss entweder durch Übergeben von api_key an den Client oder durch Setzen der Umgebungsvariable OPENAI_API_KEY festgelegt werden"} ``` ![Note the error in the BabyAGI chat interface](https://media.brightdata.com/2025/12/s_8EA673771F087AE2E9F7D72FCEC4F9277F20824890852EDABBC9CCBB30F80213_1766051561982_image.png) Um dies zu beheben, fügen Sie die Umgebungsvariable `OPENAI_API_KEY` zu Ihrer `.env` -Datei hinzu: ```none OPENAI_API_KEY="" ``` Starten Sie BabyAGI nach dem Speichern der Datei neu. Um zu überprüfen, ob die Integration funktioniert, öffnen Sie erneut die Seite „Chat“ im Dashboard. Wählen Sie die Funktion `get_call` aus, die das konfigurierte OpenAI-Modell direkt aufruft, und senden Sie eine einfache Nachricht wie „Hey!“. Sie sollten eine Antwort erhalten, die der folgenden ähnelt: ![Note that you can now talk with the OpenAI model](https://media.brightdata.com/2025/12/s_8EA673771F087AE2E9F7D72FCEC4F9277F20824890852EDABBC9CCBB30F80213_1766051932352_image.png) Zu diesem Zeitpunkt kann die zugrunde liegende LiteLLM-Ebene erfolgreich eine Verbindung zum Standard-OpenAI-Modell herstellen. Dies funktioniert, weil LiteLLM den OpenAI-API-Schlüssel automatisch aus der Umgebungsvariablen `OPENAI_API_KEY` liest. Fantastisch! Ihre BabyAGI-Anwendung ist nun korrekt mit einem OpenAI-Modell verbunden. Alternativ können Sie das gleiche Ergebnis erzielen, indem Sie den Schlüssel direkt im Code definieren: ```none babyagi.add_key_wrapper("openai_api_key", "") ``` Dadurch wird die Funktion `add_key_wrapper` aufgerufen, was der Definition des Schlüssels über das Dashboard entspricht. Beachten Sie jedoch, dass Sie den Dashboard-Ansatz nicht verwenden können, bevor die OpenAI-Integration konfiguriert ist, da das Dashboard selbst für seine Funktion auf die OpenAI-Verbindung angewiesen ist. ### Schritt 5: Erste Schritte mit Bright Data Um die SERP-API- und Web-Unlocker-Dienste in BabyAGI nutzen zu können, benötigen Sie zunächst ein Bright Data-Konto, in dem sowohl eine SERP-API-Zone als auch eine Web-Unlocker-API-Zone mit einer Zonen-Konfiguration eingerichtet sind, sowie einen API-Schlüssel. Lassen Sie uns alles einrichten! Wenn Sie noch kein Bright Data-Konto haben, [erstellen Sie eines](/?hs_signup=1). Andernfalls [melden Sie sich an](/cp/start) und gehen Sie zu Ihrem Dashboard. Navigieren Sie dann zur Seite „Proxies & Scraping“ und überprüfen Sie die Tabelle „My Zones“: ![Note the “unlocker” Web Unlocker API zone and “serp” SERP API zone](https://media.brightdata.com/2025/12/s_15C5171743EEDBEF0993090D3D85589F5C79171362D5F7D117C738A5456FCA68_1764757850531_image-2.png) Wenn die Tabelle bereits eine Web Unlocker API-Zone (in diesem Beispiel `„unlocker”`) und eine SERP-API-Zone (in diesem Beispiel `„serp”`) enthält, können Sie loslegen. Diese beiden Dienste werden verwendet, um die Dienste Web Unlocker und SERP-API über benutzerdefinierte BabyAGI-Funktionen aufzurufen. Wenn eine oder beide dieser Zonen fehlen, müssen Sie sie erstellen. Scrollen Sie nach unten zu den Karten „Unblocker API“ und „SERP-API“ und klicken Sie dann auf die Schaltflächen „Zone erstellen“. Folgen Sie den Anweisungen des Assistenten, um beide Zonen hinzuzufügen: ![Note the “Create zone” buttons](https://media.brightdata.com/2025/12/s_15C5171743EEDBEF0993090D3D85589F5C79171362D5F7D117C738A5456FCA68_1764757915299_image-3.png) Eine Schritt-für-Schritt-Anleitung finden Sie auf den folgenden Dokumentationsseiten: - [*Erste Schritte mit der SERP-API*](https://docs.brightdata.com/scraping-automation/serp-api/quickstart) - [*Schnellstartanleitung für die Web Unlocker API von Bright Data*](https://docs.brightdata.com/scraping-automation/web-unlocker/quickstart) Fügen Sie anschließend die Namen Ihrer Web Unlocker-API- und SERP-API-Zonen wie folgt zu Ihrer `.env` -Datei hinzu: ```none SERP_API_ZONE="serp" WEB_UNLOCKER_ZONE="unlocker" ``` **Wichtig**: In diesem Beispiel gehen wir davon aus, dass die SERP-API-Zone ` „serp”` und die Web Unlocker API-Zone ` „unlocker”` heißt. Ersetzen Sie diese Werte durch die tatsächlichen Namen Ihrer Zonen (falls diese abweichen). Zuletzt müssen Sie [Ihren Bright Data API-Schlüssel generieren](https://docs.brightdata.com/api-reference/authentication#how-do-i-generate-a-new-api-key) und ihn als Umgebungsvariable in `.env` speichern: ```none BRIGHT_DATA_API_KEY="" ``` Diese drei Umgebungsvariablen werden von benutzerdefinierten BabyAGI-Funktionen gelesen und verwendet, um eine Verbindung zu Ihren SERP-API- und Web Unlocker-API-Diensten in Ihrem Bright Data-Konto herzustellen. Jetzt können Sie sie in BabyAGI definieren und verwenden! ### Schritt 6: Definieren Sie die SERP-API-Funktion Beginnen Sie mit der Definition einer BabyAGI-Funktion, um Websuchen mit der Bright Data SERP-API durchzuführen: ```none @babyagi.register_function( imports=["os", "urllib", "requests"], key_dependencies=["bright_data_api_key", "serp_api_zone"], metadata={"description": "Durchsuche das Web nach einer bestimmten Abfrage mit der SERP-API von Bright Data."} ) def bright_data_serp_api(query: str) -> str: import requests import os import urllib # Lesen Sie den Bright Data API-Schlüssel aus der Umgebung BRIGHT_DATA_API_TOKEN = os.getenv("bright_data_api_key") # Anfrage an die Bright Data SERP-API stellen url = "https://api.brightdata.com/request" data = { "zone": os.getenv("serp_api_zone"), "url": f"https://www.google.com/search?q={urllib.parse.quote_plus(query)}&brd_json=1", "format": "raw" } headers = { "Authorization": f"Bearer {BRIGHT_DATA_API_TOKEN}", "Content-Type": "application/json" } response = requests.post(url, json=data, headers=headers) response.raise_for_status() return response.text ``` Diese Funktion nutzt den [HTTP-Client „Requests“](/blog/web-data/python-requests-guide), um eine POST-HTTP-Anfrage an Ihre SERP-API-Zone zu senden. Insbesondere sendet sie eine Anfrage an Google und ruft die geparsten SERP-Ergebnisse über Bright Data ab. Weitere Informationen finden Sie in der [Dokumentation zur Bright Data SERP-API](https://docs.brightdata.com/scraping-automation/serp-api/get-started-google-serp-api). Beachten Sie, dass eine BabyAGI-Funktion mit dem Dekorator `@babyagi.register_function` registriert werden muss. Dieser akzeptiert die [folgenden Felder](https://babyagi.org/#function-metadata): - `imports`: Eine Liste externer Bibliotheken, von denen die Funktion abhängt. Diese sind erforderlich, da BabyAGI-Funktionen in einer isolierten Umgebung ausgeführt werden. - `dependencies`: Eine Liste anderer BabyAGI-Funktionen, von denen diese Funktion abhängt. - `key_dependencies`: Eine Liste der geheimen Schlüssel, die für die Funktion erforderlich sind. In diesem Fall sind die erforderlichen Geheimnisse ` „bright_data_api_key”` und ` „serp_api_zone”`, die den zuvor in Ihrer `.env-Datei` definierten Umgebungsvariablen `BRIGHT_DATA_API_KEY` und `SERP_API_ZONE` entsprechen. - `metadata["description"]`: Eine für Menschen lesbare Beschreibung der Funktion. Dies hilft dem OpenAI-Modell, den Zweck der Funktion zu verstehen. Fantastisch! Ihre BabyAGI-Anwendung enthält nun die Funktion `bright_data_serp_api`, mit der sie über die Bright Data SERP-API im Internet suchen kann. ### Schritt 7: Definieren Sie die Web Unlocker API-Funktion Definieren Sie auf ähnliche Weise eine benutzerdefinierte Funktion zum Aufrufen der Web Unlocker API: ```none @babyagi.register_function( imports=["os", "requests"], key_dependencies=["bright_data_api_key", "web_unlocker_zone"], metadata={"description": "Fetch web page content through the Bright Data Web Unlocker API."} ) def bright_data_web_unlocker(page_url: str, data_format: str = "markdown") -> str: import requests import os # Lesen Sie den Bright Data API-Schlüssel aus der Umgebung BRIGHT_DATA_API_TOKEN = os.getenv("bright_data_api_key") # Senden Sie eine Anfrage an die Bright Data Web Unlocker API url = "https://api.brightdata.com/request" data = { "Zone": os.getenv("web_unlocker_zone"), "url": page_url, "format": "raw", "data_format": data_format } headers = { "Authorization": f"Bearer {BRIGHT_DATA_API_TOKEN}", "Content-Type": "application/json" } response = requests.post(url, json=data, headers=headers) response.raise_for_status() return response.text ``` Dies funktioniert genau wie die Funktion `bright_data_serp_api`, mit dem Hauptunterschied, dass sie die Web Unlocker API aufruft. Weitere Informationen zu den verfügbaren Parametern und Optionen für diese API [finden Sie in der Bright Data-Dokumentation](https://docs.brightdata.com/scraping-automation/web-unlocker/send-your-first-request). Beachten Sie, dass diese Funktion auf dem Geheimnis `web_unlocker_zone` basiert, das der in Schritt 5 definierten Umgebungsvariablen `WEB_UNLOCKER_ZONE` entspricht. Außerdem wird das Argument `data_format` automatisch auf `Markdown` gesetzt. Dadurch kann die spezielle Funktion[„Scrape as Markdown”](https://docs.brightdata.com/scraping-automation/web-unlocker/features#scrape-as-markdown)den gescrapten Inhalt einer bestimmten Webseite in einem optimierten Markdown-Format zurückgeben, das sich [ideal für die LLM-Erfassung](https://www.kaggle.com/code/brightdataml/benchmarking-ai-on-different-data-formats) eignet. **Tipp**: Durch eine ähnliche Konfiguration können Sie BabyAGI erweitern, um andere API-basierte Bright Data-Lösungen zu integrieren, z. B. [Web-Scraping-APIs](https://docs.brightdata.com/api-reference/web-scraper-api/synchronous-requests). Mission abgeschlossen! Die gewünschten Bright Data-Funktionen wurden zu BabyAGI hinzugefügt. ### Schritt 8: Vollständiger Code Der endgültige Code Ihrer `main.py` -Datei lautet: ```none import babyagi @babyagi.register_function( imports=["os", "urllib", "requests"], key_dependencies=["bright_data_api_key", "serp_api_zone"], metadata={"description": "Durchsuche das Web nach einer bestimmten Abfrage mit der SERP-API von Bright Data."} ) def bright_data_serp_api(query: str) -> str: import requests import os import urllib # Lesen Sie den Bright Data API-Schlüssel aus der Umgebung BRIGHT_DATA_API_TOKEN = os.getenv("bright_data_api_key") # Anfrage an die Bright Data SERP-API stellen url = "https://api.brightdata.com/request" data = { "zone": os.getenv("serp_api_zone"), "url": f"https://www.google.com/search?q={urllib.parse.quote_plus(query)}&brd_json=1", "format": "raw" } headers = { "Authorization": f"Bearer {BRIGHT_DATA_API_TOKEN}", "Content-Type": "application/json" } response = requests.post(url, json=data, headers=headers) response.raise_for_status() return response.text @babyagi.register_function( imports=["os", "requests"], key_dependencies=["bright_data_api_key", "web_unlocker_zone"], metadata={"description": "Fetch web page content through the Bright Data Web Unlocker API."} ) def bright_data_web_unlocker(page_url: str, data_format: str = "markdown") -> str: import requests import os # Bright Data API-Schlüssel aus der Umgebung lesen BRIGHT_DATA_API_TOKEN = os.getenv("bright_data_api_key") # Anfrage an die Bright Data Web Unlocker API senden url = "https://api.brightdata.com/request" data = { "zone": os.getenv("web_unlocker_zone"), "url": page_url, "format": "raw", "data_format": data_format } headers = { "Authorization": f"Bearer {BRIGHT_DATA_API_TOKEN}", "Content-Type": "application/json" } response = requests.post(url, json=data, headers=headers) response.raise_for_status() return response.text if __name__ == "__main__": app = babyagi.create_app("/dashboard") app.run(host="0.0.0.0", port=8080) ``` Stattdessen enthält die `.env` -Datei: ```none OPENAI_API_KEY="" SERP_API_ZONE="" WEB_UNLOCKER_ZONE="" BRIGHT_DATA_API_KEY="" ``` Starten Sie das BabyAGI-Dashboard mit: ```none python main.py ``` Öffnen Sie `http://localhost:8080/dashboard` im Browser, gehen Sie zur Seite „Chat“ und suchen Sie nach „bright\_data“. Sie werden feststellen, dass die beiden Funktionen, die im Code für die Bright Data-Integration definiert sind, ![Note the “bright_data_serp_api” and “bright_data_web_unlocker” functions](https://media.brightdata.com/2025/12/s_8EA673771F087AE2E9F7D72FCEC4F9277F20824890852EDABBC9CCBB30F80213_1766054395517_image.png) Cool! Die beiden benutzerdefinierten Funktionen wurden korrekt registriert. ### Schritt 9: Testen Sie die Integration von BabyAGI und Bright Data Überprüfen Sie, ob Ihre BabyAGI-Anwendung funktioniert, indem Sie die Bright Data-Funktionen mit der Standardfunktion `chat_with_functions` testen. Dadurch wird eine Chat-Interaktion gestartet, die eine Verbindung zu LiteLLM herstellt und ausgewählte Funktionen aus Ihrer Funktionsdatenbank ausführt. Beginnen Sie also damit, die Funktionen `„bright_data_serp_api“` und `„bright_data_web_unlocker“` auszuwählen. Wählen Sie dann `„chat_with_functions“` aus: ![Selecting the “bright_data_serp_api,” “bright_data_web_unlocker,” and “chat_with_functions” functions](https://media.brightdata.com/2025/12/s_8EA673771F087AE2E9F7D72FCEC4F9277F20824890852EDABBC9CCBB30F80213_1766054766150_image.png) Als Nächstes müssen Sie eine Eingabeaufforderung verwenden, die sowohl Websuchen als auch Datenextraktion auslöst. Versuchen Sie es beispielsweise mit: ```none Suchen Sie im Internet nach den neuesten Ankündigungen zu Google KI (2025), wählen Sie die drei zuverlässigsten Nachrichten- oder Blog-Artikel aus, rufen Sie jeden einzelnen auf und fassen Sie die wichtigsten Erkenntnisse über die Zukunft von Google KI zusammen (unter Angabe der URLs der Quellartikel). ``` **Hinweis**: Ein Vanilla-LLM ohne externe Tools für den Webzugriff wäre nicht in der Lage, diese Aufgabe zu erfüllen. Führen Sie die Eingabeaufforderung im Chat aus, und Sie sollten eine Ausgabe ähnlich der folgenden sehen: ![Note the result produced by the AI-powered chat](https://media.brightdata.com/2025/12/s_8EA673771F087AE2E9F7D72FCEC4F9277F20824890852EDABBC9CCBB30F80213_1766054868114_image.png) Beachten Sie, dass die Ausgabe fundierte Erkenntnisse enthält, die durch die Suche in Google über die SERP-API und das Scraping von Informationen aus den ausgewählten Nachrichtenseiten über die Web Unlocker-API abgerufen wurden. Nachdem Sie nun überprüft haben, dass der Agent mit aktuellen Webinhalten interagieren und daraus lernen kann, bedeutet dies, dass der Agent in der Lage ist, selbst Funktionen zu erstellen, die mit anderen Diensten interagieren können, indem er auf deren Dokumentation zugreift, um technische Details zu lernen, die er zunächst nicht kannte. Testen Sie dies mit der `self_build-Funktion` für die Erstellung eigener KI-Agenten, [wie in der BabyAGI-Dokumentation erläutert](https://babyagi.org/#2-self_build-in-the-self_build-pack). Probieren Sie verschiedene Eingabeaufforderungen und andere BabyAGI-Funktionen aus. Dank der Bright Data-Funktionen können Ihre selbst erstellten BabyAGI-Agenten eine [Vielzahl von Anwendungsfällen aus der Praxis](/ai/web-access) bewältigen. Et voilà! Sie haben gerade die Leistungsfähigkeit der Kombination von Bright Data und BabyAGI erlebt. ## Fazit In diesem Blogbeitrag haben Sie gesehen, wie Sie Bright Data-Funktionen in BabyAGI durch benutzerdefinierte Funktionen aktivieren können, die die SERP-API und die Web Unlocker-API aufrufen. Diese Einrichtung ermöglicht das Abrufen von Inhalten von jeder Webseite und Websuchen in Echtzeit. Um die Funktionalität weiter zu erweitern – beispielsweise durch den Zugriff auf Live-Web-Feeds und die Automatisierung von Web-Interaktionen – integrieren Sie BabyAGI in die [gesamte Suite der Bright Data-Dienste für KI](/ai). Schöpfen Sie das volle Potenzial selbstlernender KI-Agenten aus! Registrieren Sie sich noch heute kostenlos für ein Bright Data-Konto und probieren Sie unsere KI-fähigen Webdatenlösungen aus! Vertrieb kontaktierenGratis testen![google social icon](/wp-content/themes/brightdata/assets/images/ic_google.svg) Inhaltsverzeichnis [ ](https://news.ycombinator.com/submitlink?t=Integration+von+Bright+Data+in+BabyAGI+%C3%BCber+benutzerdefinierte+Funktionen&u=https://brightdata.de/blog/ai/babyagi-with-bright-data) [ ](https://www.linkedin.com/shareArticle?mini=true&title=Integration+von+Bright+Data+in+BabyAGI+%C3%BCber+benutzerdefinierte+Funktionen&url=https://brightdata.de/blog/ai/babyagi-with-bright-data) [ ](http://www.reddit.com/submit?title=Integration+von+Bright+Data+in+BabyAGI+%C3%BCber+benutzerdefinierte+Funktionen&url=https://brightdata.de/blog/ai/babyagi-with-bright-data) ## 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)