Mejora Databricks con el servidor MCP sin chatarra.

TL;DR:

• Un agente de Databricks puede razonar sobre tus datos, pero no puede acceder a la web en vivo hasta que conectes una herramienta: el servidor MCP Scrapeless es la forma más limpia de hacerlo. Los agentes Agent Bricks y Mosaic AI planean sobre un modelo, funciones de Unity Catalog y cualquier herramienta que registres. Apunta uno al servidor MCP Scrapeless y el agente obtiene búsqueda en Google en vivo, renderizado de JavaScript y un navegador en la nube totalmente anti-detección sin escribir un scraper a mano.
• Databricks alcanza un servidor MCP externo a través de una conexión HTTP de Unity Catalog más un proxy administrado. Registras https://api.scrapeless.com/mcp como una conexión de Unity Catalog con la opción "Es conexión mcp", almacenas el x-api-token de Scrapeless como la credencial de conexión y Databricks lo expone al código del agente en https://<workspace-host>/api/2.0/mcp/external/<connection_name>.
• DatabricksMCPClient.list_tools() integra la superficie en el código del agente. Construye un DatabricksMCPClient con la URL del proxy y un WorkspaceClient, llama a list_tools(), convierte los resultados al tipo de herramienta de tu marco de agente y el agente obtiene un scraper de SERP de Google, un scraper de Trends, ayudantes de HTML/Markdown/Captura de pantalla, y 16 herramientas de automatización del navegador.
• El servidor MCP Scrapeless expone 21 herramientas. Una llamada en vivo a tools/list contra https://api.scrapeless.com/mcp devuelve google_search, google_trends, scrape_html, scrape_markdown, scrape_screenshot y 16 herramientas browser_* — el servidor las emite como nombres simples, y cada cliente añade su propio espacio de nombres cuando las carga.
• Los proxies residenciales y la anti-detección funcionan del lado de la nube. Cada llamada a la herramienta pasa a través del navegador en la nube anti-detección de Scrapeless con proxies residenciales en más de 195 países, por lo que el agente obtiene una respuesta renderizada y utilizable de sitios comerciales sin configuración de proxy o huella digital dentro del tiempo de ejecución de Databricks.
• Transporte stdio o HTTP transmitible. Para el desarrollo local del agente, puedes iniciar el servidor con npx; para un punto final de Mosaic AI desplegado, apuntas al punto final HTTP transmitible, que es exactamente lo que envuelve la conexión de Unity Catalog.
• Gratis para empezar. Las nuevas cuentas de Scrapeless incluyen tiempo de ejecución gratuito de Scraping Browser — regístrate en app.scrapeless.com.

Introducción: da a los agentes de Databricks una vista en vivo de la web

Databricks Agent Bricks y el Marco de Agentes Mosaic AI te permiten crear agentes que razonan sobre tu lakehouse — tablas de Unity Catalog, índices de vectores, funciones gobernadas. El agente llama a las herramientas que registras y nada más. Lo que no puede hacer por sí solo es ver la web tal como existe en este momento. Su conocimiento se detiene en la fecha límite de entrenamiento del modelo más lo que tú pongas frente a él, por lo que una pregunta como "¿cuánto cobra este competidor hoy?" o "¿cuál es el resultado principal actual para esta consulta?" no tiene respuesta dentro del espacio de trabajo.

Ese límite es deliberado: el alcance de un agente sobre el mundo exterior es exactamente el conjunto de herramientas que se le han adjuntado. Por lo tanto, la capa de herramientas es el lugar para añadir acceso en tiempo real a la web, y el Protocolo de Contexto de Modelo (MCP) es la forma estándar y agnóstica del marco para hacerlo. Databricks ofrece soporte MCP de primera clase: servidores administrados para funciones de Unity Catalog y búsqueda de vectores, y un camino de proxy administrado para servidores MCP externos de terceros. Un servidor MCP externo se convierte en un conjunto de herramientas que el agente puede invocar, gobernado por el mismo modelo de conexión de Unity Catalog que el resto del espacio de trabajo.

Esta publicación conecta el servidor MCP Scrapeless a un agente de Databricks a través de ese camino de servidor externo. Una conexión de Unity Catalog y un DatabricksMCPClient le dan al agente búsqueda en Google, renderizado de JavaScript y un navegador en la nube totalmente anti-detección, accesible a través de los mismos comandos que ya le envías a tu agente Mosaic AI. Para la misma superficie de Scrapeless a través de un cliente TypeScript, consulta la integración de Mastra.

Lo Que Puedes Hacer Con Esto

• Investigación de SERP en vivo dentro de un agente Mosaic AI. Pide al agente que ejecute google_search para una consulta y devuelva las filas orgánicas superiores como JSON, de modo que la investigación ocurra dentro de tu aplicación Databricks en lugar de en una pestaña de navegador separada.
• Instantáneas de competidores y precios alimentando una tabla Delta. Pasa una URL en el aviso, haz que el agente renderice la página y extraiga nombres de planes, precios y características en un registro estructurado que tu trabajo escribe de nuevo en el lakehouse.
• Búsquedas de documentos y changelogs que fundamentan una respuesta. Haz que el agente obtenga la documentación actual o notas de versión de una biblioteca como markdown limpio y razona contra el texto renderizado en lugar de una memoria obsoleta de la API.
• Verificaciones de mercado y tendencias para un agente de planificación. Utiliza google_trends para obtener señales de interés sobre un tema en una región objetivo, luego inicia previsiones, planes de contenido o ideas de experimentos con evidencia actual.
• Extracción de páginas JavaScript en un registro tipado. Dirige al agente hacia una aplicación de página única; el navegador en la nube la hidrata y el agente analiza el resultado en un objeto que consume tu tarea posterior.
• Flujos de navegador en múltiples pasos. Encadena browser_goto, browser_click, browser_type y browser_scroll para que el agente navegue por la paginación, expanda paneles o siga un asistente antes de la extracción.
• Canales de búsqueda y lectura en una sola acción del agente. Combina google_search con scrape_markdown para que el agente encuentre los resultados principales, lea cada uno y los resuma sin salir del bucle del agente.

Por qué el servidor MCP de Scrapeless

El servidor MCP de Scrapeless es un puente personalizable y anti-detección entre un agente de IA y la web en vivo. Para un agente de Databricks específicamente, ofrece:

• Un navegador en la nube anti-detección con renderizado JavaScript. Las páginas se hidratan en un completo Navegador de Extracción Scrapeless antes de la extracción, por lo que las SPA, los feeds de desplazamiento infinito y los paneles cargados de forma perezosa se convierten en objetivos de primera clase para browser_goto más browser_get_html.
• Proxies residenciales en más de 195 países. Las consultas geolocalizadas devuelven las listas que vería un usuario local, con la salida del proxy gestionada completamente en el lado de Scrapeless en lugar de dentro de la red de Databricks.
• Un único punto de acceso externo, sin código de raspador que alojar. El servidor funciona como un punto final HTTP gestionado en https://api.scrapeless.com/mcp; Databricks lo envuelve en una conexión de Unity Catalog, por lo que no hay nada que construir, implementar como una aplicación de Databricks o mantener más allá de la conexión en sí.
• 21 herramientas que abarcan SERP, raspado sin estado y automatización completa del navegador. google_search y google_trends cubren datos SERP, scrape_html, scrape_markdown y scrape_screenshot cubren extracciones de páginas de una sola vez, y 16 herramientas browser_* cubren navegación con estado, clics, escritura, desplazamiento y capturas de pantalla.
• Gobernado como cualquier otra herramienta de Databricks. Dado que el servidor llega a través de una conexión HTTP de Unity Catalog, el acceso a él se gestiona con el mismo modelo de permisos que tus otras conexiones, y el token de API vive en la conexión en lugar de en el código del agente.

El plan gratuito es suficiente para registrar la conexión y ejecutar solicitudes reales; compara las cuotas en la página de precios cuando lo superes. Obtén tu clave API en el plan gratuito en app.scrapeless.com.

Requisitos previos

• Un espacio de trabajo de Databricks con el Marco de Agentes de IA Mosaic disponible, y permiso para crear conexiones de Unity Catalog. La ruta externa-MCP utiliza un proxy gestionado que establece la conexión que registras.
• Un punto final de servicio de modelo para el LLM del agente. El bucle del agente necesita un modelo funcional: un punto final de modelo de Fundación de Databricks o un modelo externo, antes de que se ejecute cualquier llamada a la herramienta.
• Una cuenta de Scrapeless y clave API — regístrate en el plan gratuito en app.scrapeless.com y copia la clave desde Configuración → Gestión de Claves API.
• Las dependencias del agente instaladas en tu notebook o trabajo: mcp, databricks-mcp, databricks-sdk, databricks-agents, y mlflow.
• Familiaridad básica con Python y notebooks de Databricks — la configuración es una conexión más una pequeña definición de cliente.

Nota: registrar la conexión de Unity Catalog y llamar al proxy gestionado requieren un espacio de trabajo de Databricks activo. Los pasos a continuación muestran ese flujo como se documenta; la superficie de herramientas de Scrapeless que exponen se verifica directamente contra https://api.scrapeless.com/mcp en la sección de verificación.

Conectar Scrapeless a un agente de Databricks

La configuración consta de cinco pasos; cada uno es verificable de manera independiente.

1. Instalar los paquetes del cliente

En tu notebook o proyecto de agente, instala el cliente MCP y las dependencias del agente de Databricks:

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

databricks-mcp proporciona el DatabricksMCPClient que se comunica con el proxy gestionado, y mcp proporciona los primitivos del Protocolo de Contexto de Modelo subyacentes (ClientSession, el transporte HTTP transmisible) — que enmarcan cada llamada a la herramienta como solicitudes JSON-RPC 2.0 — utilizadas cuando te conectas al punto final directamente.

2. Registre Scrapeless como una conexión de catálogo de Unity (credencial almacenada)

Un agente de Databricks accede a un servidor MCP externo a través de una conexión HTTP de catálogo de Unity. Cree la conexión apuntando al endpoint de Scrapeless, márkela como una conexión MCP y almacene la clave de Scrapeless como una credencial de encabezado de estilo portador. El host es el único campo que cambia entre los espacios de trabajo:

-- Conexión HTTP de catálogo de Unity para el servidor MCP de Scrapeless.
-- Márquelo como una conexión MCP en la interfaz de usuario ("Es conexión mcp"),
-- y suministre la clave de Scrapeless como la credencial de encabezado x-api-token.
CREATE CONNECTION scrapeless_mcp
TYPE HTTP
OPTIONS (
  host 'https://api.scrapeless.com',
  base_path '/mcp',
  bearer_token 'your_api_token_here'
);

Una vez registrado, Databricks expone el servidor al código del agente a través de su proxy administrado en https://<workspace-host>/api/2.0/mcp/external/scrapeless_mcp — el código del agente nunca contiene el token de Scrapeless; se autentica en Databricks, y Databricks adjunta la credencial almacenada cuando hace proxy a Scrapeless.

3. O conecte el endpoint directamente a través de HTTP-streamable

Cuando esté prototipando la integración fuera de un agente desplegado — un script local, un apunte de cuaderno — puede hablar con el endpoint de Scrapeless directamente con el SDK MCP estándar en lugar del proxy. Pase la clave como el encabezado x-api-token en el 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())

El servidor MCP de Scrapeless lee su clave de SCRAPELESS_KEY en el lanzamiento de stdio, pero sobre HTTP-streamable el mismo valor se envía como el encabezado x-api-token — ambos llevan la misma clave. Mantenlo en el entorno (export SCRAPELESS_KEY=...) en lugar de codificarlo directamente. La fuente del servidor se encuentra en el repositorio del servidor Scrapeless MCP.

4. Enumere las herramientas y adjúntelas al agente

Dentro del código del agente, construya un DatabricksMCPClient contra la URL del proxy administrado y un WorkspaceClient, luego enumere las herramientas. Convierta las definiciones de herramientas devueltas en el tipo de herramienta del marco de su agente — los agentes de Mosaic AI suelen ser creados como un ChatAgent de MLflow sobre un gráfico de LangGraph, así que cada herramienta MCP se convierte en una herramienta vinculada en un 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()  # las 21 herramientas de Scrapeless, gobernadas por la conexión

# Vincule los esquemas de herramientas al modelo del agente, luego construya el gráfico del agente.
tool_specs = [
    {"name": t.name, "description": t.description, "input_schema": t.inputSchema}
    for t in tools
]

DatabricksMCPClient.list_tools() devuelve las mismas definiciones de herramientas que reporta el servidor — nombre, descripción y esquema de entrada — por lo que el planificador del agente ve la superficie completa de Scrapeless. Víncule esos esquemas al modelo como cualquier herramienta de Mosaic AI, luego llame a la herramienta a través de mcp_client.call_tool(name, arguments) cuando el modelo la seleccione.

5. Verifique enumerando las 21 herramientas

Enumerar las herramientas e imprimir sus nombres confirma que el apretón de manos se completó y el servidor está reportando su superficie completa:

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

La salida lista las 21 herramientas del servidor como nombres simples — las herramientas de datos de Google (google_search, google_trends), los ayudantes de página de un solo uso (scrape_html, scrape_markdown, scrape_screenshot), y los primitivos del navegador en la nube (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). El servidor los emite sin prefijos; cualquier cliente que los cargue — el proxy de Databricks, el SDK MCP en bruto, un adaptador de TypeScript — aplica su propio espacio de nombres por encima.

Cómo usar esto: promueva su agente

Después de que la conexión esté registrada y las herramientas estén vinculadas, obtienes datos web en vivo al hablar con tu agente de Databricks, no al escribir manualmente las llamadas a las herramientas. El agente lee la lista de herramientas que el servidor Scrapeless MCP expone y elige google_search, scrape_markdown o las herramientas browser_* según sea necesario, componiéndolas turno a turno a partir de la tarea en lenguaje natural. No hay un JSON de herramienta que debas redactar de tu lado; invocas al agente de la misma manera que ya invocas a un agente Mosaic AI, en una celda de notebook o contra el punto final desplegado.

Prompts que puedes pegar

Ejemplo trabajado

Tú escribes (una sola llamada al agente en una celda de notebook):

response = agent.predict({
    "messages": [{
        "role": "user",
        "content": "Usa google_search para encontrar los mejores resultados para "
                   "'databricks mosaic ai agent framework' y devuelve los "
                   "tres mejores como un arreglo JSON de {title, link}.",
    }]
})
print(response)

El plan del agente (en inglés sencillo):

1. Llama a google_search con q: "databricks mosaic ai agent framework", hl: "en", gl: "us".
2. Recibe un arreglo de filas de resultados y lee los campos position, title y link.
3. Ordena por position y mantiene las tres primeras filas.
4. Mapea cada fila a un objeto {title, link}.
5. Devuelve el arreglo JSON como la respuesta del agente.

Lo que recibes de vuelta (forma ilustrativa — el agente trabaja con filas como estas):

[
  { "title": "Mosaic AI Agent Framework — Documentación de Databricks", "link": "https://example.com/agent-framework" },
  { "title": "Construir y desplegar un agente en Databricks", "link": "https://example.com/build-agent" },
  { "title": "Descripción general de Agent Bricks", "link": "https://example.org/agent-bricks" }
]
// Los nombres de campo coinciden con la forma de fila de google_search; los valores son ejemplos ilustrativos.

Las herramientas de datos sin estado devuelven su carga útil como un cuerpo precedido por Response:\n\n; el agente desenvuelve ese prefijo antes de analizar el JSON, por lo que nunca lo ves en la respuesta.

Modelando prompts

Obtén tu clave API en el plan gratuito: app.scrapeless.com

Todo lo que está abajo es la referencia bajo el capó: la superficie de las herramientas, las formas exactas de retorno y el comportamiento que el agente maneja por ti.

La superficie de herramientas del Scrapeless MCP

Una vez que la conexión esté activa, el agente ve 21 herramientas que abarcan datos SERP, scraping sin estado y control de navegador en la nube de anti-detección completo. Los nombres a continuación son los nombres básicos del servidor; cualquiera que cargue el cliente aplica su propio espacio de nombres.

Lo Que Obtienes de Vuelta

Una llamada a google_search devuelve un array de filas de resultados orgánicos codificados como JSON. Cada fila lleva las mismas claves, por lo que el agente puede mapear directamente a título, enlace y fragmento:

// Los nombres de los campos reflejan la salida de la herramienta google_search; los valores son ejemplos ilustrativos.
[
  {
    "position": 1,
    "title": "Construyendo Agentes en Databricks: Una Guía Completa",
    "link": "https://example.com/databricks-agents",
    "snippet": "Una guía paso a paso para construir y desplegar agentes en el Marco de Agentes de AI de Mosaic.",
    "source": "example.com"
  },
  {
    "position": 2,
    "title": "Conectando Agentes a Datos Externos",
    "link": "https://example.org/agent-data",
    "snippet": "Cómo renderizar páginas de JavaScript antes de extraer datos.",
    "source": "example.org"
  }
]

Algunas observaciones honestas una vez que comiences a ejecutar prompts:

• Herramientas sin estado como google_search y scrape_markdown devuelven un cuerpo prefijado con Response:\n\n seguido del payload JSON; el agente desenvuelve automáticamente ese prefijo, por lo que trabajas con los datos, no con el envoltorio.
• Las herramientas browser_* devuelven texto plano sin prefijo Response:\n\n.
• Los argumentos de las herramientas están en camelCase: pasa sessionId, proxyCountry, y campos similares exactamente como se nombran.
• proxyCountry es una solicitud, no una garantía; puede deferir a la región configurada en tu cuenta, así que confirma la región de salida cuando el geo-targeting sea importante.
• Los valores en la salida de la herramienta dependen del contenido: las cuentas de resultados, el orden y el texto del fragmento varían con la consulta en vivo.

Conclusión: buscar, renderizar y navegar desde Databricks

Toda la integración se reduce a una conexión de Unity Catalog más prompts en lenguaje natural. Con Scrapeless registrado como una conexión MCP, DatabricksMCPClient.list_tools() entregando las 21 herramientas a tu agente, y el token de API mantenido en la conexión en lugar de en el código, un agente de Databricks obtiene búsqueda en vivo de Google, renderizado de JavaScript, y un navegador en la nube anti-detección completo — exactamente la capa web que el lakehouse no envía por sí mismo. Tú describes la tarea; el agente elige la herramienta.

Si estás conectando otros clientes, el mismo servidor MCP de Scrapeless se integra en ellos también: mira la integración de Mastra para el camino de TypeScript y la integración del Agente Pi para otro tiempo de ejecución de agente. Mantén tu clave API en la conexión de Unity Catalog, registra el endpoint una vez, lista las herramientas, y deja que el agente elija. Referencia completa en docs.scrapeless.com.

¿Listo para construir tu pipeline de datos impulsada por AI?

Únete a nuestra comunidad para reclamar un plan gratuito y conectarte con desarrolladores que construyen agentes Databricks + Scrapeless MCP: Discord · Telegram.

Regístrate en app.scrapeless.com para obtener un tiempo de ejecución de Navegador de Scraping gratuito y adapta la integración anterior a los SERPs, páginas y regiones que tus agentes de Databricks necesitan. Referencia completa en docs.scrapeless.com.

FAQ

Q: ¿Por qué un agente de Databricks necesita un servidor MCP para acceso web?

Porque un agente de Mosaic AI solo puede llamar a las herramientas que registras con él, y no tiene búsqueda web incorporada ni navegador. MCP es la forma estándar y agnóstica de frameworks para agregar esa capacidad, y Databricks admite servidores MCP externos a través de un proxy administrado. Conectar Scrapeless le da al agente acceso a búsquedas en Google en vivo, acceso a páginas renderizadas y un navegador en la nube totalmente anti-detección en un solo movimiento.

P: ¿Cómo se conecta Databricks a un servidor MCP externo como Scrapeless?

A través de una conexión HTTP de Unity Catalog marcada como conexión MCP. Registras https://api.scrapeless.com/mcp como la conexión, almacenas el x-api-token de Scrapeless como su credencial, y Databricks lo expone al código del agente en https://<workspace-host>/api/2.0/mcp/external/<connection_name>. El código del agente utiliza un DatabricksMCPClient contra esa URL de proxy, por lo que el token de Scrapeless permanece en la conexión y nunca aparece en el agente.

P: ¿Qué variable de entorno o encabezado contiene la clave de Scrapeless?

El lanzamiento estándar del servidor lee SCRAPELESS_KEY; el punto final HTTP lee el mismo valor del encabezado x-api-token. Cuando registras la conexión de Unity Catalog, almacenas esa clave una vez como la credencial de conexión, por lo que el código del agente desplegado no la maneja directamente.

P: ¿Cuántas herramientas expone el servidor MCP de Scrapeless y cuáles son?

21 herramientas: google_search y google_trends para datos de SERP; scrape_html, scrape_markdown y scrape_screenshot para obtenciones de páginas en un solo intento; y 16 herramientas 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 control de navegador en la nube con estado. El servidor las emite como nombres simples; el cliente que las carga aplica su propio espacio de nombres.

P: ¿Necesito alojar Scrapeless como una aplicación de Databricks?

No. Alojar un servidor MCP como una aplicación de Databricks es para servidores que ejecutas tú mismo. Scrapeless es un punto final externo administrado, por lo que lo registras como una conexión HTTP de Unity Catalog y accedes a él a través del proxy MCP externo administrado; no hay nada que desplegar o mantener funcionando de tu parte.

P: ¿Puedo probar la conexión fuera de un agente desplegado?

Sí. Apunta el SDK de Python MCP estándar a https://api.scrapeless.com/mcp con el encabezado x-api-token, llama a initialize y luego a list_tools(), y verás las mismas 21 herramientas que el agente desplegado obtiene a través del proxy. Ese camino directo es la forma más rápida de confirmar tu clave y el punto final antes de registrar la conexión de Unity Catalog.

P: ¿Esto requiere un modelo específico?

No. El modelo del agente es cualquier punto final de servicio de Databricks que conectes; un punto final de Modelo de Fundación o un modelo externo. Las herramientas de Scrapeless son agnósticas al modelo; elige un modelo que maneje bien las llamadas a herramientas, y el agente compone las herramientas de Scrapeless de la misma manera, independientemente del proveedor.

P: ¿Es legal el scraping web a través del agente?

Raspar datos disponibles públicamente es generalmente permisible, pero eres responsable de cómo lo usas. Revisa los Términos de Servicio de cada sitio y respeta robots.txt, y recuerda que las reglas sobre datos personales y acceso varían según la jurisdicción. Cuando tengas dudas, busca asesoría legal para tu caso de uso específico.

P: ¿Puedes usar esto sin Databricks?

Sí. El servidor MCP de Scrapeless es un servidor MCP estándar, por lo que cualquier cliente compatible con MCP puede llamarlo, o puedes controlarlo directamente a través de JSON-RPC (initialize, luego tools/list y tools/call). Databricks es un host para ello, no un requisito.