Intégration de Bright Data dans BabyAGI via des fonctions personnalisées

Dans ce tutoriel, vous apprendrez :

• Ce qu’est BabyAGI et ce qui en fait un cadre de création d’agents IA vraiment unique.
• Pourquoi l’extension de BabyAGI avec les services Bright Data ouvre la voie à un large éventail de scénarios intéressants.
• Comment intégrer Bright Data dans BabyAGI grâce à des fonctions personnalisées.

C’est parti !

Qu’est-ce que BabyAGI ?

BabyAGI est un cadre Python expérimental conçu pour créer des agents IA autonomes capables de générer, hiérarchiser et exécuter des tâches afin d’atteindre des objectifs définis par l’utilisateur.

Il fonctionne comme un gestionnaire de tâches minimaliste et auto-améliorable, exploitant des LLM tels que les modèles OpenAI pour le raisonnement et des bases de données vectorielles pour la mémoire. En général, il fonctionne dans une boucle intelligente pour automatiser des flux de travail complexes.

À la base, BabyAGI introduit un framework basé sur les fonctions appelé functionz pour stocker, gérer et exécuter des fonctions à partir d’une base de données. Ces fonctions prennent également en charge la génération de code, ce qui permet à l’agent IA d’enregistrer de nouvelles fonctions, de les appeler et d’évoluer de manière autonome.

Ensuite, un tableau de bord intégré vous permet de gérer les fonctions, de surveiller l’exécution et d’enregistrer les secrets. Il dispose d’une structure basée sur des graphiques pour suivre les importations, les fonctions dépendantes et les secrets d’authentification, avec un chargement automatique et une journalisation détaillée.

Ce qui rend BabyAGI particulièrement intéressant, c’est sa simplicité, sa capacité d’auto-construction et son tableau de bord web convivial. L’idée centrale est que les agents autonomes les plus efficaces sont ceux qui peuvent s’étendre avec une structure minimale.

BabyAGI est open source et activement maintenu, avec plus de 22 000 étoiles sur GitHub.

Renforcez les agents IA auto-constructibles grâce à l’accès aux données web

Les LLM sont intrinsèquement limités par les données statiques sur lesquelles ils ont été entraînés, ce qui conduit souvent à des hallucinations et à d’autres problèmes courants liés aux LLM.

BabyAGI surmonte ces contraintes grâce à son cadre de fonctions d’auto-construction. Il utilise un LLM pour écrire des fonctions personnalisées, qui sont ensuite renvoyées à l’agent sous forme d’outils permettant d’étendre ses capacités.

Cependant, la logique de génération de ces fonctions reste limitée par les connaissances obsolètes du LLM. Pour remédier à cette limitation majeure, BabyAGI doit être capable de rechercher sur le web et de récupérer des informations précises et à jour, ce qui lui permet de produire des fonctions plus fiables.

Cela est rendu possible grâce à la connexion aux services Bright Data, tels que :

• API SERP: collectez les résultats des moteurs de recherche Google, Bing et autres à grande échelle sans être bloqué.
• API Web Unlocker: accédez à n’importe quel site web en une seule requête et recevez du code HTML ou Markdown propre, avec gestion automatique des Proxy, des en-têtes et des CAPTCHA.
• API de Scraping web: récupérez des données structurées et analysées à partir de plateformes populaires telles qu’Amazon, LinkedIn, Instagram, Yahoo Finance et autres.
• Et d’autres solutions…

Grâce à ces intégrations, combinées à l’architecture auto-constructive de BabyAGI, l’IA peut évoluer de manière autonome, ajouter de nouvelles fonctions et gérer des flux de travail complexes bien au-delà de ce qu’un LLM standard pourrait réaliser à lui seul.

Comment étendre BabyAGI avec Bright Data pour les capacités de récupération de données Web

Dans cette section étape par étape, vous serez guidé à travers l’intégration de Bright Data dans BabyAGI via des fonctions personnalisées. Celles-ci se connectent à deux produits Bright Data : l’API SERP et l’API Web Unlocker.

Suivez les instructions ci-dessous pour commencer !

Prérequis

Pour suivre ce tutoriel, vous avez besoin de :

• Python 3.10+ installé localement.
• Une clé API OpenAI.
• Un compte Bright Data configuré avec une zone API SERP, une zone API Web Unlocker et une clé API active.

Ne vous inquiétez pas si votre compte Bright Data n’est pas encore configuré, car vous serez guidé tout au long de ce processus dans une étape dédiée.

Étape n° 1 : Configurer un projet BabyAGI

Ouvrez le terminal et créez un nouveau dossier pour votre projet BabyAGI. Par exemple, nommez-le babyagi-bright-data-app:

mkdir babyagi-bright-data-app

babyagi-bright-data-app/ contiendra le code Python permettant de lancer le tableau de bord BabyAGI et de définir les fonctions d’intégration Bright Data.

Ensuite, entrez dans le répertoire du projet et initialisez un environnement virtuel à l’intérieur :

cd babyagi-bright-data-app
python -m venv .venv

Ajoutez un nouveau fichier appelé main.py à la racine du projet, qui devrait maintenant contenir :

babyagi-bright-data-app/
├── .venv/
└── main.py

main.py contiendra la logique de lancement et d’extension de BabyAGI.

Chargez le dossier du projet dans votre IDE Python préféré, tel que Visual Studio Code avec l’extension Python ou PyCharm Community Edition.

Activez maintenant l’environnement virtuel que vous avez créé précédemment. Sous Linux ou macOS, exécutez :

source .venv/bin/activate

De manière équivalente, sous Windows, exécutez :

.venv/Scripts/activate

Une fois l’environnement virtuel activé, installez les bibliothèques PyPI requises :

pip install babyagi requests

Les dépendances pour cette application sont les suivantes :

• babyagi: installez BabyAGI et toutes ses exigences afin de pouvoir lancer le tableau de bord.
• requests: vous aide à effectuer des requêtes HTTP pour vous connecter aux services Bright Data.

C’est fait ! Vous disposez désormais d’un environnement Python pour le développement d’agents autonomes dans BabyAGI.

Étape n° 2 : lancer le tableau de bord BabyAGI

Dans votre fichier main.py, ajoutez le code suivant pour initialiser et lancer le tableau de bord BabyAGI:

import babyagi

if __name__ == "__main__":
    app = babyagi.create_app("/dashboard")
    app.run(host="0.0.0.0", port=8080)

Cela indique à BabyAGI d’exposer l’application du tableau de bord à l’adresse suivante :

http://localhost:8080/dashboard

Vérifiez que l’application fonctionne en exécutant :

python main.py

Dans le terminal, vous devriez voir des journaux indiquant que le tableau de bord est à l’écoute à l’adresse http://localhost:8080/dashboard:

Rendez-vous à cette URL dans votre navigateur pour accéder au tableau de bord :

La page d’accueil du tableau de bord BabyAGI répertorie toutes les fonctions disponibles. Par défaut, la bibliothèque est livrée avec deux packs de fonctions préchargés :

1. Fonctions par défaut:
   • Exécution des fonctions: exécutez, ajoutez, mettez à jour et récupérez les fonctions et leurs versions.
   • Gestion des clés: ajoutez et récupérez des clés secrètes.
   • Déclencheurs: configurez des déclencheurs pour exécuter des fonctions en fonction d’autres fonctions.
   • Journaux: récupérer les journaux d’exécution avec des filtres optionnels.
2. Fonctions IA:
   • Descriptions et intégrations IA: générez automatiquement des descriptions et des intégrations de fonctions.
   • Sélection de fonctions: recherchez ou recommandez des fonctions similaires en fonction d’une invite.

Le tableau de bord BabyAGI offre une interface conviviale pour gérer les fonctions, surveiller les exécutions, traiter les secrets, configurer les déclencheurs et visualiser les dépendances. Explorez les pages disponibles pour vous familiariser avec leurs fonctionnalités et leurs options !

Étape n° 3 : configurer la gestion des secrets

Votre agent BabyAGI se connectera à des services tiers tels que OpenAI et Bright Data. Ces connexions sont authentifiées à l’aide de clés API externes. Le codage en dur des clés API directement dans votre fichier main.py n’est pas une bonne pratique, car cela peut entraîner des problèmes de sécurité. Vous devez plutôt les charger à partir de variables d’environnement.

BabyAGI inclut un mécanisme intégré permettant de lire les secrets à partir de variables d’environnement ou d’un fichier .env local, sans nécessiter de dépendances supplémentaires. Pour utiliser cette fonctionnalité, ajoutez un fichier .env à votre répertoire de projet :

babyagi-bright-data-app/
├── .venv/
├── .env # <----
└── main.py

Après avoir ajouté vos variables au fichier .env, vous pouvez y accéder dans votre code comme suit :

import os

ENV_VALUE = os.getenv("ENV_NAME")

C’est tout ! Votre script charge désormais en toute sécurité les secrets d’intégration tiers à partir de variables d’environnement au lieu de valeurs codées en dur.

Vous pouvez également définir ces secrets directement à partir du tableau de bord. Vous devez d’abord configurer une clé API OpenAI (ceci est abordé à l’étape suivante). Une fois cela fait, accédez à la page « Chat » du tableau de bord. Dans le sélecteur de fonctions, choisissez la fonction add_key_wrapper et demandez-lui de définir votre secret à l’aide d’un message tel que :

Définissez un secret ENV_NAME dont la valeur est ENV_VALUE.

Après avoir soumis l’invite, vous devriez obtenir un résultat similaire à celui-ci :

Comme indiqué, le secret a été créé avec succès. Vérifiez que le secret existe en ajoutant la fonction get_all_secrets_keys et en l’appelant.

Étape n° 4 : connecter BabyAGI à un modèle OpenAI

La page « Chat » du tableau de bord BabyAGI vous permet de sélectionner des fonctions et de les invoquer via une interface conversationnelle :

En arrière-plan, cette interface est prise en charge par LiteLLM via une intégration OpenAI. Pour cette raison, vous devez configurer une clé API OpenAI dans vos secrets.

Si le secret OPENAI_API_KEY est manquant, tout message envoyé via la page Chat échouera avec une erreur similaire à la suivante :

{"error":"litellm.AuthenticationError: AuthenticationError: OpenAIException - L'option client api_key doit être définie soit en transmettant api_key au client, soit en définissant la variable d'environnement OPENAI_API_KEY"}

Pour résoudre ce problème, ajoutez la variable d’environnement OPENAI_API_KEY à votre fichier .env:

OPENAI_API_KEY="<VOTRE_OPENAI_API_KEY>"

Après avoir enregistré le fichier, redémarrez BabyAGI. Pour vérifier que l’intégration fonctionne, ouvrez à nouveau la page « Chat » dans le tableau de bord. Sélectionnez la fonction get_call, qui invoque directement le modèle OpenAI configuré, et envoyez un message simple tel que « Hey ! ».

Vous devriez recevoir une réponse similaire à celle ci-dessous :

À ce stade, la couche LiteLLM sous-jacente peut se connecter avec succès au modèle OpenAI par défaut. Cela fonctionne parce que LiteLLM lit automatiquement la clé API OpenAI à partir de la variable d’environnement OPENAI_API_KEY.

Incroyable ! Votre application BabyAGI est désormais correctement connectée à un modèle OpenAI.

Vous pouvez également obtenir le même résultat en définissant la clé directement dans le code :

babyagi.add_key_wrapper("openai_api_key", "<VOTRE_CLÉ_API_OPENAI>")

Cela appelle la fonction add_key_wrapper, qui équivaut à définir la clé via le tableau de bord. Cependant, notez que vous ne pouvez pas utiliser l’approche du tableau de bord avant que l’intégration OpenAI ne soit configurée, car le tableau de bord lui-même dépend de la connexion OpenAI pour fonctionner.

Étape n° 5 : Démarrer avec Bright Data

Pour utiliser les services API SERP et Web Unlocker dans BabyAGI, vous devez d’abord disposer d’un compte Bright Data avec une zone API SERP et une zone Web Unlocker API configurées, ainsi qu’une clé API. Configurons tout cela !

Si vous n’avez pas de compte Bright Data, créez-en un. Sinon, connectez-vous et accédez à votre tableau de bord. Ensuite, accédez à la page « Proxies & Scraping » (Proxys et scraping) et consultez le tableau « My Zones » (Mes zones) :

Si le tableau contient déjà une zone API Web Unlocker (dans cet exemple, unlocker) et une zone API SERP (dans cet exemple, serp), vous êtes prêt. Ces deux services seront utilisés pour appeler les services Web Unlocker et API SERP via des fonctions BabyAGI personnalisées.

Si l’une de ces zones ou les deux sont manquantes, vous devez les créer. Faites défiler vers le bas jusqu’aux cartes « Unblocker API » et « API SERP », puis cliquez sur les boutons « Create zone » (Créer une zone). Suivez l’assistant pour ajouter les deux zones :

Pour obtenir des instructions étape par étape, consultez les pages de documentation suivantes :

• Comment démarrer avec l’API SERP
• Guide de démarrage rapide pour l’API Web Unlocker de Bright Data

Ensuite, ajoutez les noms de vos zones Web Unlocker API et API SERP à votre fichier .env comme suit :

SERP_API_ZONE="serp"
WEB_UNLOCKER_ZONE="unlocker"

Important: dans cet exemple, nous supposons que la zone API SERP s’appelle « serp » et que la zone Web Unlocker API s’appelle « unlocker ». Remplacez ces valeurs par les noms réels de vos zones (s’ils sont différents).

Enfin, vous devez générer votre clé API Bright Data et la stocker en tant que variable d’environnement dans .env:

BRIGHT_DATA_API_KEY="<VOTRE_CLÉ_API_BRIGHT_DATA>"

Ces trois variables d’environnement seront lues par les fonctions personnalisées de BabyAGI et utilisées pour se connecter à vos services API SERP et Web Unlocker dans votre compte Bright Data. Vous êtes maintenant prêt à les définir et à les utiliser dans BabyAGI !

Étape n° 6 : définir la fonction API SERP

Commencez par définir une fonction BabyAGI pour effectuer des recherches sur le Web à l’aide de l’API SERP de Bright Data :

@babyagi.register_function(
    imports=["os", "urllib", "requests"],
    key_dependencies=["bright_data_api_key", "serp_api_zone"],
    metadata={"description": "Rechercher sur le Web une requête donnée à l'aide de l'API SERP de Bright Data."}
)
def bright_data_serp_api(query: str) -> str:
    import requests
    import os
    import urllib

    # Lire la clé API Bright Data à partir de l'environnement
    BRIGHT_DATA_API_TOKEN = os.getenv("bright_data_api_key")

    # Envoyer une requête à l'API SERP de Bright Data
    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

Cette fonction s’appuie sur le client HTTP Requests pour envoyer une requête HTTP POST à votre zone API SERP. Elle envoie notamment une requête à Google et récupère les résultats SERP analysés via Bright Data. Pour plus d’informations, consultez la documentation de l’API SERP de Bright Data.

Notez qu’une fonction BabyAGI doit être enregistrée à l’aide du décorateur @babyagi.register_function. Celui-ci accepte les champs suivants:

• imports: liste des bibliothèques externes dont dépend la fonction. Elles sont nécessaires car les fonctions BabyAGI s’exécutent dans un environnement isolé.
• dépendances: une liste des autres fonctions BabyAGI dont dépend cette fonction.
• key_dependencies: liste des clés secrètes requises pour le fonctionnement de la fonction. Dans ce cas, les secrets requis sont « bright_data_api_key » et « serp_api_zone », qui correspondent aux variables d’environnement BRIGHT_DATA_API_KEY et SERP_API_ZONE définies précédemment dans votre fichier .env.
• metadata["description"]: description lisible par l’utilisateur de ce que fait la fonction. Cela aide le modèle OpenAI à comprendre son objectif.

Fantastique ! Votre application BabyAGI inclut désormais la fonction bright_data_serp_api, grâce à laquelle elle peut effectuer des recherches sur le Web via l’API SERP de Bright Data.

Étape n° 7 : définir la fonction API Web Unlocker

De la même manière, définissez une fonction personnalisée pour appeler l’API Web Unlocker :

@babyagi.register_function(
    imports=["os", "requests"],
    key_dependencies=["bright_data_api_key", "web_unlocker_zone"],
    metadata={"description": "Récupérer le contenu d'une page web via l'API Bright Data Web Unlocker."}
)
def bright_data_web_unlocker(page_url: str, data_format: str = "markdown") -> str:
    import requests
    import os

    # Lire la clé API Bright Data à partir de l'environnement
    BRIGHT_DATA_API_TOKEN = os.getenv("bright_data_api_key")

    # Envoyer une requête à l'API Bright Data Web Unlocker
    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

Cela fonctionne exactement comme la fonction bright_data_serp_api, à la différence près qu’elle appelle l’API Web Unlocker. Pour plus d’informations sur les paramètres et options disponibles pour cette API, consultez la documentation Bright Data.

Notez que cette fonction repose sur le secret web_unlocker_zone, qui correspond à la variable d’environnement WEB_UNLOCKER_ZONE définie à l’étape n° 5. De plus, l’argument data_format est automatiquement défini sur markdown. Cela permet à la fonctionnalité spéciale «Scrape as Markdown »(Récupérerentant queMarkdown) de renvoyer le contenu récupéré d’une page Web donnée dans un format Markdown optimisé, idéal pour l’ingestion LLM.

Astuce: grâce à une configuration similaire, vous pouvez étendre BabyAGI pour intégrer d’autres solutions Bright Data basées sur des API, telles que les API de Scraping web.

Mission accomplie ! Les fonctions souhaitées alimentées par Bright Data ont été ajoutées à BabyAGI.

Étape n° 8 : code complet

Le code final de votre fichier main.py sera le suivant :

import babyagi

@babyagi.register_function(
    imports=["os", "urllib", "requests"],
    key_dependencies=["bright_data_api_key", "serp_api_zone"],
    metadata={"description": "Rechercher sur le Web une requête donnée à l'aide de l'API SERP de Bright Data."}
)
def bright_data_serp_api(query: str) -> str:
    import requests
    import os
    import urllib

    # Lire la clé API Bright Data à partir de l'environnement
    BRIGHT_DATA_API_TOKEN = os.getenv("bright_data_api_key")

    # Envoyer une requête à l'API SERP de Bright Data
    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": "Récupérer le contenu d'une page web via l'API Bright Data Web Unlocker."}
)
def bright_data_web_unlocker(page_url: str, data_format: str = "markdown") -> str:
    import requests
    import os

    # Lire la clé API Bright Data à partir de l'environnement
    BRIGHT_DATA_API_TOKEN = os.getenv("bright_data_api_key")

    # Envoyer une requête à l'API Bright Data Web Unlocker
    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)

À la place, le fichier .env contiendra :

OPENAI_API_KEY="<VOTRE_CLÉ_API_OPENAI>"
SERP_API_ZONE="<VOTRE_NOM_DE_ZONE_API_SERP>"
WEB_UNLOCKER_ZONE="<VOTRE_NOM_DE_ZONE_WEB_UNLOCKER>"
BRIGHT_DATA_API_KEY="<VOTRE_CLÉ_API_BRIGHT_DATA>"

Lancez le tableau de bord BabyAGI avec :

python main.py

Ouvrez http://localhost:8080/dashboard dans le navigateur, accédez à la page « Chat » et recherchez « bright_data ». Vous remarquerez les deux fonctions définies dans le code pour l’intégration de Bright Data :

Super ! Les deux fonctions personnalisées ont été enregistrées correctement.

Étape n° 9 : Testez l’intégration BabyAGI + Bright Data

Vérifiez que votre application BabyAGI fonctionne en testant les fonctions Bright Data à l’aide de la fonction chat_with_functions par défaut. Cela lance une interaction de chat qui se connecte à LiteLLM et exécute les fonctions sélectionnées dans votre base de données de fonctions.

Commencez donc par choisir les fonctions bright_data_serp_api et bright_data_web_unlocker. Sélectionnez ensuite chat_with_functions:

Ensuite, vous devez utiliser une invite qui déclenche à la fois des recherches sur le Web et l’extraction de données. Par exemple, essayez avec :

Recherchez sur le Web les dernières annonces d'IA de Google (2025), sélectionnez les 3 articles de presse ou de blog les plus fiables, accédez à chacun d'eux et résumez les principales informations sur l'avenir de l'IA de Google (en mentionnant les URL des articles sources).

Remarque: un LLM standard sans outils externes pour accéder au Web ne serait pas en mesure d’accomplir cette tâche.

Exécutez l’invite dans le chat et vous devriez obtenir un résultat similaire à celui-ci :

Remarquez comment le résultat contient des informations fondées, récupérées en effectuant une recherche sur Google via l’API SERP et en extrayant des informations des pages d’actualités sélectionnées via l’API Web Unlocker.

Maintenant que vous avez vérifié que l’agent peut interagir avec le contenu web actuel et en tirer des enseignements, cela signifie qu’il est capable de créer lui-même des fonctions qui peuvent interagir avec d’autres services en accédant à leur documentation pour apprendre des détails techniques qu’il ne connaissait pas initialement. Testez cela à l’aide de la fonction self_build pour la création d’agents IA autonomes, comme expliqué dans la documentation BabyAGI.

N’hésitez pas à tester différentes invites de saisie et d’autres fonctions BabyAGI. Grâce aux fonctions Bright Data, vos agents BabyAGI auto-construits peuvent gérer une variété de cas d’utilisation réels.

Et voilà ! Vous venez de découvrir la puissance de la combinaison de Bright Data et BabyAGI.

Conclusion

Dans cet article de blog, vous avez vu comment activer les fonctionnalités de Bright Data dans BabyAGI grâce à des fonctions personnalisées qui appellent l’API SERP et l’API Web Unlocker.

Cette configuration permet la récupération de contenu à partir de n’importe quelle page web et les recherches web en temps réel. Pour étendre encore davantage les fonctionnalités, telles que l’accès aux flux web en direct et l’automatisation des interactions web, intégrez BabyAGI à la suite complète de services Bright Data pour l’IA.

Libérez tout le potentiel des agents IA auto-construits !

Inscrivez-vous gratuitement dès aujourd’hui pour obtenir un compte Bright Data et commencez à tester nos solutions de données web prêtes pour l’IA !