Compartilhar via

Usar servidores MCP externos

Importante

Esse recurso está em Beta. Os administradores do workspace podem controlar o acesso a esse recurso na página Visualizações . Consulte Gerenciar visualizações do Azure Databricks.

Conecte o Databricks a servidores do PROTOCOLO MCP (Protocolo de Contexto de Modelo) externos para dar aos seus agentes acesso a uma gama mais ampla 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 gerenciados pelo Databricks.

Autenticação e segurança

O Databricks usa proxies MCP gerenciados e conexões HTTP do Unity Catalog para manter a segurança na autenticação no seu ambiente de trabalho.

  • Gerenciamento de token seguro: o Databricks manipula todos os fluxos OAuth e a atualização de token automaticamente
  • Sem credenciais expostas: os tokens nunca são expostos aos usuários finais
  • Autenticação centralizada: padrões de autenticação consistentes usando conexões do Catálogo do Unity

Requirements

Instalar um servidor MCP externo

Você tem três opções para instalar servidores MCP externos a serem usados com seus agentes. Todos os métodos criam uma conexão do Catálogo do Unity que permite acesso seguro e autenticado ao servidor MCP.

Escolha seu método de instalação com base no servidor MCP:

De Databricks Marketplace

Importante

Esse recurso está em Visualização Pública.

Instale servidores MCP coletados e pré-configurados diretamente do Azure Databricks Marketplace:

  1. No workspace do Azure Databricks, vá para a guia Marketplace>Agentes>Servidores MCP.

  2. Localize o servidor MCP que você deseja instalar e clique em Instalar.

  3. Na caixa de diálogo de instalação, configure a conexão:

    • Nome da conexão: insira um nome para a conexão do Catálogo do Unity (por exemplo, github_connection).
    • Host: O domínio do host é preenchido automaticamente para servidores selecionados.
    • Caminho base: O caminho base é pré-preenchido para servidores curados.

    Credenciais: insira suas credenciais de autenticação. Os campos necessários dependem do tipo de credencial do servidor:

    • Para autenticação de token de portador : forneça seu token de portador.
    • Para autenticação OAuth U2M: forneça a ID do cliente e a chave secreta do cliente.

    Consulte a documentação do provedor de servidor MCP para obter instruções sobre como obter essas credenciais.

  4. Clique em Instalar para criar a conexão.

Para obter detalhes completos sobre a instalação do Marketplace, consulte Obter acesso a servidores MCP externos.

Conexão HTTP personalizada

Crie uma conexão HTTP do Catálogo do Unity para instalar qualquer servidor MCP, incluindo servidores auto-hospedados ou de terceiros não disponíveis no Marketplace.

  1. Crie uma conexão HTTP. Consulte a conexão HTTP.

  2. Ao criar a conexão HTTP, selecione a caixa de seleção É conexão MCP para habilitar a funcionalidade MCP.

  3. Verifique se a URL de conexão aponta para um ponto de extremidade de servidor MCP válido.

Registro dinâmico do cliente (experimental)

Importante

Esse recurso está em Visualização Pública.

Use o DCR (Registro Dinâmico de Cliente) para registrar e instalar automaticamente servidores MCP que dão suporte ao DCR do OAuth 2.0 (RFC7591).

O DCR lida automaticamente com a descoberta do OAuth, o registro do cliente e a criação de conexão do Catálogo do Unity sem a necessidade de configuração de credencial manual.

Para usar o DCR, você deve atender aos seguintes requisitos:

  • O servidor MCP deve dar suporte à autorização do DCR e do OAuth 2.0.
  • O servidor MCP deve expor endpoints de metadados OAuth.

  1. Instale ou atualize o databricks-mcp pacote para obter a versão mais recente:

    %pip install -U databricks-mcp
%restart_python

  2. Utilize a função de registro DCR para criar uma conexão do Unity Catalog:

    from databricks.sdk import WorkspaceClient
from databricks_mcp import register_mcp_server_via_dcr

# Initialize workspace client
workspace_client = WorkspaceClient()

# Register MCP server via DCR
connection_url = register_mcp_server_via_dcr(
    connection_name="my_mcp_server",
    mcp_url="https://mcp.example.com/api",
    workspace_client=workspace_client
)

print(f"Connection created: {connection_url}")

Depois de concluir qualquer método de instalação:

  • Uma conexão do Unity Catalog é criada com os detalhes do servidor MCP

  • O Azure Databricks provisiona um endpoint de proxy gerenciado que realiza com segurança a autenticação e o gerenciamento de tokens.

  • O servidor MCP está disponível no AI Playground e pode ser usado programaticamente em seus agentes

  • Você pode conceder a outros usuários acesso à conexão por meio de permissões do Catálogo do Unity

  • A URL do ponto de extremidade proxy segue este formato:

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

Para visualizar seu servidor MCP, vá para o workspace >Agentes>Servidores MCP

Guia de Agentes do Servidor MCP

Compartilhar a conexão do servidor MCP

Conceda USE CONNECTION privilégios a entidades de identidade que precisam usar a conexão do servidor MCP:

  1. Em seu ambiente de trabalho, vá para Catálogo>Conexões> suas >.
  2. Conceda às identidades acesso apropriado à conexão com o Unity Catalog.

Testar servidores MCP usando o ambiente de teste de IA

Teste servidores MCP diretamente no AI Playground sem escrever nenhum código:

  1. Vá para o AI Playground em seu workspace do Databricks.

  2. Escolha um modelo com o rótulo Ferramentas habilitadas.

  3. Clique em Ferramentas > + Adicionar ferramenta e selecione Servidores MCP nas opções de ferramenta disponíveis.

  4. Na seção Servidores MCP , selecione servidores MCP externos para procurar conexões disponíveis.

  5. Escolha a conexão do Catálogo do Unity instalada anteriormente (por exemplo, github_connection).

  6. Converse com a LLM para testar como ela interage com suas ferramentas de servidor MCP. O AI Playground descobre automaticamente as ferramentas disponíveis do servidor MCP e as disponibiliza para a LLM.

Isso permite que você protótipo e teste rapidamente as integrações do servidor MCP antes de criar agentes completos ou implantar em produção.

Usar servidores MCP programaticamente

Depois de instalar um servidor MCP, use-o programaticamente no código do agente conectando-se à URL do proxy. O proxy do Databricks faz com que os servidores externos se comportem como servidores MCP gerenciados, tratando a autenticação e o gerenciamento de tokens.

Cliente MCP do Databricks

A abordagem recomendada trata servidores MCP externos como servidores gerenciados do Databricks, ao adicionar o ponto de extremidade proxy à sua lista MANAGED_MCP_SERVER_URLS.

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_connection"  # External MCP proxy
]

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

# 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 Cliente MCP do Databricks:

# Direct tool call using DatabricksMCPClient
mcp_client = DatabricksMCPClient(
    server_url=f"{host}/api/2.0/mcp/external/github_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)

SDK Padrão do MCP

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

%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_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()

Notebooks de exemplo: construir um agente com servidores MCP do Databricks

Os notebooks a seguir mostram como desenvolver agentes LangGraph e OpenAI que chamam ferramentas MCP, incluindo servidores MCP externos acessados por meio de endpoints de proxy do Databricks.

Agente de chamada de ferramentas do LANGGraph MCP

Obter laptop

Agente de chamada de ferramentas do OPENAI MCP

Obter laptop

Limitações

  • Não há suporte para conectividade privada com recursos em seu VPC usando o Link Privado. Entre em contato com sua equipe de suporte se precisar dessa funcionalidade.

Próximas etapas

  • Last updated on