Créer des agents Web d'IA avec OpenAI SDK et Web Unlocker

Dans ce guide, vous apprendrez :

Qu’est-ce que le SDK OpenAI Agents ?
Pourquoi l’intégrer à un service de déverrouillage de sites web est essentiel pour maximiser son efficacité
Comment construire un agent Python en utilisant le SDK OpenAI Agents et une API Web Unlocker dans un tutoriel détaillé étape par étape.

Plongeons dans l’aventure !

Qu’est-ce que le SDK OpenAI Agents ?

Le SDK OpenAI Agents est une bibliothèque Python open-source d’OpenAI. Elle est conçue pour construire des applications d’intelligence artificielle basées sur des agents de manière simple, légère et prête pour la production. Cette bibliothèque est une évolution raffinée du projet expérimental antérieur d’OpenAI appelé Swarm.

Le SDK OpenAI Agents se concentre sur la fourniture de quelques primitives de base avec une abstraction minimale :

Agents: Les MFR sont associés à des instructions et des outils spécifiques pour effectuer des tâches.
Handoffs: Permettre aux agents de déléguer des tâches à d’autres agents si nécessaire.
Garde-fous: Valider les entrées de l’agent pour s’assurer qu’elles respectent les formats ou les conditions attendus

Ces blocs de construction, combinés à la flexibilité de Python, facilitent la définition d’interactions complexes entre les agents et les outils.

Le SDK comprend également un système de traçage intégré qui vous permet de visualiser, de déboguer et d’évaluer les flux de travail de vos agents. Il permet même d’affiner les modèles en fonction de vos cas d’utilisation spécifiques.

Principales limites de cette approche de la création d’agents d’intelligence artificielle

La plupart des agents d’intelligence artificielle visent à automatiser les opérations sur les pages web, qu’il s’agisse de récupérer du contenu ou d’interagir avec les éléments d’une page. En d’autres termes, ils ont besoin de parcourir le web de manière programmatique.

Outre les malentendus potentiels du modèle d’IA lui-même, le plus grand défi auquel ces agents sont confrontés est de faire face aux mesures de protection des sites web. En effet, de nombreux sites mettent en œuvre des technologies anti-bots et anti-scraping qui peuvent bloquer ou induire en erreur les agents d’IA. Cela est d’autant plus vrai aujourd’hui que les CAPTCHA anti-AI et les systèmes avancés de détection des robots sont de plus en plus répandus.

S’agit-il donc de la fin de la route pour les agents web d’IA ? Absolument pas !

Pour surmonter ces obstacles, vous devez améliorer la capacité de votre agent à naviguer sur le Web en l’intégrant à une solution telle que l’API Web Unlocker de Bright Data. Cet outil fonctionne avec n’importe quel client ou solution HTTP qui se connecte à Internet (y compris les agents d’intelligence artificielle), agissant comme une passerelle de déverrouillage du Web. Il fournit un code HTML propre et non bloqué à partir de n’importe quelle page web. Fini les CAPTCHA, les interdictions d’IP et les contenus bloqués.

Découvrez pourquoi la combinaison du SDK OpenAI Agents avec l’API Web Unlocker est la stratégie ultime pour construire des agents d’IA puissants et compétents sur le web !

Comment intégrer le SDK des agents à une API de déverrouillage Web ?

Dans cette section guidée, vous apprendrez à intégrer le SDK OpenAI Agents avec l’API Web Unlocker de Bright Data pour construire un agent d’intelligence artificielle capable de.. :

Résumer le texte d’une page web
Récupération de données structurées sur les produits à partir de sites web de commerce électronique
Collecte d’informations clés à partir d’articles de presse

Pour ce faire, l’agent demandera à l’OpenAI Agents SDK d’utiliser l’API Web Unlocker comme moteur pour récupérer le contenu de n’importe quelle page web. Une fois le contenu récupéré, l’agent appliquera la logique de l’IA pour extraire et formater les données nécessaires à chacune des tâches susmentionnées.

Avertissement: les trois cas d’utilisation ci-dessus ne sont que des exemples. L’approche présentée ici peut être étendue à de nombreux autres scénarios en personnalisant le comportement de l’agent.

Suivez les étapes ci-dessous pour construire un agent de scraping d’IA en Python en utilisant le SDK OpenAI Agents et l’API Web Unlocker de Bright Data pour de hautes performances !

Conditions préalables

Avant de vous plonger dans ce tutoriel, assurez-vous que vous disposez des éléments suivants :

Python 3 ou supérieur installé localement
Un compte Bright Data actif
Un compte OpenAI actif
Une compréhension de base du fonctionnement des requêtes HTTP
Connaissance du fonctionnement des modèles pydantiques
Une idée générale du fonctionnement des agents d’intelligence artificielle

Ne vous inquiétez pas si tout n’est pas encore prêt. Vous serez guidé dans la configuration dans les sections suivantes.

Étape 1 : Configuration du projet

Avant de commencer, assurez-vous que Python 3 est installé sur votre système. Si ce n’est pas le cas, téléchargez Python et suivez les instructions d’installation correspondant à votre système d’exploitation.

Ouvrez votre terminal et créez un nouveau dossier pour votre projet d’agent racleur :

mkdir openai-sdk-agent

Le dossier openai-sdk-agent contiendra tout le code de votre agent basé sur Python et alimenté par le SDK Agents.

Naviguez dans le dossier du projet et mettez en place un environnement virtuel:

cd openai-sdk-agent
python -m venv venv

Chargez le dossier du projet dans votre IDE Python préféré. Visual Studio Code avec l’extension Python ou PyCharm Community Edition sont d’excellents choix.

Dans le dossier openai-sdk-agent, créez un nouveau fichier Python appelé agent.py. La structure de votre dossier devrait maintenant ressembler à ceci :

La structure des fichiers du projet d'agent d'intelligence artificielle

Actuellement, scraper.py est un script Python vierge, mais il contiendra bientôt la logique de l’agent d’IA souhaité.

Dans le terminal de l’IDE, activer l’environnement virtuel. Sous Linux ou macOS, exécuter cette commande :

./env/bin/activate

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

env/Scripts/activate

Vous êtes prêt ! Vous disposez maintenant d’un environnement Python pour construire un puissant agent d’IA en utilisant le SDK OpenAI Agents et un déverrouilleur web.

Étape 2 : Installer les dépendances du projet et démarrer

Ce projet utilise les bibliothèques Python suivantes :

openai-agents: Le SDK OpenAI Agents, utilisé pour construire des agents d’IA en Python.
demandes: Pour se connecter à l’API Web Unlocker de Bright Data et récupérer le contenu HTML d’une page Web sur laquelle l’agent d’intelligence artificielle fonctionnera. Pour en savoir plus, consultez notre guide sur la maîtrise de la bibliothèque Requests de Python.
pydantique: Définir des modèles de sortie structurés, permettant à l’agent de renvoyer des données dans un format clair et validé.
markdownify: Convertir le contenu HTML brut en Markdown propre. (Nous expliquerons bientôt pourquoi cela est utile).
python-dotenv: Pour charger des variables d’environnement à partir d’un fichier .env. C’est là que nous stockerons les secrets pour OpenAI et Bright Data.

Dans un environnement virtuel activé, installez-les tous avec :

pip install requests pydantic openai-agents openai-agents markdownify python-dotenv

Maintenant, initialisez scraper.py avec les importations et le code asynchrone suivants :

import asyncio
from agents import Agent, RunResult, Runner, function_tool
import requests
from pydantic import BaseModel
from markdownify import markdownify as md
from dotenv import load_dotenv 

# AI agent logic...

async def run():
    # Call the async AI agent logic...

if __name__ == "__main__":
    asyncio.run(run())

Merveilleux ! Il est temps de charger les variables d’environnement.

Étape 3 : Configurer les variables d’environnement Lecture

Ajoutez un fichier .env dans le dossier de votre projet :

Ce fichier contiendra vos variables d’environnement, telles que les clés d’API et les jetons secrets. Pour charger les variables d’environnement à partir du fichier .env, utilisez la fonction load_dotenv() du paquet dotenv:

load_dotenv()

Vous pouvez maintenant lire des variables d’environnement spécifiques en utilisant os.getenv() comme ceci :

os.getenv("ENV_NAME")

N’oubliez pas d’importer os de la bibliothèque standard de Python :

import os

C’est parfait ! Les variables d’environnement sont prêtes à être lues.

Étape 4 : Configurer le SDK des agents OpenAI

Vous avez besoin d’une clé API OpenAI valide pour utiliser le SDK Agents OpenAI. Si vous n’en avez pas encore généré une, suivez le guide officiel d’OpenAI pour créer votre clé API.

Une fois que vous l’avez, ajoutez la clé à votre fichier .env comme ceci :

OPENAI_API_KEY="<YOUR_OPENAI_KEY>"

Veillez à remplacer le par votre clé réelle.

Aucune configuration supplémentaire n’est nécessaire, car le SDK openai-agents est conçu pour lire automatiquement la clé API dans l’environnement OPENAI_API_KEY.

Étape 5 : Configuration de l’API de Web Unlocker

Si vous ne l’avez pas encore fait, créez un compte Bright Data. Sinon, connectez-vous simplement.

Ensuite, lisez la documentation officielle de Bright Data sur le déverrouillage Web pour récupérer votre clé API. Vous pouvez également suivre les étapes ci-dessous.

Dans la page “Tableau de bord de l’utilisateur” de Bright Data, cliquez sur l’option “Obtenir des produits proxy” :

Cliquer sur l'option "Obtenir des produits proxy".

Dans le tableau des produits, localisez la ligne intitulée “unblocker” et cliquez dessus :

⚠️Note: Vous devrez d’abord créer une nouvelle zone API Web Unblocker si vous ne l’avez pas encore fait. Consultez la documentation d’installation de Web Unblocker pour commencer.

Sur la page “unlocker”, copiez votre jeton API à l’aide de l’icône du presse-papiers :

Assurez-vous également que la bascule située dans le coin supérieur droit est activée, ce qui indique que le produit Web Unlocker est actif.

Sous l’onglet “Configuration”, assurez-vous que ces options sont activées pour une efficacité optimale :

S'assurer que les options premium pour l'efficacité sont activées

Dans le fichier .env, ajoutez la variable d’environnement suivante :

BRIGHT_DATA_WEB_UNLOCKER_API_TOKEN="<YOUR_BRIGHT_DATA_WEB_UNLOCKER_API_TOKEN>"

Remplacez l’espace réservé par votre jeton API réel.

Parfait ! Vous pouvez désormais utiliser à la fois le SDK OpenAI et l’API Web Unlocker de Bright Data dans votre projet.

Étape 6 : Créer la fonction d’extraction du contenu de la page web

Créer une fonction get_page_content() qui :

Lit la variable d’environnement BRIGHT_DATA_WEB_UNLOCKER_API_TOKEN
Utilise les requêtes pour envoyer une demande à l’API Web Unlocker de Bright Data à l’aide de l’URL fournie.
Récupère le code HTML brut renvoyé par l’API
Convertit le HTML en Markdown et le renvoie

Voici comment vous pouvez mettre en œuvre la logique ci-dessus :

@function_tool
def get_page_content(url: str) -> str:
    """
    Retrieves the HTML content of a given web page using Bright Data's Web Unlocker API,
    bypassing anti-bot protections. The response is converted from raw HTML to Markdown
    for easier and cheaper processing.

    Args:
        url (str): The URL of the web page to scrape.

    Returns:
        str: The Markdown-formatted content of the requested page.
    """

    # Read the Bright Data's Web Unlocker API token from the envs
    BRIGHT_DATA_WEB_UNLOCKER_API_TOKEN = os.getenv("BRIGHT_DATA_WEB_UNLOCKER_API_TOKEN")

    # Configure the Web Unlocker API call
    api_url = "https://api.brightdata.com/request"
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {BRIGHT_DATA_WEB_UNLOCKER_API_TOKEN}"
    }
    data = {
        "zone": "unblocker",
        "url": url,
        "format": "raw"
    }

    # Make the call to Web Uncloker to retrieve the unblocked HTML of the target page
    response = requests.post(api_url, headers=headers, data=json.dumps(data))

    # Extract the raw HTML response
    html = response.text

    # Convert the HTML to markdown and return it
    markdown_text = md(html)

    return markdown_text

Note 1: La fonction doit être annotée avec @function_tool. Ce décorateur spécial indique au SDK OpenAI Agents que cette fonction peut être utilisée comme un outil par un agent pour effectuer des actions spécifiques. Dans ce cas, la fonction agit comme un “moteur” que l’agent peut utiliser pour récupérer le contenu de la page web sur laquelle il va opérer.

Note 2: La fonction get_page_content() doit déclarer explicitement les types d’entrée.
Si vous ne les déclarez pas, vous obtiendrez une erreur de ce type : Error getting response : Code d'erreur : 400 - {'error' : {'message' : "Schéma non valide pour la fonction 'get_page_content' : Dans context=('properties', 'url'), le schéma doit avoir une clé 'type'.``"

Vous vous demandez peut-être pourquoi convertir du HTML brut en Markdown? La réponse est simple : efficacité des performances et rentabilité !

Le langage HTML est très verbeux et comprend souvent des éléments inutiles tels que des scripts, des styles et des métadonnées. Il s’agit d’un contenu dont les agents d’intelligence artificielle n’ont généralement pas besoin. Si votre agent n’a besoin que de l’essentiel, à savoir du texte, des liens et des images, Markdown offre une représentation beaucoup plus propre et compacte.

En détail, la transformation de HTML en Markdown peut réduire la taille de l’entrée jusqu’à 99 %, ce qui permet d’économiser à la fois de l’argent et de l’énergie :

les jetons, qui réduisent le coût de l’utilisation des modèles OpenAI
Temps de traitement, car les modèles fonctionnent plus rapidement sur des données plus petites

Pour en savoir plus, lisez l’article “Why Are the New AI Agents Choosing Markdown Over HTML ?” (Pourquoi les nouveaux agents d’intelligence artificielle choisissent-ils Markdown plutôt que HTML ?).

Étape 7 : Définir les modèles de données

Pour fonctionner correctement, les agents OpenAI SDK ont besoin de modèles Pydantic pour définir la structure attendue de leurs données de sortie. Rappelons que l’agent que nous construisons peut renvoyer l’une des trois sorties possibles :

Un résumé de la page
Informations sur le produit
Informations sur les articles de presse

Définissons donc trois modèles pydantiques correspondants :

class Summary(BaseModel):
    summary: str

class Product(BaseModel):
    name: str
    price: Optional[float] = None
    currency: Optional[str] = None
    ratings: Optional[int] = None
    rating_score: Optional[float] = None

class News(BaseModel):
    title: str
    subtitle: Optional[str] = None
    authors: Optional[List[str]] = None
    text: str
    publication_date: Optional[str] = None

Remarque: l’utilisation de l’option facultative rend votre agent plus robuste et plus polyvalent. Toutes les pages ne contiennent pas toutes les données définies dans le schéma. Cette souplesse permet donc d’éviter les erreurs lorsque des champs sont manquants.

N’oubliez pas d’importer Optional et List from typing:

from typing import Optional, List

Fantastique ! Vous êtes maintenant prêt à construire la logique de votre agent.

Étape 8 : Initialisation de la logique de l’agent

Utilisez la classe Agent du SDK openai-agents pour définir les trois agents spécialisés :

summarization_agent = Agent(
    name="Text Summarization Agent",
    instructions="You are a content summarization agent that summarizes the input text.",
    tools=[get_page_content],
    output_type=Summary,
)

product_info_agent = Agent(
    name="Product Information Agent",
    instructions="You are a product parsing agent that extracts product details from text.",
    tools=[get_page_content],
    output_type=Product,
)

news_info_agent = Agent(
    name="News Information Agent",
    instructions="You are a news parsing agent that extracts relevant news details from text.",
    tools=[get_page_content],
    output_type=News,
)

Chaque agent :

Inclut une chaîne d’instructions claire qui décrit ce qu’il est censé faire. C’est ce que le SDK OpenAI Agents utilisera pour guider le comportement de l’agent.
utilise la fonction get_page_content() pour récupérer les données d’entrée (c’est-à-dire le contenu de la page web).
Renvoie son résultat dans l’un des modèles Pydantic(Résumé, Produit ou Actualité) définis précédemment.

Pour acheminer automatiquement les demandes des utilisateurs vers l’agent spécialisé approprié, définissez un agent de niveau supérieur :

routing_agent = Agent(
    name="Routing Agent",
    instructions=(
        "You are a high-level decision-making agent. Based on the user's request, "
        "hand off the task to the appropriate agent."
    ),
    handoffs=[summarization_agent, product_info_agent, news_info_agent],
)

Il s’agit de l’agent que vous interrogerez dans votre fonction run() pour piloter la logique de l’agent d’IA.

Étape n° 9 : Mise en œuvre de la boucle d’exécution

Dans la fonction run(), ajoutez la boucle suivante pour lancer la logique de votre agent IA :

# Keep iterating until the use type "exit"
while True:
    # Read the user's request
    request = input("Your request -> ")
    # Stops the execution if the user types "exit"
    if request.lower() in ["exit"]:
        print("Exiting the agent...")
        break
    # Read the page URL to operate on
    url = input("Page URL -> ")

    # Routing the user's request to the right agent
    output = await Runner.run(routing_agent, input=f"{request} {url}")
    # Conver the agent's output to a JSON string
    json_output = json.dumps(output.final_output.model_dump(), indent=4)
    print(f"Output -> \n{json_output}\n\n")

Cette boucle est continuellement à l’écoute des entrées de l’utilisateur et traite chaque demande en l’acheminant vers l’agent approprié (résumé, produit ou nouvelles). Elle combine la requête de l’utilisateur avec l’URL cible, exécute la logique, puis imprime le résultat structuré au format JSON à l’aide de json. Importez-le avec :

import json

C’est incroyable ! L’intégration de votre SDK OpenAI Agents avec l’API Web Unlocker de Bright Data est maintenant terminée.

Étape n° 10 : Assembler le tout

Votre fichier scraper.py devrait maintenant contenir :

import asyncio
from agents import Agent, RunResult, Runner, function_tool
import requests
from pydantic import BaseModel
from markdownify import markdownify as md
from dotenv import load_dotenv
import os
from typing import Optional, List
import json

# Load the environment variables from the .env file
load_dotenv()

# Define the Pydantic output models for your AI agent
class Summary(BaseModel):
    summary: str

class Product(BaseModel):
    name: str
    price: Optional[float] = None
    currency: Optional[str] = None
    ratings: Optional[int] = None
    rating_score: Optional[float] = None

class News(BaseModel):
    title: str
    subtitle: Optional[str] = None
    authors: Optional[List[str]] = None
    text: str
    publication_date: Optional[str] = None

@function_tool
def get_page_content(url: str) -> str:
    """
    Retrieves the HTML content of a given web page using Bright Data's Web Unlocker API,
    bypassing anti-bot protections. The response is converted from raw HTML to Markdown
    for easier and cheaper processing.

    Args:
        url (str): The URL of the web page to scrape.

    Returns:
        str: The Markdown-formatted content of the requested page.
    """

    # Read the Bright Data's Web Unlocker API token from the envs
    BRIGHT_DATA_WEB_UNLOCKER_API_TOKEN = os.getenv("BRIGHT_DATA_WEB_UNLOCKER_API_TOKEN")

    # Configure the Web Unlocker API call
    api_url = "https://api.brightdata.com/request"
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {BRIGHT_DATA_WEB_UNLOCKER_API_TOKEN}"
    }
    data = {
        "zone": "unblocker",
        "url": url,
        "format": "raw"
    }

    # Make the call to Web Uncloker to retrieve the unblocked HTML of the target page
    response = requests.post(api_url, headers=headers, data=json.dumps(data))

    # Extract the raw HTML response
    html = response.text

    # Convert the HTML to markdown and return it
    markdown_text = md(html)

    return markdown_text

# Define the individual OpenAI agents
summarization_agent = Agent(
    name="Text Summarization Agent",
    instructions="You are a content summarization agent that summarizes the input text.",
    tools=[get_page_content],
    output_type=Summary,
)

product_info_agent = Agent(
    name="Product Information Agent",
    instructions="You are a product parsing agent that extracts product details from text.",
    tools=[get_page_content],
    output_type=Product,
)

news_info_agent = Agent(
    name="News Information Agent",
    instructions="You are a news parsing agent that extracts relevant news details from text.",
    tools=[get_page_content],
    output_type=News,
)

# Define a high-level routing agent that delegates tasks to the appropriate specialized agent
routing_agent = Agent(
    name="Routing Agent",
    instructions=(
        "You are a high-level decision-making agent. Based on the user's request, "
        "hand off the task to the appropriate agent."
    ),
    handoffs=[summarization_agent, product_info_agent, news_info_agent],
)

async def run():
    # Keep iterating until the use type "exit"
    while True:
        # Read the user's request
        request = input("Your request -> ")
        # Stops the execution if the user types "exit"
        if request.lower() in ["exit"]:
            print("Exiting the agent...")
            break
        # Read the page URL to operate on
        url = input("Page URL -> ")

        # Routing the user's request to the right agent
        output = await Runner.run(routing_agent, input=f"{request} {url}")
        # Conver the agent's output to a JSON string
        json_output = json.dumps(output.final_output.model_dump(), indent=4)
        print(f"Output -> \n{json_output}\n\n")


if __name__ == "__main__":
    asyncio.run(run())

Et voilà ! En un peu plus de 100 lignes de Python, vous avez construit un agent d’intelligence artificielle qui peut :

Résumer le contenu de n’importe quelle page web
Extraire des informations sur les produits à partir de n’importe quel site de commerce électronique
Extraire les détails d’un article en ligne

Il est temps de le voir à l’œuvre !

Étape n° 11 : Tester l’agent d’intelligence artificielle

Pour démarrer votre agent d’intelligence artificielle, exécutez :

python agent.py

Supposons maintenant que vous souhaitiez résumer le contenu du hub de services d’IA de Bright Data. Il vous suffit d’entrer une requête comme celle-ci :

L'entrée pour obtenir un résumé des services d'IA de Bright Data

Vous trouverez ci-dessous le résultat au format JSON que vous obtiendrez :

Cette fois-ci, supposons que vous souhaitiez récupérer les données d’un produit à partir d’une page de produit Amazon, comme la liste PS5:

Normalement, les systèmes CAPTCHA et anti-bots d’Amazon bloqueraient votre demande. Grâce à l’API Web Unlocker, votre agent IA peut accéder à la page et l’analyser sans être bloqué :

Obtenir des données sur les produits Amazon

Le résultat sera le suivant :

{
    "name": "PlayStation\u00ae5 console (slim)",
    "price": 499.0,
    "currency": "USD",
    "ratings": 6321,
    "rating_score": 4.7
}

Il s’agit des données exactes de la page Amazon !

Enfin, considérons que vous souhaitez obtenir des informations structurées à partir d’un article de Yahoo News :

Atteignez votre objectif avec les données suivantes :

Your request -> Give me news info
Page URL -> https://www.yahoo.com/news/pope-francis-dies-88-080859417.html

Le résultat sera le suivant :

{
    "title": "Pope Francis Dies at 88",
    "subtitle": null,
    "authors": [
        "Nick Vivarelli",
        "Wilson Chapman"
    ],
    "text": "Pope Francis, the 266th Catholic Church leader who tried to position the church to be more inclusive, died on Easter Monday, Vatican officials confirmed. He was 88. (omitted for brevity...)",
    "publication_date": "Mon, April 21, 2025 at 8:08 AM UTC"
}

Une fois de plus, l’agent d’intelligence artificielle fournit des données précises et, grâce à Web Unlocker, le site d’information n’est pas bloqué !

Conclusion

Dans cet article de blog, vous avez appris à utiliser le SDK OpenAI Agents en combinaison avec une API de déverrouillage web pour construire un agent web très efficace en Python.

Comme nous l’avons démontré, la combinaison du SDK OpenAI et de l’API Web Unlocker de Bright Data vous permet de créer des agents d’IA qui peuvent fonctionner de manière fiable sur n’importe quelle page Web. Ce n’est qu’un exemple de la façon dont les produits et services de Bright Data peuvent prendre en charge de puissantes intégrations d’IA.

Découvrez nos solutions pour le développement d’agents d’IA :

Agents d’intelligence artificielle autonomes: Recherchez, accédez et interagissez avec n’importe quel site web en temps réel à l’aide d’un puissant ensemble d’API.
Apps d’IA verticales: créez des pipelines de données fiables et personnalisés pour extraire des données web à partir de sources spécifiques à votre secteur d’activité.
Modèles de base: Accédez à des ensembles de données conformes à l’échelle du web pour faciliter le pré-entraînement, l’évaluation et la mise au point.
IA multimodale: exploitez le plus grand référentiel d’images, de vidéos et d’audios au monde, optimisé pour l’IA.
Fournisseurs de données: Connectez-vous avec des fournisseurs de confiance pour obtenir des ensembles de données de haute qualité, prêts pour l’IA, à grande échelle.
Paquets de données: Obtenez des ensembles de données curatifs et prêts à l’emploi, structurés, enrichis et annotés.

Pour plus d’informations, découvrez notre gamme complète de produits d’IA.

Créez un compte Bright Data et essayez tous nos produits et services pour le développement d’agents d’IA !

Essai gratuit

S’inscrire avec Google

Aucune carte de crédit requise

Intégration du SDK d’agents OpenAI avec un déverrouilleur Web pour une haute performance