Conectando Agente de IA a Dados da Web ao Vivo: Guia de Integração do AWS Strands + Servidor MCP Scrapeless

Principais Conclusões:

• AWS Strands SDK + Scrapeless MCP oferece a agentes de IA uma superfície de ferramenta de dados da web tipada. O agente chama google_search, scrape_html, scrape_markdown e ferramentas de sessão de navegador completas (browser_create → browser_goto → browser_wait_for → browser_get_html → browser_close) diretamente através do loop agente, sem código de colagem em torno de uma API REST.
• 21 ferramentas MCP no endpoint hospedado (https://api.scrapeless.com/mcp). Controle da sessão do navegador (16 ferramentas), busca (google_search, google_trends) e scraping sem estado (scrape_html, scrape_markdown, scrape_screenshot) — expostas pelo scrapeless-mcp-server em HTTP transmitível. O endpoint hospedado relata serverInfo.name: "scrapeless-mcp-server", versão 0.2.0 no momento da publicação.
• Navegador em nuvem com saída de proxy residencial. As páginas são renderizadas no Navegador de Scraping Scrapeless antes que o agente leia o DOM, então alvos com JavaScript intenso funcionam sem infraestrutura de navegador local. A taxa de aprovação varia por site: páginas de desafios mais simples são liberadas após um curto browser_wait, enquanto sites com camadas de detecção de bot mais rigorosas ainda podem bloquear a sessão padrão do MCP — para esses alvos, volte à superfície do SDK com um perfil de navegador pré-configurado.
• Loop de agente agnóstico em modelo. O ciclo de percepção → raciocínio → ação do Strands permite que Claude (ou qualquer modelo suportado) decida chamadas de ferramentas de forma autônoma. Este guia usa Claude da Anthropic através do provedor Anthropic do Strands.
• Grátis para começar. Novas contas do Scrapeless incluem tempo de execução gratuito do Navegador de Scraping — inscreva-se no site do scrapeless e veja a página de preços quando você superar isso.

Agentes de IA alimentados por grandes modelos de linguagem (LLMs) podem raciocinar e tomar decisões, mas são limitados pelos dados de treinamento. Para construir agentes verdadeiramente úteis, você os conecta a dados da web em tempo real. Este guia mostra como combinar AWS Strands SDK com o servidor MCP do Scrapeless para criar agentes de IA autônomos que podem acessar e analisar dados da web ao vivo.

Neste guia, você aprenderá:

• O que é o AWS Strands SDK e o que o torna uma estrutura útil para construir agentes de IA.
• Por que o AWS Strands SDK se combina bem com o servidor MCP do Scrapeless para agentes conscientes da web.
• Como integrar o AWS Strands com o servidor MCP do Scrapeless para criar um agente autônomo de inteligência competitiva.
• Como construir agentes que decidem autonomamente quais ferramentas de scraping web usar com base em seus objetivos.

Vamos começar.

O Que Você Pode Fazer Com Isso

• Ciclos de inteligência competitiva. Varra google_search por um nome de concorrente e, em seguida, chame scrape_markdown nos principais resultados para resumir a posição e lançamentos recentes.
• Enriquecimento de página única. Execute browser_create → browser_goto → browser_wait_for → browser_get_html → browser_close contra um ASIN ou página de produto e deixe o modelo puxar título, preço, avaliação e disponibilidade em um formato JSON que você define no prompt.
• Verificações de preços em várias regiões. Execute duas sessões browser_create contra o mesmo SKU em diferentes lojas de países e compare preços em uma resposta.
• Pesquisa dirigida por motor de busca. Combine google_search + google_trends para leituras de momentum sobre um tópico, depois aprofunde em artigos individuais com scrape_markdown.
• Captura de tela para conformidade. Use scrape_screenshot (URL-in, PNG-out) ou o browser_screenshot em sessão após uma interação de UI para manter evidências de como uma página parecia em um determinado momento.
• Fluxos de UI de várias etapas. browser_click, browser_type, browser_press_key e browser_scroll permitem que o agente conduza formulários, portas de login e grades carregadas de forma preguiçosa dentro de uma sessão persistente.

No Scrapeless, acessamos apenas dados disponíveis publicamente, enquanto cumprimos rigorosamente as leis, regulamentos e políticas de privacidade dos sites aplicáveis. O conteúdo deste post é apenas para fins de demonstração.

O Que É AWS Strands SDK?

AWS Strands SDK é uma estrutura Python para construir agentes de IA, publicada no PyPI pela AWS (strands-agents, autor opensource@amazon.com). Ela expõe uma classe Agent que recebe um modelo e uma lista de ferramentas e executa um loop de percepção → raciocínio → ação até que a tarefa seja concluída.

Este guia usa três partes do SDK que estão verificadas para existir no pacote publicado:

• from strands import Agent — a classe do agente em si.
• from strands.models.anthropic import AnthropicModel — provedor Anthropic; a assinatura do construtor é AnthropicModel(*, client_args: dict | None = None, **model_config) e aceita model_id, max_tokens, params={"temperature": ...}.
• from strands.tools.mcp import MCPClient — envolve um transporte MCP para que as ferramentas de qualquer servidor MCP possam ser passadas para Agent(tools=...).
  O tipo de resultado do agente é strands.agent.agent_result.AgentResult, uma dataclass com campos stop_reason, message, metrics, state (mais opcionais interrupts, structured_output).

Como o loop funciona

1. O usuário passa um prompt para agent.invoke_async(prompt).
2. O modelo recebe o prompt mais a lista de ferramentas disponíveis.
3. Ele retorna uma mensagem final ou emite uma chamada de ferramenta.
4. Se uma ferramenta é chamada, Strands a executa e alimenta o resultado de volta ao modelo.
5. As etapas 3–4 se repetem até que o modelo retorne uma mensagem final.

Por que combinar o AWS Strands SDK com o servidor MCP da Scrapeless para recuperação de dados da web

Os LLMs não buscam dados da web ao vivo por conta própria. Para dar a um agente Strands essa capacidade, você o conecta a um servidor MCP que expõe ferramentas da web. O scrapeless-mcp-server é um desses servidores MCP — respaldado pelo Scrapeless Scraping Browser, um navegador hospedado na nuvem que utiliza proxies residenciais.

Verificado ao vivo (tools/list contra https://api.scrapeless.com/mcp, hoje): 21 ferramentas, em três grupos:

• Raspagem sem estado — scrape_html, scrape_markdown, scrape_screenshot.
• Pesquisa — google_search, google_trends.
• Uma sessão de 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.

Obtenha sua chave de API do plano gratuito da Scrapeless em site da scrapeless. O código-fonte do servidor MCP está em github.com/scrapeless-ai/scrapeless-mcp-server.

Como integrar o AWS Strands SDK com o servidor MCP da Scrapeless em Python

Nesta seção, você usará o AWS Strands SDK para construir um agente de IA equipado com capacidades de raspagem e recuperação de dados ao vivo do servidor MCP da Scrapeless.

Como exemplo, este guia constrói um agente de inteligência competitiva que pode analisar mercados e concorrentes de forma autônoma. O agente decide quais ferramentas usar com base em seus objetivos, demonstrando o poder do loop agentic.

Siga o guia passo a passo abaixo para construir seu agente de IA alimentado pelo Claude + Scrapeless MCP usando o AWS Strands SDK.

Pré-requisitos

Para replicar o exemplo de código, certifique-se de ter:

Requisitos de software:

• Python 3.10 ou superior.
• Node.js (versão LTS mais recente recomendada).
• Um IDE Python como VS Code com a extensão Python ou PyCharm.

Requisitos de conta:

• Uma conta Scrapeless e chave de API — cadastre-se em scrapeless.
• Uma conta Anthropic com acesso à API Claude e créditos.

Conhecimento básico (útil, mas não obrigatório):

• Compreensão básica de como o MCP funciona.
• Familiaridade com agentes de IA e suas capacidades.
• Conhecimento básico de programação assíncrona em Python.

Etapa #1: Crie seu projeto Python

Abra seu terminal e crie uma nova pasta para seu projeto:

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

Configure um ambiente virtual Python:

python -m venv venv

Ative o ambiente virtual:

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

# No Windows:
venv\Scripts\activate

Crie o arquivo Python principal:

touch agent.py

Sua estrutura de pasta deve parecer com isso:

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

Agora você tem um ambiente Python pronto para construir um agente de IA com acesso a dados da web.

Etapa #2: Instale o AWS Strands SDK

No seu ambiente virtual ativado, instale os pacotes necessários:

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

Isso instala:

• strands-agents: o AWS Strands SDK para construção de agentes de IA.
• anthropic: dependência necessária para strands.models.anthropic.AnthropicModel.
• mcp: o SDK oficial do MCP Python, necessário para o transporte mcp.client.streamable_http.
• python-dotenv: para gerenciamento de variáveis de ambiente.

Em seguida, adicione essas importações ao seu arquivo 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

Agora você pode usar o AWS Strands SDK para construir seu agente.

Etapa #3: Configure as variáveis de ambiente

Crie um arquivo .env em sua pasta de projeto para gerenciamento seguro de chaves de API:

touch .env

Adicione suas chaves de API ao arquivo .env:

# API do Anthropic para modelos Claude
ANTHROPIC_API_KEY=your_anthropic_key_here

# Credenciais da Scrapeless para raspagem da web via MCP
SCRAPELESS_KEY=your_scrapeless_key_here

Em seu agent.py, configure a carga das variáveis de ambiente:

import os

from dotenv import load_dotenv

load_dotenv()

# Ler chaves da API
ANTHROPIC_API_KEY = os.getenv("ANTHROPIC_API_KEY")
SCRAPELESS_KEY = os.getenv("SCRAPELESS_KEY")

Você agora está configurado para carregar as chaves da API de forma segura a partir do arquivo .env.

Passo #4: Verificar o Endpoint MCP da Scrapeless

Este guia usa o endpoint HTTP hospedado e transmitido em https://api.scrapeless.com/mcp. Nenhuma instalação local é necessária.

Teste o endpoint hospedado com 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"}}}'

Uma resposta bem-sucedida retorna:

• HTTP 200 OK com Content-Type: text/event-stream
• Um cabeçalho mcp-session-id — reutilize-o em solicitações subsequentes tools/list e tools/call
• Um evento de corpo data: {"result":{"protocolVersion":"2024-11-05","capabilities":{"tools":{"listChanged":true}},"serverInfo":{"name":"scrapeless-mcp-server","version":"0.2.0",...}},...}

Testado contra o endpoint ativo na hora da publicação: retorna 21 ferramentas MCP e as informações do serverInfo mostradas acima.

Obtenha sua chave de API no plano gratuito: app.scrapeless.com

Referência completa do SDK e CLI: site da scrapeless.

Passo #5: Inicializar o Modelo Strands

Configure o modelo Anthropic Claude no seu agent.py:

# Inicializar modelo Anthropic (Claude via provedor Anthropic do Strands)
model = AnthropicModel(
    client_args={"api_key": ANTHROPIC_API_KEY},
    model_id="claude-sonnet-4-6",
    max_tokens=4096,
    params={"temperature": 0.3}
)

Isso configura Claude como o LLM do seu agente com parâmetros ajustados para respostas consistentes e focadas. O dicionário client_args é a maneira oficial do Strands de passar a configuração do cliente Anthropic (veja a documentação do provedor Anthropic do AWS Strands).

Passo #6: Conectar ao Servidor MCP da Scrapeless

Crie a configuração do cliente MCP para se conectar ao endpoint HTTP hospedado e transmitido:

import asyncio
import logging

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

def http_transport():
    """Transporte-HTTP transmitido para o endpoint MCP hospedado da Scrapeless."""
    return streamablehttp_client(
        url="https://api.scrapeless.com/mcp",
        headers={"x-api-token": SCRAPELESS_KEY},
    )

async def connect_mcp_tools():
    """Conectar ao servidor MCP da Scrapeless e descobrir ferramentas."""

    logger.info("Conectando ao servidor MCP da Scrapeless (HTTP)...")
    mcp_client = MCPClient(http_transport)

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

    return mcp_client, tools

Testado contra o endpoint ativo: a sequência de chamadas acima registra Descobertas 21 ferramentas MCP seguido por todos os 21 nomes das ferramentas listadas na tabela abaixo.

Ferramentas MCP da Scrapeless disponíveis

A lista abaixo resume as ferramentas que o servidor MCP da Scrapeless expõe no transporte HTTP transmitido. list_tools_sync() retorna o mesmo conjunto em tempo de execução.

Passo #7: Definir o Agente de Inteligência Competitiva

Crie um agente com um prompt especializado para inteligência competitiva:

def create_agent(model, tools):

"""Crie um agente de inteligência competitiva com acesso a dados da web"""

async def conectar_ferramentas_mcp():
    """Conectar ao servidor MCP Scrapeless e descobrir ferramentas."""

    logger.info("Conectando ao servidor MCP Scrapeless (HTTP)...")
    cliente_mcp = MCPClient(http_transport)

    with cliente_mcp:
        ferramentas = cliente_mcp.list_tools_sync()
        logger.info(f"Descobertas {len(ferramentas)} ferramentas MCP")
        for ferramenta in ferramentas:
            logger.info(f"  - {ferramenta.tool_name}")

    return cliente_mcp, ferramentas


def criar_agente(modelo, ferramentas):
    """Criar um agente de inteligência competitiva com acesso a dados da web"""

    prompt_sistema = """Você é um analista especializado em inteligência competitiva com acesso a ferramentas de dados da web através do servidor MCP Scrapeless.

## Missão
Realizar uma análise de mercado e competitiva abrangente usando dados da web em tempo real.

## Ferramentas MCP Disponíveis (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

## Fluxo de Trabalho de Análise Autônoma
Quando receber uma tarefa de análise, autonomamente:
1. Decidir quais ferramentas usar com base no objetivo.
2. Coletar dados abrangentes de múltiplas fontes.
3. Sintetizar descobertas em insights acionáveis.
4. Fornecer recomendações estratégicas específicas.

Seja proativo na seleção de ferramentas. Você tem total autonomia para usar qualquer combinação de ferramentas."""

    return Agent(
        model=modelo,
        tools=ferramentas,
        system_prompt=prompt_sistema
    )


async def principal():
    """Executar o agente de inteligência competitiva"""

    print("Agente de Inteligência Competitiva AWS Strands + MCP Scrapeless")
    print("=" * 70)

    try:
        cliente_mcp, ferramentas = await conectar_ferramentas_mcp()
        agente = criar_agente(modelo, ferramentas)

        print("\nAgente pronto com acesso a dados da web.")
        print("\nIniciando análise...")
        print("-" * 40)

        prompt = """
        Analisar a posição competitiva da Tesla no mercado de veículos elétricos.

        Pesquisar:
        - Linha de produtos atual e estratégia de preços.
        - Principais concorrentes e suas ofertas.
        - Anúncios estratégicos recentes.
        - Participação de mercado e posicionamento.

        Use as ferramentas Scrapeless para coletar dados em tempo real de tesla.com e resultados de busca.
        """

        with cliente_mcp:
            resultado = await agente.invoke_async(prompt)

        print("\nResultados da análise:")
        print("=" * 50)
        print(resultado)

        print("\nAnálise concluída.")

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


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

Como mencionado na Etapa #8, invoke_async retorna um AgentResult cujos atributos são message, stop_reason, metrics e state. Use print(resultado.message) se você quiser apenas o texto do assistente em vez da string de envoltório.

Execute o agente de IA com:

python agent.py

O script se conectará ao servidor MCP Scrapeless, executará list_tools_sync() (retorna 21 ferramentas — verificado ao vivo contra o endpoint hospedado no momento da redação), instanciará o agente e chamará agent.invoke_async(prompt). O modelo decide quais ferramentas chamar. O que o agente realmente faz em uma execução específica depende de quais ferramentas o modelo escolhe — Strands não restringe a sequência de ferramentas.

Conclusão

Este guia conectou o SDK AWS Strands ao servidor MCP da Scrapeless: ~100 linhas de Python, 21 ferramentas MCP verificadas disponíveis para o modelo, e um caminho de dados verificado através do Navegador de Scraping Scrapeless com saída de proxy residencial.

Obtenha uma chave de API em app.scrapeless.com.

Pronto para Construir Seu Pipeline de Dados Potencializado por IA?

Junte-se à nossa comunidade para reivindicar um plano gratuito e se conectar com desenvolvedores que estão construindo agentes AWS Strands + MCP Scrapeless: Discord · Telegram.

Inscreva-se em app.scrapeless.com para obter tempo de execução gratuito do Navegador de Scraping e adapte a integração do AWS Strands acima aos fluxos de trabalho que sua equipe precisa. Referência completa em docs.scrapeless.com. Para um embasamento mais profundo sobre o tempo de execução do Navegador de Scraping que alimenta essas ferramentas, consulte a página do produto Navegador de Scraping Scrapeless e nosso guia irmão sobre integrando Scrapeless com agentes LangChain.

FAQ

Q1: O que é MCP e por que isso é importante para agentes de IA?

MCP (Modelo de Protocolo de Contexto) é um padrão aberto para conectar agentes de IA a ferramentas e fontes de dados. Um servidor MCP expõe uma lista de ferramentas tipadas que qualquer cliente ciente do MCP — incluindo o AWS Strands SDK — pode chamar. Com o Scrapeless MCP, o agente obtém acesso tipado a um navegador de nuvem real, consultas de mecanismo de busca e raspadores Markdown/HTML sem precisar escrever código glue por API. O agente decide quais ferramentas chamar dentro do loop agente; o MCP carrega os esquemas tipados e resultados.

**Q2: O que o endpoint MCP hospedado me oferece?**

`https://api.scrapeless.com/mcp` (com o cabeçalho `x-api-token`) retorna a superfície completa de 21 ferramentas e foi verificado de ponta a ponta com o `MCPClient` do Strands neste guia. Nenhum runtime local do Node ou processo em segundo plano necessário — `streamablehttp_client(...)` é uma importação e uma URL.

**Q3: Como o loop agente lida com uma falha de ferramenta ou desafio contra bots?**

O Strands alimenta o resultado da ferramenta — incluindo erros — de volta ao modelo, que decide se deve tentar novamente, mudar de ferramenta ou apresentar a falha. Para o Scrapeless especificamente, a recuperação comum é `browser_close` + um novo `browser_create`, ou voltar de uma sessão de navegador completa para `scrape_markdown` / `scrape_html`. A região do proxy por chamada não é um parâmetro que a ferramenta `browser_create` do MCP expõe — `scrapeless-mcp-server/src/session-manager.ts` encaminha apenas `session_ttl`, `profile_id` e `profile_persist`. Para fixar uma região específica, crie um perfil Scrapeless no painel com o país incorporado e referencie-o através da variável de ambiente `BROWSER_PROFILE_ID` no servidor MCP.

**Q4: Isso pode rodar sem um agente de IA?**

Sim. Cada ferramenta MCP Scrapeless pode ser chamada de um script Python simples ou de um `curl` contra o endpoint HTTP transmitível (o `curl` do Passo #4 retorna `serverInfo.name: "scrapeless-mcp-server"` e um cabeçalho `mcp-session-id` que você reutiliza em solicitações de `tools/list` e `tools/call`). O AWS Strands SDK adiciona o loop agente por cima.

**Q5: Quais outros modelos funcionam além do Claude Sonnet?**

O `AnthropicModel` do Strands aceita qualquer ID de modelo que a API da Anthropic expõe — `claude-haiku-*` para loops de extração e resumo mais baratos, `claude-opus-*` para raciocínio mais pesado em várias etapas. O Strands também fornece `OpenAIModel`, `BedrockModel`, `GeminiModel`, e provedores para Mistral, Ollama, LiteLLM, llamacpp e SageMaker. Troque a linha do modelo; o resto de `agent.py` permanece o mesmo.

Qualquer endpoint compatível com a API OpenAI também funciona via `OpenAIModel` com uma substituição de `base_url`. Verificado de ponta a ponta para este guia contra o 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",  # ou anthropic/claude-3.5-sonnet, google/gemini-flash-1.5, etc.
    params={"temperature": 0.3},
)

Com essa troca, o mesmo Agent(model=..., tools=tools, system_prompt=...) roda contra o catálogo OpenRouter. Testado para este guia com openai/gpt-4o-mini: o agente chamou autonomamente google_search três vezes e scrape_markdown uma vez, retornou uma resposta limpa com stop_reason: end_turn, a aproximadamente $0.001 por execução.

Q6: Como lido com erros transitórios como ERR_TUNNEL_CONNECTION_FAILED ou 503?

Ambos vêm do pool de saída do Scrapeless e geralmente são transitórios. O loop do Strands já alimenta o erro de volta ao modelo, que tentará novamente na próxima vez. Para recuperação determinística no prompt, instrua o agente: "Se uma ferramenta do navegador retornar um erro de túnel ou 503, chame browser_close e inicie um novo browser_create antes de tentar novamente." Essa formulação gera uma nova tentativa mais limpa do que confiar no modelo para decidir.

Q7: Vários agentes podem compartilhar a conexão MCP?

O MCPClient abre uma sessão por contexto with mcp_client:. Para agentes paralelos, dê a cada um sua própria instância de MCPClient (e, portanto, seu próprio ID de sessão no endpoint hospedado) em vez de reutilizar um. O endpoint hospedado escala com sessões concorrentes; o limite de concorrência por conta reside na camada de preços do Scrapeless.

Q8: Onde conecto minhas próprias ferramentas não-Scrapeless junto a isso?

Agent(tools=...) aceita uma lista. Passe tools + my_extra_tools onde my_extra_tools é qualquer ferramenta compatível com Strands (funções decoradas com @tool, ou ferramentas de outro servidor MCP). O modelo vê a união dos esquemas e decide quais chamar.