Dê aos Agentes LangChain 21 Ferramentas Web Ao Vivo com MCP Sem Raspagem

Principais Conclusões:

• Agentes LangChain obtêm 21 ferramentas web ao vivo a partir de uma configuração de cliente. O pacote langchain-mcp-adapters conecta um aplicativo LangChain ao servidor Scrapeless MCP e retorna toda a superfície de ferramentas — controle de navegador, raspagem de página, Pesquisa e Tendências do Google — como objetos StructuredTool prontos para serem vinculados.
• Nenhum Node necessário no caminho hospedado. Aponte o cliente para https://api.scrapeless.com/mcp via HTTP transmitível com seu x-api-token; o caminho stdio (npx -y scrapeless-mcp-server) é a mesma superfície para configurações locais.
• As ferramentas funcionam antes que qualquer modelo esteja envolvido. get_tools() lista-as e ainvoke() as executa diretamente — scrape_markdown em uma URL ao vivo retorna a página como markdown — então a fiação é testável sem uma chave LLM.
• Os nomes diferem por transporte. O endpoint hospedado serve nomes simples (browser_goto, scrape_markdown, google_search); o servidor stdio os denomina scrapeless_*. Mesmas 21 ferramentas de qualquer forma.
• De ferramentas a agente é um único construtor. Vínculo das ferramentas retornadas a qualquer modelo de chat LangChain e o agente pode pesquisar, navegar e raspar a web ao vivo dentro de seu ciclo de raciocínio.
• Gratuito para começar. Novas contas Scrapeless incluem créditos de teste gratuitos — inscreva-se em app.scrapeless.com.

O Que Você Pode Fazer Com Isso

• Agentes de pesquisa que leem a web ao vivo. google_search para descoberta, scrape_markdown para texto limpo da página — a metade de recuperação de um loop de agente, sem precisar construir um raspador.
• Agentes que dirigem navegadores. Dezesseis ferramentas browser_* (criar, ir para, clicar, digitar, rolar, captura de tela, instantâneo, esperar) dão a um agente uma sessão de navegador em nuvem real para operar.
• Monitoramento de mercado e tendências. google_trends mais raspagem agendada transforma um pipeline LangChain em um serviço de monitoramento.
• RAG baseado em ferramentas. Busque páginas como markdown sob demanda, em vez de pré-indexar tudo, e deixe o agente decidir o que ler.
• Uma autenticação para tudo. A mesma chave de API Scrapeless que aciona os atores da API Scraper aciona a superfície de ferramentas MCP.

Por Que o Servidor Scrapeless MCP

O MCP (Modelo Context Protocol) é a interface padrão para fornecer ferramentas a agentes, e o LangChain fala isso por meio do pacote de adaptadores oficial. Do outro lado desse protocolo, o servidor Scrapeless MCP expõe a infraestrutura de raspagem como 21 ferramentas tipadas: sessões de navegador em nuvem no Navegador de Raspagem, raspagem de página de um único disparo para HTML, markdown ou captura de tela, e Pesquisa e Tendências do Google. O agente obtém capacidades; renderização, anti-detecção e roteamento de proxy permanecem do lado do servidor.

A combinação é importante porque os agentes LangChain são úteis apenas na medida de suas ferramentas. Um modelo que pode planejar, mas não pode buscar uma página ao vivo, responde com dados de treinamento; o mesmo modelo com essa superfície de ferramentas lê a web sobre a qual está raciocinando.

Pré-requisitos

• Python 3.10+ e um ambiente virtual.
• Uma conta Scrapeless e chave de API — inscreva-se em app.scrapeless.com.
• Para o transporte stdio opcional: Node.js 18+ (o caminho HTTP hospedado não precisa de Node).

export SCRAPELESS_API_KEY=your_api_token_here

Conectar

1. Instale o adaptador

pip install langchain-mcp-adapters langchain-core

2. Configure o cliente e verifique a contagem de ferramentas

O endpoint hospedado é o caminho mais rápido — puro HTTPS, autenticado pelo cabeçalho x-api-token:

# handshake.py — conectar LangChain ao servidor Scrapeless MCP, listar as ferramentas
import asyncio
import os

from langchain_mcp_adapters.client import MultiServerMCPClient


async def main():
    client = MultiServerMCPClient({
        "scrapeless": {
            "transport": "streamable_http",
            "url": "https://api.scrapeless.com/mcp",
            "headers": {"x-api-token": os.environ["SCRAPELESS_API_KEY"]},
        }
    })
    tools = await client.get_tools()
    names = sorted(t.name for t in tools)
    print(f"contagem de ferramentas: {len(names)}")
    print("nomes:", ", ".join(names))

asyncio.run(main())

Um handshake correto imprime 21 ferramentas:

browser_click, browser_close, browser_create, browser_get_html, browser_get_text, browser_go_back, browser_go_forward, browser_goto, browser_press_key, browser_screenshot, browser_scroll, browser_scroll_to, browser_snapshot, browser_type, browser_wait, browser_wait_for, google_search, google_trends, scrape_html, scrape_markdown, scrape_screenshot

3. Ou execute o servidor localmente via stdio

Os mesmos navios de superfície como um pacote npm para configurações locais — a forma padrão de configuração MCP, com a chave passada como uma variável de ambiente:

{
  "scrapeless": {
    "command": "npx",
    "args": ["-y", "scrapeless-mcp-server"],
    "transport": "stdio",
    "env": { "SCRAPELESS_KEY": "seu_token_api_aqui" }
  }
}

Uma diferença de nível de transporte a se esperar: o servidor stdio nomeia suas ferramentas como scrapeless_*, enquanto o endpoint hospedado as serve nuas. O código que procura ferramentas pelo nome deve corresponder no sufixo.

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

Como você realmente usa isso: chama uma ferramenta, depois entrega a um agente

Os objetos retornados são StructuredTools normais do LangChain, o que significa que eles são executados diretamente — nenhum modelo é necessário. A prova mais curta possível de que a fiação funciona de ponta a ponta:

# invoke_tool.py — execute uma ferramenta MCP diretamente através do adaptador
import asyncio
import os

from langchain_mcp_adapters.client import MultiServerMCPClient


async def main():
    client = MultiServerMCPClient({
        "scrapeless": {
            "transport": "streamable_http",
            "url": "https://api.scrapeless.com/mcp",
            "headers": {"x-api-token": os.environ["SCRAPELESS_API_KEY"]},
        }
    })
    tools = {t.name: t for t in await client.get_tools()}
    result = await tools["scrape_markdown"].ainvoke(
        {"url": "https://www.scrapeless.com/pt/blog/best-llm-scrapers-2026"}
    )
    text = result if isinstance(result, str) else str(result)
    print(f"scrape_markdown retornou {len(text):,} chars de markdown")

asyncio.run(main())

Em uma execução ao vivo, isso retorna o artigo completo como markdown — dezenas de milhares de caracteres de texto limpo de página de uma chamada de ferramenta.

Vincular as ferramentas a um agente é o mesmo construtor de sempre no LangChain — traga o modelo de chat que sua pilha usa (uma chave API de modelo é o único pré-requisito que este guia não cobre):

# agent.py — anexa as ferramentas MCP a um agente LangChain (requer uma chave API de modelo)
from langchain.agents import create_agent

agent = create_agent(model, tools)  # `tools` de client.get_tools(), `model` = seu modelo de chat
result = agent.invoke({
    "messages": [{"role": "user", "content": "Pesquise por Scrapeless e resuma o principal resultado."}]
})

Da perspectiva do agente, as ferramentas são apenas funções que ele pode chamar: ele planeja, escolhe google_search, lê, escolhe scrape_markdown, lê novamente e responde com conteúdo ao vivo.

A superfície da ferramenta Scrapeless MCP

O que você recebe de volta

Os resultados das ferramentas chegam como partes de conteúdo MCP que o adaptador expõe ao LangChain — para as ferramentas de scraping, o payload é a própria página. A chamada scrape_markdown acima retorna o artigo renderizado como texto markdown pronto para alimentar um divisor, um resumidor ou o próprio contexto do agente. As ferramentas do navegador retornam suas observações (capturas de tela, texto extraído, screenshots) da mesma forma, o que torna a navegação em várias etapas dentro de um loop de agente prática.

Conclusão: um bloco de configuração, um agente capaz de web

A integração é genuinamente pequena: instale o adaptador, dê ao MultiServerMCPClient a URL hospedada e seu token, e get_tools() entrega ao LangChain 21 capacidades web ao vivo. Verifique com a contagem de ferramentas, prove com uma ainvoke direta, depois vincule a mesma lista ao seu agente. O guia de integração do Mastra mostra o mesmo servidor conectado a uma estrutura de agente TypeScript — mesma superfície, host diferente.

Pronto para dar ao seu agente a web ao vivo?

Junte-se à nossa comunidade para reivindicar um plano gratuito e conectar-se com desenvolvedores que constroem pipelines de agentes: Discord · Telegram.
Inscreva-se em app.scrapeless.com para créditos de teste gratuitos — preços cobrem os níveis atuais — e aponte seus agentes LangChain para as páginas que eles devem ler.

FAQ

P: Eu preciso do Node.js?

Apenas para o transporte stdio, que gera o pacote npm localmente. O endpoint hospedado https://api.scrapeless.com/mcp é apenas HTTPS — pilhas somente Python o utilizam sem Node em nenhum lugar.

P: Como eu me autentico?

O endpoint hospedado aceita x-api-token: <sua chave> como um cabeçalho de solicitação; o servidor stdio lê SCRAPELESS_KEY de seu ambiente. A mesma chave, ambos os transportes — criada no plano gratuito em app.scrapeless.com.

P: Como eu verifico se a integração está realmente conectada?

Duas verificações, ambas sem modelo: get_tools() retorna 21 ferramentas, e um ainvoke direto de scrape_markdown em uma URL real retorna a página como markdown. Se ambas passarem, a vinculação do agente é o único passo restante.

P: Por que os nomes das ferramentas diferem entre meu servidor local e o endpoint hospedado?

O pacote stdio nomeia os espaços de nome como scrapeless_*; o endpoint hospedado os serve sem modificação. Combine pelo sufixo se seu código precisar funcionar em ambos.

P: Posso usar as ferramentas sem um agente?

Sim — elas são objetos StructuredTool e funcionam de forma independente via ainvoke, o que também as torna utilizáveis em cadeias LangChain simples e nós LangGraph, não apenas em agentes.

P: O acesso à web através das ferramentas é legal?

As ferramentas buscam páginas acessíveis publicamente através da infraestrutura Scrapeless. As regras variam conforme a jurisdição e os termos do site — revise os Termos de Serviço dos sites que seu agente lê e consulte um advogado para seu caso de uso. Nunca colete dados pessoais protegidos sob o GDPR ou CCPA.

P: Quanto custa para operar?

As chamadas de ferramentas utilizam a mesma conta Scrapeless baseada em uso que o resto da plataforma, e novas contas começam com créditos de teste gratuitos.