En este artículo, verá:
- Qué es el AWS Cloud Development Kit (CDK) y cómo se puede utilizar para definir e implementar la infraestructura en la nube.
- Por qué debería dar a los agentes de AWS Bedrock IA, creados con AWS CDK, acceso a los resultados de búsqueda web utilizando una herramienta preparada para la IA como la API SERP de Bright Data.
- Cómo crear un agente AWS Bedrock integrado con la API SERP utilizando AWS CDK en Python.
¡Empecemos!
¿Qué es el kit de desarrollo en la nube (CDK) de AWS?
El AWS Cloud Development Kit, también conocido como AWS CDK, es un marco de código abierto para crear infraestructura en la nube como código utilizando lenguajes de programación modernos. Le proporciona lo que necesita para aprovisionar recursos de AWS e implementar aplicaciones a través de AWS CloudFormation utilizando lenguajes de programación como TypeScript, Python, Java, C# y Go.
Gracias a AWS CDK, también puede crear agentes de IA para Amazon Bedrock mediante programación, ¡exactamente lo que hará en este tutorial!
Por qué los agentes IA de Amazon Bedrock creados con AWS CDK necesitan búsquedas web
Los modelos de lenguaje grandes se entrenan con conjuntos de datos que representan conocimientos solo hasta un determinado momento. Como resultado, tienden a producir respuestas inexactas o alucinadas. Esto es especialmente problemático para los agentes de IA que requieren información actualizada.
Esto se puede resolver dotando a su agente de IA de la capacidad de obtener datos nuevos y fiables en una configuración RAG (Retrieval-Augmented Generation, generación aumentada por recuperación). Por ejemplo, el agente de IA podría realizar búsquedas en la web para recopilar información verificable, ampliando así sus conocimientos y mejorando su precisión.
Es posible crear una función AWS Lambda personalizada para rastrear los motores de búsqueda, pero resulta bastante complicado. Tendría que manejar la representación de JavaScript, los CAPTCHA, los cambios en la estructura de los sitios y los bloqueos de IP.
Un enfoque mejor es utilizar una API SERP con múltiples funciones, como la API SERP de Bright Data. Esta se encarga de los proxies, el desbloqueo, la escalabilidad, el formato de los datos y mucho más. Al integrarla con AWS Bedrock mediante una función Lambda, su agente de IA creado con AWS CDK podrá acceder a resultados de búsqueda en tiempo real para ofrecer respuestas más fiables.
Cómo desarrollar un agente de IA con integración de la API SERP utilizando AWS CDK en Python
En esta sección paso a paso, aprenderá a utilizar AWS CDK con Python para crear un agente de IA de AWS Bedrock. Este será capaz de obtener datos de los motores de búsqueda a través de la API SERP de Bright Data.
La integración se implementará a través de una función Lambda (que llama a la API SERP) que el agente puede invocar como herramienta. En concreto, para crear un agente Amazon Bedrock, los componentes principales son:
- Grupo de acciones: define las funciones que el agente puede ver y llamar.
- Función Lambda: implementa la lógica para consultar la API SERP de Bright Data.
- Agente de IA: coordina las interacciones entre los modelos básicos, las funciones y las solicitudes de los usuarios.
Esta configuración se implementará íntegramente con AWS CDK en Python. Para obtener los mismos resultados utilizando la consola visual de AWS Bedrock, consulte nuestra guía Amazon Bedrock + Bright Data.
Siga los pasos que se indican a continuación para crear un agente de IA de AWS Bedrock utilizando AWS CDK, mejorado con capacidades de búsqueda web en tiempo real a través de la API SERP.
Requisitos previos
Para seguir este tutorial, necesita:
- Node.js 22.x+ instalado localmente para utilizar la CLI de AWS CDK.
- Python 3.11+ instalado localmente para emplear AWS CDK en Python.
- Una cuenta AWS activa (incluso en una prueba gratuita).
- Requisitos previos de Amazon Bedrock Agents configurados. (Amazon Bedrock Agents soloestá disponible actualmente en algunas regiones de AWS).
- Una cuenta de Bright Data con una clave API lista.
- Conocimientos básicos de programación en Python.
Paso n.º 1: Instalar y autorizar la CLI de AWS
Antes de continuar con AWS CDK, debe instalar la CLI de AWS y configurarla para que su terminal pueda autenticarse con su cuenta de AWS.
Nota: Si ya tiene la CLI de AWS instalada y configurada para la autenticación, omita este paso y continúe con el siguiente.
Instale la CLI de AWS siguiendo la guía de instalación oficial para su sistema operativo. Una vez instalada, verifique la instalación ejecutando:
aws --versionDebería ver un resultado similar a este:
aws-cli/2.31.32 Python/3.13.9 Windows/11 exe/AMD64A continuación, ejecute el comando configure para configurar sus credenciales:
aws configureSe le pedirá que introduzca:
- ID de clave de acceso de AWS
- Clave secreta de acceso de AWS
- Nombre de la región predeterminada (por ejemplo,
us-east-1) - Formato de salida predeterminado (opcional, por ejemplo,
json)
Rellene los tres primeros campos, ya que son necesarios para el desarrollo y la implementación de CDK. Si se pregunta dónde obtener esa información:
- Vaya a AWS e inicie sesión.
- En la esquina superior derecha, haga clic en el nombre de su cuenta para abrir el menú de la cuenta y seleccione la opción «Credenciales de seguridad».
- En la sección «Claves de acceso», cree una nueva clave. Guarde tanto el «ID de la clave de acceso» como la «Clave de acceso secreta» en un lugar seguro.
¡Listo! Su máquina puede conectarse a su cuenta de AWS a través de la CLI. Ya está listo para continuar con el desarrollo de AWS CDK.
Paso n.º 2: Instalar AWS CDK
Instale AWS CDK globalmente en su sistema utilizando el paquete npm aws-cdk:
npm install -g aws-cdkA continuación, compruebe la versión instalada ejecutando:
cdk --versionDebería ver un resultado similar a este:
2.1031.2 (compilación 779352d)Nota: Se requiere la versión 2.174.3 o posterior para el desarrollo y la implementación de agentes de IA utilizando AWS CDK con Python.
¡Genial! Ahora ya tiene instalada localmente la CLI de AWS CDK.
Paso n.º 3: Configure su proyecto AWS CDK Python
Comience creando una nueva carpeta de proyecto para su agente de IA AWS CDK + Bright Data API SERP.
Por ejemplo, puede llamarla aws-cdk-bright-data-web-search-agent:
mkdir aws-cdk-bright-data-web-search-agentNavega hasta la carpeta:
cd aws-cdk-bright-data-web-search-agentA continuación, inicialice una nueva aplicación AWS CDK basada en Python mediante el comando init:
cdk init app --language pythonEsto puede tardar un momento, así que tenga paciencia mientras la CLI de CDK configura la estructura de su proyecto.
Una vez inicializada, la carpeta de su proyecto debería tener este aspecto:
aws-cdk-bright-data-web-search-agent
├── .git/
├── venv/
├── aws_cdk_bright_data_web_search_agent/
│ ├── __init__.py
│ └── aws_cdk_bright_data_web_search_agent_stack.py
├── tests/
│ ├── __init__.py
│ └── unit/
│ ├── __init__.py
│ └── test_aws_cdk_bright_data_web_search_agent_stack.py
├── .gitignore
├── app.py
├── cdk.json
├── README.md
├── requirements.txt
├── requirements-dev.txt
└── source.batLo que debes tener en cuenta son estos dos archivos:
app.py: contiene la definición de nivel superior de la aplicación AWS CDK.aws_cdk_bright_data_web_search_agent/aws_cdk_bright_data_web_search_agent_stack.py: Define la pila para el agente de búsqueda web (aquí es donde implementará la lógica de su agente de IA).
Para obtener más detalles, consulta la guía oficial de AWS sobre cómo trabajar con CDK en Python.
Ahora, carga tu proyecto en tu IDE de Python favorito, como PyCharm o Visual Studio Code con la extensión Python.
Tenga en cuenta que el comando cdk init crea automáticamente un entorno virtual Python en el proyecto. En Linux o macOS, actívelo con:
source .venv/bin/activateO, de forma equivalente, en Windows, ejecute:
.venvScriptsactivateA continuación, dentro del entorno virtual activado, instala todas las dependencias necesarias:
python -m pip install -r requirements.txt¡Fantástico! Ahora ya tiene configurado un entorno AWS CDK Python para el desarrollo de agentes de IA.
Paso n.º 4: Ejecutar el arranque de AWS CDK
El arranque es el proceso de preparación de su entorno AWS para su uso con el kit de desarrollo en la nube de AWS. Antes de implementar una pila CDK, su entorno debe arrancarse.
En términos más sencillos, este proceso configura los siguientes recursos en su cuenta de AWS:
- Un bucket de Amazon S3: almacena los archivos de su proyecto CDK, como el código de la función AWS Lambda y otros activos.
- Un repositorio de Amazon ECR: almacena imágenes de Docker.
- Roles de AWS IAM: otorgan los permisos necesarios para que AWS CDK realice implementaciones. (Para obtener más detalles, consulte la documentación de AWS sobre los roles de IAM creados durante el arranque).
Para iniciar el proceso de arranque de CDK, ejecute el siguiente comando en la carpeta de su proyecto:
cdk bootstrapEn el servicio AWS CloudFormation, este comando crea una pila denominada «CDKToolkit» que contiene todos los recursos necesarios para implementar aplicaciones CDK.
Compruébelo accediendo a la consola de CloudFormation y consultando la página «Stacks»:
Verá una pila «CDKToolkit». Siga su enlace y debería ver algo como esto:
Para obtener más información sobre cómo funciona el proceso de arranque, por qué es necesario y qué ocurre entre bastidores, consulte la documentación oficial de AWS CDK.
Paso n.º 5: Prepárese con la API SERP de Bright Data
Ahora que su entorno AWS CDK está configurado para el desarrollo y la implementación, complete los pasos preliminares preparando su cuenta de Bright Data y configurando el servicio API SERP. Puede seguir la documentación oficial de Bright Data o seguir los pasos que se indican a continuación.
Si aún no tiene una cuenta, cree una cuenta de Bright Data. También puede simplemente iniciar sesión. En su cuenta de Bright Data, vaya a la página «Proxy y scraping». En la sección «Mis zonas», busque la fila «API SERP» en la tabla:
Si no ve una fila con la etiqueta «API SERP», significa que aún no ha configurado una zona. Desplácese hacia abajo hasta la sección «API SERP» y haga clic en «Crear zona» para añadir una:
Cree una zona API SERP y asígnele un nombre como serp_api (o cualquier otro nombre que prefiera). Recuerde el nombre de la zona que ha elegido, ya que lo necesitará para acceder al servicio a través de la API.
En la página del producto API SERP, activa el interruptor «Activar» para habilitar la zona:
Por último, siga la guía oficial para generar su clave API de Bright Data. Guárdela en un lugar seguro, ya que la necesitará en breve.
¡Genial! Ahora ya tiene todo listo para utilizar la API SERP de Bright Data en su agente AWS Bedrock IA desarrollado con AWS CDK.
Paso n.º 6: almacene los secretos de su aplicación CDK en AWS Secrets Manager
Acaba de obtener información confidencial (por ejemplo, su clave API de Bright Data y el nombre de la zona API SERP). En lugar de codificar estos valores en el código de su función Lambda, debe leerlos de forma segura desde AWS Secrets Manager.
Ejecute el siguiente comando Bash para crear un secreto llamado BRIGHT_DATA que contenga su clave API de Bright Data y la zona API SERP:
aws secretsmanager create-secret --name "BRIGHT_DATA" --description "Credenciales API para la integración de Bright Data API SERP" --secret-string '{
"BRIGHT_DATA_API_KEY": "<YOUR_BRIGHT_DATA_API_KEY>",
"BRIGHT_DATA_SERP_API_ZONE": "<YOUR_BRIGHT_DATA_SERP_API_ZONE>"
}'O, de forma equivalente, en PowerShell:
aws secretsmanager create-secret `
--name "BRIGHT_DATA" `
--description "Credenciales API para la integración de Bright Data API SERP" `
--secret-string '{"BRIGHT_DATA_API_KEY":"<TU_CLAVE_API_BRIGHT_DATA>","BRIGHT_DATA_API_SERP_ZONE":"<TU_ZONA_API_BRIGHT_DATA_SERP>"}'Asegúrese de sustituir <YOUR_BRIGHT_DATA_API_KEY> y <YOUR_BRIGHT_DATA_SERP_API_ZONE> por los valores reales que ha obtenido anteriormente.
Ese comando configurará el secreto BRIGHT_DATA, como puede confirmar en la consola de AWS Secrets Manager, en la página «Secretos»:
Si hace clic en el botón «Recuperar valor secreto», debería ver los secretos BRIGHT_DATA_API_KEY y BRIGHT_DATA_SERP_API_ZONE:
¡Genial! Estos secretos se utilizarán para autenticar las solicitudes a la API SERP en una función Lambda que definirá en breve.
Paso n.º 7: Implemente su pila AWS CDK
Ahora que ha configurado todo lo necesario para crear su agente de IA, el siguiente paso es implementar la pila de AWS CDK en Python. En primer lugar, es importante comprender qué es una pila de AWS CDK.
Una pila es la unidad más pequeña que se puede implementar en CDK. Representa una colección de recursos de AWS definidos mediante construcciones de CDK. Cuando implementa una aplicación CDK, todos los recursos de la pila se implementan juntos como una única pila de CloudFormation.
El archivo de pila predeterminado se encuentra en:
aws_cdk_bright_data_web_search_agent/aws_cdk_bright_data_web_search_agent_stack.pyInspecciónelo en Visual Studio Code:
Contiene una plantilla de pila genérica en la que definirá su lógica. Su tarea consiste en implementar la pila completa de AWS CDK para crear el agente de IA con la integración de la API SERP de Bright Data, incluidas las funciones Lambda, los roles de IAM, los grupos de acciones y el agente de IA Bedrock.
Consiga todo eso con:
import aws_cdk.aws_iam as iam
from aws_cdk import (
Aws,
CfnOutput,
Duration,
Stack)
from aws_cdk import aws_bedrock as bedrock
from aws_cdk import aws_lambda as _lambda
from constructs import Construct
# Define las constantes necesarias
AI_MODEL_ID = "amazon.nova-lite-v1:0" # El nombre del LLM utilizado para alimentar el agente
ACTION_GROUP_NAME = "action_group_web_search"
LAMBDA_FUNCTION_NAME = "serp_api_lambda"
AGENT_NAME = "web_search_agent"
# Definir la pila CDK para implementar el agente de búsqueda web impulsado por Bright Data
class AwsCdkBrightDataWebSearchAgentStack(Stack):
def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
# Otorga permisos Lambda para registrar y leer secretos.
lambda_policy = iam.Policy(
self,
"LambdaPolicy",
statements=[
# Permiso para crear grupos de registros de CloudWatch.
iam.PolicyStatement(
sid="CreateLogGroup",
effect=iam.Effect.ALLOW,
actions=["logs:CreateLogGroup"],
resources=[f"arn:aws:logs:{Aws.REGION}:{Aws.ACCOUNT_ID}:*"],
),
# Permiso para crear flujos de registros y colocar eventos de registro
iam.PolicyStatement(
sid="CreateLogStreamAndPutLogEvents",
effect=iam.Effect.ALLOW,
actions=["logs:CreateLogStream", "logs:PutLogEvents"],
resources=[
f"arn:aws:logs:{Aws.REGION}:{Aws.ACCOUNT_ID}:log-group:/aws/lambda/{LAMBDA_FUNCTION_NAME}",
f"arn:aws:logs:{Aws.REGION}:{Aws.ACCOUNT_ID}:log-group:/aws/lambda/{LAMBDA_FUNCTION_NAME}:log-stream:*",
],
),
# Permiso para leer secretos BRIGHT_DATA desde Secrets Manager
iam.PolicyStatement(
sid="GetSecretsManagerSecret",
effect=iam.Effect.ALLOW,
actions=["secretsmanager:GetSecretValue"],
resources=[
f"arn:aws:secretsmanager:{Aws.REGION}:{Aws.ACCOUNT_ID}:secret:BRIGHT_DATA*",
],),
],
)
# Definir la función IAM para las funciones Lambda
lambda_role = iam.Role(
self,
"LambdaRole",
role_name=f"{LAMBDA_FUNCTION_NAME}_role",
assumed_by=iam.ServicePrincipal("lambda.amazonaws.com"),
)
# Adjuntar la política a la función Lambda
lambda_role.attach_inline_policy(lambda_policy)
# Definición de la función Lambda
lambda_function = _lambda.Function(
self,
LAMBDA_FUNCTION_NAME,
function_name=LAMBDA_FUNCTION_NAME,
runtime=_lambda.Runtime.PYTHON_3_12, # Tiempo de ejecución de Python
architecture=_lambda.Architecture.ARM_64,
code=_lambda.Code.from_asset("lambda"), # Leer el código Lambda desde la carpeta «lambda/»
handler=f"{LAMBDA_FUNCTION_NAME}.lambda_handler",
timeout=Duration.seconds(120),
role=lambda_role, # Adjuntar función IAM
environment={"LOG_LEVEL": "DEBUG", "ACTION_GROUP": f"{ACTION_GROUP_NAME}"},
)
# Permitir que el servicio Bedrock invoque funciones Lambda
bedrock_account_principal = iam.PrincipalWithConditions(
iam.ServicePrincipal("bedrock.amazonaws.com"),
conditions={
"StringEquals": {"aws:SourceAccount": f"{Aws.ACCOUNT_ID}"},
},
)
lambda_function.add_permission(
id="LambdaResourcePolicyAgentsInvokeFunction",
principal=bedrock_account_principal,
action="lambda:invokeFunction",
)
# Definir la política de IAM para el agente Bedrock
agent_policy = iam.Policy(
self,
"AgentPolicy",
statements=[
iam.PolicyStatement(
sid="AmazonBedrockAgentBedrockFoundationModelPolicy",
effect=iam.Effect.ALLOW,
actions=["bedrock:InvokeModel"], # Otorgarle permiso para llamar al modelo base
resources=[f"arn:aws:bedrock:{Aws.REGION}::foundation-model/{AI_MODEL_ID}"],
),
],
)
# Relación de confianza para que el rol de agente permita a Bedrock asumirlo
agent_role_trust = iam.PrincipalWithConditions(
iam.ServicePrincipal("bedrock.amazonaws.com"),
conditions={
"StringLike": {"aws:SourceAccount": f"{Aws.ACCOUNT_ID}"},
"ArnLike": {"aws:SourceArn": f"arn:aws:bedrock:{Aws.REGION}:{Aws.ACCOUNT_ID}:agent/*"},
},
)
# Definir la función IAM para el agente Bedrock
agent_role = iam.Role(
self,
"AmazonBedrockExecutionRoleForAgents",
role_name=f"AmazonBedrockExecutionRoleForAgents_{AGENT_NAME}",
assumed_by=agent_role_trust,
)
agent_role.attach_inline_policy(agent_policy)
# Definir el grupo de acciones para el agente de IA
action_group = bedrock.CfnAgent.AgentActionGroupProperty(
action_group_name=ACTION_GROUP_NAME,
description="Llamar a la API SERP de Bright Data para realizar búsquedas web y recuperar información actualizada de los motores de búsqueda.",
action_group_executor=bedrock.CfnAgent.ActionGroupExecutorProperty(lambda_=lambda_function.function_arn),
function_schema=bedrock.CfnAgent.FunctionSchemaProperty(
functions=[
bedrock.CfnAgent.FunctionProperty(
name=LAMBDA_FUNCTION_NAME,
description="Se integra con la API SERP de Bright Data para realizar búsquedas web.",
parameters={
"search_query": bedrock.CfnAgent.ParameterDetailProperty(
type="string",
description="La consulta de búsqueda para la búsqueda web de Google.",
required=True,
)
},
),
]
),
)
# Crear y especificar el agente Bedrock AI
agent_description = """
Un agente de IA que puede conectarse a la API SERP de Bright Data para recuperar contexto de búsqueda web actualizado de los motores de búsqueda.
"""
agent_instruction = """
Eres un agente diseñado para gestionar casos de uso que requieren recuperar y procesar información actualizada.
Puedes acceder a datos actuales, incluyendo noticias y resultados de motores de búsqueda, a través de búsquedas web impulsadas por la API SERP de Bright Data.
"""
agent = bedrock.CfnAgent(
self,
AGENT_NAME,
description=agent_description,
agent_name=AGENT_NAME,
foundation_model=AI_MODEL_ID,
action_groups=[action_group],
auto_prepare=True,
instruction=agent_instruction,
agent_resource_role_arn=agent_role.role_arn,
)
# Exportar las salidas clave para la implementación.
CfnOutput(self, "agent_id", value=agent.attr_agent_id)
CfnOutput(self, "agent_version", value=agent.attr_agent_version)El código anterior es una versión modificada de la implementación oficial de la pila AWS CDK para un agente de IA de búsqueda web.
Lo que ocurre en esas más de 150 líneas de código refleja los pasos descritos anteriormente en la guía: Paso n.º 1, Paso n.º 2 y Paso n.º 3 de nuestro artículo«Cómo integrar la API SERP de Bright Data con los agentes de IA de AWS Bedrock».
Para comprender mejor lo que ocurre en ese archivo, desglosemos el código en cinco bloques funcionales:
- Política y función IAM de Lambda: configura los permisos para la función Lambda. Lambda requiere acceso a los registros de CloudWatch para registrar los detalles de ejecución y a AWS Secrets Manager para leer de forma segura la clave y la zona de la API de Bright Data. Se crea una función IAM para Lambda y se adjunta la política adecuada, lo que garantiza que funcione de forma segura con solo los permisos que necesita.
- Definición de la función Lambda: aquí se define y configura la función Lambda. Especifica el tiempo de ejecución y la arquitectura de Python, apunta a la carpeta que contiene el código Lambda (que se implementará en el siguiente paso) y configura variables de entorno como el nivel de registro y el nombre del grupo de acciones. Se conceden permisos para que AWS Bedrock pueda invocar Lambda, lo que permite al agente de IA activar búsquedas web a través de la API SERP de Bright Data.
- Rol IAM del agente Bedrock: crea el rol de ejecución para el agente de IA Bedrock. El agente necesita permisos para invocar el modelo de IA base seleccionado de entre los compatibles (
amazon.nova-lite-v1:0, en este caso). Se define una relación de confianza para que solo Bedrock pueda asumir el rol dentro de su cuenta. Se adjunta una política que concede acceso al modelo. - Definición del grupo de acciones: un grupo de acciones define las acciones específicas que puede realizar el agente de IA. Vincula al agente con la función Lambda que le permite ejecutar búsquedas web a través de la API SERP de Bright Data. El grupo de acciones también incluye metadatos para los parámetros de entrada, de modo que el agente entiende cómo interactuar con la función y qué información se requiere para cada búsqueda.
- Definición del agente IA de Bedrock: define el propio agente IA. Vincula al agente con el grupo de acciones y la función de ejecución, y proporciona una descripción clara e instrucciones para su uso.
Después de implementar la pila CDK, aparecerá un agente de IA en su consola de AWS. Ese agente puede realizar búsquedas web de forma autónoma y recuperar información actualizada aprovechando la integración de la API SERP de Bright Data en la función Lambda. ¡Fantástico!
Paso n.º 8: Implementar Lambda para la integración de la API SERP
Eche un vistazo a este fragmento del código anterior:
lambda_function = _lambda.Function(
self,
LAMBDA_FUNCTION_NAME,
function_name=LAMBDA_FUNCTION_NAME,
runtime=_lambda.Runtime.PYTHON_3_12, # Tiempo de ejecución de Python
architecture=_lambda.Architecture.ARM_64,
code=_lambda.Code.from_asset("lambda"), # Lee el código Lambda de la carpeta «lambda/»
handler=f"{LAMBDA_FUNCTION_NAME}.lambda_handler",
timeout=Duration.seconds(120),
role=lambda_role, # Adjuntar función IAM
environment={"LOG_LEVEL": "DEBUG", "ACTION_GROUP": f"{ACTION_GROUP_NAME}"},
)La línea code=_lambda.Code.from_asset("lambda") especifica que el código de la función Lambda se cargará desde la carpeta lambda/. Por lo tanto, cree una carpeta lambda/ en su proyecto y añada un archivo llamado serp_api_lambda.py dentro de ella:
El archivo serp_api_lambda.py debe contener la implementación de la función Lambda utilizada por el agente de IA definido anteriormente. Implemente esta función para gestionar la integración con la API SERP de Bright Data de la siguiente manera:
import json
import logging
import os
import urllib.parse
import urllib.request
import boto3
# ----------------------------
# Configuración de registro
# ----------------------------
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)
# ----------------------------
# Región AWS del entorno
# ----------------------------
AWS_REGION = os.environ.get("AWS_REGION")
if not AWS_REGION:
logger.warning("Variable de entorno AWS_REGION no establecida; boto3 utilizará la región predeterminada")
# ----------------------------
# Recuperar el objeto secreto de AWS Secrets Manager
# ----------------------------
def get_secret_object(key: str) -> str:
"""
Obtener un valor secreto de AWS Secrets Manager.
"""
session = boto3.session.Session()
client = session.client(
service_name='secretsmanager',
region_name=AWS_REGION
)
try:
get_secret_value_response = client.get_secret_value(
SecretId=key
)
except Exception as e:
logger.error(f"No se pudo obtener el secreto '{key}' de Secrets Manager: {e}")
raise e
secret = json.loads(get_secret_value_response["SecretString"])
return secret
# Recuperar credenciales 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"]
# ----------------------------
# Búsqueda web API SERP
# ----------------------------
def serp_api_web_search(search_query: str) -> str:
"""
Llama a la API SERP de Bright Data para recuperar los resultados de búsqueda de Google.
"""
logger.info(f"Ejecutando búsqueda en la API SERP de Bright Data para search_query='{search_query}'")
# Codifica la consulta para la URL
encoded_query = urllib.parse.quote(search_query)
# Construye la URL de Google para extraer la SERP desde
search_engine_url = f"https://www.google.com/search?q={encoded_query}"
# Solicitud de la API SERP de Bright Data (documentación: 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" # Para obtener el SERP como un documento Markdown listo para 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"Respuesta de la API SERP: {response_data}")
return response_data
except urllib.error.HTTPError as e:
logger.error(f"Error al llamar a la API SERP de Bright Data. Error HTTP {e.code}: {e.reason}")
except urllib.error.URLError as e:
logger.error(f"Error al llamar a la API SERP de Bright Data. Error de URL: {e.reason}")
return ""
# ----------------------------
# Controlador Lambda
# ----------------------------
def lambda_handler(event, _):
"""
Controlador AWS Lambda.
Espera un evento con actionGroup, function y parámetros opcionales (incluido search_query).
"""
logger.debug(f"lambda_handler llamado con evento: {event}")
action_group = event.get("actionGroup")
function = event.get("function")
parameters = event.get("parameters", [])
# Extrae search_query de los parámetros
search_query = next(
(param["value"] for param in parameters if param.get("name") == "search_query"),
None,
)
logger.debug(f"Entrada de consulta de búsqueda: {search_query}")
serp_page = serp_api_web_search(search_query) if search_query else ""
logger.debug(f"Resultados de la consulta de búsqueda: {serp_page}")
# Preparar la respuesta Lambda
function_response_body = {"TEXT": {"body": serp_page}}
action_response = {
"actionGroup": action_group,
"function": function,
"functionResponse": {"responseBody": function_response_body},
}
response = {"response": action_response, "messageVersion": event.get("messageVersion")}
logger.debug(f"lambda_handler response: {response}")
return responseEsta función Lambda gestiona tres tareas principales:
- Recuperar credenciales API de forma segura: obtiene la clave API de Bright Data y la zona API SERP de AWS Secrets Manager, de modo que la información confidencial nunca queda codificada.
- Realizar búsquedas web a través de la API SERP: codifica la consulta de búsqueda, construye la URL de búsqueda de Google y envía una solicitud a la API SERP de Bright Data. La API devuelve los resultados de la búsqueda con formato Markdown, que es un formato de datos ideal para el consumo de IA.
- Responder a AWS Bedrock: devuelve los resultados en una respuesta estructurada que el agente de IA puede utilizar.
¡Ya está! Su función AWS Lambda para conectarse a la API SERP de Bright Data ya se ha definido correctamente.
Paso n.º 9: Implemente su aplicación AWS CDK
Ahora que se han implementado su pila CDK y su función Lambda relacionada, el último paso es implementar su pila en AWS. Para ello, en la carpeta de su proyecto, ejecute el comando de implementación:
cdk deployCuando se le solicite permiso para crear la función IAM, escriba y para aprobar.
Al cabo de unos instantes, si todo funciona como se espera, debería ver un resultado como este:
A continuación, vaya a la consola de Amazon Bedrock. Dentro de la página «Agentes», debería ver una entrada «web_search_agent»:
Abra el agente y verá los detalles del agente implementado:
Inspecciónelo pulsando el botón «Edit and Agent Builder» (Editar y creador de agentes) y verá exactamente el mismo agente de IA implementado en«Cómo integrar la API SERP de Bright Data con AWS Bedrock».
Por último, ten en cuenta que puedes probar el agente directamente utilizando la interfaz de chat de la esquina derecha. ¡Esto es lo que harás en el siguiente y último paso!
Paso n.º 10: Prueba el agente de IA
Para probar las capacidades de búsqueda web y recuperación de datos en tiempo real de su agente de IA, pruebe con un comando como:
«Dame las tres últimas noticias sobre el cierre del Gobierno de EE. UU.».(Nota: esto es solo un ejemplo. Por lo tanto, puede probar cualquier comando que requiera resultados de búsqueda web).
Es una solicitud ideal porque pide información actualizada que el modelo base por sí solo no conoce. El agente llamará a la función Lambda integrada con la API SERP, recuperará los resultados y procesará los datos para generar una respuesta coherente.
Ejecute esta indicación en la sección «Probar agente» de su agente y debería ver un resultado similar a este:
Entre bastidores, el agente invoca la función Lambda de la API SERP, recupera los últimos resultados de búsqueda de Google para la consulta «cierre del gobierno de EE. UU.» y extrae los artículos más relevantes (junto con sus URL). Esto es algo que un LLM estándar, como el Nova Lite configurado, no puede hacer por sí solo.
En detalle, esta es la respuesta generada por el agente:
Los artículos de noticias seleccionados (y sus URL) coinciden con lo que encontrarías manualmente en Google para la consulta «cierre del gobierno de EE. UU.» (al menos en la fecha en que se probó el agente):
Ahora bien, cualquiera que haya intentado extraer resultados de búsqueda de Google sabe lo difícil que puede resultar debido a la detección de bots, las prohibiciones de IP, la representación de JavaScript y otros retos. La API SERP de Bright Data se encarga de todos estos problemas por usted, devolviendo SERP extraídos en formato Markdown (o HTML, JSON, etc.) optimizado para IA.
Para confirmar que su agente realmente llamó a la función Lambda de la API SERP, haga clic en el botón «Mostrar rastro» en el cuadro de respuesta. En la sección «Paso 1 del rastro», desplácese hacia abajo hasta el registro de invocación del grupo para inspeccionar el resultado de la llamada a Lambda:
Esto verifica que la función Lambda se ha ejecutado correctamente y que el agente ha interactuado con la API SERP según lo previsto. También puede consultar los registros de AWS CloudWatch de su función Lambda para confirmar la ejecución.
¡Es hora de llevar a tu agente más allá! Prueba las indicaciones relacionadas con la verificación de datos, la supervisión de marcas, el análisis de tendencias de mercado u otros escenarios para ver cómo funciona en diferentes casos de uso de agentes y RAG.
¡Et voilà! Ha creado con éxito un agente AWS Bedrock integrado con la API SERP de Bright Data utilizando Python y la biblioteca AWS CDK. Este agente de IA es capaz de recuperar datos de búsqueda web actualizados, fiables y contextuales bajo demanda.
Conclusión
En esta entrada del blog, ha aprendido a integrar la API SERP de Bright Data en un agente de IA de AWS Bedrock utilizando un proyecto AWS CDK Python. Este flujo de trabajo es perfecto para los desarrolladores que desean crear agentes de IA más sensibles al contexto en AWS.
Para crear agentes de IA aún más sofisticados, explore la infraestructura de Bright Data para IA. Esta ofrece un conjunto de herramientas para recuperar, validar y transformar datos web en tiempo real.
¡Cree hoy mismo una cuenta gratuita en Bright Data y comience a experimentar con nuestras soluciones de datos web preparadas para la IA!
