Use servidores MCP externos

info

Beta

Esse recurso está na versão beta.

Conecte o Databricks a servidores externos do Model Context Protocol (MCP) para dar aos seus agentes acesso a uma gama maior de ferramentas hospedadas fora do Databricks. Servidores MCP externos são servidores MCP de terceiros hospedados fora do Databricks aos quais você se conecta por meio de proxies de gerenciamento Databricks .

Autenticação e segurança

Databricks usa proxies MCP de gerenciamento e conexões HTTP Unity Catalog para lidar com segurança com a autenticação no seu workspace:

Gerenciamento seguro de tokens : o site Databricks lida com todos os fluxos e tokens do OAuth refresh automaticamente
Nenhuma credencial exposta : Os tokens nunca são expostos aos usuários finais
Autenticação centralizada : padrões de autenticação consistentes usando conexões do Unity Catalog

Requisitos

Um workspace com a visualização dos Servidores MCP gerenciados habilitada. Veja as prévias do gerenciar Databricks.
Para se conectar a servidores MCP externos, você deve usar uma conexão HTTP do Unity Catalog. Você deve ter privilégios CREATE CONNECTION no metastore Unity Catalog anexado ao workspace. Consulte Criar uma conexão HTTP do Unity Catalog para obter mais detalhes.

Criar uma conexão HTTP do Unity Catalog

Para se conectar a um servidor MCP externo, você deve criar uma conexão HTTP do Unity Catalog com o servidor.

Crie uma conexão HTTP, veja Conexão HTTP.
Ao criar a conexão HTTP, marque a caixa de seleção Conexão mcp para habilitar a funcionalidade MCP.
Verifique se o URL de conexão aponta para um endpoint de servidor MCP válido.

Após a criação da conexão UC, Databricks provisiona automaticamente um endpoint proxy que atua como um servidor MCP de gerenciamento Databricks . Este endpoint envia o tráfego com segurança para o servidor MCP externo, gerenciando a injeção e a renovação de tokens.

Os URLs de endpoint do proxy seguem este formato:

https://<workspace-hostname>/api/2.0/mcp/external/{connection_name}

Conecte-se com a AI Playground

Você pode testar servidores MCP externos diretamente no AI Playground sem escrever nenhum código:

Navegue até o AI Playground no seu workspace Databricks .
Escolha um modelo com o rótulo Ferramentas habilitadas .
Clique em Ferramentas > + Adicionar ferramenta e selecione Servidores MCP nas opções de ferramentas disponíveis.
Na seção Servidores MCP , selecione Servidores MCP externos para navegar pelas conexões externas disponíveis.
Escolha a conexão HTTP do Unity Catalog que você criou anteriormente (por exemplo, github_u2m_connection).
Converse com o LLM para testar como ele interage com suas ferramentas de servidor MCP externo. O AI Playground descobre automaticamente as ferramentas disponíveis no seu servidor MCP externo e as disponibiliza para o LLM.

Isso permite que o senhor crie rapidamente protótipos e teste integrações de servidores MCP externos antes de criar agentes completos ou implantá-los na produção.

Conectar-se a servidores MCP externos

Conecte-se a um servidor MCP externo usando o URL do proxy. O proxy Databricks faz com que servidores externos se comportem como servidores MCP gerenciados.

Databricks MCP Client
Standard MCP SDK

A abordagem recomendada trata servidores MCP externos como servidores de gerenciamento Databricks adicionando o endpoint do proxy à sua lista MANAGED_MCP_SERVER_URLS .

Python
from databricks.sdk import WorkspaceClient
from databricks_mcp import DatabricksMCPClient

# Initialize workspace client
workspace_client = WorkspaceClient()
host = workspace_client.config.host

# External MCP servers are proxied as managed servers, allowing you
# to use the same API for both managed and external servers
MANAGED_MCP_SERVER_URLS = [
    f"{host}/api/2.0/mcp/functions/system/ai",  # Default managed MCP
    f"{host}/api/2.0/mcp/external/github_u2m_connection"  # External MCP proxy
]

Para usar o servidor MCP externo em um agente, passe a URL do proxy para o parâmetro managed_server_urls :

Python
# Use with agents - external servers work just like managed ones
import asyncio
from your_agent_code import create_mcp_tools  # Your agent's tool creation function

# Create tools from both managed and external (proxied) servers
mcp_tools = asyncio.run(
    create_mcp_tools(
        ws=workspace_client,
        managed_server_urls=MANAGED_MCP_SERVER_URLS
    )
)

Você também pode chamar a ferramenta diretamente usando o Databricks MCP Client:

Python
# Direct tool call using DatabricksMCPClient
mcp_client = DatabricksMCPClient(
    server_url=f"{host}/api/2.0/mcp/external/github_u2m_connection",
    workspace_client=workspace_client
)

# List available tools
tools = mcp_client.list_tools()
print(f"Available tools: {[tool.name for tool in tools]}")

# Call a tool
response = mcp_client.call_tool(
    "list_commits",
    {"owner": "mlflow", "repo": "mlflow", "sha": "master"}
)
print(response.content[0].text)

Conecte-se a servidores MCP externos usando o SDK MCP padrão com async/await:

Python
%pip install -U databricks-sdk databricks_mcp tabulate databricks_ai_bridge
%restart_python

import json
from databricks.sdk import WorkspaceClient
from databricks_mcp import DatabricksOAuthClientProvider
from databricks.sdk.credentials_provider import ModelServingUserCredentials
from mcp.client.streamable_http import streamablehttp_client as connect
from mcp import ClientSession
from tabulate import tabulate


async def main():
    app_url = "https://<workspace-hostname>/api/2.0/mcp/external/github_u2m_connection"
    client = WorkspaceClient()

    async with connect(app_url, auth=DatabricksOAuthClientProvider(client)) as (
        read_stream,
        write_stream,
        _,
    ):
        async with ClientSession(read_stream, write_stream) as session:
            init = await session.initialize()
            print(json.dumps(init.model_dump(), indent=2))
            tools = await session.list_tools()
            print(json.dumps(tools.model_dump(), indent=2))

            arguments = {
                "owner": "mlflow",
                "repo": "mlflow",
                "sha": "master"
            }
            response = await session.call_tool(name="list_commits", arguments=arguments)

            data = json.loads(response.content[0].text)
            rows = []
            for commit in data:
                author = commit.get("commit", {}).get("author", {}).get("name")
                message = commit.get("commit", {}).get("message", "").split("\n")[0]
                html_url = commit.get("html_url", "")
                rows.append([author, message, html_url])

            # Print as table
            print(tabulate(rows, headers=["Author", "Message", "Commit URL"], tablefmt="github"))

await main()

Exemplo de Notebook: Crie um agente com servidores MCP Databricks

O Notebook a seguir mostra como criar agentes LangGraph e OpenAI que chamam ferramentas MCP, incluindo servidores MCP externos acessados por meio do ponto de extremidade proxy Databricks .

Agente de chamada de ferramenta LangGraph MCP

Open notebook in new tab

Agente de chamada de ferramenta OpenAI MCP

Open notebook in new tab

Limitações

A conectividade privada para recurso em sua VPC usando Private Link não é suportada. Entre em contato com sua equipe de suporte se precisar dessa funcionalidade.
O Databricks suporta apenas servidores MCP externos que usam o mecanismo de transporte HTTP Streamable.

Next os passos

Usar servidores MCP gerenciar juntamente com servidores externos
Conecte clientes aos servidores MCP para acessar a infraestrutura MCP do Databricks
Crie servidores MCP personalizados para as necessidades da sua organização
Agentes implantados que usam servidores MCP externos

Autenticação e segurança​

Requisitos​

Criar uma conexão HTTP do Unity Catalog​

Conecte-se com a AI Playground​

Conectar-se a servidores MCP externos​

Exemplo de Notebook: Crie um agente com servidores MCP Databricks​