Los agentes de IA impulsados por grandes modelos de lenguaje (LLM) pueden razonar y tomar decisiones, pero están limitados por sus datos de entrenamiento. Para crear agentes verdaderamente útiles, es necesario conectarlos a datos web en tiempo real. Esta guía le muestra cómo combinar AWS Strands SDK con el servidor Web MCP de Bright Data para crear agentes de IA autónomos que puedan acceder y analizar datos web en tiempo real.

En esta guía aprenderá:

Qué es AWS Strands SDK y qué lo hace único como marco para crear agentes de IA
Por qué AWS Strands SDK se combina perfectamente con el servidor Web MCP de Bright Data para agentes con conciencia web
Cómo integrar AWS Strands con Web MCP de Bright Data para crear un agente de inteligencia competitiva autónomo
Cómo crear agentes que decidan de forma autónoma qué herramientas de Scraping web utilizar en función de sus objetivos

¡Empecemos!

¿Qué es AWS Strands SDK?

AWS Strands SDK es un marco ligero y centrado en el código desarrollado por AWS para crear agentes de IA con un mínimo de código. Adopta un enfoque basado en modelos, en el que las capacidades de los agentes surgen de las decisiones de los modelos en lugar de la lógica codificada.

En comparación con otros marcos de agentes de IA, AWS Strands SDK hace hincapié en la simplicidad, la flexibilidad y la preparación para la producción. En detalle, algunas de sus principales características son:

Independiente del modelo: compatibilidad con múltiples proveedores de LLM, incluidos AWS Bedrock, OpenAI, Anthropic y otros.
Compatibilidad nativa con MCP: integración incorporada con Model Context Protocol para acceder a más de 1000 herramientas preconstruidas.
Código mínimo: crea agentes sofisticados con solo unas pocas líneas de código.
Listo para la producción: incluye gestión de errores, reintentos y observabilidad desde el primer momento.
Bucle agencial: implementa ciclos de percepción-razonamiento-acción para la toma de decisiones autónoma.
Compatibilidad con múltiples agentes: primitivas de orquestación para coordinar múltiples agentes especializados.
Gestión de estado: gestión de sesiones y contexto en todas las interacciones.

Comprensión del SDK de AWS Strands

Arquitectura central

AWS Strands SDK simplifica el desarrollo de agentes con un diseño limpio de tres componentes que no compromete la potencia.

Este enfoque le permite crear agentes inteligentes con un código mínimo que, de otro modo, requeriría miles de líneas.

Componente de modelo: el cerebro que funciona con múltiples proveedores de IA
Integración de herramientas: conecta los agentes a sistemas externos a través de servidores MCP.
Tareas basadas en comandos: defina el comportamiento del agente con lenguaje natural en lugar de código.

Implementación del bucle agentico

El bucle agencial es lo que hace que los agentes de Strands sean tan inteligentes. Es como un ciclo continuo en el que el agente percibe lo que está sucediendo, lo piensa y actúa, lo que le permite manejar tareas complejas por sí mismo.

Strands cambia las reglas del juego al permitir que el modelo de IA decida qué hacer a continuación. En lugar de codificar todos los escenarios posibles, el modelo deduce las cosas basándose en la situación actual.

Así es como funciona en la práctica:

Tu agente recibe una tarea de un usuario.
El modelo analiza lo que está sucediendo y las herramientas de las que dispone.
Decide si utilizar una herramienta, pedir una aclaración o dar una respuesta definitiva.
Si utiliza una herramienta, Strands la ejecuta y envía los resultados al modelo.
Este ciclo continúa hasta que se completa el trabajo o se necesita ayuda humana.

Piense en crear una herramienta de monitoreo de precios: con la codificación tradicional, tendría que escribir la lógica para comprobar los sitios web de la competencia, gestionar diferentes diseños de página, gestionar errores, recopilar resultados y establecer umbrales de alerta.

Con Strands, solo tienes que proporcionar herramientas de scraping web y decirle al agente: «Supervisa estos sitios de la competencia en busca de cambios de precios superiores al 5 % y avísame con un resumen». El modelo determina por sí mismo qué sitios debe comprobar, cómo gestionar los problemas y cuándo enviar alertas.

¿Por qué combinar AWS Strands SDK con un servidor MCP para la recuperación de datos web?

Los agentes de IA creados con AWS Strands heredan las limitaciones de sus LLM subyacentes, en particular la falta de acceso a información en tiempo real. Esto puede dar lugar a respuestas obsoletas o inexactas cuando los agentes necesitan datos actuales, como los precios de la competencia, las condiciones del mercado o la opinión de los clientes.

Aquí es donde entra en juego el servidor Web MCP de Bright Data. Creado en Node.js, este servidor MCP se integra con el conjunto de herramientas de recuperación de datos preparadas para IA de Bright Data. Estas herramientas permiten a su agente:

Acceder a cualquier contenido web, incluso a aquellos con protección anti-bot.
Consultar conjuntos de datos estructurados de más de 120 sitios web populares.
Realizar búsquedas en varios motores de búsqueda simultáneamente.
Interactuar con páginas web dinámicas en tiempo real.

En este momento, el servidor MCP incluye 40 herramientas especializadas para recopilar datos estructurados de sitios como Amazon, LinkedIn, TikTok y muchos más utilizando API de Web Scraper.

Ahora, veamos cómo puede utilizar estas herramientas MCP con AWS Strands SDK.

Cómo integrar AWS Strands SDK con el servidor MCP de Bright Data en Python

En esta sección, aprenderá a utilizar AWS Strands SDK para crear un agente de IA equipado con capacidades de extracción y recuperación de datos en tiempo real desde el servidor Web MCP.

Como ejemplo, crearemos un agente de Inteligencia competitiva que pueda analizar de forma autónoma los mercados y la competencia. El agente decidirá qué herramientas utilizar en función de sus objetivos, lo que demuestra el poder del bucle agencial.

Sigue esta guía paso a paso para crear tu agente de IA Claude + Bright Data MCP con AWS Strands SDK.

Requisitos previos

Para replicar el ejemplo de código, asegúrese de que dispone de:

Requisitos de software:

Python 3.10 o superior
Node.js (se recomienda la última versión LTS)
Un IDE de Python (VS Code con extensión Python o PyCharm)

Requisitos de la cuenta:

Una cuenta de Bright Data (el nivel gratuito ofrece 5000 solicitudes mensuales)
Una cuenta de Anthropic con acceso a la API de Claude y créditos

Conocimientos previos (útiles, pero no obligatorios):

Conocimientos básicos sobre el funcionamiento de MCP
Familiaridad con los agentes de IA y sus capacidades
Conocimientos básicos de programación asíncrona en Python

Paso n.º 1: Crea tu proyecto Python

Abra su terminal y cree una nueva carpeta para su proyecto:

mkdir strands-mcp-agent
cd strands-mcp-agent

Configura un entorno virtual Python:

python -m venv venv

Activa el entorno virtual:

# En Linux/macOS:
source venv/bin/activate

# En Windows:
venvScriptsactivate

Cree el archivo Python principal:

touch agent.py

La estructura de carpetas debería tener este aspecto:

strands-mcp-agent/
├── venv/
└── agent.py

¡Ya está todo listo! Ahora dispone de un entorno Python preparado para crear un agente de IA con acceso a datos web.

Paso n.º 2: Instalar AWS Strands SDK

En tu entorno virtual activado, instala los paquetes necesarios:

pip install strands-agents python-dotenv

Esto instala:

strands-agents: el SDK de AWS Strands para crear agentes de IA
python-dotenv: para la gestión segura de variables de entorno

A continuación, añada estas importaciones a su archivo agent.py:

from strands import Agent
from strands.models.anthropic import AnthropicModel
from strands.tools.mcp.mcp_client import MCPClient
from mcp.client.stdio import stdio_client, StdioServerParameters

¡Genial! Ahora puede utilizar el SDK de AWS Strands para crear agentes.

Paso n.º 3: configurar las variables de entorno

Cree un archivo .env en la carpeta de su proyecto para gestionar de forma segura las claves API:

touch .env

Añade tus claves API al archivo .env:

# API de Anthropic para modelos Claude
ANTHROPIC_API_KEY=tu_clave_anthropic_aquí

# Credenciales de Bright Data para scraping web
BRIGHT_DATA_API_KEY=tu_token_bright_data_aquí

En su agente.py, configure la carga de variables de entorno:

import os
from dotenv import load_dotenv

load_dotenv()

# Leer claves API
ANTHROPIC_API_KEY = os.getenv("ANTHROPIC_API_KEY")
BRIGHT_DATA_API_KEY = os.getenv("BRIGHT_DATA_API_KEY")

¡Ya está! Ahora ya está todo listo para cargar de forma segura las claves API desde el archivo .env.

Paso n.º 4: Instalar y probar el servidor MCP de Bright Data

Instala Bright Data Web MCP globalmente a través de npm:

npm install -g @brightdata/mcp

Comprueba que funciona con tu clave API:

# En Linux/macOS:
API_TOKEN="<TU_API_DE_BRIGHT_DATA>" npx -y @brightdata/mcp

# En Windows PowerShell:
$env:API_TOKEN="<TU_API_DE_BRIGHT_DATA>"; npx -y @brightdata/mcp

Si todo va bien, verás registros que muestran el inicio del servidor MCP. La primera ejecución creará automáticamente dos zonas en tu cuenta de Bright Data:

mcp_unlocker: para Web Unlocker
mcp_browser: para Browser API

Puede verificarlas en su panel de control de Bright Data, en«Proxy e infraestructura de scraping».

¡Genial! El servidor Web MCP funciona a las mil maravillas.

Bright Data's control panel showing the free tier MCP requests

Paso n.º 5: Inicializar el modelo Strands

Configure el modelo Anthropic Claude en su agent.py:

# Inicializar el modelo Anthropic
model = AnthropicModel(
    model_id="claude-3-opus-20240229",  # También puede utilizar claude-3-sonnet para reducir el coste.
    max_tokens=4096,
    params={"temperature": 0.3}
)

# Establecer la clave API
os.environ["ANTHROPIC_API_KEY"] = ANTHROPIC_API_KEY

Esto configura Claude como el LLM de su agente con los parámetros adecuados para obtener respuestas coherentes y centradas.

Paso n.º 6: Conéctese al servidor MCP web

Cree la configuración del cliente MCP para conectarse a las herramientas de Bright Data:

import asyncio
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

async def connect_mcp_tools():
    """Conectarse al servidor MCP de Bright Data y descubrir herramientas"""

    logger.info("Conectándose a Bright Data MCP...")

    # Configurar la conexión con el MCP alojado en Bright Data
    server_params = StdioServerParameters(
        command="npx",
        args=["-y", "@brightdata/mcp"],
        env={"API_TOKEN": BRIGHT_DATA_API_KEY, "PRO_MODE": "true"}
    )

    # Crear cliente MCP
    mcp_client = MCPClient(lambda: stdio_client(server_params))

    # Descubrir herramientas disponibles
    with mcp_client:
        tools = mcp_client.list_tools_sync()
        logger.info(f"📦 Descubiertas {len(tools)} herramientas MCP")

        for tool in tools:
            logger.info(f"  - {tool.tool_name}")

    return mcp_client, tools

Esto establece la conexión con el servidor MCP de Bright Data y descubre todas las herramientas de Scraping web disponibles.

Paso n.º 7: definir el agente de Inteligencia competitiva

Crea un agente con un mensaje especializado para inteligencia competitiva:

def create_agent(model, tools):
    """Crear un agente de inteligencia competitiva con acceso a datos web"""

    system_prompt = """Eres un analista experto en inteligencia competitiva con acceso a potentes herramientas de datos web a través de MCP.

## Tu misión
Realizar un análisis exhaustivo del mercado y de la competencia utilizando datos web en tiempo real.

## Herramientas MCP disponibles
Tienes acceso a estas herramientas MCP de Bright Data:
- search_engine: extrae resultados de búsqueda de Google, Bing o Yandex.
- scrape_as_markdown: extrae contenido de cualquier página web con omisión de CAPTCHA.
- search_engine_batch: realiza varias búsquedas simultáneamente.
- scrape_batch: extrae varias páginas web en paralelo.

## Flujo de trabajo de análisis autónomo
Cuando se te asigne una tarea de análisis, de forma autónoma:
1. Decide qué herramientas utilizar en función del objetivo.
2. Recopila datos completos de múltiples fuentes.
3. Sintetiza los resultados en información útil.
4. Proporciona recomendaciones estratégicas específicas.

Sé proactivo en la selección de herramientas: tienes total autonomía para utilizar cualquier combinación de herramientas.

    return Agent(
        model=model,
        tools=tools,
        system_prompt=system_prompt
    )

Esto crea un agente especializado en Inteligencia competitiva con capacidad de toma de decisiones autónoma.

Paso n.º 8: Inicie su agente

Cree la función de ejecución principal para ejecutar su agente:

async def main():
    """Ejecutar el agente de Inteligencia competitiva"""

    print("🚀 AWS Strands + Bright Data MCP Competitive Intelligence Agent")
    print("=" * 70)

    try:
        # Conectarse a las herramientas MCP
        mcp_client, tools = await connect_mcp_tools()

        # Crear el agente
        agent = create_agent(model, tools)

        print("n✅ ¡Agente listo con acceso a datos web!")
        print("n📊 Iniciando análisis...")
        print("-" * 40)

        # Ejemplo: Analizar la posición competitiva de Tesla
        prompt = """
        Analizar la posición competitiva de Tesla en el mercado de los vehículos eléctricos.

        Investiga:
        - La gama actual de productos y la estrategia de precios.
        - Los principales competidores y sus ofertas.
        - Los anuncios estratégicos recientes.
        - La cuota de mercado y el posicionamiento.

        Utiliza herramientas de scraping web para recopilar datos en tiempo real de tesla.com y los resultados de búsqueda.
        """

# Ejecutar el análisis con el contexto MCP
with mcp_client:
result = await agent.invoke_async(prompt)

print("n📈 Resultados del análisis:")
print("=" * 50)
print(result.content)

print("n✅ ¡Análisis completado!")

    except Exception as e:
        logger.error(f"Error: {e}")
        print(f"n❌ Error: {e}")

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

¡Misión cumplida! Tu agente está listo para realizar análisis competitivos autónomos.

Paso n.º 9: Ponlo todo junto

Aquí está el código completo en agent.py:

import asyncio
import os
import logging
from dotenv import load_dotenv

from strands import Agent
from strands.models.anthropic import AnthropicModel
from strands.tools.mcp.mcp_client import MCPClient
from mcp.client.stdio import stdio_client, StdioServerParameters

# Cargar variables de entorno
load_dotenv()
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Leer claves API
ANTHROPIC_API_KEY = os.getenv("ANTHROPIC_API_KEY")
BRIGHT_DATA_API_KEY = os.getenv("BRIGHT_DATA_API_KEY")

# Inicializar el modelo Anthropic
model = AnthropicModel(
    model_id="claude-3-opus-20240229",
    max_tokens=4096,
    params={"temperature": 0.3}
)

# Establecer clave API
os.environ["ANTHROPIC_API_KEY"] = ANTHROPIC_API_KEY

async def connect_mcp_tools():
    """Conectarse al servidor MCP de Bright Data y descubrir herramientas"""

    logger.info("Conectando con Bright Data MCP...")

    # Configurar la conexión con MCP alojado en Bright Data
    server_params = StdioServerParameters(
        command="npx",
        args=["-y", "@brightdata/mcp"],
        env={"API_TOKEN": BRIGHT_DATA_API_KEY, "PRO_MODE": "true"}
    )

    # Crear cliente MCP
    mcp_client = MCPClient(lambda: stdio_client(server_params))

    # Descubrir herramientas disponibles
    with mcp_client:
        tools = mcp_client.list_tools_sync()
        logger.info(f"📦 Descubiertas {len(tools)} herramientas MCP")

        for tool in tools:
            logger.info(f"  - {tool.tool_name}")

    return mcp_client, tools

def create_agent(model, tools):
    """Crear un agente de inteligencia competitiva con acceso a datos web"""

    system_prompt = """Eres un analista experto en inteligencia competitiva con acceso a potentes herramientas de datos web a través de MCP.

## Tu misión
Realizar un análisis exhaustivo del mercado y de la competencia utilizando datos web en tiempo real.

## Herramientas MCP disponibles
Tienes acceso a estas herramientas MCP de Bright Data:
- search_engine: extrae resultados de búsqueda de Google, Bing o Yandex
- scrape_as_markdown: extrae contenido de cualquier página web con omisión de CAPTCHA
- search_engine_batch: realiza múltiples búsquedas simultáneamente
- scrape_batch: extrae múltiples páginas web en paralelo

## Flujo de trabajo de análisis autónomo
Cuando se le asigne una tarea de análisis, de forma autónoma:
1. Decida qué herramientas utilizar en función del objetivo
2. Recopile datos exhaustivos de múltiples fuentes
3. Sintetiza los resultados en información útil.
4. Proporciona recomendaciones estratégicas específicas.

Sé proactivo en la selección de herramientas: tienes total autonomía para utilizar cualquier combinación de herramientas.

    return Agent(
        model=model,
        tools=tools,
        system_prompt=system_prompt
    )

async def main():
    """Ejecuta el agente de inteligencia competitiva"""

    print("🚀 AWS Strands + Bright Data MCP Competitive Intelligence Agent")
    print("=" * 70)

    try:
        # Conectarse a las herramientas MCP
        mcp_client, tools = await connect_mcp_tools()

        # Crear el agente
        agent = create_agent(model, tools)

        print("n✅ ¡Agente listo con acceso a datos web!")
        print("n📊 Iniciando análisis...")
        print("-" * 40)

        # Ejemplo: Analizar la posición competitiva de Tesla
        prompt = """
        Analizar la posición competitiva de Tesla en el mercado de los vehículos eléctricos.

        Investiga:
        - La gama actual de productos y la estrategia de precios.
        - Los principales competidores y sus ofertas.
        - Los anuncios estratégicos recientes.
        - La cuota de mercado y el posicionamiento.

        Utiliza herramientas de scraping web para recopilar datos en tiempo real de tesla.com y los resultados de búsqueda.
        """

# Ejecutar el análisis con el contexto MCP
with mcp_client:
result = await agent.invoke_async(prompt)

print("n📈 Resultados del análisis:")
print("=" * 50)
print(result)

print("n✅ ¡Análisis completado!")

    except Exception as e:
        logger.error(f"Error: {e}")
        print(f"n❌ Error: {e}")

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

Ejecuta el agente IA con:

python agent.py

The agent demo including the output in the terminal.png

En la terminal, debería ver el siguiente resultado:

Establecimiento de la conexión MCP
Descubrimiento de herramientas Bright Data disponibles
El agente seleccionando de forma autónoma las herramientas que se van a utilizar
Recopilación de datos en tiempo real de Tesla.com y resultados de búsqueda
Un análisis competitivo completo con datos actuales

El agente decide de forma autónoma:

Utilizar search_engine para encontrar información sobre Tesla y sus competidores
Utilizar scrape_as_markdown para extraer datos de tesla.com
Combinar múltiples fuentes de datos para realizar un análisis exhaustivo

¡Et voilà! Ha creado con éxito un agente de Inteligencia competitiva autónomo que puede acceder y analizar datos web en tiempo real.

Próximos pasos

El agente IA creado aquí es funcional, pero solo sirve como punto de partida. Considere llevarlo al siguiente nivel mediante:

Crear un bucle de conversación: añada una interfaz REPL para chatear con el agente de forma interactiva
Crear agentes especializados: cree agentes para el Monitoreo de precios, el Estudio de mercado o la generación de clientes potenciales.
Implementar flujos de trabajo con múltiples agentes: coordine varios agentes especializados para tareas complejas.
Añada memoria y estado: utilice la gestión de estado de AWS Strands para conversaciones sensibles al contexto.
Implementación en producción: aproveche la infraestructura de AWS para la implementación escalable de agentes.
Ampliación con herramientas personalizadas: cree sus propias herramientas MCP para fuentes de datos especializadas
Añadir observabilidad: implemente el registro y la supervisión para las implementaciones en producción.

Casos de uso en el mundo real

La combinación de AWS Strands y Bright Data permite disponer de agentes de IA más avanzados en diversas aplicaciones empresariales:

Agente de inteligencia competitiva: supervise los precios de la competencia, las características de los productos y las campañas de marketing en tiempo real
Agente de estudio de mercado: analice las tendencias del sector, la opinión de los consumidores y las oportunidades emergentes
Agente de optimización del comercio electrónico: realizar un seguimiento de los catálogos y los precios de la competencia para desarrollar estrategias de precios dinámicas.
Agente de generación de clientes potenciales: identifica y califica a los clientes potenciales a partir de fuentes web.
Agente de supervisión de marca: realiza un seguimiento de las menciones, reseñas y reputación de la marca en la web.
Agente de investigación de inversiones: recopilar datos financieros, noticias y señales del mercado para tomar decisiones de inversión.

Conclusión

En este artículo, ha aprendido a integrar AWS Strands SDK con el servidor Web MCP de Bright Data para crear agentes de IA autónomos capaces de acceder y analizar datos web en tiempo real. Esta potente combinación le permite crear agentes que pueden pensar estratégicamente mientras se mantienen informados con información en tiempo real.

Las principales ventajas de este enfoque son:

Código mínimo: cree agentes sofisticados con solo unas 100 líneas de Python.
Toma de decisiones autónoma: los agentes deciden qué herramientas utilizar en función de sus objetivos.
Listo para la producción: gestión de errores y escalabilidad integradas en ambas plataformas
Acceso a datos en tiempo real: supere las limitaciones de LLM con datos web en tiempo real.

Para crear agentes más sofisticados, explore toda la gama de servicios disponibles en la infraestructura de IA de Bright Data. Estas soluciones pueden impulsar una amplia variedad de escenarios de agentes.

¡Cree una cuenta Bright Data gratuita y comience a experimentar hoy mismo con las herramientas de datos web basadas en IA!

Contactar Ventas Prueba gratuita

Agentes de IA que utilizan AWS Strands SDK y Web MCP de Bright Data