Donnez aux agents AWS Bedrock la possibilité d’effectuer des recherches sur le Web via l’API SERP de Bright Data

Dans ce tutoriel, vous apprendrez

• Ce qu’est un agent AWS Bedrock IA et ce qu’il peut faire.
• Pourquoi le fait de donner aux agents l’accès aux résultats de recherche sur le web via un outil prêt pour l’IA comme l’API SERP de Bright Data améliore la précision et le contexte.
• Comment construire un agent AWS Bedrock intégré à l’API SERP, étape par étape, dans la console AWS.
• Comment il est possible de réaliser la même chose en utilisant du code avec AWS CDK.

Plongeons dans le vif du sujet !

Qu’est-ce qu’un agent IA AWS Bedrock ?

Dans AWS Bedrock, un agent IA est un service qui utilise des LLM pour automatiser des tâches à plusieurs étapes en les décomposant en étapes logiques. Plus en détail, un agent IA Amazon Bedrock est un système qui tire parti des modèles de fondation, des API et des données pour comprendre les demandes des utilisateurs, recueillir des informations pertinentes et accomplir des tâches automatiquement.

Les agents AWS Bedrock prennent en charge la mémoire pour la continuité des tâches, la sécurité intégrée via Bedrock Guardrails, et peuvent collaborer avec d’autres agents pour des flux de travail complexes. Grâce à l’infrastructure AWS, ils sont gérés, évolutifs et sans serveur, ce qui simplifie le processus de construction et de déploiement d’applications alimentées par l’IA.

Pourquoi les agents IA d’Amazon Bedrock bénéficient d’un contexte de recherche dynamique sur le web.

Les LLM sont formés sur de grands jeux de données qui représentent les connaissances disponibles jusqu’à un point précis dans le temps. Cela signifie que lorsqu’un LLM est publié, il ne connaît que ce qui a été inclus dans ses données de formation, qui deviennent rapidement obsolètes.

C’est pourquoi les modèles d’IA n’ont pas une connaissance en temps réel des événements actuels et des connaissances émergentes. Par conséquent, ils peuvent produire des réponses obsolètes, incorrectes, voire hallucinées, ce qui constitue un énorme problème pour les agents d’IA.

Cette limitation peut être surmontée en donnant à votre agent IA la capacité d’aller chercher des informations fraîches et fiables dans une configuration RAG (Retrieval-Augmented Generation). L’idée est de doter votre agent d’un outil fiable capable d’effectuer des recherches sur le web et de récupérer des données vérifiables afin d’étayer son raisonnement, d’élargir ses connaissances et, en fin de compte, de fournir des résultats plus précis.

Une option serait de construire une fonction AWS Lambda personnalisée qui scrape les SERP (Search Engine Results Pages) et prépare les données pour l’ingestion LLM. Cependant, cette approche est techniquement complexe. Elle nécessite de gérer le rendu JavaScript, la Résolution de CAPTCHA et l’évolution constante de la structure des sites. En outre, elle n’est pas facilement extensible, car les moteurs de recherche comme Google peuvent rapidement bloquer vos adresses IP après quelques requêtes automatisées.

Une bien meilleure solution consiste à utiliser une API SERP et de recherche web de premier ordre, telle que l’API SERP de Bright Data. Ce service renvoie les données des moteurs de recherche tout en gérant automatiquement les proxys, le déblocage, l’analyse des données et tous les autres défis.

En intégrant l’API SERP de Bright Data dans AWS Bedrock via une fonction Lambda, votre agent IA obtient un accès aux informations de recherche web – sans aucune charge opérationnelle. Voyons comment !

Comment intégrer l’API SERP de Bright Data à votre agent IA AWS Bedrock pour les cas d’utilisation contextualisés de la recherche ?

Dans cette section étape par étape, vous apprendrez comment donner à votre agent IA AWS Bedrock la capacité de récupérer des données en temps réel à partir des moteurs de recherche à l’aide de l’API SERP de Bright Data.

Cette intégration permet à votre agent de fournir des réponses plus contextuelles et actualisées, y compris des liens pertinents pour une lecture plus approfondie. La configuration se fera visuellement dans la console AWS Bedrock, avec seulement une petite quantité de code nécessaire.

Suivez les étapes ci-dessous pour construire un agent IA AWS Bedrock suralimenté par l’API SERP !

Conditions préalables

Pour suivre ce tutoriel, vous avez besoin de :

• Un compte AWS actif (une version d’essai gratuite fonctionne très bien).
• Les prérequis pour les agents Amazon Bedrock configurés. (Remarque : les agents Amazon Bedrock ne sont actuellement disponibles que dans certaines régions AWS. Vérifiez la dernière liste des régions prises en charge et assurez-vous que vous utilisez l’une d’entre elles).
• Un compte Bright Data avec une clé API prête.
• Des compétences de base en programmation Python.

Ne vous inquiétez pas si vous n’avez pas encore créé de compte Bright Data. Vous serez guidé dans ce processus plus loin dans le guide.

Étape 1 : Créer un agent AWS Bedrock

Pour créer un agent AWS Bedrock IA, connectez-vous à votre compte AWS et ouvrez la console Amazon Bedrock en recherchant le service dans la barre de recherche :

Ensuite, dans la console Bedrock, sélectionnez “Agents” dans le menu de gauche, puis cliquez sur le bouton “Créer un agent” :

Donnez un nom et une description à votre agent, par exemple :

• Nom: web_search_agent
• Description: “Un agent IA qui peut se connecter à l’API SERP de Bright Data pour récupérer le contexte frais de la recherche sur le web à partir des moteurs de recherche”.

Important: si vous prévoyez d’utiliser les LLM d’Amazon, vous devez utiliser des traits de soulignement (_) au lieu de traits d’union (-) dans le nom de l’agent, les fonctions, etc. L’utilisation de traits d’union peut provoquer une “Ressource de dépendance : exception de délai d’attente/erreur de modèle reçue de Bedrock. Si cela se produit, réessayez la requête“.

Cliquez sur “Créer” pour finaliser votre agent IA. Vous devriez maintenant être redirigé vers la page “Agent builder” :

Génial ! Vous avez créé avec succès un agent IA dans AWS Bedrock.

Étape 2 : Configurer l’agent IA

Maintenant que vous avez créé un agent, vous devez compléter son installation en configurant quelques options.

Pour l’info “Agent resource role”, laissez l’option par défaut “Create and use a new service role”. Cela crée automatiquement un rôle AWS Identity and Access Management (IAM) que l’agent assumera :

Ensuite, cliquez sur “Select model” et choisissez le modèle LLM qui alimentera votre agent. Dans cet exemple, nous utiliserons le modèle “Nova Lite” d’Amazon (mais tout autre modèle fera l’affaire) :

Après avoir sélectionné le modèle, cliquez sur “Appliquer” pour confirmer.

Dans la section “Instructions pour l’agent”, fournissez des instructions claires et spécifiques indiquant à l’agent ce qu’il doit faire. Pour cet agent de recherche sur le web, vous pouvez entrer quelque chose comme : “Vous êtes un agent conçu pour gérer l’utilisation de l’Internet :

Vous êtes un agent conçu pour traiter des cas d'utilisation qui nécessitent la récupération et le traitement d'informations actualisées. Vous pouvez accéder aux données actuelles, y compris les actualités et les résultats des moteurs de recherche, par le biais de recherches sur le Web alimentées par l'API SERP de Bright Data.

Après avoir suivi les instructions, la section finale des détails de l’agent devrait ressembler à ceci :

Terminez la configuration des détails de l’agent en cliquant sur “Enregistrer” dans la barre supérieure pour enregistrer tous les détails de l’agent.

Remarque: AWS Bedrock offre de nombreuses autres options de configuration. Explorez-les pour adapter vos agents à vos cas d’utilisation spécifiques.

Etape #3 : Ajouter le groupe d’action de l’API SERP

Lesgroupes d’action permettent aux agents d’interagir avec des systèmes ou des API externes pour recueillir des informations ou effectuer des actions. Vous devrez en définir un pour l’intégrer à l’API SERP de Bright Data.

Dans la page “Agent builder”, faites défiler jusqu’à la section “Action groups” et cliquez sur “Add” :

Un formulaire s’ouvre alors pour définir le groupe d’action. Remplissez-le comme suit :

• Entrez le nom du groupe d’action: action_group_web_search (à nouveau, utilisez les underscores _, pas les traits d’union -)
• Description: “Appeler l’API SERP de Bright Data pour effectuer des recherches sur le web et récupérer des informations actualisées à partir des moteurs de recherche.”
• Type de groupe d’action: Sélectionnez l’option “Définir avec les détails de la fonction”.
• Invocation du groupe d’action: Sélectionnez l’option “Créer rapidement une nouvelle fonction Lambda”, qui configure une fonction Lambda de base que l’agent peut appeler. Dans ce cas, la fonction gérera la logique d’appel de l’API SERP de Bright Data.

Remarque: avec l’option “Créer rapidement une nouvelle fonction Lambda”, Amazon Bedrock génère un modèle de fonction Lambda pour votre agent. Vous pouvez ultérieurement modifier cette fonction dans la console Lambda (nous le ferons dans une étape ultérieure).

Maintenant, configurez la fonction dans le groupe. Descendez jusqu’à la section “Action group function 1 : serp_api” et remplissez-la comme suit :

• Name: serp_api (encore une fois, préférez les underscores).
• Description : “S’intègre à l’API SERP de Bright Data pour effectuer des recherches sur le web”.
• Paramètres: Ajoutez un paramètre nommé search_query de type string et indiquez qu’il est obligatoire. Ce paramètre sera transmis à la fonction Lambda et représente l’entrée de l’API SERP de Bright Data pour récupérer le contexte de la recherche web.

Enfin, cliquez sur “Créer” pour terminer la configuration du groupe d’action :

Enfin, cliquez sur “Enregistrer” pour sauvegarder la configuration de votre agent. Voilà qui est fait !

Étape 4 : Configurer votre compte Bright Data

Il est maintenant temps de créer votre compte Bright Data et de configurer le service API SERP. Notez que vous pouvez suivre la documentation officielle de Bright Data ou les étapes ci-dessous.

Si vous n’avez pas encore de compte, inscrivez-vous à Bright Data. Sinon, connectez-vous à votre compte existant. Une fois connecté, accédez à la section “My Zones” de la page “Proxy & Scraping” et recherchez une ligne “API SERP” dans le tableau :

Si vous ne voyez pas de ligne pour API SERP, cela signifie que vous n’avez pas encore configuré de zone. Faites défiler vers le bas et cliquez sur “Créer une zone” dans la section “API SERP” :

Créez une zone API SERP, en la nommant par exemple serp_api (ou tout autre nom que vous préférez). Notez le nom de la zone API SERP, car vous en aurez besoin pour vous connecter via l’API.

Sur la page du produit, basculez l’interrupteur “Activer” pour activer la zone :

Enfin, suivez le guide officiel pour générer votre clé API Bright Data. Conservez-la en lieu sûr, car vous en aurez bientôt besoin.

Voilà, c’est fait ! Vous avez maintenant tout ce qu’il vous faut pour utiliser l’API SERP de Bright Data dans votre agent AWS Bedrock IA.

Étape 5 : Stocker les secrets dans AWS

À l’étape précédente, vous avez obtenu des informations sensibles, telles que votre clé API Bright Data et le nom de votre zone API SERP. Au lieu de coder en dur ces valeurs dans le code de votre fonction Lambda, stockez-les en toute sécurité dans AWS Secrets Manager.

Recherchez “Secrets Manager” dans la barre de recherche AWS et ouvrez le service :

Cliquez sur le bouton “Store a new secret” et sélectionnez l’option “Other type of secret”. Dans la section “Key/value pairs”, ajoutez les paires clé-valeur suivantes :

• BRIGHT_DATA_API_KEY: saisissez votre clé d’API Bright Data obtenue précédemment.
• BRIGHT_DATA_SERP_API_ZONE: Entrez le nom de la zone de l’API SERP de Bright Data (par exemple, serp_api).

Cliquez ensuite sur “Suivant” et indiquez un nom secret. Par exemple, appelez-le BRIGHT_DATA:

Ce secret stockera un objet JSON contenant les champs BRIGHT_DATA_API_KEY et BRIGHT_DATA_SERP_API_ZONE.

Terminez la création du secret en suivant les invites restantes pour terminer le stockage du secret. Une fois terminé, votre secret ressemblera à ceci :

Cool ! Vous accéderez à ces secrets dans votre fonction Lambda Python pour vous connecter en toute sécurité à l’API SERP de Bright Data, que vous configurerez à l’étape suivante.

Étape 6 : création de la fonction Lambda pour appeler l’API SERP

Vous disposez de tous les éléments nécessaires pour définir la fonction Lambda associée au groupe d’action créé à l’étape 3. Cette fonction contiendra le code Python pour appeler l’API SERP de Bright Data et récupérer les données de recherche sur le web.

Pour créer la fonction Lambda, recherchez “Lambda” dans la barre de recherche AWS et ouvrez la console Amazon Lambda. Vous remarquerez qu’une fonction a déjà été créée automatiquement à l’étape 3 par AWS Bedrock :

Cliquez sur la fonction nommée action_group_serp_api_web_search_XXXX pour ouvrir sa page de présentation :

Sur cette page, faites défiler vers le bas jusqu’à l’onglet Code, où vous trouverez un éditeur Visual Studio Code intégré pour modifier votre logique Lambda :

Remplacez le contenu du fichier dummy_lambda.py par le code suivant :

import json
import logging
import os
import urllib.parse
import urllib.request

import boto3

# ----------------------------
# Configuration de l'enregistrement
# ----------------------------
log_level = os.environ.get("LOG_LEVEL", "INFO").strip().upper()
logging.basicConfig(
    format="[%(asctime)s] p%(process)s {%(filename)s:%(lineno)d} %(levelname)s - %(message)s"
)
logger = logging.getLogger(__name__)
logger.setLevel(log_level)

# ----------------------------
# Région AWS de l'environnement
# ----------------------------
AWS_REGION = os.environ.get("AWS_REGION")
if not AWS_REGION :
    logger.warning("La variable d'environnement AWS_REGION n'est pas définie ; boto3 utilisera la région par défaut")

# ----------------------------
# Récupérer l'objet secret depuis AWS Secrets Manager
# ----------------------------
def get_secret_object(key : str) -> str :
    """
    Récupère une valeur secrète depuis AWS Secrets Manager.
    """
    session = boto3.session.Session()
    client = session.client(
        service_name='secretsmanager',
        region_name=AWS_REGION
    )

    essayer :
        get_secret_value_response = client.get_secret_value(
            SecretId=clé
        )
    except Exception as e :
        logger.error(f "Impossible d'obtenir le secret '{key}' du gestionnaire de secrets : {e}")
        raise e

    secret = json.loads(get_secret_value_response["SecretString"])

    return secret


# Récupérer les informations d'identification de Bright Data
bright_data_secret = get_secret_object("BRIGHT_DATA")
BRIGHT_DATA_API_KEY = bright_data_secret["BRIGHT_DATA_API_KEY"]
BRIGHT_DATA_SERP_API_ZONE = bright_data_secret["BRIGHT_DATA_SERP_API_ZONE"]

# ----------------------------
# API SERP Web Search
# ----------------------------
def serp_api_web_search(search_query : str) -> str :
    """
    Appelle l'API SERP de Bright Data pour récupérer les résultats de la recherche Google.
    """
    logger.info(f "Exécution de la recherche de l'API SERP de Bright Data pour search_query='{search_query}'")

    # Encoder la requête pour l'URL
    encoded_query = urllib.parse.quote(search_query)
    # Construire l'URL de Google à partir de laquelle le SERP sera scrappé
    search_engine_url = f "https://www.google.com/search?q={encoded_query}"

    # Demande d'API SERP (docs : https://docs.brightdata.com/scraping-automation/serp-api/send-your-first-request)
    url = "https://api.brightdata.com/request"
    headers = {
        "Content-Type" : "application/json",
        "Authorization" : f "Bearer {BRIGHT_DATA_API_KEY}"
    }
    data = {
        "zone" : BRIGHT_DATA_SERP_API_ZONE,
        "url" : search_engine_url,
        "format" : "raw",
        "data_format" : "markdown" # Pour obtenir la SERP sous la forme d'un document Markdown prêt pour l'IA.
    }

    payload = json.dumps(data).encode("utf-8")
    request = urllib.request.Request(url, data=payload, headers=headers)

    try :
        response = urllib.request.urlopen(request)
        response_data : str = response.read().decode("utf-8")
        logger.debug(f "Réponse de l'API SERP : {response_data}")
        return response_data
    except urllib.error.HTTPError as e :
        logger.error(f "Échec de l'appel à l'API SERP de Bright Data. Erreur HTTP {e.code} : {e.raison}")
    except urllib.error.URLError as e :
        logger.error(f "Échec de l'appel à l'API SERP de Bright Data. Erreur d'URL : {e.reason}")

    return ""


# ----------------------------
# Lambda handler
# ----------------------------
def lambda_handler(event, _) :
    """
    Gestionnaire Lambda AWS.
    Attend l'événement avec actionGroup, fonction, et des paramètres optionnels incluant search_query.
    """
    logger.debug(f "lambda_handler called with event : {event}")

    action_group = event.get("actionGroup")
    function = event.get("function")
    parameters = event.get("parameters", [])

    # Extraction de la requête de recherche à partir des paramètres
    search_query = next(
        (param["value"] for param in parameters if param.get("name") == "search_query"),
        Aucun,
    )
    logger.debug(f "Entrée de la requête de recherche : {recherche_quête}")

    serp_page = serp_api_web_search(search_query) if search_query else ""
    logger.debug(f "Résultats de la requête de recherche : {serp_page}")

    # Préparer la réponse Lambda
    function_response_body = {"TEXT" : {"body" : serp_page}}

    action_response = {
        "actionGroup" : action_group,
        "function" : fonction,
        "functionResponse" : {"responseBody" : function_response_body},
    }

    response = {"response" : action_response, "messageVersion" : event.get("messageVersion")}

    logger.debug(f "lambda_handler response : {response}")

    return response

Cet extrait récupère les informations d’identification de l’API Bright Data depuis AWS Secrets Manager, appelle l’API SERP avec une requête de recherche Google et renvoie les résultats de la recherche sous forme de texte Markdown. Pour plus d’informations sur l’appel de l’API SERP, consultez la documentation.

Collez le code ci-dessus dans l’IDE en ligne :

Ensuite, appuyez sur “Deploy” pour mettre à jour la fonction Lambda :

Si tout se passe comme prévu, vous recevrez un message du type “Successfully updated the function action_group_serp_api_web_search_XXXX“.

Remarque: la fonction Lambda est automatiquement configurée avec une politique basée sur les ressources qui permet à Amazon Bedrock de l’invoquer. Comme cela a été géré par l’option “Créer rapidement une nouvelle fonction Lambda” plus tôt, il n’est pas nécessaire de modifier manuellement le rôle IAM.

Parfait ! Votre fonction AWS Lambda pour la connexion à l’API SERP de Bright Data est maintenant terminée.

Étape 7 : configuration des autorisations Lambda

Bien que votre fonction Lambda n’ait pas besoin d’autorisations IAM personnalisées pour être invoquée, elle doit avoir accès aux clés API stockées dans AWS Secrets Manager.

Pour configurer cela, sur la page des détails de la fonction Lambda, accédez à l’onglet “Configuration”, puis sélectionnez l’option “Permissions” :

Sous la section “Execution role”, cliquez sur le lien “Role name” pour ouvrir la console IAM :

Sur la page du rôle, localisez et sélectionnez la politique de permission attachée :

Ouvrez la vue “JSON” et cliquez sur “Edit” pour préparer la mise à jour de la politique de permission :

Assurez-vous que le tableau des déclarations comprend le bloc suivant :

{
  "Action" : "secretsmanager:GetSecretValue",
  "Resource" : [
    "arn:aws:secretsmanager:<YOUR_AWS_REGION>:<YOUR_AWS_ACCOUNT_ID>:secret:BRIGHT_DATA*"
  ],
  "Effect" : "Allow",
  "Sid" : "GetSecretsManagerSecret"
}

Remplacez <YOUR_AWS_REGION> et <YOUR_AWS_ACCOUNT_ID> par les valeurs correspondant à votre configuration. Ce bloc de code JSON donnera à la fonction Lambda la possibilité d’accéder au secret BRIGHT_DATA à partir du gestionnaire de secrets.

Cliquez ensuite sur le bouton “Next”, puis sur “Save changes”. En conséquence, vous devriez voir que votre fonction Lambda a également des permissions d’accès au Secrets Manager :

Fantastique ! Votre fonction Lambda est maintenant correctement configurée et peut être invoquée par votre agent AWS Bedrock IA avec un accès aux informations d’identification Bright Data stockées dans Secrets Manager.

Étape #8 : Finaliser votre agent IA

Retournez à la section “Agent builder” et cliquez sur “Save” une dernière fois pour appliquer toutes les modifications que vous avez apportées précédemment :

Ensuite, cliquez sur “Prepare” pour préparer votre agent à être testé avec la dernière configuration.

Vous devriez obtenir un message de confirmation du type “Agent : web_search_agent was successfully prepared“.

La mission est terminée ! Votre agent IA alimenté par l’API SERP de Bright Data est maintenant entièrement mis en œuvre et prêt à fonctionner.

Étape n° 9 : tester votre agent IA

Votre agent IA AWS Bedrock a accès à la fonction de groupe serp_api, mise en œuvre par la fonction Lambda lambda_handler que vous avez définie à l’étape #6. En termes plus simples, votre agent peut effectuer des recherches web en temps réel sur Google (et potentiellement d’autres moteurs de recherche) via l’API SERP de Bright Data, en récupérant et en traitant le contenu en ligne frais de manière dynamique.

Pour tester cette capacité, supposons que vous souhaitiez obtenir les dernières informations sur l’ouragan Melissa. Essayez de demander à votre agent :

"Donnez-moi les 3 derniers articles d'actualité sur l'ouragan Melissa"

(N’oubliez pas: Il ne s’agit que d’un exemple, et vous pouvez tester n’importe quelle autre invite impliquant des résultats de recherche sur le web en temps réel).

Exécutez cette invite dans la section “Test Agent” de votre agent et vous devriez obtenir un résultat similaire à celui-ci :

En coulisses, l’agent invoque l’API SERP Lambda, récupère les derniers résultats de recherche Google pour “Hurricane Melissa”, et extrait les actualités les plus pertinentes avec leurs URL. C’est quelque chose que n’importe quel LLM vanille, y compris Nova Lite, ne peut pas faire tout seul !

Voici la réponse textuelle spécifique générée par l’agent (sans les URL) :

Voici les 3 articles les plus récents sur l'ouragan Melissa :
1. La Jamaïque se prépare à l'ouragan Melissa, la plus forte tempête de 2025 - BBC, il y a 6 heures
2. L'ouragan Melissa en direct - La Jamaïque fait face à un impact "catastrophique" - Newsweek, il y a 7 heures
3. L'ouragan Melissa s'abat sur la Jamaïque et menace d'être la tempête la plus forte jamais enregistrée sur l'île - AP News, il y a 10 heures
Veuillez consulter les sources originales pour les articles complets.

Ces résultats ne sont pas des hallucinations ! Au contraire, ils correspondent à ce que vous trouveriez sur Google en recherchant manuellement “Hurricane Melissa” (à la date à laquelle l’agent a été testé) :

Si vous avez déjà essayé de récupérer les résultats de recherche de Google, vous savez à quel point cela peut être difficile en raison de la détection des robots, des interdictions d’IP, du rendu JavaScript et de bien d’autres problèmes.

L’API SERP de Bright Data résout tout cela efficacement, et sa capacité à renvoyer les SERP scrappés dans un format Markdown optimisé pour l’IA(ce qui est particulièrement précieux pour l’ingestion LLM).

Pour confirmer que votre agent a effectivement appelé l’API SERP Lambda, cliquez sur ” Afficher la trace ” :

Dans la section “Trace step 1”, faites défiler vers le bas jusqu’à la section du journal d’invocation de groupe pour voir la sortie de l’appel de fonction :

Cela confirme que la fonction Lambda s’est exécutée avec succès et que l’agent a interagi avec l’API SERP comme prévu. De même, vérifiez cela en consultant les journaux AWS CloudWatch pour votre Lambda.

Maintenant, poussez votre agent plus loin ! Essayez des invites liées à la vérification des faits, à la surveillance des marques, à l’analyse des tendances du marché ou à d’autres scénarios. Voyez comment votre agent se comporte dans différents cas d’utilisation.

Et voilà ! Vous venez de construire un agent AWS Bedrock IA intégré à l’API SERP de Bright Data, capable de récupérer à la demande des données de recherche web actualisées, fiables et contextuelles.

[Extra] Construire un agent Amazon Bedrock avec la recherche Web à l’aide d’AWS CDK

Dans la section précédente, vous avez appris à définir et à mettre en œuvre un agent IA qui s’intègre à l’API SERP directement via la console Amazon Bedrock.

Si vous préférez une approche basée sur le code, vous pouvez obtenir le même résultat en utilisant le kit de développement du nuage AWS (AWS CDK). Cette méthode suit les mêmes étapes générales mais gère tout localement dans un projet AWS CDK.

Pour obtenir des conseils détaillés, consultez le guide officiel d’AWS. Vous devriez également jeter un coup d’œil au dépôt GitHub qui soutient ce tutoriel. Cette base de code peut être facilement adaptée pour fonctionner avec l’API SERP de Bright Data.

Conclusion

Dans cet article de blog, vous avez vu comment intégrer l’API SERP de Bright Data dans un agent AWS Bedrock IA. Ce flux de travail est idéal pour tous ceux qui cherchent à construire des agents IA plus puissants et conscients du contexte dans AWS.

Pour créer des flux de travail d’IA encore plus avancés, explorez l’infrastructure de Bright Data pour l’IA. Vous y trouverez une suite d’outils pour récupérer, valider et transformer des données Web en direct.

Créez un compte Bright Data gratuit dès aujourd’hui et commencez à expérimenter nos solutions de données pour le web prêtes pour l’IA !