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 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 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.
Bessere selbstaufbauende KI-Agenten durch Zugriff auf Webdaten
LLMs sind von Natur aus durch die statischen Daten begrenzt, mit denen sie trainiert wurden, 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: Sammeln Sie Suchmaschinenergebnisse von Google, Bing und anderen in großem Umfang, ohne blockiert zu werden.
- Web Unlocker API: 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: Rufen Sie strukturierte, geparste Daten von beliebten Plattformen wie Amazon, LinkedIn, Instagram, Yahoo Finance und anderen ab.
- Und weitere Lösungen…
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+ lokal installiert.
- Einen OpenAI-API-Schlüssel.
- 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:
mkdir babyagi-bright-data-appbabyagi-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 darin eine virtuelle Umgebung:
cd babyagi-bright-data-app
python -m venv .venvFügen Sie eine neue Datei namens main.py im Projektstammverzeichnis hinzu, die nun Folgendes enthalten sollte:
babyagi-bright-data-app/
├── .venv/
└── main.pymain.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 oder PyCharm Community Edition.
Aktivieren Sie nun die zuvor erstellte virtuelle Umgebung. Führen Sie unter Linux oder macOS folgenden Befehl aus:
source .venv/bin/activateUnter Windows führen Sie stattdessen folgenden Befehl aus:
.venv/Scripts/activateInstallieren Sie nach Aktivierung der virtuellen Umgebung die erforderlichen PyPI-Bibliotheken:
pip install babyagi requestsDie Abhängigkeiten für diese Anwendung sind:
babyagi: Installieren Sie BabyAGI und alle erforderlichen Komponenten, damit Sie das Dashboard starten können.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 zu initialisieren und zu starten:
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:
http://localhost:8080/dashboardÜberprüfen Sie, ob die Anwendung funktioniert, indem Sie Folgendes ausführen:
python main.pyIm Terminal sollten Sie Protokolle sehen, die anzeigen, dass das Dashboard unter http://localhost:8080/dashboard empfangsbereit ist:
Rufen Sie diese URL in Ihrem Browser auf, um auf das Dashboard zuzugreifen:
Auf der Startseite des BabyAGI-Dashboards werden alle verfügbaren Funktionen aufgelistet. Standardmäßig enthält die Bibliothek zwei vorinstallierte Funktionspakete:
- 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.
- 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:
babyagi-bright-data-app/
├── .venv/
├── .env # <----
└── main.pyNachdem Sie Ihre Variablen zur .env-Datei hinzugefügt haben, können Sie in Ihrem Code wie folgt darauf zugreifen:
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:
Definieren Sie einen ENV_NAME-Geheimcode, dessen Wert ENV_VALUE ist.Nach dem Absenden der Eingabeaufforderung sollte ein Ergebnis ähnlich dem folgenden angezeigt werden:
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:
Hinter den Kulissen wird diese Schnittstelle durch eine OpenAI-Integration von LiteLLM 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:
{"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"}
Um dies zu beheben, fügen Sie die Umgebungsvariable OPENAI_API_KEY zu Ihrer .env -Datei hinzu:
OPENAI_API_KEY="<YOUR_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:
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:
babyagi.add_key_wrapper("openai_api_key", "<YOUR_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. Andernfalls melden Sie sich an und gehen Sie zu Ihrem Dashboard. Navigieren Sie dann zur Seite „Proxies & Scraping“ und überprüfen Sie die Tabelle „My Zones“:
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:
Eine Schritt-für-Schritt-Anleitung finden Sie auf den folgenden Dokumentationsseiten:
Fügen Sie anschließend die Namen Ihrer Web Unlocker-API- und SERP-API-Zonen wie folgt zu Ihrer .env -Datei hinzu:
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 und ihn als Umgebungsvariable in .env speichern:
BRIGHT_DATA_API_KEY="<IHR_BRIGHT_DATA_API_SCHLÜSSEL>"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:
@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.textDiese Funktion nutzt den HTTP-Client „Requests“, 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.
Beachten Sie, dass eine BabyAGI-Funktion mit dem Dekorator @babyagi.register_function registriert werden muss. Dieser akzeptiert die folgenden Felder:
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-Dateidefinierten UmgebungsvariablenBRIGHT_DATA_API_KEYundSERP_API_ZONEentsprechen.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:
@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.textDies 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.
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”den gescrapten Inhalt einer bestimmten Webseite in einem optimierten Markdown-Format zurückgeben, das sich ideal für die LLM-Erfassung 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.
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:
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:
OPENAI_API_KEY="<YOUR_OPENAI_API_KEY>"
SERP_API_ZONE="<YOUR_SERP_API_ZONE_NAME>"
WEB_UNLOCKER_ZONE="<YOUR_WEB_UNLOCKER_ZONE_NAME>"
BRIGHT_DATA_API_KEY="<IHR_BRIGHT_DATA_API_SCHLÜSSEL>"Starten Sie das BabyAGI-Dashboard mit:
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,
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:
Als Nächstes müssen Sie eine Eingabeaufforderung verwenden, die sowohl Websuchen als auch Datenextraktion auslöst. Versuchen Sie es beispielsweise mit:
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:
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.
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 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.
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!
