--- title: "Adaptadores Langchain MCP com Bright Data MCP da Bright Data" slug: langchain-mcp-adapters-with-web-mcp date: 2026-01-05T13:21:35+00:00 modified: 2026-01-05T13:21:37+00:00 permalink: https://brightdata.com.br/blog/ai/langchain-mcp-adapters-with-web-mcp type: blog --- [ Blog ](https://brightdata.com.br/blog "Blog") / [AI](https://brightdata.com.br/blog/ai) [AI](https://brightdata.com.br/blog/ai) # Adaptadores Langchain MCP com Bright Data MCP da Bright Data Aprenda como potencializar os agentes IA do LangChain com recursos da web ao vivo, integrando o Web MCP da Bright Data por meio da biblioteca LangChain MCP Adapters. 19 min de leitura [ ![Antonello Zanini](https://media.brightdata.com.br/2022/12/Antonello-Zanini-2-50x50.jpg) ](https://brightdata.com/blog/authors/antonello-zanini) [Antonello Zanini Technical Writer ](https://brightdata.com/blog/authors/antonello-zanini) ![Langchain × Bright Data MCP](https://media.brightdata.com.br/2025/10/Langchain-%C3%97-Bright-Data-MCP.png) 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 MCP](/ai/mcp-server). - Como conectar os adaptadores Langchain MCP ao Bright Data MCP em um agente ReAct. Vamos começar! ## O que é a biblioteca LangChain MCP Adapters? O [Langchain MCP Adapters](https://changelog.langchain.com/announcements/mcp-adapters-for-langchain-and-langgraph) é 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`](https://github.com/langchain-ai/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](https://docs.langchain.com/mcp-adapters). ## Por que integrar um agente LangGraph com o Bright Data 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 Bright Data MCP da Bright Data**](/ai/mcp-server)! Disponível como um [pacote Node.js de código aberto](https://github.com/brightdata/brightdata-mcp), *o Bright Data 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 Bright Data MCP são: FerramentaDescriçã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 Bright Data MCP da Bright Data oferece [cerca de 60 ferramentas especializadas](https://github.com/brightdata/brightdata-mcp/blob/main/assets/Tools.md) 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 Bright Data MCP!](https://docs.brightdata.com/mcp-server/overview) Se você estiver procurando [integrações](https://python.langchain.com/docs/integrations/providers/brightdata/) diretas [da Bright Data por meio das ferramentas Langchain](https://python.langchain.com/docs/integrations/providers/brightdata/), consulte estes guias: - [*Como configurar o Bright Data com Langchain* ](https://docs.brightdata.com/integrations/langchain) - [*Scraping de dados com Langchain e Bright Data*](/blog/ai/web-scraping-with-langchain-and-bright-data) - [*Usando Langchain e Bright Data para pesquisa na web*](/blog/ai/langchain-serp-scraping) ## Como conectar o Bright Data MCP em um agente de IA usando adaptadores MCP Langchain Nesta seção passo a passo, você aprenderá como integrar o Bright Data 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](https://js.langchain.com/docs/introduction/). 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](https://www.python.org/downloads/). - Node.js instalado localmente (recomendamos a versão LTS mais recente). - Uma chave API da Bright Data. - Uma [chave API OpenAI](https://platform.openai.com/api-keys) (ou uma chave API de qualquer [outro LLM compatível com Langchain](https://python.langchain.com/docs/concepts/chat_models/)). 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.](https://modelcontextprotocol.io/docs/learn/architecture) - Alguma familiaridade com o Bright Data 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: ```none 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](https://docs.python.org/3/library/venv.html): ```none 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](https://code.visualstudio.com/docs/languages/python) ou [o PyCharm Community Edition](https://www.jetbrains.com/pycharm/download/). Dentro da pasta do projeto, crie um novo arquivo chamado `agent.py`. Seu projeto agora deve estar assim: ```none 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: ```none 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: ```none source .venv/bin/activate ``` De forma equivalente, no Windows, execute: ```none .venv/Scripts/activate ``` Com o ambiente ativado, instale as dependências necessárias: ```none pip install langchain["openai"] langchain-mcp-adapters langgraph ``` Veja o que cada pacote faz: - [`langchain["openai"]`](https://pypi.org/project/langchain/): biblioteca principal do LangChain com integração OpenAI. - [`langchain-mcp-adapters`](https://pypi.org/project/langchain-mcp-adapters/): Wrapper leve que torna as ferramentas MCP compatíveis com LangChain e LangGraph - [`langgraph`](https://pypi.org/project/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](https://python.langchain.com/docs/integrations/providers/). Pronto! Seu ambiente de desenvolvimento Python está pronto para oferecer suporte a um agente de IA que se conecta ao Bright Data 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: ```none import os os.environ["OPENAI_API_KEY"] = "" ``` 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`](https://python.langchain.com/docs/integrations/chat/openai/) do pacote `langchain_openai`: ```none 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: ```none llm = ChatOpenAI( model="gpt-5-mini", ) ``` Neste exemplo, estamos usando [`gpt-5-mini`](https://platform.openai.com/docs/models/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 MCP Antes de conectar seu agente ao Bright Data 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](/?hs_signup=1). Se já tiver uma, basta [fazer login](/cp/start). Para uma configuração rápida, [abra a página “MCP” na sua conta](/cp/mcp) e siga as instruções: ![The Bright Data “MCP” page in your account](https://media.brightdata.com.br/2025/10/image-60.png)Caso contrário, siga as etapas abaixo para uma abordagem mais orientada. Primeiro, [gere uma chave API da Bright Data](https://docs.brightdata.com/api-reference/authentication#generating-an-api-key%3A) 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 Bright Data MCP globalmente através do pacote [`@brightdata/mcp`](https://www.npmjs.com/package/@brightdata/mcp): ```none npm install -g @brightdata/mcp ``` Verifique se o servidor MCP local funciona com este comando Bash: ```none API_TOKEN="" npx -y @brightdata/mcp ``` Ou, de forma equivalente, no Windows PowerShell, execute: ```none $Env:API_TOKEN=""; npx -y @brightdata/mcp ``` Substitua o espaço reservado `` 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: ![Bright Data MCP startup logs](https://media.brightdata.com.br/2025/10/image-61.png)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](/products/web-unlocker). - `mcp_browser`: uma zona para [a API do navegador](/products/scraping-browser). Essas duas zonas são necessárias para que o Bright Data 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](/cp/zones)” (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 Bright Data MCP at startup](https://media.brightdata.com.br/2025/10/image-62.png)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](https://github.com/brightdata/brightdata-mcp?tab=readme-ov-file#-account-setup). **Observação**: por padrão, o servidor Bright Data MCP expõe apenas as ferramentas `search_engine` e `scrape_as_markdown` ([que podem ser usadas gratuitamente](/blog/ai/web-mcp-free-tier)!). 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: ```none API_TOKEN="" PRO_MODE="true" npx -y @brightdata/mcp ``` Ou, no PowerShell: ```none $Env:API_TOKEN=""; $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 Bright Data 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 Bright Data MCP por meio dos adaptadores Langchain MCP Primeiro, importe as bibliotecas necessárias do pacote Langchain MCP Adapters: ```none 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 Bright Data MCP local, a maneira mais fácil de se conectar é [via `stdio`](https://modelcontextprotocol.io/specification/2025-06-18/basic/transports#stdio) (entrada/saída padrão) em vez de [SSE ou Streamable HTTP](/blog/ai/sse-vs-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: ```none server_params = StdioServerParameters( command="npx", args=["-y", "@brightdata/mcp"], env={ "API_TOKEN": "", "PRO_MODE": "true" } ) ``` Essa configuração reflete o comando que você executou manualmente anteriormente para testar o Bright Data 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 Bright Data MCP como um subprocesso. Em seguida, inicialize a sessão do MCP e carregue as ferramentas expostas: ```none 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()`](https://langchain-ai.github.io/langgraph/reference/prebuilt/#langgraph.prebuilt.chat_agent_executor.create_react_agent): ```none agent = create_react_agent(llm, tools) ``` **Observação**: ao trabalhar com ferramentas, é melhor contar com [agentes de IA que seguem a arquitetura ReAct](https://hackernoon.com/inside-the-react-design-pattern-how-modern-ai-thinks-and-acts). 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: ```none 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: ```none 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](https://www.zoominfo.com/c/nike-inc/27722128?utm_source=chatgpt.com)‘. 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 Bright Data MCP para buscar e estruturar dados reais. Isso torna a integração uma demonstração perfeita! Ótimo! Seu agente Bright Data 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: ```none import asyncio import os os.environ["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 MCP server_params = StdioServerParameters( command="npx", args=["-y", "@brightdata/mcp"], env={ "API_TOKEN": "", # 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: ```none python agent.py ``` No terminal, você deverá ver imediatamente: ![MCP tool calling from the LangGraph agent](https://media.brightdata.com.br/2025/10/image-63.png)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 Bright Data 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á: ![The tool output](https://media.brightdata.com.br/2025/10/image-64.png)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](/products/web-scraper/zoominfo) disponível na infraestrutura da Bright Data, que é chamado nos bastidores pela ferramenta Bright Data 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](https://www.zoominfo.com/c/nike-inc/27722128), os dados recuperados são precisos e vêm diretamente da página de destino: ![The target ZoomInfo company profile page](https://media.brightdata.com.br/2025/10/image-65.png)Tenha em mente que [fazer scraping do ZoomInfo](/blog/web-data/how-to-scrape-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 MCP! Dados os dados do perfil da empresa ZoomInfo, o relatório Markdown produzido pelo agente ficará mais ou menos assim: ```none # 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](https://media.brightdata.com.br/2025/10/image-66.png)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 Bright Data 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](https://realpython.com/python-repl/)) 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](https://python.langchain.com/docs/how_to/chatbots_memory/)— 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](https://docs.langchain.com/langgraph-platform/deployment-options). Experimente seu agente Langchain + Bright Data MCP com diferentes prompts e explore outros [fluxos de trabalho avançados orientados por agentes](/ai/web-access)! ## Conclusão Neste artigo, você aprendeu como aproveitar o Bright Data MCP da Bright Data ([agora disponível com um nível gratuito!](/blog/ai/web-mcp-free-tier)) 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](/ai/web-access), incluindo configurações com vários agentes. Com as mais de 60 ferramentas oferecidas pelo Bright Data MCP e a gama completa de soluções na [infraestrutura de IA da Bright Data](/ai), 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-nosTeste grátis![google social icon](/wp-content/themes/brightdata/assets/images/ic_google.svg) Índice Data for AI Supercharge your AI with instant and reliable access to web data. No blockers. No hassle. Talk to an expert Bright Data MCP Get started with Bright Data’s Web MCP Server today with 5000 free monthly requests and unlock your AI’s full potential. Start free now [ ](https://news.ycombinator.com/submitlink?t=Adaptadores+Langchain+MCP+com+Bright+Data+MCP+da+Bright+Data&u=https://brightdata.com.br/blog/ai/langchain-mcp-adapters-with-web-mcp) [ ](https://www.linkedin.com/shareArticle?mini=true&title=Adaptadores+Langchain+MCP+com+Bright+Data+MCP+da+Bright+Data&url=https://brightdata.com.br/blog/ai/langchain-mcp-adapters-with-web-mcp) [ ](http://www.reddit.com/submit?title=Adaptadores+Langchain+MCP+com+Bright+Data+MCP+da+Bright+Data&url=https://brightdata.com.br/blog/ai/langchain-mcp-adapters-with-web-mcp) ## Você também pode estar interessado em [ ![OpenHuman with Bright Data](https://media.brightdata.com.br/2026/09/OpenHuman-with-Bright-Data.png) ](https://brightdata.com.br/blog/ai/openhuman-with-bright-data "Acesso à Web Pronto para Produção no OpenHuman Através do Bright Data CLI") [AI ![Antonello Zanini](https://media.brightdata.com.br/2022/12/Antonello-Zanini-2-50x50.jpg) Antonello Zanini Technical Writer ### Acesso à Web Pronto para Produção no OpenHuman Através do Bright Data CLI Integre o Bright Data CLI ao OpenHuman para habilitar acesso à web pronto para produção e coleta de dados para agentes de IA. 09-Sep-2026 14 min de leitura ](https://brightdata.com.br/blog/ai/openhuman-with-bright-data) [ ![Multimodal Web Scraping with MiniMax](https://media.brightdata.com.br/2026/09/Multimodal-Web-Scraping-with-MiniMax.png) ](https://brightdata.com.br/blog/dados-do-site/multimodal-web-scraping-with-minimax "Scraping de Dados Multimodal com MiniMax") [Dados do site ![Antonello Zanini](https://media.brightdata.com.br/2022/12/Antonello-Zanini-2-50x50.jpg) Antonello Zanini Technical Writer ### Scraping de Dados Multimodal com MiniMax Combine a API Web Unlocker da Bright Data com a visão MiniMax M3 para extrair dados estruturados de imagens e capturas de tela de páginas web. 09-Sep-2026 5 min de leitura ](https://brightdata.com.br/blog/dados-do-site/multimodal-web-scraping-with-minimax) [ ![The 10 Best CLI Tools for Codex in 2026](https://media.brightdata.com.br/2026/08/The-10-Best-CLI-Tools-for-Codex-in-2026.png) ](https://brightdata.com.br/blog/ai/best-cli-tools-for-codex "As 10 Melhores Ferramentas CLI para Codex em 2026 – Testadas & Classificadas") [AI ![Daniel Shashko](https://media.brightdata.com.br/2022/04/Daniel-Shashko-2-50x50.png) Daniel Shashko Web Data & AI Expert ### As 10 Melhores Ferramentas CLI para Codex em 2026 – Testadas & Classificadas As 10 ferramentas CLI que tornam o Codex mais rápido e capaz, começando com o Bright Data CLI para acesso real à web de dentro do sandbox. 06-Sep-2026 24 min de leitura ](https://brightdata.com.br/blog/ai/best-cli-tools-for-codex)