Conectando el Agente de IA a Datos Web en Vivo: Guía de Integración del Servidor MCP Scrapeless + AWS Strands

Puntos Clave:

• AWS Strands SDK + Scrapeless MCP proporciona a los agentes de IA una superficie de herramienta de datos web tipada. El agente llama a google_search, scrape_html, scrape_markdown, y herramientas de sesión de navegador completas (browser_create → browser_goto → browser_wait_for → browser_get_html → browser_close) directamente a través del bucle agente, sin código adicional alrededor de una API REST.
• 21 herramientas MCP en el punto final alojado (https://api.scrapeless.com/mcp). Control de sesión de navegador (16 herramientas), búsqueda (google_search, google_trends), y scraping sin estado (scrape_html, scrape_markdown, scrape_screenshot) — expuestas por scrapeless-mcp-server en HTTP transmitible. El punto final alojado informa serverInfo.name: "scrapeless-mcp-server", versión 0.2.0 al momento de la publicación.
• Navegador en la nube con salida de proxy residencial. Las páginas se renderizan en el Navegador de Scraping de Scrapeless antes de que el agente lea el DOM, por lo que los objetivos pesados en JavaScript funcionan sin infraestructura de navegador local. La tasa de éxito varía según el sitio: las páginas de desafío más simples se despejan después de un corto browser_wait, mientras que los sitios con capas de detección de bots más estrictas aún pueden bloquear la sesión MCP por defecto; para esos objetivos, retroceda a la superficie SDK con un perfil de navegador preconfigurado.
• Bucle de agente agnóstico al modelo. El ciclo de percepción → razonamiento → acción de Strands permite que Claude (o cualquier modelo compatible) decida las llamadas a las herramientas de forma autónoma. Esta guía utiliza Anthropic Claude a través del proveedor Anthropic de Strands.
• Gratis para comenzar. Nuevas cuentas de Scrapeless incluyen tiempo de ejecución gratuito del Navegador de Scraping — inscríbete en el sitio web de Scrapeless y consulta la página de precios cuando lo superes.

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

En esta guía, aprenderás:

• Qué es AWS Strands SDK y qué lo convierte en un marco útil para construir agentes de IA.
• Por qué AWS Strands SDK se empareja limpiamente con el servidor MCP de Scrapeless para agentes conscientes de la web.
• Cómo integrar AWS Strands con el servidor MCP de Scrapeless para crear un agente autónomo de inteligencia competitiva.
• Cómo construir agentes que decidan de forma autónoma qué herramientas de scraping usar en función de sus objetivos.

Empecemos.

Lo Que Puedes Hacer Con Él

• Bucles de inteligencia competitiva. Busca google_search por el nombre de un competidor y luego llama a scrape_markdown en los mejores resultados para resumir la posicionamiento y lanzamientos recientes.
• Enriquecimiento de una sola página. Ejecuta browser_create → browser_goto → browser_wait_for → browser_get_html → browser_close contra un ASIN o página de producto y deja que el modelo extraiga título, precio, calificación y disponibilidad en una forma JSON que defines en el aviso.
• Verificaciones de precios en múltiples regiones. Ejecuta dos sesiones browser_create contra el mismo SKU en diferentes escaparates de países y compara precios en una respuesta.
• Investigación impulsada por motores de búsqueda. Combina google_search + google_trends para lecturas de momento sobre un tema y luego profundiza en artículos individuales con scrape_markdown.
• Captura de pantalla para cumplimiento. Utiliza scrape_screenshot (URL dentro, PNG fuera) o el browser_screenshot en sesión después de una interacción de UI para mantener evidencia de cómo se veía una página en un momento dado.
• Flujos de UI de múltiples pasos. browser_click, browser_type, browser_press_key, y browser_scroll permiten que el agente impulse formularios, puertas de inicio de sesión y cuadrículas cargadas perezosamente dentro de una sesión persistente.

En Scrapeless, solo accedemos a datos disponibles públicamente mientras cumplimos estrictamente con las leyes, regulaciones y políticas de privacidad de los sitios web aplicables. El contenido de esta publicación es solo para fines de demostración.

¿Qué Es AWS Strands SDK?

AWS Strands SDK es un marco de Python para construir agentes de IA, publicado en PyPI por AWS (strands-agents, autor opensource@amazon.com). Expone una clase Agent que toma un modelo y una lista de herramientas y ejecuta un bucle de percepción → razonamiento → acción hasta que la tarea se complete.

Esta guía utiliza tres piezas del SDK que están verificadas para existir en el paquete publicado:

• from strands import Agent — la clase de agente en sí.
• from strands.models.anthropic import AnthropicModel — proveedor Anthropic; la firma del constructor es AnthropicModel(*, client_args: dict | None = None, **model_config) y acepta model_id, max_tokens, params={"temperature": ...}.
• from strands.tools.mcp import MCPClient — envuelve un transporte MCP para que las herramientas de cualquier servidor MCP puedan pasarse a Agent(tools=...).
  El tipo de resultado del agente es strands.agent.agent_result.AgentResult, una dataclass con campos stop_reason, message, metrics, state (más opcionales interrupts, structured_output).

Cómo se ejecuta el bucle

1. El usuario pasa un prompt a agent.invoke_async(prompt).
2. El modelo recibe el prompt más la lista de herramientas disponibles.
3. Devuelve un mensaje final o emite una llamada a una herramienta.
4. Si se llama a una herramienta, Strands la ejecuta y envía el resultado de vuelta al modelo.
5. Los pasos 3–4 se repiten hasta que el modelo devuelva un mensaje final.

Por qué combinar el SDK de AWS Strands con el servidor MCP de Scrapeless para la recuperación de datos web

Los LLM no obtienen datos web en vivo por sí mismos. Para darle a un agente Strands esa capacidad, lo conectas a un servidor MCP que expone herramientas web. El scrapeless-mcp-server es uno de esos servidores MCP, respaldado por el navegador de scraping Scrapeless, un navegador hospedado en la nube que egresa a través de proxies residenciales.

Verificado en vivo (tools/list contra https://api.scrapeless.com/mcp, hoy): 21 herramientas, en tres grupos:

• Scraping sin estado — scrape_html, scrape_markdown, scrape_screenshot.
• Búsqueda — google_search, google_trends.
• Una sesión del navegador persistente — browser_create, browser_goto, browser_go_back, browser_go_forward, browser_wait, browser_wait_for, browser_get_html, browser_get_text, browser_snapshot, browser_click, browser_type, browser_press_key, browser_scroll, browser_scroll_to, browser_screenshot, browser_close.

Obtén tu clave API del plan gratuito de Scrapeless en sitio web de scrapeless. El código fuente del servidor MCP está en github.com/scrapeless-ai/scrapeless-mcp-server.

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

En esta sección, utilizarás el SDK de AWS Strands para construir un agente de IA equipado con capacidades de scraping y recuperación de datos en vivo desde el servidor MCP de Scrapeless.

Como ejemplo, esta guía construye un agente de inteligencia competitiva que puede analizar mercados y competidores de manera autónoma. El agente decide qué herramientas usar en función de sus objetivos, demostrando el poder del bucle agente.

Sigue la guía paso a paso a continuación para construir tu agente de IA potenciado por Claude + Scrapeless MCP usando el SDK de AWS Strands.

Prerrequisitos

Para replicar el ejemplo de código, asegúrate de tener:

Requisitos de software:

• Python 3.10 o superior.
• Node.js (versión LTS más reciente recomendada).
• Un IDE de Python como VS Code con la extensión de Python o PyCharm.

Requisitos de cuenta:

• Una cuenta de Scrapeless y clave API — regístrate en scrapeless.
• Una cuenta de Anthropic con acceso a la API de Claude y créditos.

Conocimientos de fondo (útiles pero no requeridos):

• Comprensión básica de cómo funciona MCP.
• Familiaridad con los agentes de IA y sus capacidades.
• Conocimiento básico de programación asíncrona en Python.

Paso #1: Crea tu proyecto en Python

Abre tu terminal y crea una nueva carpeta para tu proyecto:

mkdir strands-scrapeless-agent
cd strands-scrapeless-agent

Configura un entorno virtual de Python:

python -m venv venv

Activa el entorno virtual:

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

# En Windows:
venv\Scripts\activate

Crea el archivo principal de Python:

touch agent.py

La estructura de tu carpeta debería verse así:

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

Ahora tienes un entorno de Python listo para construir un agente de IA con acceso a datos web.

Paso #2: Instala el SDK de AWS Strands

En tu entorno virtual activado, instala los paquetes requeridos:

pip install "strands-agents>=1.0" anthropic "mcp>=1.0" python-dotenv

Esto instala:

• strands-agents: el SDK de AWS Strands para construir agentes de IA.
• anthropic: dependencia requerida para strands.models.anthropic.AnthropicModel.
• mcp: el SDK oficial de MCP para Python, necesario para el transporte mcp.client.streamable_http.
• python-dotenv: para la gestión de variables de entorno.

A continuación, agrega estas importaciones a tu archivo agent.py:

from strands import Agent
from strands.models.anthropic import AnthropicModel
from strands.tools.mcp import MCPClient
from mcp.client.streamable_http import streamablehttp_client

Ahora puedes usar el SDK de AWS Strands para construir agentes.

Paso #3: Configura las variables de entorno

Crea un archivo .env en tu carpeta de proyecto para la gestión segura de claves API:

touch .env

Agrega tus claves API al archivo .env:

# API de Anthropic para modelos Claude
ANTHROPIC_API_KEY=tu_clave_anthropic_aqui

# Credenciales de Scrapeless para web scraping a través de MCP
SCRAPELESS_KEY=tu_clave_scrapeless_aqui

En tu agent.py, configura la carga de variables de entorno:

import os

from dotenv import load_dotenv

load_dotenv()

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

Ahora estás configurado para cargar de manera segura las claves API desde el archivo .env.

Paso #4: Verificar el Endpoint MCP de Scrapeless

Esta guía utiliza el endpoint HTTP transmitible alojado en https://api.scrapeless.com/mcp. No se requiere instalación local.

Prueba de conexión al endpoint alojado con curl:

curl -X POST "https://api.scrapeless.com/mcp" \
  -H "x-api-token: $SCRAPELESS_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"smoke","version":"1.0"}}}'

Una respuesta exitosa devuelve:

• HTTP 200 OK con Content-Type: text/event-stream
• Un encabezado mcp-session-id — reutilízalo en solicitudes posteriores de tools/list y tools/call
• Un evento en el cuerpo data: {"result":{"protocolVersion":"2024-11-05","capabilities":{"tools":{"listChanged":true}},"serverInfo":{"name":"scrapeless-mcp-server","version":"0.2.0",...}},...}

Probado contra el endpoint en vivo al momento de la publicación: devuelve 21 herramientas MCP y el serverInfo mostrado arriba.

Obtén tu clave API en el plan gratuito: app.scrapeless.com

Referencia completa del SDK y CLI: sitio web de scrapeless.

Paso #5: Inicializar el Modelo Strands

Configura el modelo Claude de Anthropic en tu agent.py:

# Inicializar modelo de Anthropic (Claude a través del proveedor Strands de Anthropic)
model = AnthropicModel(
    client_args={"api_key": ANTHROPIC_API_KEY},
    model_id="claude-sonnet-4-6",
    max_tokens=4096,
    params={"temperature": 0.3}
)

Esto configura a Claude como el LLM de tu agente con parámetros ajustados para respuestas consistentes y enfocadas. El diccionario client_args es la forma oficial de Strands de pasar la configuración del cliente de Anthropic (ver la documentación del proveedor de Anthropic de AWS Strands).

Paso #6: Conectar al Servidor MCP de Scrapeless

Crea la configuración del cliente MCP para conectarte al endpoint HTTP transmitible alojado:

import asyncio
import logging

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

def http_transport():
    """Transporte HTTP transmisible al endpoint Scranless MCP alojado."""
    return streamablehttp_client(
        url="https://api.scrapeless.com/mcp",
        headers={"x-api-token": SCRAPELESS_KEY},
    )

async def connect_mcp_tools():
    """Conectar al servidor MCP de Scrapeless y descubrir herramientas."""

    logger.info("Conectando al servidor MCP de Scrapeless (HTTP)...")
    mcp_client = MCPClient(http_transport)

    with mcp_client:
        tools = mcp_client.list_tools_sync()
        logger.info(f"Herramientas MCP descubiertas: {len(tools)}")
        for tool in tools:
            logger.info(f"  - {tool.tool_name}")

    return mcp_client, tools

Probado contra el endpoint en vivo: la secuencia de llamadas anteriores registra Herramientas MCP descubiertas: 21 seguido de todos los nombres de las 21 herramientas listadas en la tabla a continuación.

Herramientas MCP de Scrapeless disponibles

La lista a continuación resume las herramientas que el servidor MCP de Scrapeless expone en el transporte HTTP transmisible. list_tools_sync() devuelve el mismo conjunto en tiempo de ejecución.

Paso #7: Definir el Agente de Inteligencia Competitiva

Crea un agente con un aviso especializado para inteligencia competitiva:

def create_agent(model, tools):

"""Crea un agente de inteligencia competitiva con acceso a datos web"""

async def conectar_herramientas_mcp():
    """Conectar al servidor MCP de Scrapeless y descubrir herramientas."""

    logger.info("Conectando al servidor MCP de Scrapeless (HTTP)...")
    cliente_mcp = MCPClient(transport_http)

    with cliente_mcp:
        herramientas = cliente_mcp.listar_herramientas_sync()
        logger.info(f"Se descubrieron {len(herramientas)} herramientas MCP")
        for herramienta in herramientas:
            logger.info(f"  - {herramienta.nombre_herramienta}")

    return cliente_mcp, herramientas


def crear_agente(modelo, herramientas):
    """Crear un agente de inteligencia competitiva con acceso a datos web"""

    aviso_sistema = """Eres un analista experto en inteligencia competitiva con acceso a herramientas de datos web a través del servidor MCP de Scrapeless.

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

## Herramientas MCP disponibles (Scrapeless)
- google_search, google_trends
- scrape_html, scrape_markdown, scrape_screenshot
- browser_create, browser_close
- browser_goto, browser_go_back, browser_go_forward
- browser_wait_for, browser_wait
- browser_get_html, browser_get_text, browser_snapshot
- browser_click, browser_type, browser_press_key
- browser_scroll, browser_scroll_to
- browser_screenshot

## Flujo de trabajo de análisis autónomo
Cuando se te asigne una tarea de análisis, de manera autónoma:
1. Decide qué herramientas usar en función del objetivo.
2. Reúne datos completos de múltiples fuentes.
3. Sintetiza los hallazgos en ideas procesables.
4. Proporciona recomendaciones estratégicas específicas.

Sé proactivo en la selección de herramientas. Tienes plena autonomía para usar cualquier combinación de herramientas."""

    return Agente(
        modelo=modelo,
        herramientas=herramientas,
        aviso_sistema=aviso_sistema
    )


async def principal():
    """Ejecutar el agente de inteligencia competitiva"""

    print("AWS Strands + Agente de Inteligencia Competitiva Scrapeless MCP")
    print("=" * 70)

    try:
        cliente_mcp, herramientas = await conectar_herramientas_mcp()
        agente = crear_agente(modelo, herramientas)

        print("\nAgente listo con acceso a datos web.")
        print("\nIniciando análisis...")
        print("-" * 40)

        aviso = """
        Analizar la posición competitiva de Tesla en el mercado de vehículos eléctricos.

        Investigación:
        - Línea de productos actual y estrategia de precios.
        - Principales competidores y sus ofertas.
        - Anuncios estratégicos recientes.
        - Cuota de mercado y posicionamiento.

        Utiliza las herramientas de Scrapeless para reunir datos en tiempo real de tesla.com y resultados de búsqueda.
        """

        with cliente_mcp:
            resultado = await agente.invocar_async(aviso)

        print("\nResultados del análisis:")
        print("=" * 50)
        print(resultado)

        print("\nAnálisis completo.")

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


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

Como se indicó en el Paso #8, invocar_async devuelve un ResultadoAgente cuyos atributos son mensaje, razón_detener, métricas y estado. Usa print(resultado.mensaje) si solo deseas el texto del asistente en lugar de la cadena envolvente.

Ejecuta el agente de IA con:

python agente.py

El script se conectará al servidor MCP de Scrapeless, ejecutará listar_herramientas_sync() (devuelve 21 herramientas, verificadas en vivo contra el punto final alojado en el momento de escribir), instanciará el agente y llamará a agente.invocar_async(aviso). El modelo decide qué herramientas llamar. Lo que el agente realmente hace en una ejecución dada depende de lo que el modelo elija; Strands no restringe la secuencia de herramientas.

Conclusión

Esta guía conectó el SDK de AWS Strands al servidor MCP de Scrapeless: ~100 líneas de Python, 21 herramientas MCP verificadas disponibles para el modelo y un camino de datos verificado a través del Navegador de Scraping de Scrapeless con salida de proxy residencial.

Obtén una clave API en app.scrapeless.com.

¿Listo para construir tu Pipeline de Datos potenciado por IA?

Únete a nuestra comunidad para reclamar un plan gratuito y conectar con desarrolladores que construyen agentes de AWS Strands + Scrapeless MCP: Discord · Telegram.

Regístrate en app.scrapeless.com para obtener un tiempo de ejecución gratuito en el Navegador de Scraping y adapta la integración de AWS Strands anterior a los flujos de trabajo que necesita tu equipo. Referencia completa en docs.scrapeless.com. Para un trasfondo más profundo sobre el tiempo de ejecución del Navegador de Scraping que alimenta estas herramientas, consulta la página del producto del Navegador de Scraping de Scrapeless y nuestra guía hermana sobre integración de Scrapeless con agentes de LangChain.

FAQ

Q1: ¿Qué es MCP y por qué es importante para los agentes de IA?

MCP (Protocolo de Contexto del Modelo) es un estándar abierto para conectar agentes de IA a herramientas y fuentes de datos. Un servidor MCP expone una lista tipada de herramientas que cualquier cliente consciente de MCP —incluido el SDK AWS Strands— puede llamar. Con Scrapeless MCP, el agente obtiene acceso tipado a un navegador en la nube real, consultas de motores de búsqueda, y raspadores de Markdown/HTML sin necesidad de escribir código de enlace por API. El agente decide qué herramientas llamar dentro del bucle agente; MCP transporta los esquemas y resultados tipados.

**P2: ¿Qué me proporciona el endpoint MCP alojado?**

`https://api.scrapeless.com/mcp` (con el encabezado `x-api-token`) devuelve la superficie completa de 21 herramientas y fue verificado de extremo a extremo con el `MCPClient` de Strands en esta guía. No se necesita un entorno de ejecución local de Node ni un proceso en segundo plano — `streamablehttp_client(...)` es una importación y una URL.

**P3: ¿Cómo maneja el bucle agente un fallo de herramienta o un desafío anti-bot?**

Strands alimenta el resultado de la herramienta —incluidos los errores— de vuelta al modelo, que decide si volver a intentar, cambiar de herramienta, o mostrar el fallo. Para Scrapeless específicamente, la recuperación común es `browser_close` + un nuevo `browser_create`, o retroceder de una sesión de navegador completa a `scrape_markdown` / `scrape_html`. La región del proxy por llamada no es un parámetro que la herramienta `browser_create` de MCP exponga — `scrapeless-mcp-server/src/session-manager.ts` solo reenvía `session_ttl`, `profile_id` y `profile_persist`. Para fijar una región específica, crea un perfil de Scrapeless en el panel de control con el país integrado y referencia a través de la variable de entorno `BROWSER_PROFILE_ID` en el servidor MCP.

**P4: ¿Puede esto funcionar sin un agente de IA?**

Sí. Cada herramienta de Scrapeless MCP es invocable desde un script de Python simple o a través de un `curl` contra el endpoint HTTP transmitible (el `curl` del Paso #4 devuelve `serverInfo.name: "scrapeless-mcp-server"` y un encabezado `mcp-session-id` que reutilizas en solicitudes de `tools/list` y `tools/call`). El SDK AWS Strands añade el bucle agente encima.

**P5: ¿Qué otros modelos funcionan además de Claude Sonnet?**

El `AnthropicModel` de Strands acepta cualquier ID de modelo que exponga la API de Anthropic — `claude-haiku-*` para bucles de extracción y resumen más baratos, `claude-opus-*` para razonamientos multistep más pesados. Strands también incluye `OpenAIModel`, `BedrockModel`, `GeminiModel`, y proveedores para Mistral, Ollama, LiteLLM, llamacpp y SageMaker. Cambia la línea del modelo; el resto de `agent.py` se mantiene igual.

Cualquier endpoint compatible con la API de OpenAI también funciona a través de `OpenAIModel` con una anulación de `base_url`. Verificado de extremo a extremo para esta guía contra OpenRouter:

```python
from strands.models.openai import OpenAIModel
model = OpenAIModel(
    client_args={
        "api_key": OPENROUTER_API_KEY,
        "base_url": "https://openrouter.ai/api/v1",
    },
    model_id="openai/gpt-4o-mini",  # o anthropic/claude-3.5-sonnet, google/gemini-flash-1.5, etc.
    params={"temperature": 0.3},
)

Con ese cambio, el mismo Agent(model=..., tools=tools, system_prompt=...) se ejecuta contra el catálogo de OpenRouter. Probado para esta guía con openai/gpt-4o-mini: el agente llamó autónomamente a google_search tres veces y scrape_markdown una vez, devolviendo una respuesta limpia con stop_reason: end_turn, a aproximadamente $0.001 por ejecución.

P6: ¿Cómo manejo errores transitorios como ERR_TUNNEL_CONNECTION_FAILED o 503?

Ambos provienen del grupo de salida de Scrapeless y son generalmente transitorios. El bucle de Strands ya alimenta el error de vuelta al modelo, que volverá a intentar en el siguiente turno. Para una recuperación determinista en el aviso, instruye al agente: "Si una herramienta de navegador devuelve un error de túnel o 503, llama a browser_close y comienza un nuevo browser_create antes de volver a intentar." Esa formulación produce un reintento más limpio que depender de que el modelo decida.

P7: ¿Pueden múltiples agentes compartir la conexión MCP?

El MCPClient abre una sesión por cada contexto with mcp_client:. Para agentes paralelos, dale a cada uno su propia instancia de MCPClient (y por lo tanto su propio ID de sesión en el endpoint alojado) en lugar de reutilizar uno. El endpoint alojado se escala con sesiones concurrentes; el límite de concurrencia por cuenta se encuentra en la tarifa de precios de Scrapeless.

P8: ¿Dónde puedo integrar mis propias herramientas no-Scrapeless junto a esto?

Agent(tools=...) acepta una lista. Pasa tools + my_extra_tools donde my_extra_tools es cualquier herramienta compatible con Strands (funciones decoradas con @tool o herramientas de otro servidor MCP). El modelo ve la unión de los esquemas y decide cuál llamar.