Conecte os agentes LangChain ao Bright Data Web MCP facilmente

Neste tutorial, você aprenderá:

O que é a biblioteca Langchain MCP Adapters e o que ela oferece.
Por que utilizá-la para fornecer a um agente recursos de pesquisa na web, recuperação de dados da web e interação com a web por meio do Bright Data Web MCP.
Como conectar os adaptadores Langchain MCP ao Web MCP em um agente ReAct.

Vamos começar!

O que é a biblioteca LangChain MCP Adapters?

O Langchain MCP Adapters é um pacote que permite usar ferramentas MCP no Langchain e no LangGraph. Ele está disponível através do pacote de código aberto langchain-mcp-adapters, que se encarrega de converter ferramentas MCP em ferramentas compatíveis com Langchain e LangGraph.

Graças a essa conversão, você pode usar ferramentas MCP de servidores locais ou remotos diretamente em seus fluxos de trabalho Langchain ou agentes LangGraph. Essas ferramentas MCP podem ser empregadas da mesma forma que as centenas de ferramentas já publicadas para agentes LangGraph.

Especificamente, o pacote também inclui uma implementação de cliente MCP que permite conectar-se a vários servidores MCP e carregar ferramentas a partir deles. Saiba mais sobre como usá-lo na documentação oficial.

Por que integrar um agente LangGraph com o Web MCP da Bright Data

Os agentes IA criados com o LangGraph IA herdam as limitações do LLM subjacente. Isso inclui a falta de acesso a informações em tempo real, o que às vezes pode levar a respostas imprecisas ou desatualizadas.

Felizmente, essa limitação pode ser superada equipando o agente com dados da web atualizados e a capacidade de realizar exploração da web ao vivo. É aí que entra o Web MCP da Bright Data!

Disponível como um pacote Node.js de código aberto, o Web MCP se integra ao conjunto de ferramentas de recuperação de dados prontas para IA da Bright Data, permitindo que seu agente acesse conteúdo da web, consulte conjuntos de dados estruturados, realize pesquisas na web e interaja com páginas da web em tempo real.

Em particular, duas ferramentas populares expostas pelo Web MCP são:

Ferramenta	Descrição
`scrape_as_markdown`	Rasteja o conteúdo de uma única URL de página da web com opções avançadas de extração, retornando os resultados como Markdown. Pode contornar a detecção de bots e CAPTCHA.
`search_engine`	Extraia resultados de pesquisa do Google, Bing ou Yandex, retornando dados SERP no formato JSON ou Markdown.

Além disso, o Web MCP da Bright Data oferece cerca de 60 ferramentas especializadas para interagir com páginas da web (por exemplo, scraping_browser_click) e coletar dados estruturados de uma ampla variedade de sites, incluindo Amazon, TikTok, Instagram, Yahoo Finance, LinkedIn, ZoomInfo e muito mais.

Por exemplo, a ferramenta web_data_zoominfo_company_profile recupera informações detalhadas e estruturadas do perfil da empresa do ZoomInfo, aceitando uma URL válida da empresa como entrada. Saiba mais nos documentos oficiais do Web MCP!

Se você estiver procurando integrações diretas da Bright Data por meio das ferramentas Langchain, consulte estes guias:

Como conectar o Web MCP em um agente de IA usando adaptadores MCP Langchain

Nesta seção passo a passo, você aprenderá como integrar o Bright Data Web MCP a um agente LagnGraph usando a biblioteca de adaptadores MCP. O resultado será um agente de IA com acesso a mais de 60 ferramentas para pesquisa na web, acesso a dados e interação na web.

Depois de configurado, o agente IA será empregado para buscar dados da empresa no ZoomInfo e gerar um relatório detalhado. Esse resultado pode ajudá-lo a avaliar se vale a pena investir, se candidatar ou explorar mais uma empresa.

Siga as etapas abaixo para começar!

Observação: este tutorial se concentra no Langchain em Python, mas pode ser facilmente adaptado ao Langchain JavaScript SDK. Da mesma forma, embora o agente dependa do OpenAI, você pode substituí-lo por qualquer outro LLM compatível.

Pré-requisitos

Para acompanhar este tutorial, certifique-se de ter:

Python 3.8+ instalado localmente.
Node.js instalado localmente (recomendamos a versão LTS mais recente).
Uma chave API da Bright Data.
Uma chave API OpenAI (ou uma chave API de qualquer outro LLM compatível com Langchain).

Não se preocupe com a configuração do Bright Data ainda, pois você será orientado sobre isso nas próximas etapas.

Também é útil (mas opcional) ter algum conhecimento prévio, como:

Uma compreensão geral de como o MCP funciona.
Alguma familiaridade com o Web MCP da Bright Data e as ferramentas que ele oferece.

Etapa 1: Configure seu projeto Langchain

Abra um terminal e crie um novo diretório para o seu agente de IA com tecnologia LangGraph MCP:

mkdir langchain-mcp-agent

A pasta langchain-mcp-agent/ conterá o código Python para o seu agente de IA.

Em seguida, navegue até o diretório do projeto e configure um ambiente virtual:

cd langchain-mcp-agent
python -m venv .venv

Agora, abra o projeto em seu IDE Python favorito. Recomendamos o Visual Studio Code com a extensão Python ou o PyCharm Community Edition.

Dentro da pasta do projeto, crie um novo arquivo chamado agent.py. Seu projeto agora deve estar assim:

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

Aqui, agent.py será seu arquivo Python principal. Inicialize-o para execução de código assíncrono com:

import asyncio

async def main():
    # Lógica de definição do agente...

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

É hora de ativar o ambiente virtual. No Linux ou macOS, execute:

source .venv/bin/activate

De forma equivalente, no Windows, execute:

.venv/Scripts/activate

Com o ambiente ativado, instale as dependências necessárias:

pip install langchain["openai"] langchain-mcp-adapters langgraph

Veja o que cada pacote faz:

langchain["openai"]: biblioteca principal do LangChain com integração OpenAI.
langchain-mcp-adapters: Wrapper leve que torna as ferramentas MCP compatíveis com LangChain e LangGraph
langgraph: uma estrutura de orquestração de baixo nível para construir, gerenciar e implantar agentes de longa duração e com estado, geralmente sobre o LangChain.

Observação: se você não planeja usar o OpenAI para integração LLM, substitua langchain["openai"] pelo pacote equivalente para o seu provedor de IA.

Pronto! Seu ambiente de desenvolvimento Python está pronto para oferecer suporte a um agente de IA que se conecta ao Bright Data Web MCP.

Etapa 2: integre seu LLM

Isenção de responsabilidade: se você estiver usando um provedor LLM diferente do OpenAI, ajuste esta seção de acordo.

Primeiro, defina sua chave API OpenAI no ambiente:

import os
os.environ["OPENAI_API_KEY"] = "<SUA_CHAVE_API_OPENAI>"

Em produção, use um método mais seguro e confiável para variáveis de ambiente (por exemplo, via python-dotenv) para evitar codificar segredos diretamente em seu script.

Em seguida, importe o ChatOpenAI do pacote langchain_openai:

from langchain_openai import ChatOpenAI

O ChatOpenAI lerá automaticamente sua chave API da variável de ambiente OPENAI_API_KEY.

Agora, na função main(), inicialize uma instância do ChatOpenAI com o modelo desejado:

llm = ChatOpenAI(
    model="gpt-5-mini",
)

Neste exemplo, estamos usando gpt-5-mini, mas você pode substituí-lo por qualquer outro modelo disponível. Esta instância LLM servirá como o mecanismo para o seu agente de IA. Ótimo!

Etapa 3: teste o Bright Data Web MCP

Antes de conectar seu agente ao Web MCP da Bright Data, verifique primeiro se sua máquina pode realmente executar o servidor MCP.

Se ainda não o fez, comece por criar uma conta Bright Data. Se já tiver uma, basta fazer login. Para uma configuração rápida, abra a página “MCP” na sua conta e siga as instruções:

The Bright Data “MCP” page in your account

Caso contrário, siga as etapas abaixo para uma abordagem mais orientada.

Primeiro, gere uma chave API da Bright Data e guarde-a em um local seguro (pois você precisará dela em breve). Neste tutorial, vamos supor que a chave API tenha permissões de administrador, pois isso torna o processo de integração muito mais simples.

Abra seu terminal e instale o Web MCP globalmente através do pacote @brightdata/mcp:

npm install -g @brightdata/mcp

Verifique se o servidor MCP local funciona com este comando Bash:

API_TOKEN="<YOUR_BRIGHT_DATA_API>" npx -y @brightdata/mcp

Ou, de forma equivalente, no Windows PowerShell, execute:

$Env:API_TOKEN="<YOUR_BRIGHT_DATA_API>"; npx -y @brightdata/mcp

Substitua o espaço reservado <YOUR_BRIGHT_DATA_API> pelo token real da API da Bright Data. Os dois comandos acima definem a variável de ambiente API_TOKEN necessária e, em seguida, ativam o servidor MCP localmente.

Em caso de sucesso, você deverá ver logs semelhantes a este:

Na primeira inicialização, o pacote @brightdata/mcp configura automaticamente duas zonas padrão 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 são necessárias para que o Web MCP exponha todas as mais de 60 ferramentas.

Para confirmar que as zonas acima foram criadas, faça login no painel do Bright Data. Navegue até a página“Proxy & Infraestrutura de scraping” (Proxy e infraestrutura de scraping) e você deverá ver as duas zonas listadas na tabela:

The mcp_unlocker and mcp_browser zones created by the Web MCP at startup

Se o seu token de API não tiver permissões de administrador, essas zonas não serão configuradas para você. Nesse caso, você pode criá-las manualmente no painel e especificar seus nomes por meio de variáveis de ambiente, conforme explicado na página do GitHub do pacote.

Observação: por padrão, o servidor Web MCP expõe apenas as ferramentas search_engine e scrape_as_markdown (que podem ser usadas gratuitamente!). Para desbloquear ferramentas avançadas para automação do navegador e extração de dados estruturados, você precisa habilitar o modo Pro.

Para ativar o modo Pro, defina a variável de ambiente PRO_MODE=true antes de iniciar o servidor MCP:

API_TOKEN="<YOUR_BRIGHT_DATA_API>" PRO_MODE="true" npx -y @brightdata/mcp

Ou, no PowerShell:

$Env:API_TOKEN="<YOUR_BRIGHT_DATA_API>"; $Env:PRO_MODE="true"; npx -y @brightdata/mcp

Importante: se você optar por usar o modo Pro, terá acesso a todas as mais de 60 ferramentas. Por outro lado, o modo Pro não está incluído no plano gratuito e acarretará custos adicionais.

Perfeito! Você verificou que sua máquina pode executar o servidor Web MCP. Encerre o processo do servidor, pois agora você configurará o Langchain para iniciá-lo automaticamente e se conectar a ele.

Etapa 4: inicialize a conexão Web MCP por meio dos adaptadores Langchain MCP

Primeiro, importe as bibliotecas necessárias do pacote Langchain MCP Adapters:

from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client
from langchain_mcp_adapters.tools import load_mcp_tools

Como sua máquina pode executar um servidor Web MCP local, a maneira mais fácil de se conectar é via stdio (entrada/saída padrão) em vez de SSE ou Streamable HTTP. Em termos mais simples, você está configurando seu aplicativo de IA para iniciar o servidor MCP como um subprocesso e se comunicar com ele diretamente usando entrada/saída padrão.

Para fazer isso, defina o objeto de configuração StdioServerParameters desta forma:

server_params = StdioServerParameters(
    command="npx",
    args=["-y", "@brightdata/mcp"],
    env={
        "API_TOKEN": "<YOUR_BRIGHT_DATA_API_KEY>",
        "PRO_MODE": "true"
    }
)

Essa configuração reflete o comando que você executou manualmente anteriormente para testar o Web MCP. Seu aplicativo usará essa configuração para executar o npx com as variáveis de ambiente necessárias (lembre-se de que PRO_MODE é opcional) e iniciar o Web MCP como um subprocesso.

Em seguida, inicialize a sessão do MCP e carregue as ferramentas expostas:

async com stdio_client(server_params) como (leitura, gravação):
    async com ClientSession(leitura, gravação) como sessão:
        await session.initialize()

        tools = await load_mcp_tools(session)

A função load_mcp_tools() faz o trabalho pesado: ela converte automaticamente as ferramentas MCP em ferramentas compatíveis com Langchain e LangGraph.

Fantástico! Agora você tem uma lista de ferramentas prontas para passar para a definição do seu agente LangGraph.

Etapa 5: Crie e interrogue um agente ReAct

Dentro do bloco with interno, use o mecanismo LLM junto com a lista de ferramentas MCP para criar seu agente LangGraph com create_react_agent():

agent = create_react_agent(llm, tools)

Observação: ao trabalhar com ferramentas, é melhor contar com agentes de IA que seguem a arquitetura ReAct. O motivo é que essa abordagem permite que eles raciocinem mais profundamente sobre o processo e escolham as ferramentas certas para concluir a tarefa.

Importe create_react_agent() do LangGraph:

from langgraph.prebuilt import create_react_agent

Em seguida, interrogue o agente de IA. Em vez de esperar pela resposta completa e imprimi-la de uma só vez, é melhor transmitir a saída diretamente para o console. O uso da ferramenta pode levar tempo, portanto, a transmissão fornece feedback útil à medida que o agente processa a tarefa:

input_prompt = """
    Extraia dados da página da empresa ZoomInfo: 'https://www.zoominfo.com/c/nike-inc/27722128'. Em seguida, usando os dados recuperados, produza um relatório conciso no formato Markdown resumindo as principais informações sobre a empresa.
"""

# Transmita a resposta do agente
async for step in agent.astream({"messages": [input_prompt]}, stream_mode="values"):
    step["messages"][-1].pretty_print()

Neste exemplo, o agente é solicitado a:

“Extraia os dados da página da empresa ZoomInfo:‘https://www.zoominfo.com/c/nike-inc/27722128‘. Em seguida, usando os dados recuperados, produza um relatório conciso no formato Markdown resumindo as principais informações sobre a empresa.”

Observação: a URL da página da empresa ZoomInfo refere-se à Nike, mas você pode alterá-la para qualquer outra empresa ou modificar completamente o prompt para um cenário diferente de recuperação de dados.

Isso reflete exatamente o que foi descrito na introdução deste capítulo. É importante ressaltar que essa tarefa obriga o agente a usar as ferramentas Web MCP para buscar e estruturar dados reais. Isso torna a integração uma demonstração perfeita!

Ótimo! Seu agente Web MCP + Langchain LangGraph IA está pronto. Resta apenas vê-lo em ação.

Etapa 6: Junte tudo

O código final em agent.py deve ser:

import asyncio
import os
os.environ["OPENAI_API_KEY"] = "<YOUR_OPENAI_API_KEY>" # Substitua pela sua chave API OpenAI

from langchain_openai import ChatOpenAI
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client
from langchain_mcp_adapters.tools import load_mcp_tools
from langgraph.prebuilt import create_react_agent

async def main():
    # Inicialize o mecanismo LLM
    llm = ChatOpenAI(
        model="gpt-5-mini",
    )

    # Configuração para conectar-se a uma instância local do servidor Bright Data Web MCP
    server_params = StdioServerParameters(
        command="npx",
        args=["-y", "@brightdata/mcp"],
        env={
            "API_TOKEN": "<YOUR_BRIGHT_DATA_API_KEY>", # Substitua pela sua chave API Bright Data
            "PRO_MODE": "true"
        }
    )

    # Conecte-se ao servidor MCP
    async with stdio_client(server_params) as (read, write):
        async with ClientSession(read, write) as session:
            # Inicialize a sessão do cliente MCP
            await session.initialize()

            # Obter as ferramentas MCP
            tools = await load_mcp_tools(session)

            # Criar o agente ReAct
            agent = create_react_agent(llm, tools)

            # Descrição da tarefa do agente
            input_prompt = """
                Extraia dados da página da empresa ZoomInfo: 'https://www.zoominfo.com/c/nike-inc/27722128'. Em seguida, usando os dados recuperados, produza um relatório conciso no formato Markdown resumindo as principais informações sobre a empresa.
            """

# Transmita a resposta do agente
async for step in agent.astream({"messages": [input_prompt]}, stream_mode="values"):
step["messages"][-1].pretty_print()

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

Uau! Com apenas ~50 linhas de código, você acabou de criar um agente ReAct com integração MCP, graças aos adaptadores MCP do Langchain.

Inicie seu agente com:

python agent.py

No terminal, você deverá ver imediatamente:

MCP tool calling from the LangGraph agent

Isso prova que o agente LangGraph recebe seu prompt conforme o esperado. Em seguida, o mecanismo LLM o processa e determina imediatamente que web_data_zoominfo_company_profile é a ferramenta MCP correta do Web MCP a ser chamada para concluir a tarefa. Em detalhes, ele chama a ferramenta com o argumento URL ZoomInfo correto inferido do prompt (https://www.zoominfo.com/c/nike-inc/27722128).

A saída da chamada da ferramenta será:

A ferramenta web_data_zoominfo_company_profile retorna os dados do perfil da empresa ZoomInfo no formato JSON. Observe que este não é um conteúdo alucinado ou inventado pelo modelo GPT-5 mini!

Em vez disso, os dados vêm diretamente do ZoomInfo Scraper disponível na infraestrutura da Bright Data, que é chamado nos bastidores pela ferramenta Web MCP web_data_zoominfo_company_profile selecionada.

O ZoomInfo Scraper contorna todas as proteções anti-bot, coleta dados da página de perfil público da empresa em tempo real e os retorna em um formato JSON estruturado. Como você pode verificar na página real do ZoomInfo, os dados recuperados são precisos e vêm diretamente da página de destino:

Tenha em mente que fazer scraping do ZoomInfo não é uma tarefa fácil devido às suas técnicas anti-scraping, incluindo um CAPTCHA desafiador. Portanto, essa não é uma tarefa que qualquer LLM pode realizar. Pelo contrário, ela só pode ser realizada por um agente com acesso a ferramentas dedicadas de recuperação de dados da web.

Este exemplo simples demonstra o poder da integração Langchain + Bright Data Web MCP!

Dados os dados do perfil da empresa ZoomInfo, o relatório Markdown produzido pelo agente ficará mais ou menos assim:

# NIKE, Inc. — Visão geral da empresa

## Visão geral
A NIKE, Inc. projeta, desenvolve, comercializa e vende calçados, roupas, equipamentos e acessórios esportivos em todo o mundo.

## Fatos rápidos
- **Nome:** NIKE, Inc.
- **Site:** [https://www.nike.com/](https://www.nike.com/)  
- **Sede:** 1 SW Bowerman Dr, Beaverton, OR 97005, Estados Unidos  
- **Telefone:** (503) 671-6453  
- **Código da ação:** NYSE: NKE  
- **Receita:** US$ 46,3 bilhões (relatada)  
- **Funcionários:** 77.800  
- **Setores:** Manufatura; Varejo; Artigos esportivos; Têxteis e vestuário; Varejo de vestuário e acessórios  
- **Carimbo de data/hora do ZoomInfo:** 2026-09-02T08:47:19.789Z  

## Finanças/Financiamento
- **Receita declarada:** US$ 46,3 bilhões  
- **Financiamento (ZoomInfo):** Financiamento total de US$ 1,0 bilhão em três rodadas *(os números podem refletir dados históricos ou não públicos; a Nike é uma empresa de capital aberto)*  

## Força de trabalho e cultura
- **Total de funcionários:** 77.800  
- **Distribuição dos funcionários (ZoomInfo):**  
  - Nível C: 23  
  - Vice-presidentes: ~529  
  - Diretores: ~6.115  
  - Gerentes: ~13.289  
  - Não gerentes: ~29.578  
- **Pontuação eNPS:** 20 *(Promotores 50% / Passivos 20% / Detratores 30%)*  

## Liderança (selecionada / do organograma)
- Amy Montagne — Presidente, Nike  
- Nicole Graham — Vice-presidente executiva e diretora de marketing  
- Cheryan Jacob — Diretor de Informação  
- Muge Dogan — Vice-presidente executivo e diretor de Tecnologia  
- Chris George — Vice-presidente e diretor financeiro (Geo...)  
- Sarah Mensah — Presidente, Jordan Brand  
> *Observação: o perfil da ZoomInfo não listou nenhuma entrada de CEO nos dados capturados.*  

## Tecnologia e ferramentas (exemplos)
- SolidWorks (Dassault Systèmes)
- EventPro (Profit Systems)
- Microsoft IIS (Microsoft)
- SAP Sybase RAP (SAP)

## Notícias recentes/destaques da mídia (resumo)
- **Contratação:** Diretor sênior, Mercado (Xangai).  
- **Mudança de pessoal:** Ron Faris Virtual Studios deixou a Nike para ingressar na Disney Consumer Products (vice-presidente, Marketing Global).
- **Notas comerciais:** Tarifas/contratempos geopolíticos afetaram os resultados de curto prazo; a empresa está implementando ações de mitigação e medidas para “vencer agora”.
- **Demissões:** Relatos de uma pequena demissão corporativa (~1% dos funcionários corporativos).  

## Empresas comparáveis (exemplos)
- ANTA Sports Products  
- adidas AG  
- Foot Locker  
- Guess  
- Timberland  
- Genesco  

## Contatos e divulgação
- **Site corporativo:** [https://www.nike.com/](https://www.nike.com/)  
- **Formatos típicos de e-mail (observados):** `[email protected]` (também `@converse.com` para marcas relacionadas)

## Fonte dos dados
- Perfil da empresa ZoomInfo para a NIKE, Inc.  
  [https://www.zoominfo.com/c/nike-inc/27722128](https://www.zoominfo.com/c/nike-inc/27722128)  
  **Data da captura:** 2026-09-02T08:47:19.789Z

Visualize em um visualizador Markdown e você verá:

The AI-generated report in a Markdown viewer

Et voilà! Seu agente ReAct selecionou a ferramenta certa para a tarefa e a utilizou para produzir um relatório Markdown rico em informações com dados reais da empresa extraídos do ZoomInfo.

Tudo isso não teria sido possível sem a integração do Web MCP, que agora é compatível com o Langchain graças à biblioteca MCP Adapters.

Próximos passos

O agente Langchain com tecnologia MCP desenvolvido aqui é um exemplo simples, mas funcional. Para torná-lo pronto para produção, considere as seguintes etapas:

Implemente um REPL: adicione um REPL (Read-Eval-Print Loop) para que você possa interagir com seu agente em tempo real. Para manter o contexto e rastrear interações anteriores, introduza uma camada de memória— idealmente armazenada em um banco de dados temporário ou armazenamento persistente.
Exporte a saída para um arquivo: modifique a lógica de saída para permitir o salvamento das saídas produzidas (por exemplo, relatórios) em um arquivo local. Isso facilita o compartilhamento dos resultados com outros membros da equipe.
Implemente seu agente: Implante o agente de IA na nuvem, em um ambiente de nuvem híbrida ou por meio de opções auto-hospedadas, conforme explicado na documentação do Langchain.

Experimente seu agente Langchain + Web MCP com diferentes prompts e explore outros fluxos de trabalho avançados orientados por agentes!

Conclusão

Neste artigo, você aprendeu como aproveitar o Web MCP da Bright Data (agora disponível com um nível gratuito!) para criar um agente de IA no LangGraph. Isso é possível graças à biblioteca Langchain MCP Adapters, que adiciona suporte MCP aos ecossistemas Langchain e LangGraph.

A tarefa demonstrada neste artigo foi apenas um exemplo, mas você pode usar a mesma integração para projetar fluxos de trabalho muito mais complexos, incluindo configurações com vários agentes. Com as mais de 60 ferramentas oferecidas pelo Web MCP e a gama completa de soluções na infraestrutura de IA da Bright Data, você pode capacitar seus agentes de IA para buscar, validar e transformar dados da web em tempo real de forma eficaz.

Crie uma conta Bright Data gratuitamente e comece a experimentar nossas soluções de dados da web prontas para IA hoje mesmo!

Contate-nos Teste grátis