Os agentes de IA alimentados por grandes modelos de linguagem (LLMs) podem raciocinar e tomar decisões, mas são limitados pelos seus dados de treinamento. Para criar agentes verdadeiramente úteis, você precisa conectá-los a dados da web em tempo real. Este guia mostra como combinar o AWS Strands SDK com o servidor Web MCP da Bright Data 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 único como estrutura para a criação de agentes de IA
Por que o AWS Strands SDK combina perfeitamente com o servidor Web MCP da Bright Data para agentes com reconhecimento da web
Como integrar o AWS Strands com o Web MCP da Bright Data para criar um agente de Inteligência competitiva autônomo
Como criar agentes que decidem autonomamente quais ferramentas de Scraping de Dados usar com base em seus objetivos

Vamos começar!

O que é o AWS Strands SDK?

O AWS Strands SDK é uma estrutura leve e orientada a código desenvolvida pela AWS para criar agentes de IA com o mínimo de código. Ele adota uma abordagem orientada a modelos, na qual as capacidades do agente emergem de decisões do modelo, em vez de lógica codificada.

Em comparação com outras estruturas de agentes de IA, o AWS Strands SDK enfatiza a simplicidade, a flexibilidade e a prontidão para produção. Em detalhes, algumas de suas principais características são:

Independente do modelo: suporte para vários provedores de LLM, incluindo AWS Bedrock, OpenAI, Anthropic e outros
Suporte nativo a MCP: integração incorporada com o Model Context Protocol para acessar mais de 1.000 ferramentas pré-construídas
Código mínimo: crie agentes sofisticados com apenas algumas linhas de código
Pronto para produção: inclui tratamento de erros, novas tentativas e observabilidade prontos para uso
Loop Agênico: implementa ciclos de percepção-raciocínio-ação para tomada de decisão autônoma
Suporte para múltiplos agentes: primitivas de orquestração para coordenar vários agentes especializados
Gerenciamento de estado: gerenciamento de sessão e contexto entre interações

Entendendo o AWS Strands SDK

Arquitetura central

O AWS Strands SDK simplifica o desenvolvimento de agentes com um design simples de três componentes que não compromete o desempenho.

Essa abordagem permite que você crie agentes inteligentes com o mínimo de código, o que, de outra forma, exigiria milhares de linhas.

Componente do modelo: o cérebro que funciona com vários provedores de IA
Integração de ferramentas: conecta agentes a sistemas externos por meio de servidores MCP
Tarefas baseadas em prompts: define o comportamento do agente com linguagem natural em vez de código

Implementação do ciclo agênico

O loop agênico é o que torna os agentes Strands tão inteligentes. É como um ciclo contínuo em que o agente percebe o que está acontecendo, pensa sobre isso e age, permitindo que ele lide com tarefas complexas por conta própria.

A Strands muda o jogo ao permitir que o modelo de IA decida o que fazer a seguir. Em vez de codificar todos os cenários possíveis, o modelo descobre as coisas com base na situação atual.

Veja como isso funciona na prática:

Seu agente recebe uma tarefa de um usuário.
O modelo analisa o que está acontecendo e quais ferramentas tem disponíveis.
Ele decide se deve usar uma ferramenta, pedir esclarecimentos ou dar uma resposta final.
Se usar uma ferramenta, o Strands a executa e envia os resultados de volta para o modelo.
Esse ciclo continua até que o trabalho seja concluído ou seja necessária a ajuda humana.

Pense em criar uma ferramenta de monitoramento de preços. Com a codificação tradicional, você teria que escrever uma lógica para verificar os sites dos concorrentes, lidar com diferentes layouts de página, gerenciar erros, coletar resultados e definir limites de alerta.

Com o Strands, basta fornecer ferramentas de scraping de dados e dizer ao agente: “Monitore esses sites concorrentes para alterações de preço acima de 5% e me alerte com um resumo”. O modelo descobre quais sites verificar, como lidar com problemas e quando enviar alertas, tudo por conta própria.

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

Os agentes de IA criados com o AWS Strands herdam as limitações de seus LLMs subjacentes, especialmente a falta de acesso a informações em tempo real. Isso pode levar a respostas desatualizadas ou imprecisas quando os agentes precisam de dados atuais, como preços dos concorrentes, condições de mercado ou opinião dos clientes.

É aí que entra o servidor Web MCP da Bright Data. Construído em Node.js, este servidor MCP se integra ao conjunto de ferramentas de recuperação de dados prontas para IA da Bright Data. Essas ferramentas capacitam seu agente a:

Acessar qualquer conteúdo de site, mesmo aqueles com proteção anti-bot
Consultar conjuntos de dados estruturados de mais de 120 sites populares
Pesquisar em vários mecanismos de pesquisa simultaneamente
Interagir com páginas da web dinâmicas em tempo real

Atualmente, o servidor MCP inclui 40 ferramentas especializadas para coletar dados estruturados de sites como Amazon, LinkedIn, TikTok e outros usando APIs Web Scraper.

Agora, vamos ver como você pode usar essas ferramentas MCP com o AWS Strands SDK!

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

Nesta seção, você aprenderá como usar o AWS Strands SDK para criar um agente de IA equipado com recursos de coleta e recuperação de dados em tempo real do servidor Web MCP.

Como exemplo, criaremos um agente de Inteligência competitiva que pode analisar mercados e concorrentes de forma autônoma. O agente decidirá quais ferramentas usar com base em seus objetivos, demonstrando o poder do loop agênico.

Siga este guia passo a passo para criar seu agente de IA Claude + Bright Data 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 (recomenda-se a versão LTS mais recente)
Um IDE Python (VS Code com extensão Python ou PyCharm)

Requisitos de conta:

Uma conta Bright Data (o plano gratuito oferece 5.000 solicitações mensais)
Uma conta Anthropic com acesso à API Claude e créditos

Conhecimento prévio (útil, mas não obrigatório):

Conhecimento básico 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 o seu projeto:

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

Configure um ambiente virtual Python:

python -m venv venv

Ative o ambiente virtual:

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

# No Windows:
venvScriptsactivate

Crie o arquivo Python principal:

touch agent.py

Sua estrutura de pastas deve ficar assim:

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

Tudo pronto! Agora você tem um ambiente Python pronto para criar 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 python-dotenv

Isso instala:

strands-agents: o AWS Strands SDK para criar agentes de IA
python-dotenv: para gerenciamento seguro de variáveis de ambiente

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

Ótimo! Agora você pode usar o AWS Strands SDK para criar agentes.

Etapa 3: Configure as variáveis de ambiente

Crie um arquivo .env na pasta do seu projeto para gerenciamento seguro de chaves de API:

touch .env

Adicione suas chaves API ao arquivo .env:

# API Anthropic para modelos Claude
ANTHROPIC_API_KEY=sua_chave_anthropic_aqui

# Credenciais Bright Data para scraping de dados
BRIGHT_DATA_API_KEY=seu_token_bright_data_aqui

No seu agent.py, configure o carregamento da variável de ambiente:

import os
from dotenv import load_dotenv

load_dotenv()

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

Pronto! Agora você está configurado para carregar com segurança as chaves API do arquivo .env.

Etapa 4: Instalar e testar o servidor Bright Data MCP

Instale o Bright Data Web MCP globalmente via npm:

npm install -g @brightdata/mcp

Teste se ele funciona com sua chave API:

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

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

Se for bem-sucedido, você verá logs mostrando o servidor MCP sendo iniciado. A primeira execução criará automaticamente duas zonas na sua conta Bright Data:

mcp_unlocker: Para Web Unlocker
mcp_browser: para API do navegador

Você pode verificar isso no painel do Bright Data em “Proxy e infraestrutura de scraping”.

Ótimo! O servidor Web MCP funciona perfeitamente.

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

Etapa 5: inicializar o modelo Strands

Configure o modelo Anthropic Claude no seu agent.py:

# Inicializar o modelo Anthropic
model = AnthropicModel(
    model_id="claude-3-opus-20240229",  # Você também pode usar claude-3-sonnet para um custo menor
    max_tokens=4096,
    params={"temperature": 0.3}
)

# Defina a chave API
os.environ["ANTHROPIC_API_KEY"] = ANTHROPIC_API_KEY

Isso configura o Claude como o LLM do seu agente com parâmetros apropriados para respostas consistentes e focadas.

Etapa 6: Conecte-se ao servidor Web MCP

Crie a configuração do cliente MCP para se conectar às ferramentas da Bright Data:

import asyncio
import logging

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

async def connect_mcp_tools():
    """Conecte-se ao servidor MCP da Bright Data e descubra as ferramentas"""

    logger.info("Conectando-se ao MCP da Bright Data...")

    # Configure a conexão com o MCP hospedado pela Bright Data
    server_params = StdioServerParameters(
        command="npx",
        args=["-y", "@brightdata/mcp"],
        env={"API_TOKEN": BRIGHT_DATA_API_KEY, "PRO_MODE": "true"}
    )

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

    # Descobrir ferramentas disponíveis
    com mcp_client:
        tools = mcp_client.list_tools_sync()
        logger.info(f"📦 Descobriu {len(tools)} ferramentas MCP")

        para ferramenta em ferramentas:
            logger.info(f"  - {tool.tool_name}")

    retornar mcp_client, ferramentas

Isso estabelece a conexão com o servidor MCP da Bright Data e descobre todas as ferramentas de Scraping de dados disponíveis.

Etapa 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"""

    system_prompt = """Você é um analista especialista em Inteligência competitiva com acesso a poderosas ferramentas de dados da web através do MCP.

## Sua missão
Realizar análises abrangentes de mercado e da concorrência usando dados da web em tempo real.

## Ferramentas MCP disponíveis
Você tem acesso a estas ferramentas Bright Data MCP:
- search_engine: extraia resultados de pesquisa do Google, Bing ou Yandex
- scrape_as_markdown: extraia conteúdo de qualquer página da web com bypass de CAPTCHA
- search_engine_batch: execute várias pesquisas simultaneamente
- scrape_batch: extraia várias páginas da web em paralelo

## Fluxo de trabalho de análise autônoma
Quando receber uma tarefa de análise, de forma autônoma:
1. Decida quais ferramentas usar com base no objetivo
2. Reúna dados abrangentes de várias fontes
3. Sintetize as descobertas em insights acionáveis
4. Forneça 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=model,
        tools=tools,
        system_prompt=system_prompt
    )

Isso cria um agente especializado em Inteligência competitiva com capacidade de tomada de decisão autônoma.

Etapa 8: Inicie seu agente

Crie a função de execução principal para executar seu agente:

async def main():
    """Executar o agente de Inteligência competitiva"""

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

    try:
        # Conectar-se às ferramentas MCP
        mcp_client, tools = await connect_mcp_tools()

        # Criar o agente
        agent = create_agent(model, tools)

        print("n✅ Agente pronto com acesso aos dados da web!")
        print("n📊 Iniciando a análise...")
        print("-" * 40)

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

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

        Use ferramentas de scraping de dados para coletar dados em tempo real do site tesla.com e dos resultados de pesquisa.
        """

# Executar análise com contexto MCP
com mcp_client:
resultado = aguardar agente.invocar_assíncrono(prompt)

imprimir("n📈 Resultados da análise:")
imprimir("=" * 50)
imprimir(resultado.conteúdo)

imprimir("n✅ Análise concluída!")

    exceto Exception como e:
        logger.error(f"Erro: {e}")
        imprimir(f"n❌ Erro: {e}")

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

Missão cumprida! Seu agente está pronto para realizar análises competitivas autônomas.

Etapa 9: Junte tudo

Aqui está o código completo em 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

# Carregar variáveis de ambiente
load_dotenv()
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

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

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

# Definir chave API
os.environ["ANTHROPIC_API_KEY"] = ANTHROPIC_API_KEY

async def connect_mcp_tools():
    """Conectar ao servidor Bright Data MCP e descobrir ferramentas"""

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

    # Configurar conexão com o MCP hospedado pela Bright Data
    server_params = StdioServerParameters(
        command="npx",
        args=["-y", "@brightdata/mcp"],
        env={"API_TOKEN": BRIGHT_DATA_API_KEY, "PRO_MODE": "true"}
    )

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

    # Descobrir ferramentas disponíveis
    com mcp_client:
        tools = mcp_client.list_tools_sync()
        logger.info(f"📦 Descobriu {len(tools)} ferramentas MCP")

        para ferramenta em ferramentas:
            logger.info(f"  - {tool.tool_name}")

    retornar mcp_client, ferramentas

def create_agent(model, tools):
    """Criar um agente de inteligência competitiva com acesso a dados da web"""

    system_prompt = """Você é um analista especialista em Inteligência competitiva com acesso a poderosas ferramentas de dados da web através do MCP.

## Sua missão
Realizar análises abrangentes de mercado e da concorrência usando dados da web em tempo real.

## Ferramentas MCP disponíveis
Você tem acesso a estas ferramentas Bright Data MCP:
- search_engine: extraia resultados de pesquisa do Google, Bing ou Yandex
- scrape_as_markdown: extraia conteúdo de qualquer página da web com bypass de CAPTCHA
- search_engine_batch: execute várias pesquisas simultaneamente
- scrape_batch: extraia várias páginas da web em paralelo

## Fluxo de trabalho de análise autônoma
Ao receber uma tarefa de análise, de forma autônoma:
1. Decida quais ferramentas usar com base no objetivo
2. Reúna dados abrangentes de várias fontes
3. Sintetiza as descobertas em insights acionáveis
4. Fornece 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=model,
        tools=tools,
        system_prompt=system_prompt
    )

async def main():
    """Executa o agente de inteligência competitiva"""

    imprimir("🚀 AWS Strands + Bright Data MCP Agente de Inteligência Competitiva")
    imprimir("=" * 70)

    tentar:
        # Conectar-se às ferramentas MCP
        mcp_client, tools = aguardar connect_mcp_tools()

        # Criar o agente
        agente = criar_agente(modelo, ferramentas)

        imprimir("n✅ Agente pronto com acesso aos dados da web!")
imprimir("n📊 Iniciando a análise...")
imprimir("-" * 40)

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

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

        Use ferramentas de scraping de dados para coletar dados em tempo real do site tesla.com e dos resultados de pesquisa.
        """

# Executar análise com contexto MCP
com mcp_client:
resultado = aguardar agente.invocar_assíncrono(prompt)

imprimir("n📈 Resultados da análise:")
imprimir("=" * 50)
imprimir(resultado)

imprimir("n✅ Análise concluída!")

    exceto Exception como e:
        logger.error(f"Erro: {e}")
        imprimir(f"n❌ Erro: {e}")

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

Execute o agente IA com:

python agent.py

The agent demo including the output in the terminal.png

No terminal, você deverá ver a seguinte saída:

A conexão MCP sendo estabelecida
Descoberta das ferramentas Bright Data disponíveis
O agente selecionando autonomamente as ferramentas a serem usadas
Dados em tempo real sendo coletados do Tesla.com e resultados de pesquisa
Uma análise competitiva abrangente com dados atuais

O agente decide autonomamente:

Usar o search_engine para encontrar informações sobre a Tesla e seus concorrentes
Usar scrape_as_markdown para extrair dados do site tesla.com
Combinar várias fontes de dados para uma análise abrangente

Et voilà! Você criou com sucesso um agente de Inteligência competitiva autônomo que pode acessar e analisar dados da web em tempo real.

Próximos passos

O agente IA criado aqui é funcional, mas serve apenas como ponto de partida. Considere levá-lo para o próximo nível:

Criar um loop de conversação: adicione uma interface REPL para conversar com o agente de forma interativa
Criar agentes especializados: crie agentes para monitoramento de preços, pesquisa de mercado ou geração de leads
Implementar fluxos de trabalho com vários agentes: coordene vários agentes especializados para tarefas complexas
Adicionar memória e estado: use o gerenciamento de estado do AWS Strands para conversas sensíveis ao contexto
Implantando em produção: aproveite a infraestrutura da AWS para implantação escalável de agentes
Ampliação com ferramentas personalizadas: crie suas próprias ferramentas MCP para fontes de dados especializadas
Adicionar observabilidade: implemente registro e monitoramento para implantações em produção

Casos de uso do mundo real

A combinação do AWS Strands e da Bright Data permite agentes de IA mais avançados em diversas aplicações comerciais:

Agente de Inteligência competitiva: monitore preços, recursos de produtos e campanhas de marketing dos concorrentes em tempo real
Agente de pesquisa de mercado: analise tendências do setor, opinião dos consumidores e oportunidades emergentes
Agente de otimização de comércio eletrônico: acompanhe os catálogos e preços dos concorrentes para estratégias de preços dinâmicas
Agente de geração de leads: identifique e qualifique clientes potenciais a partir de fontes da web
Agente de monitoramento de marca: acompanhe menções, avaliações e reputação da marca na web
Agente de pesquisa de investimentos: coleta dados financeiros, notícias e sinais do mercado para decisões de investimento

Conclusão

Neste artigo, você aprendeu como integrar o AWS Strands SDK ao servidor Web MCP da Bright Data para criar agentes de IA autônomos capazes de acessar e analisar dados da web em tempo real. Essa combinação poderosa permite que você crie agentes que podem pensar estrategicamente enquanto se mantêm informados com informações em tempo real.

As principais vantagens dessa abordagem incluem:

Código mínimo: crie agentes sofisticados com apenas cerca de 100 linhas de Python
Tomada de decisão autônoma: os agentes decidem quais ferramentas usar com base em seus objetivos
Pronto para produção: tratamento de erros integrado e escalabilidade de ambas as plataformas
Acesso a dados em tempo real: supere as limitações do LLM com dados da web em tempo real

Para criar agentes mais sofisticados, explore toda a gama de serviços disponíveis na infraestrutura de IA da Bright Data. Essas soluções podem impulsionar uma ampla variedade de cenários de agentes.

Crie uma conta Bright Data gratuitamente e comece a experimentar as ferramentas de dados da web com tecnologia de IA hoje mesmo!

Contate-nos Teste grátis

Agentes de IA usando AWS Strands SDK e Web MCP da Bright Data