Agents CrewAI plus intelligents : API SERP pour données en direct

Dans ce tutoriel, vous apprendrez :

Ce qu’est CrewAI et en quoi il diffère des autres bibliothèques d’agents d’IA.
Ses principales limites et la manière de les surmonter avec un flux de travail RAG.
Comment l’intégrer à une API de scraping pour fournir aux agents d’IA des données SERP pour des réponses plus précises.

Plongeons dans l’aventure !

Qu’est-ce que CrewAI ?

CrewAI est un framework Python open-source pour l’orchestration et la gestion d’agents d’intelligence artificielle autonomes qui collaborent pour accomplir des tâches complexes. Contrairement aux systèmes à agent unique comme Browser Use, CrewAI s’articule autour d'”équipages”, qui sont un ensemble d’agents.

Dans un équipage, chaque agent a un rôle, un objectif et un ensemble d’outils définis. En détail, vous pouvez équiper les agents d’IA d’outils personnalisés pour des tâches spécialisées telles que l’exploration de sites web, la connexion à des bases de données, etc. Cette approche ouvre la voie à la résolution de problèmes spécialisés par l’IA et à une prise de décision efficace.

L’architecture multi-agents de CrewAI favorise à la fois l’efficacité et l’évolutivité. De nouvelles fonctionnalités sont régulièrement ajoutées, telles que la prise en charge des modèles Qwen et des appels de fonctions parallèles, ce qui en fait un écosystème en évolution rapide.

Limites de CrewAI et comment les surmonter avec des données Web fraîches

CrewAI est un cadre riche en fonctionnalités pour la construction de systèmes multi-agents. Cependant, il hérite de certaines limitations clés des LLM sur lesquels il s’appuie. Étant donné que les LLM sont généralement préformés sur des ensembles de données statiques, ils ne sont pas conscients du temps réel et ne peuvent généralement pas accéder aux dernières nouvelles ou au contenu web en direct.

Il peut en résulter des réponses périmées ou, pire encore, des hallucinations. Ces problèmes sont particulièrement probables si les agents ne sont pas soumis à des contraintes ou s’ils ne disposent pas de données actualisées et fiables dans le cadre d’une configuration de récupération et de génération augmentée.

Pour remédier à ces limitations, vous devez fournir aux agents (et, par extension, à leurs gestionnaires d’apprentissage tout au long de la vie) des données externes fiables. Le Web est la source de données la plus complète et la plus dynamique qui soit, ce qui en fait une cible idéale. Par conséquent, une approche efficace consiste à permettre aux agents CrewAI d’effectuer des recherches en direct sur des plateformes telles que Google ou d’autres moteurs de recherche.

Cela peut se faire en construisant un outil CrewAI personnalisé qui permet aux agents d’extraire des pages web pertinentes pour apprendre. Cependant, l’extraction des SERP (Search Engine Results Pages) est un défi technique – en raison de la nécessité d’un rendu JavaScript, de la résolution des CAPTCHA, de la rotation des IP et de l’évolution constante de la structure des sites.

La gestion de tout cela en interne peut être plus complexe que le développement de la logique CrewAI elle-même. Une meilleure solution consiste à s’appuyer sur des API de raclage de SERP de premier ordre, telles que l’API SERP de Bright Data. Ces services se chargent d’extraire des données propres et structurées du web.

En intégrant de telles API dans votre flux de travail CrewAI, vos agents ont accès à des informations fraîches et précises sans frais opérationnels. La même stratégie peut être appliquée à d’autres domaines en connectant les agents à des API de scraping spécifiques à un domaine.

Comment intégrer CrewAI avec les API SERP pour un accès aux données en temps réel ?

Dans cette section guidée, vous verrez comment donner à votre agent d’IA construit avec CrewAI la capacité de récupérer des données directement à partir des moteurs SERP via l’API SERP de Bright Data.

Cette intégration RAG permet à vos agents CrewAI de fournir des résultats plus contextuels et actualisés, avec des liens réels pour une lecture plus approfondie.

Suivez les étapes ci-dessous pour constituer une équipe surpuissante grâce à l’intégration de l’API SERP de Bright Data !

Conditions préalables

Pour suivre ce tutoriel, assurez-vous d’avoir :

Une clé d’API de Bright Data.
Une clé API pour se connecter à un LLM (nous utiliserons Gemini dans ce tutoriel).
Python 3.10 ou supérieur installé localement.

Pour plus de détails, consultez la page d’installation de la documentation CrewAI, qui contient des conditions préalables actualisées.

Ne vous inquiétez pas si vous n’avez pas encore de clé API Bright Data, car vous serez guidé pour en créer une dans les étapes suivantes. Pour ce qui est de la clé API LLM, si vous n’en avez pas, nous vous recommandons de configurer une clé API Gemini en suivant le guide officiel de Google.

Étape 1 : Installer CrewAI

Commencez par installer CrewAI globalement en lançant la commande suivante dans votre terminal :

pip install crewai

Note: Cette opération va télécharger et configurer plusieurs paquets, ce qui peut prendre un certain temps.

Si vous rencontrez des problèmes lors de l’installation ou de l’utilisation, reportez-vous à la section de dépannage de la documentation officielle.

Une fois installé, vous aurez accès à la commande CLI crewai. Vérifiez-la en exécutant la commande suivante dans votre terminal :

crewai

Vous devriez obtenir un résultat similaire à celui-ci :

Usage: crewai [OPTIONS] COMMAND [ARGS]...

  Top-level command group for crewai.

Options:
  --version  Show the version and exit.
  --help     Show this message and exit.

Commands:
  chat               Start a conversation with the Crew, collecting...
  create             Create a new crew, or flow.
  deploy             Deploy the Crew CLI group.
  flow               Flow related commands.
  install            Install the Crew.
  log-tasks-outputs  Retrieve your latest crew.kickoff() task outputs.
  login              Sign Up/Login to CrewAI+.
  replay             Replay the crew execution from a specific task.
  reset-memories     Reset the crew memories (long, short, entity,...
  run                Run the Crew.
  signup             Sign Up/Login to CrewAI+.
  test               Test the crew and evaluate the results.
  tool               Tool Repository related commands.
  train              Train the crew.
  update             Update the pyproject.toml of the Crew project to use...
  version            Show the installed version of crewai.

C’est très bien ! Vous avez maintenant le CLI CrewAI prêt à initialiser votre projet.

Étape 2 : Configuration du projet

Exécutez la commande suivante pour créer un nouveau projet CrewAI appelé serp_agent:

crewai create crew serp_agent

Lors de l’installation, vous serez invité à sélectionner votre fournisseur de LLM préféré :

Select a provider to set up:
1. openai
2. anthropic
3. gemini
4. nvidia_nim
5. groq
6. huggingface
7. ollama
8. watson
9. bedrock
10. azure
11. cerebras
12. sambanova
13. other
q. Quit
Enter the number of your choice or 'q' to quit:

Dans ce cas, nous allons choisir l’option “3” pour Gemini, car son intégration via l’API est gratuite.

Ensuite, sélectionnez le modèle spécifique de Gemini que vous souhaitez utiliser :

Select a model to use for Gemini:
1. gemini/gemini-1.5-flash
2. gemini/gemini-1.5-pro
3. gemini/gemini-2.0-flash-lite-001
4. gemini/gemini-2.0-flash-001
5. gemini/gemini-2.0-flash-thinking-exp-01-21
6. gemini/gemini-2.5-flash-preview-04-17
7. gemini/gemini-2.5-pro-exp-03-25
8. gemini/gemini-gemma-2-9b-it
9. gemini/gemini-gemma-2-27b-it
10. gemini/gemma-3-1b-it
11. gemini/gemma-3-4b-it
12. gemini/gemma-3-12b-it
13. gemini/gemma-3-27b-it
q. Quit

Dans cet exemple, le modèle gratuit gemini/gemini-1.5-flash est suffisant. Vous pouvez donc sélectionner l’option “1”.

Ensuite, il vous sera demandé d’entrer votre clé API Gemini :

Enter your GEMINI API key from https://ai.dev/apikey (press Enter to skip):

Collez-le et, si tout se passe comme prévu, vous devriez obtenir un résultat comme celui-ci :

API keys and model saved to .env file
Selected model: gemini/gemini-1.5-flash
  - Created serp_agent.gitignore
  - Created serp_agentpyproject.toml
  - Created serp_agentREADME.md
  - Created serp_agentknowledgeuser_preference.txt
  - Created serp_agentsrcserp_agent__init__.py
  - Created serp_agentsrcserp_agentmain.py
  - Created serp_agentsrcserp_agentcrew.py
  - Created serp_agentsrcserp_agenttoolscustom_tool.py
  - Created serp_agentsrcserp_agenttools__init__.py
  - Created serp_agentsrcserp_agentconfigagents.yaml
  - Created serp_agentsrcserp_agentconfigtasks.yaml
Crew serp_agent created successfully!

Cette procédure génère la structure de projet suivante :

serp_agent/
├── .gitignore
├── pyproject.toml
├── README.md
├── .env
├── knowledge/
├── tests/
└── src/
    └── serp_agent/
        ├── __init__.py
        ├── main.py
        ├── crew.py
        ├── tools/
        │   ├── custom_tool.py
        │   └── __init__.py
        └── config/
            ├── agents.yaml
            └── tasks.yaml

Ici :

main.py est le point d’entrée principal de votre projet.
crew.py est l’endroit où vous définissez la logique de votre équipe.
config/agents.yaml définit vos agents d’IA.
config/tasks.yaml définit les tâches que vos agents traiteront.
tools/custom_tool.py vous permet d’ajouter des outils personnalisés que vos agents peuvent utiliser.
.env stockent les clés d’API et d’autres variables d’environnement.

Naviguez dans le dossier du projet et installez les dépendances CrewAI :

cd serp_agent
crewai install

La dernière commande créera un dossier d’environnement virtuel local .venv à l’intérieur de votre répertoire de projet. Cela vous permettra d’exécuter votre CrewAI localement.

C’est parfait ! Vous avez maintenant un projet CrewAI entièrement initialisé utilisant l’API Gemini. Vous êtes prêt à construire et à faire fonctionner votre agent SERP intelligent.

Étape 3 : Démarrer avec SERP API

Comme indiqué précédemment, nous utiliserons l’API SERP de Bright Data pour récupérer le contenu des pages de résultats des moteurs de recherche et l’envoyer à nos agents CrewAI. Plus précisément, nous effectuerons des recherches Google précises sur la base des données fournies par l’utilisateur et utiliserons les données récupérées en direct pour améliorer les réponses de l’agent.

Pour configurer l’API SERP, vous pouvez vous référer à la documentation officielle. Vous pouvez également suivre les étapes ci-dessous.

Si vous ne l’avez pas encore fait, ouvrez un compte sur Bright Data. Sinon, connectez-vous simplement. Une fois connecté, accédez à la section “My Zones” et cliquez sur la ligne “SERP API” :

Si vous ne voyez pas cette ligne dans le tableau, cela signifie que vous n’avez pas encore configuré de zone SERP API. Dans ce cas, faites défiler le tableau et cliquez sur “Créer une zone” dans la section “SERP API” :

Sur la page du produit SERP API, basculez le bouton “Activer” pour activer le produit :

Ensuite, suivez le guide officiel pour générer votre clé API Bright Data. Ensuite, ajoutez-la à votre fichier .env comme ci-dessous :

BRIGHT_DATA_API_KEY=<YOUR_BRIGHT_DATA_API_KEY>

Remplacez le par la valeur réelle de votre clé API Bright Data.

Nous y sommes ! Vous pouvez désormais utiliser l’API SERP de Bright Data dans votre intégration CrewAI.

Étape 4 : Créer un outil de recherche SERP CrewAI

Il est temps de définir un outil de recherche SERP que vos agents peuvent utiliser pour interagir avec l’API SERP de Bright Data et récupérer les données des résultats de recherche.

Pour ce faire, ouvrez le fichier custom_tool.py dans le dossier tools/ et remplacez son contenu par ce qui suit :

# src/search_agent/tools/custom_tool.py

import os
import json
from typing import Type
import requests
from pydantic import BaseModel, PrivateAttr
from crewai.tools import BaseTool


class SerpSearchToolInput(BaseModel):
    query: str


class SerpSearchTool(BaseTool):
    _api_key: str = PrivateAttr()

    name: str = "Bright Data SERP Search Tool"
    description: str = """
    Uses Bright Data's SERP API to retrieve real-time Google search results based on the user's query.
    This tool fetches organic search listings to support agent responses with live data.
    """
    args_schema: Type[BaseModel] = SerpSearchToolInput

    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        # Read the Bright Data API key from the envs
        self._api_key = os.environ.get("BRIGHT_DATA_API_KEY")

        if not self._api_key:
            raise ValueError("Missing Bright Data API key. Please set BRIGHT_DATA_API_KEY in your .env file")

    def _run(self, query: str) -> str:
        url = "https://api.brightdata.com/request"
        headers = {
            "Content-Type": "application/json",
            "Authorization": f"Bearer {self._api_key}"
        }
        payload = {
            "zone": "serp", # Replace with the name of your actual Bright Data SERP API zone
            "format": "json",
            "url": f"https://www.google.com/search?q={query}&brd_json=1"
        }

        try:
            response = requests.post(url, json=payload, headers=headers)
            # Raise exceptions in case of errors
            response.raise_for_status()

            # Parse the JSON response
            json_response = response.json()
            response_body = json.loads(json_response.get("body", "{}"))

            if "organic" not in response_body:
                return "The response did not include organic search results."

            # Return the SERP data as a JSON string
            return json.dumps(response_body["organic"], indent=4)

        except requests.exceptions.HTTPError as http_err:
            return f"HTTP error occurred while querying Bright Data SERP API: {http_err}"
        except requests.exceptions.RequestException as req_err:
            return f"Network error occurred while connecting to Bright Data: {req_err}"
        except (json.JSONDecodeError, KeyError) as parse_err:
            return f"Error parsing Bright Data SERP API response: {parse_err}"

Cet outil CrewAI définit une fonction qui prend une requête d’utilisateur et récupère les résultats SERP de l’API SERP de Bright Data via des requêtes.

Notez que lorsque le paramètre de requête brd_json=1 est utilisé et que le format est défini sur json, l’API SERP répond avec cette structure :

{
  "status_code": 200,
  "headers": {
    "content-type": "application/json",
    // omitted for brevity...
  },
  "body": "{"general":{"search_engine":"google","query":"pizza","results_cnt":1980000000, ...}}"
}

En particulier, après avoir analysé le champ ” body", qui contient une chaîne JSON, vous obtiendrez la structure de données suivante :

{
  "general": {
    "search_engine": "google",
    "query": "pizza",
    "results_cnt": 1980000000,
    "search_time": 0.57,
    "language": "en",
    "mobile": false,
    "basic_view": false,
    "search_type": "text",
    "page_title": "pizza - Google Search",
    "timestamp": "2023-06-30T08:58:41.786Z"
  },
  "input": {
    "original_url": "https://www.google.com/search?q=pizza&brd_json=1",
    "request_id": "hl_1a1be908_i00lwqqxt1"
  },
  "organic": [
    {
      "link": "https://www.pizzahut.com/",
      "display_link": "https://www.pizzahut.com",
      "title": "Pizza Hut | Delivery & Carryout - No One OutPizzas The Hut!",
      "rank": 1,
      "global_rank": 1
    },
    {
      "link": "https://www.dominos.com/en/",
      "display_link": "https://www.dominos.com",
      "title": "Domino's: Pizza Delivery & Carryout, Pasta, Chicken & More",
      "description": "Order pizza, pasta, sandwiches & more online...",
      "rank": 2,
      "global_rank": 3
    },
    // ...additional organic results omitted for brevity
  ]
}

Vous êtes donc principalement intéressé par le champ organique. Il s’agit du champ auquel le code accède, qui est analysé dans une chaîne JSON et renvoyé par l’outil.

Génial ! Votre agent CrewAI peut maintenant utiliser cet outil pour récupérer des données SERP fraîches.

Étape 5 : Définir les agents

Pour accomplir cette tâche, vous aurez besoin de deux agents CrewAI, chacun ayant une fonction distincte :

Chercheur: Rassemble les résultats de recherche de Google et filtre les informations utiles.
Analyste des rapports: Rassemble les résultats dans un résumé structuré et lisible.

Vous pouvez les définir dans votre fichier agents.yml en le remplissant comme suit :

# src/search_agent/configs/agents.yml

researcher:
  role: >
    Online Research Specialist
  goal: >
    Conduct smart Google searches and collect relevant, trustworthy details from the top results.
  backstory: >
    You have a knack for phrasing search queries that deliver the most accurate and insightful content.
    Your expertise lies in quickly identifying high-quality information from reputable sources.

reporting_analyst:
  role: >
    Strategic Report Creator
  goal: >
    Organize collected data into a clear, informative narrative that’s easy to understand and act on.
  backstory: >
    You excel at digesting raw information and turning it into meaningful analysis. Your work helps
    teams make sense of data by presenting it in a well-structured and strategic format.

Remarquez que cette configuration capture ce que chaque agent est censé faire – rien de plus, rien de moins. Il suffit de définir leur rôle, leur objectif et leur histoire. C’est très bien !

Étape 6 : Spécifier les tâches pour chaque agent

Préparez-vous à définir des tâches spécifiques qui décrivent clairement le rôle de chaque agent dans le flux de travail. Selon la documentation de CrewAI, pour obtenir des résultats précis, ladéfinition des tâches est plus importante que celle des agents.

Ainsi, dans le fichier tasks.yml, vous devez indiquer à vos agents exactement ce qu’ils doivent faire, comme ci-dessous :

# src/search_agent/configs/tasks.yml

research_task:
  description: >
    Leverage SerpSearchTool to perform a targeted search based on the user's {query}.
    Build API parameters like:
    - 'query': develop a short, Google-like, keyword-optimized search phrase for search engines.
    From the returned data, identify the most relevant and factual content.

  expected_output: >
    A file containing well-structured raw JSON content with the data from search results.
    Avoid rewriting, summarizing, or modifying any content.

  agent: researcher
  output_file: output/serp_data.json

report_task:
  description: >
    Turn the collected data into a digestible, insight-rich report.
    Address the user's {query} with fact-based findings. Add links for further reading. Do not fabricate or guess any information.

  expected_output: >
    A Markdown report with key takeaways and meaningful insights.
    Keep the content brief and clearly, visually structured.

  agent: reporting_analyst
  context: [research_task]
  output_file: output/report.md

Dans cette configuration, vous définissez deux tâches, une pour chaque agent :

research_task: Indique au chercheur comment utiliser l’API SERP de Bright Data via l’outil, y compris comment construire les paramètres de l’API de manière dynamique en fonction de la requête.
report_task: Spécifie que le résultat final doit être un rapport lisible et informatif élaboré strictement à partir des données collectées.

Cette définition tasks.yml est tout ce dont vos agents CrewAI ont besoin pour collecter des données SERP et produire un rapport basé sur des résultats de recherche réels.

Il est temps d’intégrer vos agents CrewAI dans votre code et de les laisser travailler !

Étape n° 7 : Créer votre équipe

Maintenant que tous les composants sont en place, connectez tout dans le fichier crew.py pour créer un équipage entièrement fonctionnel. Plus précisément, voici comment vous pouvez définir votre fichier crew.py :

# src/search_agent/crew.py

from crewai import Agent, Crew, Process, Task
from crewai.project import CrewBase, agent, crew, task
from .tools.custom_tool import SerpSearchTool
from crewai.agents.agent_builder.base_agent import BaseAgent
from typing import List

@CrewBase
class SerpAgent():
    """SerpAgent crew"""

    agents: List[BaseAgent]
    tasks: List[Task]

    @agent
    def researcher(self) -> Agent:
        return Agent(
            config=self.agents_config["researcher"],
            tools=[SerpSearchTool()],
            verbose=True
        )

    @agent
    def reporting_analyst(self) -> Agent:
        return Agent(
            config=self.agents_config["reporting_analyst"],
            verbose=True
        )

    @task
    def research_task(self) -> Task:
        return Task(
            config=self.tasks_config["research_task"],
            output_file="output/serp_data.json"
        )

    @task
    def report_task(self) -> Task:
        return Task(
            config=self.tasks_config["report_task"],
            output_file="output/report.md"
        )

    @crew
    def crew(self) -> Crew:
        """Creates the SerpAgent crew"""
        return Crew(
            agents=self.agents,
            tasks=self.tasks,
            process=Process.sequential,
            verbose=True,
        )

Dans crew.py, vous devez utiliser les décorateurs CrewAI(@agent, @task, @crew, dans ce cas) pour lier la logique de vos fichiers YAML et câbler la fonctionnalité réelle.

Dans cet exemple :

L’agent de recherche a accès à l’outil SerpSearchTool, ce qui lui permet d’effectuer de vraies recherches sur Google à l’aide de l’API SERP de Bright Data.
L’agent reporting_analyst est configuré pour générer le rapport final à partir des résultats obtenus par le chercheur.
Chaque tâche correspond à ce qui a été défini dans votre fichier tasks.yml, et est explicitement liée au fichier de sortie approprié.
Le processus est défini comme séquentiel, ce qui garantit que le chercheur s’exécute en premier et transmet ensuite ses données à reporting_analyst.

C’est parti ! Votre équipage SerpAgent est maintenant prêt à exécuter.

Étape 8 : Créer la boucle principale

Dans main.py, déclenchez l’équipe en passant la requête de l’utilisateur en entrée :

# src/search_crew/main.py

import os
from serp_agent.crew import SerpAgent

# Create the output/ folder if it doesn"t already exist
os.makedirs("output", exist_ok=True)

def run():
    try:
        # Read the user's input and pass it to the crew
        inputs = {"query": input("nSearch for: ").strip()}

        # Start the SERP agent crew
        result = SerpAgent().crew().kickoff(
            inputs=inputs
        )
        return result
    except Exception as e:
        print(f"An error occurred: {str(e)}")

if __name__ == "__main__":
    run()

Mission terminée ! Votre intégration CrewAI + SERP API (en utilisant Gemini comme LLM) est maintenant entièrement fonctionnelle. Lancez simplement main.py, entrez une requête de recherche et regardez l’équipe collecter et analyser les données SERP pour produire un rapport.

Étape n° 9 : Exécuter votre agent d’IA

Dans le dossier de votre projet, lancez votre application CrewAI avec la commande suivante :

crewai run

Saisissez maintenant une requête telle que

"What are the new AI protocols?"

C’est le genre de question à laquelle un LLM typique pourrait avoir du mal à répondre avec précision. En effet, la plupart des protocoles d’IA les plus récents, tels que CMP, A2A, AGP et ACP, n’existaient pas lorsque le modèle a été formé à l’origine.

Voici ce qui se passera en détail :

Comme vous pouvez le constater ci-dessus, CrewAI traite la demande de cette manière :

L’agent de recherche est exécuté, ce qui :
1. Transforme l’entrée de l’utilisateur en une requête structurée "nouveaux protocoles d'IA".
2. Envoie la requête à l’API SERP de Bright Data via l’outil SerpSearchTool.
3. Reçoit les résultats de l’API et les enregistre dans le fichier output/serp_data.json.
L’agent reporting_analyst est alors déclenché, ce qui :
1. Lit les données structurées du fichier serp_data.json.
2. Il utilise ces nouvelles informations pour générer un rapport contextuel en Markdown.
3. Enregistre le rapport structuré final dans output/report.md.

Si vous ouvrez le fichier report.md à l’aide d’une visionneuse Markdown, vous obtiendrez quelque chose comme ceci :

Le rapport final Markdown produit par CrewAI

Le rapport comprend des informations contextuelles pertinentes et même des liens pour vous aider à approfondir la question.

Et voilà ! Vous venez de mettre en œuvre un flux de travail RAG dans CrewAI grâce à l’intégration d’une API SERP.

Prochaines étapes

L’outil SERP API de Bright Data intégré à Crew permet aux agents de recevoir des résultats de moteurs de recherche récents. Avec les URL de ces SERP, vous pouvez les utiliser pour appeler d’autres API de scraping afin d’extraire le contenu brut des pages liées, soit sous forme brute(à convertir en Markdown et à transmettre à l’agent), soit déjà analysé en JSON.

Cette idée permet aux agents de découvrir automatiquement des sources fiables et d’en extraire des informations actualisées. En outre, vous pouvez intégrer une solution comme Agent Browser pour permettre aux agents d’interagir de manière dynamique avec n’importe quelle page web en direct.

Il ne s’agit là que de quelques exemples, mais les scénarios potentiels et les cas d’utilisation sont pratiquement illimités.

Conclusion

Dans cet article de blog, vous avez appris comment rendre vos agents CrewAI plus sensibles au contexte en intégrant une configuration RAG à l’aide de l’API SERP de Bright Data.

Comme nous l’avons expliqué, il s’agit d’une des nombreuses possibilités que vous pouvez explorer en connectant vos agents à des API de scraping externes ou à des outils d’automatisation. En particulier, les solutions de Bright Data peuvent servir de blocs de construction puissants pour les flux de travail intelligents de l’IA.

Améliorez votre infrastructure d’IA avec les outils de Bright Data :

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 curatées, prêtes à l’emploi, structurées, enrichies et annotées.

Pour plus d’informations, consultez notre centre d’information sur l’IA.

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

Amélioration des agents CrewAI à l’aide d’API de récupération de SERP via RAG