Nesta postagem do blog, você verá:
- O que é o Claude Agent SDK e o que o torna único.
- Por que estendê-lo por meio do Web MCP da Bright Data é a abordagem ideal para agentes de IA mais poderosos.
- Como conectar um agente de IA criado com o Claude Agent SDK às ferramentas da web da Bright Data por meio do Web MCP.
Vamos começar!
O que é o Claude Agent SDK?
O Claude Agent SDK é uma estrutura de código aberto da Anthropic que permite construir agentes de IA autônomos com tecnologia Claude Code. Em particular, ele permite que os agentes leiam arquivos, executem comandos, pesquisem na web, editem códigos e interajam com ferramentas sem a necessidade de lógica de orquestração personalizada.
O SDK fornece um loop de agente robusto que pode reunir contexto, agir e verificar resultados. Dessa forma, ele permite que seus agentes executem fluxos de trabalho complexos de maneira confiável. O SDK está disponível em:
- Python, com uma biblioteca que tem mais de 4,5 mil estrelas no GitHub.
- TypeScript, com uma biblioteca que possui mais de 720 estrelas no GitHub.
O SDK do Claude Agent oferece suporte a ferramentas integradas, subagentes e integração nativa com MCP (Model Context Protocol) para serviços externos. Seu objetivo final é tornar o desenvolvimento de agentes de IA mais simples, equipando você com uma API simples para criar assistentes especializados, agentes de pesquisa e bots de automação que aproveitam os recursos de raciocínio e execução de ferramentas do Claude.
Por que estender o Claude Agent SDK com os recursos de dados da web da Bright Data
Conheça as limitações do Claude Agent e saiba como resolvê-las!
Um pouco de contexto sobre as ferramentas do SDK do Claude Agent
Mesmo os modelos de IA Claude mais capazes têm limitações inerentes a todos os LLMs. Essas limitações decorrem do fato de que os modelos de IA são treinados com dados que representam um instantâneo do passado.
Como resultado, os LLMs só podem gerar respostas com base no que foram treinados. Quando questionados sobre coisas que não sabem (ou sobre eventos muito recentes), eles podem falhar completamente ou, pior ainda, produzir alucinações. Além disso, eles não podem interagir com o mundo exterior por conta própria.
Como os agentes de IA são alimentados por LLMs, eles herdam todas essas limitações. Ao mesmo tempo, os agentes têm uma vantagem importante: eles podem usar ferramentas! As ferramentas permitem que os agentes chamem serviços e sistemas externos, ampliando suas capacidades limitadas, que seriam apenas as dos LLMs.
O Claude Agent SDK fornece aos agentes um conjunto padrão de ferramentas integradas para trabalhar com arquivos, executar comandos, pesquisar na web, editar código e muito mais.
Ele também introduz uma abordagem distinta para a definição de ferramentas personalizadas. No SDK do Claude Agent, as ferramentas personalizadas são implementadas como servidores MCP em processo. Isso não deve ser surpresa, dado que o MCP é definido pela Anthropic, a empresa por trás do Claude.
Embora as ferramentas padrão do Claude Agent SDK sejam úteis, elas nem sempre são suficientes para casos de uso em nível de produção. Na prática, é melhor integrar fornecedores terceirizados especializados, projetados para lidar com limitações comuns do LLM, como conhecimento desatualizado e interação limitada com a web ao vivo.
É aí que entra o Bright Data Web MCP!
Apresentando o Bright Data Web MCP
As ferramentas personalizadas no Claude Agent SDK são executadas em segundo plano no MCP. Portanto, faz sentido estender as compilações do agente com um MCP que já fornece um rico conjunto de ferramentas prontas para produção.
O Web MCP da Bright Data oferece mais de 60 ferramentas prontas para IA para coleta automatizada de dados da web, extração de dados estruturados e interações no nível do navegador. Ele está disponível como um serviço remoto e como um servidor local, apoiado por um repositório público com mais de 2 mil estrelas no GitHub.
Mesmo na versão gratuita, o servidor MCP oferece duas ferramentas particularmente úteis (junto com suas variantes em lote):
| Ferramenta | Descrição |
|---|---|
search_engine |
Recupera resultados do Google, Bing ou Yandex no formato JSON ou Markdown. |
scrape_as_markdown |
Extraia qualquer página da web para Markdown limpo, contornando medidas anti-bot. |
Onde o Web MCP realmente se destaca é no modo Pro, que desbloqueia ferramentas premium para extração de dados estruturados de plataformas como Amazon, LinkedIn, Yahoo Finance, YouTube, TikTok, Zillow, Google Maps e muitas outras. Além disso, ele equipa qualquer agente de IA com a capacidade de navegar na web e interagir com páginas da web como um usuário humano.
Agora, vamos ver como integrar o Bright Data Web MCP ao Claude Agent SDK!
Como conectar o Claude Agent SDK às ferramentas da Bright Data via Web MCP
Neste guia passo a passo, você aprenderá como integrar os serviços da Bright Data a um agente de IA criado com o SDK do Claude Agent via MCP. Mais especificamente, você conectará o Web MCP da Bright Data a um agente de IA do SDK do Claude Agent, dando a ele acesso a toda a gama de ferramentas de dados da web disponíveis.
Observação: o Claude Agent SDK também está disponível em TypeScript. A seção a seguir pode ser facilmente convertida de Python para JavaScript ou TypeScript consultando a documentação oficial.
Siga as instruções abaixo!
Pré-requisitos
Para seguir este tutorial, certifique-se de que você atende aos seguintes requisitos:
- Python 3.10 ou posterior instalado localmente.
- Claude Code instalado em sua máquina.
- Uma chave API Claude com créditos disponíveis.
- Uma conta Bright Data com uma chave API.
Observação: você será orientado pelo processo de configuração da sua conta Bright Data para uso do Web MCP em uma seção dedicada mais adiante neste tutorial.
Lembre-se de que o Claude Agent SDK usa o Claude Code como seu tempo de execução, e é por isso que o Claude Code deve estar instalado localmente. Para obter instruções passo a passo, consulte nosso guia sobre integração do Claude Code + Bright Data Web MCP.
Por fim, algum conhecimento básico do protocolo MCP e das ferramentas fornecidas pelo Web MCP será útil.
Etapa 1: Configure um projeto Claude Agent SDK em Python
Primeiro, verifique se o Claude Code está instalado em sua máquina. Execute o seguinte comando:
claude --versionVocê deverá ver uma saída semelhante a:
2.1.29 (Claude Code)Se isso acontecer, ótimo! Isso confirma que o principal pré-requisito para usar o Claude Agent SDK está em vigor.
Em seguida, continue criando um diretório de projeto. Depois, navegue até ele a partir do seu terminal:
mkdir claude-agent-sdk-bright-data-ia-agent
cd claude-agent-sdk-bright-data-ia-agentAgora, inicialize um ambiente virtual dentro do projeto:
python -m venv .venvCrie um novo arquivo chamado agent.py na raiz do projeto, que agora deve ficar assim:
claude-agent-sdk-bright-data-IA-agent/
├── .venv/
└── agent.pyO arquivo agent.py conterá a lógica do seu agente de IA, criado com o Claude Agent SDK e interagindo com o Bright Data Web MCP.
Abra a pasta do projeto em seu IDE Python preferido. Por exemplo, carregue-o no PyCharm Community Edition ou no Visual Studio Code com a extensão Python.
Agora, ative o ambiente virtual que você criou anteriormente. No Linux ou macOS, execute:
source .venv/bin/activateDe forma equivalente, no Windows, execute:
.venv/Scripts/activateCom o ambiente virtual ativado, instale as dependências necessárias:
pip install claude-agent-sdk python-dotenvAs dependências para este aplicativo são:
claude-agent-sdk: para criar agentes de IA em Python por meio do Claude Agent SDK.python-dotenv: para carregar segredos (como sua chave API Claude e chave API Bright Data) de um arquivo .env local.
Tudo pronto! Seu ambiente Python agora está pronto para criar agentes de IA com o SDK do Claude Agent.
Etapa 2: Prepare-se para carregar variáveis de ambiente
Seu agente de IA se conectará a serviços de terceiros, como Bright Data e (obviamente) Claude. Para fazer isso, você precisa usar as chaves de API associadas às suas contas nesses serviços. Como prática recomendada, você nunca deve codificar credenciais diretamente em seu código-fonte.
Em vez disso, você deve carregar as chaves API necessárias a partir de um arquivo .env. É exatamente por isso que você instalou o python-dotenv na etapa anterior. Comece importando a biblioteca no seu arquivo agent.py:
from dotenv import load_dotenvEm seguida, crie um arquivo .env na raiz do projeto:
claude-agent-sdk-bright-data-IA-agent/
├─── .venv/
├─── agent.py
└─── .env # <-----O arquivo .env armazenará sua chave API Claude e sua chave API Bright Data, que são os dois segredos necessários para este projeto.
Agora, carregue as variáveis de ambiente do arquivo .env chamando a seguinte função em agent.py:
load_dotenv()Ótimo! Seu script pode ler com segurança credenciais confidenciais das variáveis de ambiente, mantendo-as fora de sua base de código.
Etapa 3: Comece a usar o SDK do Claude Agent
Em agent.py, adicione o seguinte código para criar um agente de IA simples usando o SDK do Claude Agent:
import asyncio
from claude_agent_sdk import query, ClaudeAgentOptions
from claude_agent_sdk.types import StreamEvent
async def main():
# Configure o agente Claude
options = ClaudeAgentOptions(
model="claude-haiku-4-5", # Substitua pelo seu modelo Claude preferido
include_partial_messages=True # Habilite respostas de streaming
)
# O prompt enviado ao agente
prompt = "Olá! Como vai?"
# Loop do agente: transmite eventos retornados pelo SDK do agente Claude
async for message in query(prompt=prompt, options=options):
# Intercepta apenas eventos de streaming
if isinstance(message, StreamEvent):
event = message.event
event_type = event.get("type")
# Lida com a saída de texto incremental
if event_type == "content_block_delta":
delta = event.get("delta", {})
if delta.get("type") == "text_delta":
# Imprime o texto transmitido à medida que chega
print(delta.get("text", ""), end="", flush=True)
asyncio.run(main())Este script tem três componentes principais:
options: Configura o agente. Neste exemplo, o agente usa o modelo Claude Haiku 4.5 e habilita respostas em fluxo, permitindo que a saída seja impressa de forma incremental.prompt: Define o que você deseja que o agente IA Claude faça. O Claude decide automaticamente como lidar com a tarefa com base nessa entrada.query: O ponto de entrada principal que inicia o loop do agente. Ele retorna um iterador assíncrono, e é por isso que você usaasync forpara transmitir mensagens enquanto o Claude raciocina, chama ferramentas, observa resultados e produz saídas.
O loop async for continua em execução enquanto o Claude está “pensando”. Cada iteração pode produzir diferentes tipos de mensagens, como etapas de raciocínio, chamadas de ferramentas, resultados de ferramentas ou a resposta final. Neste exemplo, você está transmitindo apenas a saída de texto final para o terminal.
Para funcionar corretamente, o SDK do Claude Agent requer acesso à API do Claude. Por padrão, ele lê a chave da API da variável de ambiente ANTHROPIC_API_KEY. Portanto, adicione-a ao seu arquivo .env desta forma:
ANTHROPIC_API_KEY="<SUA_CHAVE_ANTHROPIC_API>" Substitua <SUA_CHAVE_API_ANTHROPIC> pela sua chave API Anthropic Claude real.
Observação: se o seu agente Claude Agent SDK não conseguir acessar a chave da API, ele falhará com o seguinte erro:
Sua organização não tem acesso ao Claude. Faça login novamente ou entre em contato com seu administrador.Com tudo considerado a partir do código da etapa anterior, inicie o agente executando:
python agent.pyNo seu terminal, você deverá ver uma resposta de streaming semelhante à seguinte:
Ótimo! A resposta corresponde ao prompt de entrada, o que significa que o agente de IA com tecnologia Claude Agent SDK está funcionando perfeitamente.
Etapa 4: Comece com o Web MCP da Bright Data
Lembre-se de que as ferramentas personalizadas no SDK do Claude Agent são implementadas por meio de servidores MCP em processo. Por esse motivo, faz sentido conectar seu agente de IA diretamente a uma instância do servidor Web MCP da Bright Data.
Afinal, definir ferramentas personalizadas integrando-as diretamente aos serviços da Bright Data e, em seguida, expô-las via MCP não faria muito sentido. Isso porque já existe um servidor MCP oficial (e amplamente utilizado!).
Nesta seção, mostraremos uma conexão com uma instância local. Ao mesmo tempo, você também pode se conectar a servidores Web MCP remotos para configurações mais escaláveis e prontas para uso corporativo.
Antes de conectar o Claude Agent SDK ao Web MCP da Bright Data, verifique se o servidor MCP pode ser executado em sua máquina!
Primeiro, crie uma conta Bright Data. Ou, se você já tiver uma, basta fazer login. Para uma configuração rápida, siga o assistente na seção“MCP”do seu painel:
Caso contrário, para obter orientações adicionais, consulte as instruções abaixo.
Comece gerando sua chave API da Bright Data. Você utilizará a chave API em breve para autenticar sua instância Web MCP local com sua conta Bright Data. Como você precisará acessá-la em seu código, adicione-a ao seu arquivo .env com:
BRIGHT_DATA_API_KEY="<SUA_CHAVE_API_BRIGHT_DATA>"Em seguida, carregue-a no seu arquivo agent.py:
import os
BRIGHT_DATA_API_KEY = os.getenv("BRIGHT_DATA_API_KEY")Continue instalando o Web MCP globalmente através do pacote @brightdata/mcp:
npm install -g @brightdata/mcpNo Linux/macOS, verifique se o servidor MCP está sendo executado localmente com:
API_TOKEN="<YOUR_BRIGHT_DATA_API>" npx -y @brightdata/mcpOu, de forma equivalente, no PowerShell:
$Env:API_TOKEN="<YOUR_BRIGHT_DATA_API>"; npx -y @brightdata/mcpSubstitua o espaço reservado <YOUR_BRIGHT_DATA_API> pelo seu token API Bright Data real. Esses comandos (equivalentes) definem a variável de ambiente API_TOKEN necessária e iniciam o servidor Web MCP localmente.
Se for bem-sucedido, você deverá receber logs semelhantes aos abaixo:
Na primeira inicialização, o pacote Web MCP configura automaticamente duas zonas na sua conta Bright Data:
mcp_unlocker: uma zona para o Web Unlocker.mcp_browser: uma zona para a API do navegador.
Essas duas zonas alimentam as mais de 60 ferramentas disponíveis no Web MCP. Observe que você também pode substituir os nomes padrão das duas zonas, conforme explicado na documentação.
Se você quiser confirmar que elas foram criadas, acesse a página“Proxies & Infraestrutura de scraping”(Proxies einfraestrutura de scraping) no painel do Bright Data. Você deverá ver as duas zonas listadas na tabela “My Zones” (Minhas zonas):
Agora, lembre-se de que o nível gratuito do Web MCP só dá acesso às ferramentas search_engine e scrape_as_markdown (e suas versões em lote).
Para desbloquear todas as mais de 60 ferramentas, você deve habilitar o modo Pro definindo a variável de ambiente PRO_MODE="true":
API_TOKEN="<YOUR_BRIGHT_DATA_API>" PRO_MODE="true" npx -y @brightdata/mcpOu, no Windows:
$Env:API_TOKEN="<YOUR_BRIGHT_DATA_API>"; $Env:PRO_MODE="true"; npx -y @brightdata/mcpImportante: o modo Pro não está incluído no plano gratuito e acarreta custos adicionais.
Ótimo! Agora você tem certeza de que o servidor Web MCP está em execução na sua máquina. Em seguida, você configurará o Claude Agent SDK para iniciar o servidor automaticamente e se conectar a ele.
Etapa 5: Conecte o Claude Agent SDK ao Web MCP
O Claude Agent SDK suporta conexões MCP por meio da opção mcp_servers na classe ClaudeAgentOptions. Isso permite que seu agente se comunique diretamente com o Web MCP da Bright Data.
Para se conectar ao Web MCP, atualize sua variável de opções desta forma:
options = ClaudeAgentOptions(
# Conectar-se ao Web MCP da Bright Data
mcp_servers={
"bright_data": {
"command": "npx",
"args": ["-y", "@brightdata/mcp"],
"env": {
"API_TOKEN": BRIGHT_DATA_API_KEY,
"PRO_MODE": "true" # Para ativar o modo Pro
}
}
},
allowed_tools=["mcp__bright_data__*"], # Ativar todas as ferramentas do Bright Data Web MCP
model="claude-haiku-4-5", # Substitua pelo seu modelo Claude preferido
include_partial_messages=True, # Ativar respostas de streaming
)Esta configuração reflete o comando npx que você testou anteriormente, passando credenciais e configuração por meio de variáveis de ambiente:
API_TOKEN: necessário para autenticação. Defina isso como sua chave API Bright Data.PRO_MODE: necessário para ativar o modo Pro.
Importante: o campo allowed_tools usa um curinga para permitir todas as ferramentas do servidor bright_data configurado. Sem isso, o agente com tecnologia Claude pode ver as ferramentas, mas não poderá usá-las.
Se você preferir não especificar a opção mcp_servers no código, pode criar um arquivo .mcp.json na raiz do seu projeto com a seguinte estrutura:
{
"mcpServers": {
"bright_data": {
"command": "npx",
"args": ["-y", "@brightdata/mcp"],
"env": {
"API_TOKEN": "<SUA_CHAVE_API_BRIGHT_DATA>",
"PRO_MODE": "true"
}
}
}
}Para verificar a conexão do Web MCP, teste o agente com um prompt simples:
prompt = "A qual ferramenta Bright Data MCP você tem acesso?"No modo Pro (PRO_MODE="true"), a resposta deve listar todas as mais de 60 ferramentas disponíveis, semelhante a isto:
Agora seu agente pode ver e usar todas as ferramentas de alto nível disponíveis no servidor Web MCP. Missão cumprida! Seu agente de IA, criado com o Claude Agent SDK, agora está ampliado com os recursos de dados da web da Bright Data por meio das ferramentas Web MCP.
Etapa 6: Execute o agente
Para demonstrar a eficácia de um agente de IA quando integrado ao Bright Data Web MCP, você precisa do prompt certo. Em particular, o prompt deve envolver a recuperação de dados da web e/ou interação com a web.
Por exemplo, imagine que você deseja criar um agente de IA que monitore sites concorrentes, tirando capturas de tela automaticamente e extraindo o texto da página. Essa é uma tarefa que um agente de IA padrão não pode realizar sozinho sem as ferramentas certas.
Suponha que a Nike seja sua concorrente. Você poderia escrever um prompt como:
prompt = """
Abra uma sessão do Navegador de scraping e navegue até a seguinte página da web:
"https://www.nike.com/"
Aguarde até que a página carregue completamente e, em seguida, capture uma captura de tela da página inteira. Além disso, extraia todo o texto da página. Salve a captura de tela em um arquivo local `screenshot.png` e o texto da página em um arquivo local `text.txt`.
"""Graças aos recursos de navegação disponíveis nas ferramentas premium Bright Data Web MCP, o agente de IA agora pode:
- Abrir uma sessão remota do navegador na nuvem por meio da API do navegador, contornando as proteções comuns contra bots e acessando praticamente qualquer página da web.
- Esperar que a página carregue completamente.
- Capturar uma captura de tela da página inteira e extrair todo o texto visível.
Por fim, o agente usa as ferramentas integradas fornecidas pelo Claude Agent SDK para salvar a saída gerada no disco, conforme solicitado.
Observe que, para habilitar o manuseio de imagens e a gravação em disco, você também precisará das duas opções extras a seguir:
options = ClaudeAgentOptions(
# ...
permission_mode="acceptEdits", # Para habilitar o agente a gravar arquivos no disco
max_buffer_size=10 * 1024 * 1024, # Aumente para 10 MB para o manuseio de imagens
)Como a execução do agente envolverá o uso de ferramentas, faz sentido atualizar a lógica de streaming para também interceptar eventos relacionados a chamadas de ferramentas. Atualize seu loop async for desta forma:
# Rastreie a ferramenta atual e acumule sua entrada JSON
current_tool = None
tool_input = ""
# Loop Agentic: transmite eventos retornados pelo Claude Agent SDK
async for message in query(prompt=prompt, options=options):
# Intercepte apenas eventos de streaming
if isinstance(message, StreamEvent):
event = message.event
event_type = event.get("type")
if event_type == "content_block_start":
# Nova chamada de ferramenta está começando
content_block = event.get("content_block", {})
if content_block.get("type") == "tool_use":
current_tool = content_block.get("name")
tool_input = ""
print(f"nIniciando ferramenta: {current_tool}")
# Lidar com saída de texto incremental
elif event_type == "content_block_delta":
delta = event.get("delta", {})
if delta.get("type") == "text_delta":
# Imprimir texto transmitido à medida que chega
imprimir(delta.obter("texto", ""), fim="", flush=True)
elif delta.obter("tipo") == "input_json_delta":
# Acumular entrada JSON à medida que é transmitida
chunk = delta.obter("partial_json", "")
tool_input += chunk
elif event_type == "content_block_stop":
# Chamada da ferramenta concluída (mostrar entrada final)
if current_tool:
print(f"Ferramenta {current_tool} chamada com: {tool_input}")
current_tool = NoneEssa lógica ajudará você a entender melhor as ferramentas chamadas pelo agente e suas respectivas entradas. Incrível! Agora só falta testar o agente.
Etapa 7: teste o agente de IA
Seu arquivo agent.py final conterá:
from dotenv import load_dotenv
import os
import asyncio
from claude_agent_sdk import query, ClaudeAgentOptions
from claude_agent_sdk.types import StreamEvent
# Carregar variáveis de ambiente do arquivo .env
load_dotenv()
# Acessar a variável de ambiente da chave da API Bright Data
BRIGHT_DATA_API_KEY = os.getenv("BRIGHT_DATA_API_KEY")
async def main():
options = ClaudeAgentOptions(
# Conecte-se ao Web MCP da Bright Data
mcp_servers={
"bright_data": {
"command": "npx",
"args": ["-y", "@brightdata/mcp"],
"env": {
"API_TOKEN": BRIGHT_DATA_API_KEY,
"PRO_MODE": "true" # Para ativar o modo Pro
}
}
},
allowed_tools=["mcp__bright_data__*"], # Ativar todas as ferramentas do Bright Data Web MCP
model="claude-haiku-4-5", # Substitua pelo seu modelo Claude preferido
include_partial_messages=True, # Ativar respostas de streaming
permission_mode="acceptEdits", # Para permitir que o agente grave arquivos no disco
max_buffer_size=10 * 1024 * 1024, # Aumente para 10 MB para manipulação de imagens
)
# O prompt enviado ao agente
prompt = """
Abra uma sessão do Navegador de scraping e navegue até a seguinte página da web:
"https://www.nike.com/"
Aguarde até que a página seja totalmente carregada e, em seguida, capture uma captura de tela da página inteira. Extraia também o texto completo da página. Salve a captura de tela em um arquivo local `screenshot.png` e o texto da página em um arquivo local `text.txt`.
"""
# Rastreie a ferramenta atual e acumule sua entrada JSON
current_tool = None
tool_input = ""
# Loop Agentic: transmite eventos retornados pelo Claude Agent SDK
async for message in query(prompt=prompt, options=options):
# Intercepte apenas eventos de streaming
if isinstance(message, StreamEvent):
event = message.event
event_type = event.get("type")
if event_type == "content_block_start":
# Nova chamada de ferramenta está começando
content_block = event.get("content_block", {})
if content_block.get("type") == "tool_use":
current_tool = content_block.get("name")
tool_input = ""
print(f"nIniciando ferramenta: {current_tool}")
# Lidar com saída de texto incremental
elif event_type == "content_block_delta":
delta = event.get("delta", {})
if delta.get("type") == "text_delta":
# Imprimir texto transmitido à medida que chega
imprimir(delta.obter("texto", ""), fim="", flush=True)
elif delta.obter("tipo") == "input_json_delta":
# Acumular entrada JSON à medida que é transmitida
chunk = delta.obter("partial_json", "")
tool_input += chunk
elif event_type == "content_block_stop":
# Chamada da ferramenta concluída (mostrar entrada final)
if current_tool:
print(f"Ferramenta {current_tool} chamada com: {tool_input}")
current_tool = None
asyncio.run(main())Inicie com:
python agent.pySe você executar o agente, deverá ver uma saída como esta:
Como você pode ver, o agente se conecta ao Web MCP e usa as seguintes ferramentas:
mcp__bright_data__scraping_browser_screenshotpara capturar uma captura de tela de página inteiramcp__bright_data__scraping_browser_get_textpara extrair todo o texto da página da web
Em seguida, ele usa a ferramenta “Write” para salvar a saída nos arquivos solicitados. Após a execução, a pasta raiz do seu projeto deve agora incluir screenshot.png e text.txt:
Abra screenshot.png para ver a captura de tela da página inicial da Nike:
Abra o arquivo text.txt para visualizar o texto extraído da página acima:
Et voilà! Seu agente de IA, orquestrado por meio do Claude Agent SDK e ampliado com o Bright Data Web MCP, agora pode lidar com a navegação na web e muito mais!
Conclusão
Neste tutorial, você aprendeu como aproveitar as ferramentas personalizadas por meio da integração MCP no SDK do Claude Agent para criar agentes de IA estendidos. Especificamente, você viu por que e como aprimorar um agente de IA alimentado pelo SDK Python do Claude Agent, conectando-o ao Web MCP da Bright Data.
Essa integração equipa seu agente de IA com tecnologia Claude com recursos poderosos, como pesquisa na web, extração de dados estruturados, recuperação de dados da web em tempo real e interações automatizadas na web, permitindo uma ampla gama de casos de uso de agentes.
Cadastre-se gratuitamente hoje mesmo para obter uma conta Bright Data e comece a usar as ferramentas de dados da web prontas para IA!
