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.
• Você deve ter privilégio CREATE CONNECTION no metastore Unity Catalog que armazena as informações de conexão MCP.
• O servidor MCP deve usar o mecanismo de transporte HTTP Streamable.

Instale um servidor MCP externo.

Você tem duas opções para instalar servidores MCP externos para usar com seus agentes. Ambos os métodos criam uma conexão Unity Catalog que permite acesso seguro e autenticado ao servidor MCP.

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

From Databricks Marketplace

info

Visualização

Este recurso está em Pré-visualização Pública.

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

1. No seu workspace Databricks , acesse Marketplace > Agentes > tab Servidores MCP .

2. Localize o servidor MCP que 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 Unity Catalog (por exemplo, github_connection).
   • Host : O domínio do host é preenchido previamente para servidores selecionados.
   • Caminho base : O caminho base é preenchido previamente para servidores selecionados.

   Credenciais : Insira suas credenciais de autenticação. Os campos obrigatórios dependem do tipo de credencial do servidor:

   • Para autenticação com tokens de portador : Forneça seus tokens de portador.
   • Para autenticação OAuth U2M : Forneça seu ID de cliente e segredo do cliente.

   Consulte a documentação do provedor do 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.

Custom HTTP connection

Crie uma conexão HTTP Unity Catalog para instalar qualquer servidor MCP, incluindo servidores auto-hospedados ou de terceiros não disponíveis no marketplace.

1. Criar uma conexão HTTP. Consulte Conexão HTTP.

2. Ao criar a conexão HTTP, marque a caixa de seleção Conexão mcp para habilitar a funcionalidade MCP.

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

Após concluir qualquer um dos métodos de instalação:

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

• Databricks provisionamento gerencia um endpoint proxy que lida com segurança com autenticação e gerenciamento de tokens.

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

• Você pode conceder acesso à conexão a outros usuários por meio das permissões Unity Catalog

• A URL do endpoint do proxy segue este formato:

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

Para view seu servidor MCP, acesse seu workspace > Agentes > Servidores MCP.

Compartilhar a conexão do servidor MCP

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

1. Em seu workspace, acesse Catálogo > Conexões > Sua conexão > Permissões .
2. Conceda às identidades o acesso apropriado à conexão com o Unity Catalog .

Teste servidores MCP com o AI Playground

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

1. Acesse o AI Playground no seu workspace 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 ferramentas disponíveis.

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

5. Escolha a conexão Unity Catalog que você instalou anteriormente (por exemplo, github_connection).

6. Converse com o LLM para testar como ele interage com as ferramentas do seu servidor MCP. O AI Playground descobre automaticamente as ferramentas disponíveis no seu servidor MCP e as disponibiliza para o LLM.

Isso permite que você crie protótipos e teste rapidamente as integrações do servidor MCP antes de desenvolver agentes completos ou implantá-los em produção.

Use servidores MCP programaticamente

Após instalar um servidor MCP, utilize-o programaticamente no código do seu agente, conectando-se ao URL do proxy. O proxy Databricks faz com que servidores externos se comportem como servidores MCP, gerenciando autenticação e tokens.

Databricks MCP Client

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

Para usar o servidor MCP 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_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)

Standard MCP SDK

Conecte-se aos servidores MCP 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_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

• Utilize servidores MCP externos com Agent Bricks: Multi-Agent Supervisor.