Aprimore o Databricks com o Servidor MCP Sem Desperdício.

Resumo:

• Um agente Databricks pode raciocinar sobre seus dados, mas não pode acessar a web ao vivo até que você conecte uma ferramenta — o servidor Scrapeless MCP é a maneira mais limpa de fazer isso. Os agentes Agent Bricks e Mosaic AI planejam sobre um modelo, funções do Unity Catalog e quaisquer ferramentas que você registrar. Aponte um para o servidor Scrapeless MCP e o agente ganha acesso ao Google em tempo real, renderização em JavaScript e um navegador em nuvem completo contra detecção sem precisar escrever um scraper manualmente.
• O Databricks acessa um servidor MCP externo por meio de uma conexão HTTP do Unity Catalog mais um proxy gerenciado. Você registra https://api.scrapeless.com/mcp como uma conexão do Unity Catalog com a opção "É conexão mcp", armazena o x-api-token do Scrapeless como a credencial de conexão, e o Databricks o expõe ao código do agente em https://<workspace-host>/api/2.0/mcp/external/<connection_name>.
• DatabricksMCPClient.list_tools() conecta a interface ao código do agente. Construa um DatabricksMCPClient com a URL do proxy e um WorkspaceClient, chame list_tools(), converta os resultados para o tipo de ferramenta do seu framework de agente, e o agente ganha um scraper de SERP do Google, um scraper de Tendências, ajudantes de HTML/Markdown/Captura de tela, e 16 ferramentas de automação de navegador.
• O servidor Scrapeless MCP expõe 21 ferramentas. Uma chamada ao vivo tools/list contra https://api.scrapeless.com/mcp retorna google_search, google_trends, scrape_html, scrape_markdown, scrape_screenshot e 16 ferramentas browser_* — o servidor as emite como nomes simples, e cada cliente adiciona seu próprio namespace ao carregá-las.
• Proxies residenciais e anti-detectores operam do lado da nuvem. Cada chamada de ferramenta passa pelo navegador de nuvem anti-deteção Scrapeless com proxies residenciais em mais de 195 países, então o agente recebe uma resposta renderizada e utilizável de sites comerciais sem configuração de proxy ou impressão digital dentro do tempo de execução do Databricks.
• Transporte via stdio ou HTTP-streamable. Para desenvolvimento local de agentes, você pode iniciar o servidor com npx; para um ponto final Mosaic AI implantado, você se conecta ao ponto final HTTP streamable, que é exatamente o que a conexão do Unity Catalog envolve.
• Gratuito para começar. Novas contas Scrapeless incluem runtime gratuito do Scraping Browser — inscreva-se em app.scrapeless.com.

Introdução: dê aos agentes Databricks uma visão ao vivo da web

Os Agentes Databricks Bricks e o Framework de Agentes Mosaic AI permitem que você construa agentes que raciocinam sobre seu lakehouse — tabelas do Unity Catalog, índices vetoriais, funções governadas. O agente chama as ferramentas que você registra e nada mais. O que ele não pode fazer por conta própria é ver a web como ela existe agora. Seu conhecimento para na data de corte do treinamento do modelo mais o que quer que você coloque à sua frente, então uma pergunta como "quanto esse concorrente cobra hoje" ou "qual é o resultado principal atual para esta consulta" não tem resposta dentro do espaço de trabalho.

Esse limite é deliberado: o alcance de um agente sobre o mundo exterior é exatamente o conjunto de ferramentas a ele anexadas. Portanto, a camada de ferramentas é o lugar para adicionar acesso à web em tempo real, e o Protocolo de Contexto do Modelo (MCP) é a forma padrão e agnóstica ao framework de fazer isso. O Databricks oferece suporte de primeira classe ao MCP — servidores gerenciados para funções do Unity Catalog e pesquisa vetorial, e um caminho de proxy gerenciado para servidores MCP externos de terceiros. Um servidor MCP externo se torna um conjunto de ferramentas que o agente pode chamar, governado pelo mesmo modelo de conexão do Unity Catalog que o restante do espaço de trabalho.

Este post conecta o servidor Scrapeless MCP a um agente Databricks através desse caminho de servidor externo. Uma conexão do Unity Catalog e um DatabricksMCPClient dão ao agente busca no Google, renderização em JavaScript e um navegador em nuvem completo contra detecção, acessível através dos mesmos prompts que você já passa para seu agente Mosaic AI. Para a mesma interface Scrapeless via um cliente TypeScript, veja a integração Mastra.

O Que Você Pode Fazer Com Isso

• Pesquisa de SERP ao vivo dentro de um agente Mosaic AI. Peça ao agente para executar google_search para uma consulta e retornar as principais linhas orgânicas como JSON, assim a pesquisa acontece dentro do seu aplicativo Databricks em vez de uma aba separada do navegador.
• Instantâneas de concorrentes e preços alimentando uma tabela Delta. Passe uma URL no prompt, faça o agente renderizar a página e extrair nomes de planos, preços e recursos em um registro estruturado que seu trabalho grava de volta no lakehouse.
• Consultas de documentos e changelogs que fundamentam uma resposta. Faça o agente buscar a documentação atual de uma biblioteca ou notas de lançamento como markdown limpo e raciocinar contra o texto renderizado em vez de uma memória desatualizada da API.
• Verificações de mercado e tendências para um agente de planejamento. Use google_trends para puxar sinais de interesse sobre um tópico em uma região-alvo, depois alimente previsões, planos de conteúdo ou ideias de experimentos com evidências atuais.
• Extração de página JavaScript em um registro tipado. Aponte o agente para um aplicativo de página única; o navegador na nuvem carrega a página e o agente analisa o resultado em um objeto que sua tarefa subsequente consome.
• Fluxos de navegador em múltiplas etapas. Encadeie browser_goto, browser_click, browser_type e browser_scroll para que o agente navegue por paginações, expanda painéis ou passe por um assistente antes da extração.
• Pipelines de pesquisa-para-leitura em uma única interação do agente. Combine google_search com scrape_markdown para que o agente encontre os principais resultados, leia cada um deles e os resuma sem sair do loop do agente.

Por que o Servidor Scrapeless MCP

O servidor Scrapeless MCP é uma ponte personalizável e anti-detecção entre um agente de IA e a web ao vivo. Para um agente Databricks especificamente, ele oferece:

• Um navegador na nuvem anti-detecção com renderização JavaScript. As páginas são carregadas em um completo Navegador de Extração Scrapeless antes da extração, então SPAs, feeds de rolagem infinita e painéis carregados de forma preguiçosa se tornam alvos de primeira classe para browser_goto mais browser_get_html.
• Proxies residenciais em mais de 195 países. Consultas geográficas retornam as listagens que um usuário local veria, com a saída do proxy sendo totalmente gerida pelo lado Scrapeless em vez de dentro da sua rede Databricks.
• Um endpoint externo, sem código de raspagem para hospedar. O servidor funciona como um endpoint HTTP gerenciado em https://api.scrapeless.com/mcp; o Databricks o envolve em uma conexão do Unity Catalog, de modo que não há nada para construir, implantar como um App Databricks ou manter além da própria conexão.
• 21 ferramentas abrangendo SERP, raspagem sem estado e automação completa de navegador. google_search e google_trends cobrem dados de SERP, scrape_html, scrape_markdown e scrape_screenshot cobrem capturas de página pontuais, e 16 ferramentas browser_* cobrem navegação com estado, cliques, digitação, rolagem e capturas de tela.
• Governado como qualquer outra ferramenta Databricks. Como o servidor chega através de uma conexão HTTP do Unity Catalog, o acesso a ele é gerenciado com o mesmo modelo de permissão que suas outras conexões, e o token da API vive na conexão em vez de no código do agente.

O plano gratuito é suficiente para registrar a conexão e executar prompts reais; compare cotas na página de preços quando você ultrapassar isso. Obtenha sua chave de API no plano gratuito em app.scrapeless.com.

Pré-requisitos

• Um workspace Databricks com o Mosaic AI Agent Framework disponível, e permissão para criar conexões do Unity Catalog. O caminho externo-MCP usa um proxy gerenciado que fornece a conexão que você registra.
• Um endpoint de serviço de modelo para o LLM do agente. O loop do agente precisa de um modelo funcional — um endpoint de Modelo da Fundação Databricks ou um modelo externo — antes que qualquer chamada de ferramenta seja executada.
• Uma conta Scrapeless e uma chave de API — registre-se no plano gratuito em app.scrapeless.com e copie a chave de Configurações → Gerenciamento de Chaves da API.
• As dependências do agente instaladas no seu notebook ou job: mcp, databricks-mcp, databricks-sdk, databricks-agents e mlflow.
• Familiaridade básica com Python e notebooks Databricks — a configuração é uma conexão mais uma pequena definição de cliente.

Nota: registrar a conexão do Unity Catalog e chamar o proxy gerenciado requer um workspace Databricks ativo. Os passos abaixo mostram esse fluxo como documentado; a superfície da ferramenta Scrapeless que eles expõem é verificada diretamente contra https://api.scrapeless.com/mcp na seção de verificação.

Conectar Scrapeless a um agente Databricks

A configuração é composta por cinco etapas; cada uma é verificável de forma independente.

1. Instalar os pacotes do cliente

No seu notebook ou projeto de agente, instale o cliente MCP e as dependências do agente Databricks:

pip install mcp databricks-mcp "databricks-sdk[openai]" databricks-agents mlflow

databricks-mcp fornece o DatabricksMCPClient que se comunica com o proxy gerenciado, e mcp fornece os primitivos subjacentes do Protocolo de Contexto do Modelo (ClientSession, o transporte HTTP transmitível) — que estruturam cada chamada de ferramenta como solicitações JSON-RPC 2.0 — usadas quando você se conecta ao endpoint diretamente.

2. Registrar o Scrapeless como uma conexão do Unity Catalog (credencial armazenada)

Um agente do Databricks acessa um servidor MCP externo através de uma conexão HTTP do Unity Catalog. Crie a conexão apontando para o endpoint do Scrapeless, marque-a como uma conexão MCP e armazene a chave do Scrapeless como uma credencial de cabeçalho no estilo bearer. O host é o único campo que muda entre os espaços de trabalho:

-- Conexão HTTP do Unity Catalog para o servidor MCP do Scrapeless.
-- Marque-a como uma conexão MCP na interface ("É conexão mcp"),
-- e forneça a chave do Scrapeless como a credencial de cabeçalho x-api-token.
CREATE CONNECTION scrapeless_mcp
TYPE HTTP
OPTIONS (
  host 'https://api.scrapeless.com',
  base_path '/mcp',
  bearer_token 'sua_chave_api_aqui'
);

Uma vez registrada, o Databricks expõe o servidor para o código do agente através de seu proxy gerenciado em https://<host-do-trabalho>/api/2.0/mcp/external/scrapeless_mcp — o código do agente nunca armazena o token do Scrapeless; ele se autentica no Databricks e o Databricks anexa a credencial armazenada quando faz a proxy para o Scrapeless.

3. Ou conecte o endpoint diretamente via HTTP-streamable

Quando você está prototipando a integração fora de um agente implantado — um script local, um spike de notebook — você pode se comunicar diretamente com o endpoint do Scrapeless com o SDK MCP padrão em vez do proxy. Passe a chave como o cabeçalho x-api-token no transporte HTTP streamable:

# pip install mcp
import asyncio, os
from mcp import ClientSession
from mcp.client.streamable_http import streamablehttp_client

URL = "https://api.scrapeless.com/mcp"

async def main():
    headers = {"x-api-token": os.environ["SCRAPELESS_KEY"]}
    async with streamablehttp_client(URL, headers=headers) as (read, write, _):
        async with ClientSession(read, write) as session:
            await session.initialize()
            tools = await session.list_tools()
            print([t.name for t in tools.tools])

asyncio.run(main())

O servidor MCP do Scrapeless lê sua chave de SCRAPELESS_KEY no lançamento do stdio, mas sobre HTTP-streamable o mesmo valor é enviado como o cabeçalho x-api-token — ambos carregam a chave idêntica. Mantenha-a no ambiente (export SCRAPELESS_KEY=...) em vez de codificá-la diretamente. A fonte do servidor está em o repositório do servidor MCP do Scrapeless.

4. Liste as ferramentas e as conecte ao agente

Dentro do código do agente, construa um DatabricksMCPClient contra a URL do proxy gerenciado e um WorkspaceClient, e então liste as ferramentas. Converta as definições de ferramentas retornadas no tipo de ferramenta do seu framework de agente — os agentes Mosaic AI geralmente são criados como um ChatAgent do MLflow sobre um gráfico LangGraph, então cada ferramenta MCP se torna uma ferramenta vinculada em um modelo ChatDatabricks:

from databricks.sdk import WorkspaceClient
from databricks_mcp import DatabricksMCPClient

workspace = WorkspaceClient()
proxy_url = f"{workspace.config.host}/api/2.0/mcp/external/scrapeless_mcp"

mcp_client = DatabricksMCPClient(server_url=proxy_url, workspace_client=workspace)
tools = mcp_client.list_tools()  # as 21 ferramentas do Scrapeless, governadas pela conexão

# Vincule os esquemas de ferramenta ao modelo do agente, e então construa o gráfico do agente.
tool_specs = [
    {"name": t.name, "description": t.description, "input_schema": t.inputSchema}
    for t in tools
]

DatabricksMCPClient.list_tools() retorna as mesmas definições de ferramentas que o servidor reporta — nome, descrição e esquema de entrada — então o planejador do agente vê toda a superfície do Scrapeless. Você vincula esses esquemas ao modelo da mesma forma que vincula qualquer ferramenta Mosaic AI, e depois chama a ferramenta através de mcp_client.call_tool(name, arguments) quando o modelo a seleciona.

5. Verifique enumerando as 21 ferramentas

Listar as ferramentas e imprimir seus nomes confirma que o handshake foi concluído e o servidor está reportando toda a sua superfície:

tools = mcp_client.list_tools()
print(len(tools), [t.name for t in tools])

A saída lista as 21 ferramentas do servidor como nomes simples — as ferramentas de dados do Google (google_search, google_trends), os helpers de página one-shot (scrape_html, scrape_markdown, scrape_screenshot), e os primitivos de navegador em nuvem (browser_create, browser_goto, browser_get_html, browser_get_text, browser_click, browser_type, browser_press_key, browser_scroll, browser_scroll_to, browser_screenshot, browser_snapshot, browser_wait, browser_wait_for, browser_go_back, browser_go_forward, browser_close). O servidor os emite sem prefixo; qualquer cliente que os carregar — o proxy do Databricks, o SDK MCP bruto, um adaptador em TypeScript — aplica seu próprio namespace por cima.

Como você realmente usa isso: solicite ao seu agente

Após a conexão ser registrada e as ferramentas serem vinculadas, você obtém dados da web ao vivo conversando com seu agente Databricks — não por meio de chamadas de ferramenta escritas à mão. O agente lê a lista de ferramentas que o servidor Scrapeless MCP expõe e escolhe google_search, scrape_markdown ou as ferramentas browser_* conforme necessário, compondo-as uma a uma a partir da tarefa em linguagem natural. Não há JSON de ferramenta a ser criado do seu lado; você invoca o agente da mesma forma que já invoca um agente Mosaic AI, em uma célula de notebook ou contra o endpoint implantado.

Sugestões que você pode colar

Exemplo prático

Você escreve (uma única chamada de agente em uma célula de notebook):

response = agent.predict({
    "messages": [{
        "role": "user",
        "content": "Use google_search para encontrar os principais resultados para "
                   "'databricks mosaic ai agent framework' e retorne os "
                   "3 melhores como um array JSON de {título, link}.",
    }]
})
print(response)

O plano do agente (em inglês simples):

1. Chame google_search com q: "databricks mosaic ai agent framework", hl: "en", gl: "us".
2. Receba um array de linhas de resultado e leia os campos posição, título e link.
3. Classifique por posição e mantenha as três primeiras linhas.
4. Mapear cada linha para um objeto {título, link}.
5. Retorne o array JSON como a resposta do agente.

O que você recebe de volta (forma ilustrativa — o agente trabalha a partir de linhas como estas):

[
  { "title": "Mosaic AI Agent Framework — Databricks docs", "link": "https://example.com/agent-framework" },
  { "title": "Build and deploy an agent on Databricks", "link": "https://example.com/build-agent" },
  { "title": "Agent Bricks overview", "link": "https://example.org/agent-bricks" }
]
// Os nomes dos campos correspondem à forma da linha de google_search; os valores são exemplos ilustrativos.

As ferramentas de dados sem estado retornam seu payload como um corpo prefixado com Response:\n\n; o agente remove esse prefixo antes de analisar o JSON, então você nunca o vê na resposta.

Formatação de sugestões

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

Tudo abaixo é a referência interna — a superfície da ferramenta, as formas exatas de retorno e o comportamento que o agente cuida para você.

A superfície da ferramenta Scrapeless MCP

Uma vez que a conexão esteja ativa, o agente vê 21 ferramentas abrangendo dados SERP, scraping sem estado e controle total do navegador em nuvem anti-detecção. Os nomes abaixo são os nomes básicos do servidor; qualquer cliente que os carrega aplica seu próprio namespace.

Para uma visão mais ampla do que o servidor pode controlar, a visão geral do servidor Scrapeless MCP aborda a mesma superfície do lado do produto, e a documentação completa do Scrapeless cobre todos os parâmetros de cada ferramenta.

O Que Você Recebe de Volta

Uma chamada google_search retorna um array de linhas de resultados orgânicos codificado como JSON. Cada linha possui as mesmas chaves, para que o agente possa mapear diretamente para título, link e snippet:

// Nomes de campo refletem a saída da ferramenta google_search; valores são exemplos ilustrativos.
[
  {
    "position": 1,
    "title": "Construindo Agentes na Databricks: Um Guia Completo",
    "link": "https://example.com/databricks-agents",
    "snippet": "Um guia passo a passo para construir e implantar agentes na Mosaic AI Agent Framework.",
    "source": "example.com"
  },
  {
    "position": 2,
    "title": "Conectando Agentes a Dados Externos",
    "link": "https://example.org/agent-data",
    "snippet": "Como renderizar páginas JavaScript antes de extrair dados.",
    "source": "example.org"
  }
]

Algumas observações honestas uma vez que você começa a executar prompts:

• Ferramentas sem estado como google_search e scrape_markdown retornam um corpo prefixado com Response:\n\n, seguido pelo payload JSON; o agente remove automaticamente esse prefixo, assim você trabalha com os dados, não com o wrapper.
• As ferramentas browser_* retornam texto simples sem o prefixo Response:\n\n.
• Os argumentos das ferramentas são camelCase: passe sessionId, proxyCountry e campos semelhantes exatamente como nomeados.
• proxyCountry é um pedido, não uma garantia — pode se basear na região configurada na sua conta, então confirme a região de saída quando a geo-targeting importa.
• Os valores na saída da ferramenta dependem do conteúdo: contagens de resultados, ordenação e texto de snippet variam com a consulta ao vivo.

Conclusão: pesquise, renderize e navegue a partir da Databricks

Toda a integração se resume a uma conexão do Unity Catalog mais prompts em linguagem natural. Com o Scrapeless registrado como uma conexão MCP, DatabricksMCPClient.list_tools() passando as 21 ferramentas para o seu agente, e o token da API mantido na conexão em vez de no código, um agente Databricks ganha busca Google ao vivo, renderização JavaScript e um navegador em nuvem completo contra detecção — exatamente a camada web que o lakehouse não envia por conta própria. Você descreve a tarefa; o agente escolhe a ferramenta.

Se você estiver conectando outros clientes, o mesmo servidor Scrapeless MCP também pode ser integrado a eles: veja a integração Mastra para o caminho TypeScript e a integração do Pi Agent para outro tempo de execução de agente. Mantenha sua chave da API na conexão do Unity Catalog, registre o endpoint uma vez, liste as ferramentas e deixe o agente escolher. Referência completa em docs.scrapeless.com.

Pronto para Construir Seu Pipeline de Dados Potenciado por IA?

Junte-se à nossa comunidade para reivindicar um plano gratuito e conectar-se com desenvolvedores que constroem agentes Databricks + Scrapeless MCP: Discord · Telegram.

Inscreva-se em app.scrapeless.com para runtime gratuito do Scraping Browser e adapte a integração acima para os SERPs, páginas e regiões que seus agentes Databricks precisam. Referência completa em docs.scrapeless.com.

FAQ

Q: Por que um agente Databricks precisa de um servidor MCP para acesso à web?

Porque um agente de IA Mosaic só pode chamar as ferramentas que você registrar com ele, e não possui busca na web ou navegador embutido. O MCP é a maneira padrão e independente de framework para adicionar essa capacidade, e a Databricks suporta servidores MCP externos através de um proxy gerenciado. Conectar-se ao Scrapeless dá ao agente pesquisa ao vivo no Google, acesso a páginas renderizadas e um navegador em nuvem completo contra detecções em um único movimento.

Q: Como a Databricks se conecta a um servidor MCP externo como o Scrapeless?

Através de uma conexão HTTP do Unity Catalog marcada como conexão MCP. Você registra https://api.scrapeless.com/mcp como a conexão, armazena o x-api-token do Scrapeless como sua credencial, e a Databricks o expõe ao código do agente em https://<workspace-host>/api/2.0/mcp/external/<connection_name>. O código do agente usa um DatabricksMCPClient contra essa URL de proxy, de modo que o token Scrapeless permanece na conexão e nunca aparece no agente.

Q: Qual variável de ambiente ou cabeçalho contém a chave do Scrapeless?

O lançamento do servidor em stdio lê SCRAPELESS_KEY; o ponto de extremidade HTTP lê o mesmo valor do cabeçalho x-api-token. Quando você registra a conexão do Unity Catalog, armazena essa chave uma vez como a credencial da conexão, assim o código do agente implantado não a manipula diretamente.

Q: Quantas ferramentas o servidor MCP Scrapeless expõe, e quais são elas?

21 ferramentas: google_search e google_trends para dados SERP; scrape_html, scrape_markdown e scrape_screenshot para capturas de páginas em uma única chamada; e 16 ferramentas browser_* (browser_create, browser_goto, browser_get_html, browser_get_text, browser_click, browser_type, browser_press_key, browser_scroll, browser_scroll_to, browser_screenshot, browser_snapshot, browser_wait, browser_wait_for, browser_go_back, browser_go_forward, browser_close) para controle de navegador em nuvem com estado. O servidor emite elas como nomes simples; o cliente que as carrega aplica seu próprio espaço de nomes.

Q: Preciso hospedar o Scrapeless como um aplicativo Databricks?

Não. Hospedar um servidor MCP como um aplicativo Databricks é para servidores que você executa sozinho. O Scrapeless é um ponto de extremidade externo gerenciado, então você o registra como uma conexão HTTP do Unity Catalog e o acessa através do proxy MCP externo gerenciado — não há nada para implantar ou manter funcionando do seu lado.

Q: Posso testar a conexão fora de um agente implantado?

Sim. Aponte o SDK Python MCP padrão para https://api.scrapeless.com/mcp com o cabeçalho x-api-token, chame initialize e, em seguida, list_tools(), e você verá as mesmas 21 ferramentas que o agente implantado obtém através do proxy. Esse caminho direto é a forma mais rápida de confirmar sua chave e o ponto de extremidade antes de você registrar a conexão do Unity Catalog.

Q: Isso requer um modelo específico?

Não. O modelo do agente é qualquer ponto de extremidade que a Databricks disponibiliza — um ponto de extremidade de Modelo de Fundação ou um modelo externo. As ferramentas Scrapeless são independentes de modelo; escolha um modelo que lide bem com chamadas de ferramentas, e o agente compõe as ferramentas Scrapeless da mesma maneira, independentemente do provedor.

Q: É legal fazer scraping via o agente?

Extrair dados disponíveis publicamente é geralmente permitido, mas você é responsável por como os utiliza. Revise os Termos de Serviço de cada site e respeite o robots.txt, e lembre-se de que as regras sobre dados pessoais e acesso variam conforme a jurisdição. Quando em dúvida, obtenha aconselhamento jurídico para seu caso de uso específico.

Q: Posso usar isso sem a Databricks?

Sim. O servidor MCP Scrapeless é um servidor MCP padrão, então qualquer cliente compatível com MCP pode chamá-lo — ou você pode acioná-lo diretamente via JSON-RPC (initialize, em seguida tools/list e tools/call). A Databricks é um host para isso, não uma exigência.